diff --git a/include/cudaq/Frontend/nvqpp/ASTBridge.h b/include/cudaq/Frontend/nvqpp/ASTBridge.h
index f36f7b03b99..0d42e316406 100644
--- a/include/cudaq/Frontend/nvqpp/ASTBridge.h
+++ b/include/cudaq/Frontend/nvqpp/ASTBridge.h
@@ -288,6 +288,10 @@ class QuakeBridgeVisitor
   bool TraverseCXXConstructExpr(clang::CXXConstructExpr *x,
                                 DataRecursionQueue *q = nullptr);
   bool VisitCXXConstructExpr(clang::CXXConstructExpr *x);
+  bool TraverseCXXTemporaryObjectExpr(clang::CXXTemporaryObjectExpr *x,
+                                      DataRecursionQueue *q = nullptr) {
+    return TraverseCXXConstructExpr(x, q);
+  }
   bool VisitCXXOperatorCallExpr(clang::CXXOperatorCallExpr *x);
   bool VisitCXXParenListInitExpr(clang::CXXParenListInitExpr *x);
   bool WalkUpFromCXXOperatorCallExpr(clang::CXXOperatorCallExpr *x);
diff --git a/include/cudaq/Optimizer/Builder/Intrinsics.h b/include/cudaq/Optimizer/Builder/Intrinsics.h
index fbcbed8aaeb..65c3d1dae25 100644
--- a/include/cudaq/Optimizer/Builder/Intrinsics.h
+++ b/include/cudaq/Optimizer/Builder/Intrinsics.h
@@ -53,10 +53,14 @@ static constexpr const char getNumQubitsFromCudaqState[] =
     "__nvqpp_cudaq_state_numberOfQubits";
 
 // Create a new state from data.
-static constexpr const char createCudaqStateFromDataFP64[] =
-    "__nvqpp_cudaq_state_createFromData_fp64";
-static constexpr const char createCudaqStateFromDataFP32[] =
-    "__nvqpp_cudaq_state_createFromData_fp32";
+static constexpr const char createCudaqStateFromDataComplexF64[] =
+    "__nvqpp_cudaq_state_createFromData_complex_f64";
+static constexpr const char createCudaqStateFromDataComplexF32[] =
+    "__nvqpp_cudaq_state_createFromData_complex_f32";
+static constexpr const char createCudaqStateFromDataF64[] =
+    "__nvqpp_cudaq_state_createFromData_f64";
+static constexpr const char createCudaqStateFromDataF32[] =
+    "__nvqpp_cudaq_state_createFromData_f32";
 
 // Delete a state created by the runtime functions above.
 static constexpr const char deleteCudaqState[] = "__nvqpp_cudaq_state_delete";
diff --git a/include/cudaq/Optimizer/Dialect/Quake/QuakeOps.td b/include/cudaq/Optimizer/Dialect/Quake/QuakeOps.td
index 5322818f329..915037f301e 100644
--- a/include/cudaq/Optimizer/Dialect/Quake/QuakeOps.td
+++ b/include/cudaq/Optimizer/Dialect/Quake/QuakeOps.td
@@ -121,7 +121,7 @@ def quake_InitializeStateOp : QuakeOp<"init_state",
   }];
 
   let arguments = (ins
-    VeqType:$targets,
+    NonStruqRefType:$targets,
     AnyStateInitType:$state
   );
   let results = (outs VeqType);
diff --git a/lib/Frontend/nvqpp/ConvertExpr.cpp b/lib/Frontend/nvqpp/ConvertExpr.cpp
index e1f70b84839..f765219f9c0 100644
--- a/lib/Frontend/nvqpp/ConvertExpr.cpp
+++ b/lib/Frontend/nvqpp/ConvertExpr.cpp
@@ -682,9 +682,12 @@ bool QuakeBridgeVisitor::VisitCastExpr(clang::CastExpr *x) {
         if (cxxExpr->getNumArgs() == 1)
           return true;
     }
-    if (isa<ComplexType>(castToTy) && isa<ComplexType>(peekValue().getType())) {
+    if (isa<ComplexType>(castToTy) && isa<ComplexType>(peekValue().getType()))
       return true;
-    }
+    if (isa<quake::StateType>(castToTy))
+      if (auto ptrTy = dyn_cast<cudaq::cc::PointerType>(peekValue().getType()))
+        if (isa<quake::StateType>(ptrTy.getElementType()))
+          return pushValue(builder.create<cudaq::cc::LoadOp>(loc, popValue()));
     if (auto funcTy = peelPointerFromFunction(castToTy))
       if (auto fromTy = dyn_cast<cc::CallableType>(peekValue().getType())) {
         auto inputs = funcTy.getInputs();
@@ -1003,8 +1006,8 @@ bool QuakeBridgeVisitor::VisitMaterializeTemporaryExpr(
   // The following cases are λ expressions, quantum data, or a std::vector view.
   // In those cases, there is nothing to materialize, so we can just pass the
   // Value on the top of the stack.
-  if (isa<cc::CallableType, quake::VeqType, quake::RefType, cc::SpanLikeType>(
-          ty))
+  if (isa<cc::CallableType, quake::VeqType, quake::RefType, cc::SpanLikeType,
+          quake::StateType>(ty))
     return true;
 
   // If not one of the above special cases, then materialize the value to a
@@ -2689,6 +2692,11 @@ bool QuakeBridgeVisitor::VisitInitListExpr(clang::InitListExpr *x) {
   }
 
   // List has 1 or more members.
+  if (size == 1 && isa<clang::MaterializeTemporaryExpr>(x->getInit(0)))
+    if (auto alloc = peekValue().getDefiningOp<cudaq::cc::AllocaOp>())
+      if (auto arrTy = dyn_cast<cudaq::cc::ArrayType>(initListTy))
+        if (alloc.getElementType() == arrTy.getElementType())
+          return true;
   auto last = lastValues(size);
   bool allRef = std::all_of(last.begin(), last.end(), [](auto v) {
     return isa<quake::RefType, quake::VeqType>(v.getType());
@@ -2916,6 +2924,32 @@ bool QuakeBridgeVisitor::VisitCXXConstructExpr(clang::CXXConstructExpr *x) {
             loc, quake::VeqType::getUnsized(builder.getContext()), sizeVal));
       }
 
+      if (ctorName == "state") {
+        // cudaq::state ctor can be materialized when using local simulators and
+        // converting raw data to state vectors. Use a runtime helper function
+        // to perform the conversion.
+        Value stdvec = popValue();
+        auto stateTy = cudaq::cc::PointerType::get(
+            quake::StateType::get(builder.getContext()));
+        if (auto stdvecTy = dyn_cast<cudaq::cc::StdvecType>(stdvec.getType())) {
+          auto dataTy = cudaq::cc::PointerType::get(stdvecTy.getElementType());
+          Value data =
+              builder.create<cudaq::cc::StdvecDataOp>(loc, dataTy, stdvec);
+          auto i64Ty = builder.getI64Type();
+          Value size =
+              builder.create<cudaq::cc::StdvecSizeOp>(loc, i64Ty, stdvec);
+          return pushValue(builder.create<quake::CreateStateOp>(
+              loc, stateTy, ValueRange{data, size}));
+        }
+        if (auto alloc = stdvec.getDefiningOp<cudaq::cc::AllocaOp>()) {
+          Value size = alloc.getSeqSize();
+          return pushValue(builder.create<quake::CreateStateOp>(
+              loc, stateTy, ValueRange{alloc, size}));
+        }
+        TODO_loc(loc, "unhandled state constructor");
+        return false;
+      }
+
       // lambda determines: is `t` a cudaq::state* ?
       auto isStateType = [&](Type t) {
         if (auto ptrTy = dyn_cast<cc::PointerType>(t))
@@ -2925,9 +2959,17 @@ bool QuakeBridgeVisitor::VisitCXXConstructExpr(clang::CXXConstructExpr *x) {
 
       if (ctorName == "qudit") {
         auto initials = popValue();
+        if (isa<quake::StateType>(initials.getType()))
+          if (auto load = initials.getDefiningOp<cudaq::cc::LoadOp>())
+            initials = load.getPtrvalue();
         if (isStateType(initials.getType())) {
-          TODO_x(loc, x, mangler, "qudit(state) ctor");
-          return false;
+          Value alloca = builder.create<quake::AllocaOp>(loc);
+          auto veq1Ty = quake::VeqType::get(builder.getContext(), 1);
+          Value initSt = builder.create<quake::InitializeStateOp>(
+              loc, veq1Ty, ValueRange{alloca, initials});
+          if (auto initOp = initials.getDefiningOp<quake::CreateStateOp>())
+            builder.create<quake::DeleteStateOp>(loc, initOp);
+          return pushValue(builder.create<quake::ExtractRefOp>(loc, initSt, 0));
         }
         bool ok = false;
         if (auto ptrTy = dyn_cast<cc::PointerType>(initials.getType()))
@@ -2953,10 +2995,9 @@ bool QuakeBridgeVisitor::VisitCXXConstructExpr(clang::CXXConstructExpr *x) {
           return pushValue(builder.create<quake::AllocaOp>(
               loc, quake::VeqType::getUnsized(ctx), initials));
         }
-        if (isa<quake::StateType>(initials.getType())) {
+        if (isa<quake::StateType>(initials.getType()))
           if (auto load = initials.getDefiningOp<cudaq::cc::LoadOp>())
             initials = load.getPtrvalue();
-        }
         if (isStateType(initials.getType())) {
           Value state = initials;
           auto i64Ty = builder.getI64Type();
@@ -2964,46 +3005,16 @@ bool QuakeBridgeVisitor::VisitCXXConstructExpr(clang::CXXConstructExpr *x) {
               builder.create<quake::GetNumberOfQubitsOp>(loc, i64Ty, state);
           auto veqTy = quake::VeqType::getUnsized(ctx);
           Value alloc = builder.create<quake::AllocaOp>(loc, veqTy, numQubits);
-          return pushValue(builder.create<quake::InitializeStateOp>(
-              loc, veqTy, alloc, state));
+          Value initSt = builder.create<quake::InitializeStateOp>(loc, veqTy,
+                                                                  alloc, state);
+          if (auto initOp = initials.getDefiningOp<quake::CreateStateOp>())
+            builder.create<quake::DeleteStateOp>(loc, initOp);
+          return pushValue(initSt);
         }
-        // Otherwise, it is the cudaq::qvector(std::vector<complex>) ctor.
-        Value numQubits;
-        Type initialsTy = initials.getType();
-        if (auto ptrTy = dyn_cast<cc::PointerType>(initialsTy)) {
-          if (auto arrTy = dyn_cast<cc::ArrayType>(ptrTy.getElementType())) {
-            if (arrTy.isUnknownSize()) {
-              if (auto allocOp = initials.getDefiningOp<cc::AllocaOp>())
-                if (auto size = allocOp.getSeqSize())
-                  numQubits =
-                      builder.create<math::CountTrailingZerosOp>(loc, size);
-            } else {
-              std::size_t arraySize = arrTy.getSize();
-              if (!std::has_single_bit(arraySize)) {
-                reportClangError(x, mangler,
-                                 "state vector must be a power of 2 in length");
-              }
-              numQubits = builder.create<arith::ConstantIntOp>(
-                  loc, std::countr_zero(arraySize), 64);
-            }
-          }
-        } else if (auto stdvecTy = dyn_cast<cc::StdvecType>(initialsTy)) {
-          Value vecLen = builder.create<cc::StdvecSizeOp>(
-              loc, builder.getI64Type(), initials);
-          numQubits = builder.create<math::CountTrailingZerosOp>(loc, vecLen);
-          auto ptrTy = cc::PointerType::get(stdvecTy.getElementType());
-          initials = builder.create<cc::StdvecDataOp>(loc, ptrTy, initials);
-        }
-        if (!numQubits) {
-          reportClangError(
-              x, mangler,
-              "internal error: could not determine the number of qubits");
-          return false;
-        }
-        auto veqTy = quake::VeqType::getUnsized(ctx);
-        auto alloc = builder.create<quake::AllocaOp>(loc, veqTy, numQubits);
-        return pushValue(builder.create<quake::InitializeStateOp>(
-            loc, veqTy, alloc, initials));
+        reportClangError(
+            x, mangler,
+            "internal error: could not determine the number of qubits");
+        return false;
       }
       if ((ctorName == "qspan" || ctorName == "qview") &&
           isa<quake::VeqType>(peekValue().getType())) {
diff --git a/lib/Optimizer/Builder/Intrinsics.cpp b/lib/Optimizer/Builder/Intrinsics.cpp
index a1661e71153..9ca77a0df9b 100644
--- a/lib/Optimizer/Builder/Intrinsics.cpp
+++ b/lib/Optimizer/Builder/Intrinsics.cpp
@@ -304,11 +304,17 @@ static constexpr IntrinsicCode intrinsicTable[] = {
   }
 )#"},
 
-    {cudaq::createCudaqStateFromDataFP32, {}, R"#(
-  func.func private @__nvqpp_cudaq_state_createFromData_fp32(%p : !cc.ptr<i8>, %s : i64) -> !cc.ptr<!quake.state>
+    {cudaq::createCudaqStateFromDataComplexF32, {}, R"#(
+  func.func private @__nvqpp_cudaq_state_createFromData_complex_f32(%p : !cc.ptr<i8>, %s : i64) -> !cc.ptr<!quake.state>
 )#"},
-    {cudaq::createCudaqStateFromDataFP64, {}, R"#(
-  func.func private @__nvqpp_cudaq_state_createFromData_fp64(%p : !cc.ptr<i8>, %s : i64) -> !cc.ptr<!quake.state>
+    {cudaq::createCudaqStateFromDataComplexF64, {}, R"#(
+  func.func private @__nvqpp_cudaq_state_createFromData_complex_f64(%p : !cc.ptr<i8>, %s : i64) -> !cc.ptr<!quake.state>
+)#"},
+    {cudaq::createCudaqStateFromDataF32, {}, R"#(
+  func.func private @__nvqpp_cudaq_state_createFromData_f32(%p : !cc.ptr<i8>, %s : i64) -> !cc.ptr<!quake.state>
+)#"},
+    {cudaq::createCudaqStateFromDataF64, {}, R"#(
+  func.func private @__nvqpp_cudaq_state_createFromData_f64(%p : !cc.ptr<i8>, %s : i64) -> !cc.ptr<!quake.state>
 )#"},
 
     {cudaq::deleteCudaqState, {}, R"#(
diff --git a/lib/Optimizer/CodeGen/ConvertToQIRAPI.cpp b/lib/Optimizer/CodeGen/ConvertToQIRAPI.cpp
index 7ddb4aae51e..1e578077d7a 100644
--- a/lib/Optimizer/CodeGen/ConvertToQIRAPI.cpp
+++ b/lib/Optimizer/CodeGen/ConvertToQIRAPI.cpp
@@ -785,8 +785,8 @@ struct QmemRAIIOpRewrite : public OpConversionPattern<cudaq::codegen::RAIIOp> {
 
     Value sizeOperand;
     if (!adaptor.getAllocSize()) {
-      auto type = cast<quake::VeqType>(allocTy);
-      auto constantSize = type.getSize();
+      auto type = dyn_cast<quake::VeqType>(allocTy);
+      auto constantSize = type ? type.getSize() : 1;
       sizeOperand =
           rewriter.create<arith::ConstantIntOp>(loc, constantSize, 64);
     } else {
diff --git a/lib/Optimizer/CodeGen/QuakeToCodegen.cpp b/lib/Optimizer/CodeGen/QuakeToCodegen.cpp
index 623aa4b2e08..369142f3c1d 100644
--- a/lib/Optimizer/CodeGen/QuakeToCodegen.cpp
+++ b/lib/Optimizer/CodeGen/QuakeToCodegen.cpp
@@ -80,15 +80,27 @@ class CreateStateOpPattern : public OpRewritePattern<quake::CreateStateOp> {
 
     auto bufferTy = buffer.getType();
     auto ptrTy = cast<cudaq::cc::PointerType>(bufferTy);
-    auto arrTy = cast<cudaq::cc::ArrayType>(ptrTy.getElementType());
-    auto eleTy = arrTy.getElementType();
+    auto arrTy = dyn_cast<cudaq::cc::ArrayType>(ptrTy.getElementType());
+    auto eleTy = arrTy ? arrTy.getElementType() : ptrTy.getElementType();
     auto is64Bit = isa<Float64Type>(eleTy);
+    bool isComplex = false;
 
-    if (auto cTy = dyn_cast<ComplexType>(eleTy))
+    if (auto cTy = dyn_cast<ComplexType>(eleTy)) {
       is64Bit = isa<Float64Type>(cTy.getElementType());
+      isComplex = true;
+    }
+
+    auto createStateFunc = [&]() {
+      if (isComplex) {
+        if (is64Bit)
+          return cudaq::createCudaqStateFromDataComplexF64;
+        return cudaq::createCudaqStateFromDataComplexF32;
+      }
+      if (is64Bit)
+        return cudaq::createCudaqStateFromDataF64;
+      return cudaq::createCudaqStateFromDataF32;
+    }();
 
-    auto createStateFunc = is64Bit ? cudaq::createCudaqStateFromDataFP64
-                                   : cudaq::createCudaqStateFromDataFP32;
     cudaq::IRBuilder irBuilder(ctx);
     auto result = irBuilder.loadIntrinsic(module, createStateFunc);
     assert(succeeded(result) && "loading intrinsic should never fail");
@@ -97,11 +109,9 @@ class CreateStateOpPattern : public OpRewritePattern<quake::CreateStateOp> {
     auto statePtrTy = cudaq::cc::PointerType::get(stateTy);
     auto i8PtrTy = cudaq::cc::PointerType::get(rewriter.getI8Type());
     auto cast = rewriter.create<cudaq::cc::CastOp>(loc, i8PtrTy, buffer);
-    auto one = rewriter.create<arith::ConstantIntOp>(loc, 1, size.getType());
-    auto powsz = rewriter.create<arith::ShLIOp>(loc, size.getType(), one, size);
 
     rewriter.replaceOpWithNewOp<func::CallOp>(
-        createStateOp, statePtrTy, createStateFunc, ValueRange{cast, powsz});
+        createStateOp, statePtrTy, createStateFunc, ValueRange{cast, size});
     return success();
   }
 };
diff --git a/lib/Optimizer/CodeGen/VerifyNVQIRCalls.cpp b/lib/Optimizer/CodeGen/VerifyNVQIRCalls.cpp
index d473911b6fa..34e7625e378 100644
--- a/lib/Optimizer/CodeGen/VerifyNVQIRCalls.cpp
+++ b/lib/Optimizer/CodeGen/VerifyNVQIRCalls.cpp
@@ -46,8 +46,10 @@ struct VerifyNVQIRCallOpsPass
           cudaq::opt::QIRArrayQubitAllocateArrayWithStateComplex32,
           cudaq::opt::QIRArrayQubitAllocateArrayWithStateComplex64,
           cudaq::getNumQubitsFromCudaqState,
-          cudaq::createCudaqStateFromDataFP32,
-          cudaq::createCudaqStateFromDataFP64,
+          cudaq::createCudaqStateFromDataComplexF32,
+          cudaq::createCudaqStateFromDataComplexF64,
+          cudaq::createCudaqStateFromDataF32,
+          cudaq::createCudaqStateFromDataF64,
           cudaq::deleteCudaqState};
       // It must be either NVQIR extension functions or in the allowed list.
       return std::find(NVQIR_FUNCS.begin(), NVQIR_FUNCS.end(), functionName) !=
diff --git a/runtime/cudaq/algorithms/get_state.h b/runtime/cudaq/algorithms/get_state.h
index 36bbd6b1833..1770d848963 100644
--- a/runtime/cudaq/algorithms/get_state.h
+++ b/runtime/cudaq/algorithms/get_state.h
@@ -202,8 +202,12 @@ async_state_result get_state_async(QuantumKernel &&kernel, Args &&...args) {
 
 extern "C" {
 std::int64_t __nvqpp_cudaq_state_numberOfQubits(state *);
-state *__nvqpp_cudaq_state_createFromData_fp64(void *, std::size_t);
-state *__nvqpp_cudaq_state_createFromData_fp32(void *, std::size_t);
+state *__nvqpp_cudaq_state_createFromData_f64(double *, std::size_t);
+state *__nvqpp_cudaq_state_createFromData_f32(float *, std::size_t);
+state *__nvqpp_cudaq_state_createFromData_complex_f64(std::complex<double> *,
+                                                      std::size_t);
+state *__nvqpp_cudaq_state_createFromData_complex_f32(std::complex<float> *,
+                                                      std::size_t);
 void __nvqpp_cudaq_state_delete(state *);
 }
 
diff --git a/runtime/cudaq/qis/qudit.h b/runtime/cudaq/qis/qudit.h
index a7a915c06df..8f890d1c79b 100644
--- a/runtime/cudaq/qis/qudit.h
+++ b/runtime/cudaq/qis/qudit.h
@@ -12,6 +12,8 @@
 
 namespace cudaq {
 
+class state;
+
 /// The qudit models a general d-level quantum system.
 /// This type is templated on the number of levels d.
 template <std::size_t Levels>
@@ -28,29 +30,14 @@ class qudit {
 public:
   /// Construct a qudit, will allocated a new unique index
   qudit() : idx(getExecutionManager()->allocateQudit(n_levels())) {}
-  qudit(const std::vector<complex> &state) : qudit() {
-    if (state.size() != Levels)
-      throw std::runtime_error(
-          "Invalid number of state vector elements for qudit allocation (" +
-          std::to_string(state.size()) + ").");
-
-    auto norm = std::inner_product(
-                    state.begin(), state.end(), state.begin(), complex{0., 0.},
-                    [](auto a, auto b) { return a + b; },
-                    [](auto a, auto b) { return std::conj(a) * b; })
-                    .real();
-    if (std::fabs(1.0 - norm) > 1e-4)
-      throw std::runtime_error("Invalid vector norm for qudit allocation.");
-
-    // Perform the initialization
-    auto precision = std::is_same_v<complex::value_type, float>
-                         ? simulation_precision::fp32
-                         : simulation_precision::fp64;
-    getExecutionManager()->initializeState({QuditInfo(n_levels(), idx)},
-                                           state.data(), precision);
+  qudit(const state &state) : qudit() {
+    // Note: the internal state data will be cloned by the simulator backend.
+    std::vector<QuditInfo> v{QuditInfo{Levels, id()}};
+    getExecutionManager()->initializeState(v, state.internal.get());
   }
-  qudit(const std::initializer_list<complex> &list)
-      : qudit({list.begin(), list.end()}) {}
+  qudit(const state *s) : qudit(*s) {}
+  qudit(state *s) : qudit(const_cast<const state *>(s)) {}
+  qudit(state &s) : qudit(const_cast<const state &>(s)) {}
 
   // Qudits cannot be copied
   qudit(const qudit &q) = delete;
diff --git a/runtime/cudaq/qis/qvector.h b/runtime/cudaq/qis/qvector.h
index b31dac3dae0..a9e2f7dc64e 100644
--- a/runtime/cudaq/qis/qvector.h
+++ b/runtime/cudaq/qis/qvector.h
@@ -31,54 +31,6 @@ class qvector {
   /// @brief Construct a `qvector` with `size` qudits in the |0> state.
   qvector(std::size_t size) : qudits(size) {}
 
-  /// @brief Construct a `qvector` from an input state vector.
-  /// The number of qubits is determined by the size of the input vector.
-  /// If `validate` is set, it will check the norm of input state vector.
-  explicit qvector(const std::vector<complex> &vector, bool validate)
-      : qudits(std::log2(vector.size())) {
-    if (Levels == 2) {
-      auto numElements = std::log2(vector.size());
-      if (std::floor(numElements) != numElements)
-        throw std::runtime_error(
-            "Invalid state vector passed to qvector initialization - number of "
-            "elements must be power of 2.");
-    }
-    if (validate) {
-      auto norm = std::inner_product(
-                      vector.begin(), vector.end(), vector.begin(),
-                      complex{0., 0.}, [](auto a, auto b) { return a + b; },
-                      [](auto a, auto b) { return std::conj(a) * b; })
-                      .real();
-      if (std::fabs(1.0 - norm) > 1e-4)
-        throw std::runtime_error("Invalid vector norm for qudit allocation.");
-    }
-    std::vector<QuditInfo> targets;
-    for (auto &q : qudits)
-      targets.emplace_back(QuditInfo{Levels, q.id()});
-
-    auto precision = std::is_same_v<complex::value_type, float>
-                         ? simulation_precision::fp32
-                         : simulation_precision::fp64;
-    getExecutionManager()->initializeState(targets, vector.data(), precision);
-  }
-  qvector(const std::vector<complex> &vector)
-      : qvector(vector, /*validate=*/false){};
-
-  qvector(const std::vector<double> &vector)
-      : qvector(std::vector<complex>{vector.begin(), vector.end()}) {}
-  qvector(std::vector<double> &&vector)
-      : qvector(std::vector<complex>{vector.begin(), vector.end()}) {}
-  qvector(const std::initializer_list<double> &list)
-      : qvector(std::vector<complex>{list.begin(), list.end()}) {}
-  qvector(const std::vector<float> &vector)
-      : qvector(std::vector<complex>{vector.begin(), vector.end()}) {}
-  qvector(std::vector<float> &&vector)
-      : qvector(std::vector<complex>{vector.begin(), vector.end()}) {}
-  qvector(const std::initializer_list<float> &list)
-      : qvector(std::vector<complex>{list.begin(), list.end()}) {}
-  qvector(const std::initializer_list<complex> &list)
-      : qvector(std::vector<complex>{list.begin(), list.end()}) {}
-
   /// @cond
   /// Nullary constructor
   /// meant to be used with `kernel_builder<cudaq::qvector<>>`
@@ -91,16 +43,16 @@ class qvector {
   /// @brief Construct a `qvector` from a pre-existing `state`.
   /// This `state` could be constructed with `state::from_data` or retrieved
   /// from an cudaq::get_state.
-  explicit qvector(const state &state) : qudits(state.get_num_qubits()) {
+  qvector(const state &state) : qudits(state.get_num_qubits()) {
     std::vector<QuditInfo> targets;
     for (auto &q : qudits)
       targets.emplace_back(QuditInfo{Levels, q.id()});
     // Note: the internal state data will be cloned by the simulator backend.
     getExecutionManager()->initializeState(targets, state.internal.get());
   }
-  explicit qvector(const state *ptr) : qvector(*ptr){};
-  explicit qvector(state *ptr) : qvector(*ptr){};
-  explicit qvector(state &s) : qvector(const_cast<const state &>(s)){};
+  qvector(const state *ptr) : qvector(*ptr) {}
+  qvector(state *ptr) : qvector(*ptr) {}
+  qvector(state &s) : qvector(const_cast<const state &>(s)) {}
 
   /// @brief `qvectors` cannot be copied
   qvector(qvector const &) = delete;
diff --git a/runtime/cudaq/qis/state.cpp b/runtime/cudaq/qis/state.cpp
index 717ca94272d..07d0b4ce4f7 100644
--- a/runtime/cudaq/qis/state.cpp
+++ b/runtime/cudaq/qis/state.cpp
@@ -17,13 +17,15 @@ namespace cudaq {
 
 std::mutex deleteStateMutex;
 
-state state::from_data(const state_data &data) {
+state &state::initialize(const state_data &data) {
   auto *simulator = cudaq::get_simulator();
   if (!simulator)
     throw std::runtime_error(
         "[state::from_data] Could not find valid simulator backend.");
-
-  return state(simulator->createStateFromData(data).release());
+  std::shared_ptr<SimulationState> newPtr{
+      simulator->createStateFromData(data).release()};
+  std::swap(internal, newPtr);
+  return *this;
 }
 
 SimulationState::precision state::get_precision() const {
@@ -128,34 +130,23 @@ std::int64_t __nvqpp_cudaq_state_numberOfQubits(state *obj) {
   return obj->get_num_qubits();
 }
 
-state *__nvqpp_cudaq_state_createFromData_fp64(void *data, std::size_t size) {
-  auto d = reinterpret_cast<std::complex<double> *>(data);
-
-  // Convert the data to the current simulation precision
-  // if different from the data's precision.
-  auto *simulator = cudaq::get_simulator();
-  if (simulator->isSinglePrecision()) {
-    std::vector<std::complex<float>> converted(d, d + size);
-    return new state(state::from_data(converted));
-  }
-
-  std::vector<std::complex<double>> current(d, d + size);
-  return new state(state::from_data(current));
+// Code gen helpers to convert spans (device side data) to state objects.
+state *__nvqpp_cudaq_state_createFromData_complex_f64(std::complex<double> *d,
+                                                      std::size_t size) {
+  return new state(std::vector<std::complex<double>>{d, d + size});
 }
 
-state *__nvqpp_cudaq_state_createFromData_fp32(void *data, std::size_t size) {
-  auto d = reinterpret_cast<std::complex<float> *>(data);
+state *__nvqpp_cudaq_state_createFromData_f64(double *d, std::size_t size) {
+  return new state(std::vector<double>{d, d + size});
+}
 
-  // Convert the data to the current simulation precision
-  // if different from the data's precision.
-  auto *simulator = cudaq::get_simulator();
-  if (simulator->isDoublePrecision()) {
-    std::vector<std::complex<double>> converted(d, d + size);
-    return new state(state::from_data(converted));
-  }
+state *__nvqpp_cudaq_state_createFromData_complex_f32(std::complex<float> *d,
+                                                      std::size_t size) {
+  return new state(std::vector<std::complex<float>>{d, d + size});
+}
 
-  std::vector<std::complex<float>> current(d, d + size);
-  return new state(state::from_data(current));
+state *__nvqpp_cudaq_state_createFromData_f32(float *d, std::size_t size) {
+  return new state(std::vector<float>{d, d + size});
 }
 
 void __nvqpp_cudaq_state_delete(state *obj) { delete obj; }
diff --git a/runtime/cudaq/qis/state.h b/runtime/cudaq/qis/state.h
index c1dee6c0923..754ac93b069 100644
--- a/runtime/cudaq/qis/state.h
+++ b/runtime/cudaq/qis/state.h
@@ -9,9 +9,7 @@
 #pragma once
 
 #include "common/SimulationState.h"
-#include <memory>
-#include <variant>
-#include <vector>
+#include "cudaq/host_config.h"
 
 namespace cudaq {
 
@@ -26,16 +24,52 @@ class state {
 private:
   /// @brief Reference to the simulation data
   std::shared_ptr<SimulationState> internal;
-  template <std::size_t Levels>
+  template <std::size_t>
   friend class qvector;
+  template <std::size_t>
+  friend class qudit;
   friend class state_helper;
 
 public:
   /// @brief The constructor, takes the simulation data and owns it
   explicit state(SimulationState *ptrToOwn)
-      : internal(std::shared_ptr<SimulationState>(ptrToOwn)) {}
+      : internal(std::shared_ptr<SimulationState>{ptrToOwn}) {}
   /// @brief Copy constructor (default)
   state(const state &other) = default;
+
+  /// Overloaded constructors.
+  /// These construct a `state` from a raw input state vector. The number of
+  /// qubits is determined by the size of the input vector. The user is
+  /// responsible for providing (and verifying) the element values. These values
+  /// must be correct for the simulator that is in use.
+  state(const std::vector<std::complex<double>> &vector) {
+    initialize(std::vector<complex>{vector.begin(), vector.end()});
+  }
+  state(const std::vector<std::complex<float>> &vector) {
+    initialize(std::vector<complex>{vector.begin(), vector.end()});
+  }
+  state(const std::vector<double> &vector) {
+    initialize(std::vector<complex>{vector.begin(), vector.end()});
+  }
+  state(std::vector<double> &&vector) {
+    initialize(std::vector<complex>{vector.begin(), vector.end()});
+  }
+  state(const std::initializer_list<double> &list) {
+    initialize(std::vector<complex>{list.begin(), list.end()});
+  }
+  state(const std::vector<float> &vector) {
+    initialize(std::vector<complex>{vector.begin(), vector.end()});
+  }
+  state(std::vector<float> &&vector) {
+    initialize(std::vector<complex>{vector.begin(), vector.end()});
+  }
+  state(const std::initializer_list<float> &list) {
+    initialize(std::vector<complex>{list.begin(), list.end()});
+  }
+  state(const std::initializer_list<complex> &list) {
+    initialize(std::vector<complex>{list.begin(), list.end()});
+  }
+
   /// @brief Copy assignment
   state &operator=(state &&other);
 
@@ -91,15 +125,23 @@ class state {
 
   /// @brief Return the amplitude of the given computational basis state
   std::complex<double> amplitude(const std::vector<int> &basisState);
+
   /// @brief Return the amplitudes of the given list of computational basis
   /// states
   std::vector<std::complex<double>>
   amplitudes(const std::vector<std::vector<int>> &basisStates);
+
   /// @brief Create a new state from user-provided data.
   /// The data can be host or device data.
-  static state from_data(const state_data &data);
+  static state from_data(const state_data &data) {
+    return state{}.initialize(data);
+  }
 
   ~state();
+
+private:
+  state() : internal{nullptr} {}
+  state &initialize(const state_data &data);
 };
 
 class state_helper {
diff --git a/targettests/Remote-Sim/qvector_init_from_vector.cpp b/targettests/Remote-Sim/qvector_init_from_vector.cpp
deleted file mode 100644
index 1c2bd67e237..00000000000
--- a/targettests/Remote-Sim/qvector_init_from_vector.cpp
+++ /dev/null
@@ -1,252 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2022 - 2025 NVIDIA Corporation & Affiliates.                  *
- * All rights reserved.                                                        *
- *                                                                             *
- * This source code and the accompanying materials are made available under    *
- * the terms of the Apache License 2.0 which accompanies this distribution.    *
- ******************************************************************************/
-
-// REQUIRES: remote-sim
-
-// clang-format off
-// RUN: nvq++ %cpp_std --enable-mlir --target remote-mqpu %s -o %t  && %t | FileCheck %s
-// TODO-FIX-KERNEL-EXEC
-// RUN: nvq++ %cpp_std --enable-mlir --target remote-mqpu -fkernel-exec-kind=2 %s -o %t && %t | FileCheck %s
-// clang-format on
-
-#include <cudaq.h>
-#include <iostream>
-
-__qpu__ void test_large_double_constant_array() {
-  std::vector<double> vec(1ULL << 19);
-  vec[0] = M_SQRT1_2 / vec.size();
-  vec[1] = M_SQRT1_2 / vec.size();
-  for (std::size_t i = 2; i < vec.size(); i++) {
-    vec[i] = 0;
-  }
-  cudaq::qvector v(vec);
-}
-
-__qpu__ void test_complex_constant_array() {
-  cudaq::qvector v(std::vector<cudaq::complex>({M_SQRT1_2, M_SQRT1_2, 0., 0.}));
-}
-
-__qpu__ void test_complex_constant_array2() {
-  cudaq::qvector v1(
-      std::vector<cudaq::complex>({M_SQRT1_2, M_SQRT1_2, 0., 0.}));
-  cudaq::qvector v2(
-      std::vector<cudaq::complex>({0., 0., M_SQRT1_2, M_SQRT1_2}));
-}
-
-__qpu__ void test_complex_constant_array3() {
-  cudaq::qvector v({cudaq::complex(M_SQRT1_2), cudaq::complex(M_SQRT1_2),
-                    cudaq::complex(0.0), cudaq::complex(0.0)});
-}
-
-__qpu__ void test_complex_array_param(std::vector<cudaq::complex> inState) {
-  cudaq::qvector q1 = inState;
-}
-
-__qpu__ void test_real_constant_array() {
-  cudaq::qvector v({M_SQRT1_2, M_SQRT1_2, 0., 0.});
-}
-
-__qpu__ void test_real_array_param(std::vector<cudaq::real> inState) {
-  cudaq::qvector q1 = inState;
-}
-
-__qpu__ void test_double_array_param(std::vector<double> inState) {
-  cudaq::qvector q = inState;
-}
-
-__qpu__ void test_float_array_param(std::vector<float> inState) {
-  cudaq::qvector q = inState;
-}
-
-void printCounts(cudaq::sample_result &result) {
-  std::vector<std::string> values{};
-  for (auto &&[bits, counts] : result) {
-    values.push_back(bits);
-  }
-
-  std::sort(values.begin(), values.end());
-  for (auto &&bits : values) {
-    std::cout << bits << '\n';
-  }
-}
-
-int main() {
-  {
-    auto counts = cudaq::sample(test_large_double_constant_array);
-    std::cout << "Part 1\n";
-    printCounts(counts);
-  }
-
-  // CHECK-LABEL: Part 1
-  // CHECK: 0000000000000000000
-  // CHECK: 1000000000000000000
-
-  {
-    auto counts = cudaq::sample(test_complex_constant_array);
-    std::cout << "Part 2\n";
-    printCounts(counts);
-  }
-
-  // CHECK-LABEL: Part 2
-  // CHECK: 00
-  // CHECK: 10
-
-  {
-    auto counts = cudaq::sample(test_complex_constant_array2);
-    std::cout << "Part 3\n";
-    printCounts(counts);
-  }
-
-  // CHECK-LABEL: Part 3
-  // CHECK: 0001
-  // CHECK: 0011
-  // CHECK: 1001
-  // CHECK: 1011
-
-  {
-    auto counts = cudaq::sample(test_complex_constant_array3);
-    std::cout << "Part 4\n";
-    printCounts(counts);
-  }
-
-  // CHECK-LABEL: Part 4
-  // CHECK: 00
-  // CHECK: 10
-
-  {
-    auto counts = cudaq::sample(test_real_constant_array);
-    std::cout << "Part 5\n";
-    printCounts(counts);
-  }
-
-  // CHECK-LABEL: Part 5
-  // CHECK: 00
-  // CHECK: 10
-
-  {
-    std::vector<cudaq::complex> vec{M_SQRT1_2, M_SQRT1_2, 0., 0.};
-    std::vector<cudaq::complex> vec1{0., 0., M_SQRT1_2, M_SQRT1_2};
-    {
-      // Passing state data as argument (kernel mode)
-      auto counts = cudaq::sample(test_complex_array_param, vec);
-      std::cout << "Part 6\n";
-      printCounts(counts);
-
-      counts = cudaq::sample(test_complex_array_param, vec1);
-      printCounts(counts);
-    }
-
-    // CHECK-LABEL: Part 6
-    // CHECK: 00
-    // CHECK: 10
-
-    // CHECK: 01
-    // CHECK: 11
-
-    {
-      // Passing state data as argument (builder mode)
-      auto [kernel, v] = cudaq::make_kernel<std::vector<cudaq::complex>>();
-      auto qubits = kernel.qalloc(v);
-
-      auto counts = cudaq::sample(kernel, vec);
-      std::cout << "Part 7\n";
-      printCounts(counts);
-
-      counts = cudaq::sample(kernel, vec1);
-      printCounts(counts);
-    }
-  }
-
-  // CHECK-LABEL: Part 7
-  // CHECK: 00
-  // CHECK: 10
-
-  // CHECK: 01
-  // CHECK: 11
-
-  {
-    std::vector<cudaq::real> vec{M_SQRT1_2, M_SQRT1_2, 0., 0.};
-    std::vector<cudaq::real> vec1{0., 0., M_SQRT1_2, M_SQRT1_2};
-    {
-      // Passing state data as argument (kernel mode)
-      auto counts = cudaq::sample(test_real_array_param, vec);
-      std::cout << "Part 8\n";
-      printCounts(counts);
-
-      counts = cudaq::sample(test_real_array_param, vec1);
-      printCounts(counts);
-    }
-
-    // CHECK-LABEL: Part 8
-    // CHECK: 00
-    // CHECK: 10
-
-    // CHECK: 01
-    // CHECK: 11
-
-    {
-      // Passing state data as argument (builder mode)
-      auto [kernel, v] = cudaq::make_kernel<std::vector<cudaq::real>>();
-      auto qubits = kernel.qalloc(v);
-
-      auto counts = cudaq::sample(kernel, vec);
-      std::cout << "Part 9\n";
-      printCounts(counts);
-
-      counts = cudaq::sample(kernel, vec1);
-      printCounts(counts);
-    }
-
-    // CHECK-LABEL: Part 9
-    // CHECK: 00
-    // CHECK: 10
-
-    // CHECK: 01
-    // CHECK: 11
-  }
-
-  {
-    std::vector<double> vec{M_SQRT1_2, M_SQRT1_2, 0., 0.};
-    std::vector<double> vec1{0., 0., M_SQRT1_2, M_SQRT1_2};
-
-    // Passing state data as argument (kernel mode)
-    auto counts = cudaq::sample(test_double_array_param, vec);
-    std::cout << "Part 10\n";
-    printCounts(counts);
-
-    counts = cudaq::sample(test_double_array_param, vec1);
-    printCounts(counts);
-  }
-
-  // CHECK-LABEL: Part 10
-  // CHECK: 00
-  // CHECK: 10
-
-  // CHECK: 01
-  // CHECK: 11
-
-  {
-    std::vector<float> vec{M_SQRT1_2, M_SQRT1_2, 0., 0.};
-    std::vector<float> vec1{0., 0., M_SQRT1_2, M_SQRT1_2};
-
-    // Passing state data as argument (kernel mode)
-    auto counts = cudaq::sample(test_float_array_param, vec);
-    std::cout << "Part 11\n";
-    printCounts(counts);
-
-    counts = cudaq::sample(test_float_array_param, vec1);
-    printCounts(counts);
-  }
-
-  // CHECK-LABEL: Part 11
-  // CHECK: 00
-  // CHECK: 10
-
-  // CHECK: 01
-  // CHECK: 11
-}
diff --git a/targettests/execution/from_state_complex.cpp b/targettests/execution/from_state_complex.cpp
index 51c5d151c28..a9dd44c9078 100644
--- a/targettests/execution/from_state_complex.cpp
+++ b/targettests/execution/from_state_complex.cpp
@@ -6,13 +6,12 @@
  * the terms of the Apache License 2.0 which accompanies this distribution.    *
  ******************************************************************************/
 
-// RUN: nvq++ %cpp_std --enable-mlir %s -o %t && %t | FileCheck %s
-// RUN: nvq++ %cpp_std %s -o %t && %t | FileCheck %s
+// RUN: nvq++ %s -o %t && %t | FileCheck %s
 
 #include <cudaq.h>
 
 __qpu__ void test(std::vector<cudaq::complex> inState) {
-  cudaq::qvector q = inState;
+  cudaq::qvector q{cudaq::state(inState)};
 }
 
 // CHECK: size 2
diff --git a/targettests/execution/from_state_double.cpp b/targettests/execution/from_state_double.cpp
index e7b7bf6eb05..151b69abff2 100644
--- a/targettests/execution/from_state_double.cpp
+++ b/targettests/execution/from_state_double.cpp
@@ -6,13 +6,12 @@
  * the terms of the Apache License 2.0 which accompanies this distribution.    *
  ******************************************************************************/
 
-// RUN: nvq++ %cpp_std --enable-mlir %s -o %t && %t | FileCheck %s
-// RUN: nvq++ %cpp_std %s -o %t && %t | FileCheck %s
+// RUN: nvq++ %s -o %t && %t | FileCheck %s
 
 #include <cudaq.h>
 
 __qpu__ void test(std::vector<double> inState) {
-  cudaq::qvector q = inState;
+  cudaq::qvector q{cudaq::state(inState)};
 }
 
 // CHECK: size 2
diff --git a/targettests/execution/graph_coloring-1.cpp b/targettests/execution/graph_coloring-1.cpp
index 1aa727cb0e4..b474a547874 100644
--- a/targettests/execution/graph_coloring-1.cpp
+++ b/targettests/execution/graph_coloring-1.cpp
@@ -8,10 +8,12 @@
 
 // REQUIRES: c++20
 // clang-format off
-// RUN: nvq++ %s -o %t --target infleqtion --emulate && %t | FileCheck %s
-// RUN: nvq++ %s -o %t --target quantinuum --emulate && %t | FileCheck %s
-// RUN: if %braket_avail; then nvq++ %s -o %t --target braket --emulate && %t | FileCheck %s; fi
-// RUN: if %qci_avail; then nvq++ %cpp_std --target qci --emulate %s -o %t && %t | FileCheck %s; fi
+// RUN: nvq++ --target infleqtion --emulate %s -o %t && %t | FileCheck %s
+// RUN: nvq++ --target quantinuum --emulate %s -o %t && %t | FileCheck %s
+// RUN: if %braket_avail; \
+// RUN: then nvq++ --target braket --emulate %s -o %t && %t | FileCheck %s; fi
+// RUN: if %qci_avail; \
+// RUN: then nvq++ --target qci --emulate %s -o %t && %t | FileCheck %s; fi
 // clang-format on
 
 #include <cudaq.h>
@@ -41,7 +43,8 @@ struct init_state {
 __qpu__ void reflect_uniform(cudaq::qvector<> &qubits, double theta) {
   cudaq::adjoint(init_state{}, qubits, theta);
   x(qubits);
-  z<cudaq::ctrl>(qubits[0], qubits[1], qubits[2], qubits[3], qubits[4], qubits[5], qubits[6], qubits[7]);
+  z<cudaq::ctrl>(qubits[0], qubits[1], qubits[2], qubits[3], qubits[4],
+                 qubits[5], qubits[6], qubits[7]);
   x(qubits);
   init_state{}(qubits, theta);
 }
@@ -102,7 +105,7 @@ int main() {
   for (auto &&[bits, count] : result) {
     strings.push_back(bits);
   }
-  std::sort(strings.begin(), strings.end(), [&](auto& a, auto& b) {
+  std::sort(strings.begin(), strings.end(), [&](auto &a, auto &b) {
     return result.count(a) > result.count(b);
   });
   std::unordered_set<std::string> most_probable;
diff --git a/targettests/execution/qvector_mismatch.cpp b/targettests/execution/qvector_mismatch.cpp
index 083bdd3442b..01ab4a7e7b2 100644
--- a/targettests/execution/qvector_mismatch.cpp
+++ b/targettests/execution/qvector_mismatch.cpp
@@ -6,12 +6,12 @@
  * the terms of the Apache License 2.0 which accompanies this distribution.    *
  ******************************************************************************/
 
-// RUN: nvq++ %cpp_std --enable-mlir %s -o %t && %t | FileCheck %s
+// RUN: nvq++ %s -o %t && %t | FileCheck %s
 
 #include <cudaq.h>
 
 __qpu__ void test(std::vector<double> inState) {
-  cudaq::qvector q = inState;
+  cudaq::qvector q{cudaq::state(inState)};
 }
 
 int main() {
diff --git a/targettests/execution/state_preparation.cpp b/targettests/execution/state_preparation.cpp
index 2c03f611efc..45eedb81371 100644
--- a/targettests/execution/state_preparation.cpp
+++ b/targettests/execution/state_preparation.cpp
@@ -7,17 +7,7 @@
  ******************************************************************************/
 
 // Simulators
-// RUN: nvq++ %cpp_std --enable-mlir  %s                             -o %t && %t | FileCheck %s
-
-// Quantum emulators
-// RUN: nvq++ %cpp_std --target infleqtion --emulate %s -o %t && %t | FileCheck %s
-// RUN: nvq++ %cpp_std --target quantinuum --emulate %s -o %t && %t | FileCheck %s
-// RUN: nvq++ %cpp_std --target ionq       --emulate %s -o %t && %t | FileCheck %s
-// RUN: nvq++ %cpp_std --target iqm        --emulate %s -o %t && IQM_QPU_QA=%iqm_tests_dir/Crystal_5.txt  %t | FileCheck %s
-// RUN: nvq++ %cpp_std --target oqc        --emulate %s -o %t && %t | FileCheck %s
-// RUN: if %braket_avail; then nvq++ %cpp_std --target braket --emulate %s -o %t && %t | FileCheck %s; fi
-// RUN: if %qci_avail; then nvq++ %cpp_std --target qci --emulate %s -o %t && %t | FileCheck %s; fi
-// RUN: if %quantum_machines_avail; then nvq++ %cpp_std --target quantum_machines --emulate %s -o %t && %t | FileCheck %s; fi
+// RUN: nvq++ %s -o %t && %t | FileCheck %s
 
 #include <bitset>
 #include <cudaq.h>
@@ -25,21 +15,28 @@
 
 struct kernel {
   __qpu__ void operator()(std::vector<cudaq::complex> vec) {
-    cudaq::qvector qubits = vec;
+    cudaq::qvector qubits{vec};
     mz(qubits);
   }
 };
 
-int main() {
+struct kernel2 {
+  __qpu__ void operator()(std::vector<cudaq::real> vec) {
+    cudaq::qvector qubits{vec};
+    mz(qubits);
+  }
+};
+
+void test1() {
+  std::cout << "test1\n";
   std::vector<cudaq::complex> vec{0., 0., 0., 0.};
   for (std::size_t i = 0; i < vec.size(); i++) {
     if (i > 0)
-      vec[i-1] = 0;
+      vec[i - 1] = 0;
     vec[i] = 1;
 
     auto result = cudaq::sample(kernel{}, vec);
 
-#ifndef SYNTAX_CHECK
     std::bitset<8> binary(i);
     auto expected = binary.to_string().substr(binary.size() - 2);
 
@@ -48,12 +45,42 @@ int main() {
     std::cout << bits << '\n';
 
     assert(bits == expected);
-#endif
   }
+}
+
+void test2() {
+  std::cout << "test2\n";
+  std::vector<cudaq::real> vec{0., 0., 0., 0.};
+  for (std::size_t i = 0; i < vec.size(); i++) {
+    if (i > 0)
+      vec[i - 1] = 0;
+    vec[i] = 1;
+
+    auto result = cudaq::sample(kernel2{}, vec);
+
+    std::bitset<8> binary(i);
+    auto expected = binary.to_string().substr(binary.size() - 2);
 
+    auto bits = result.most_probable();
+    std::reverse(bits.begin(), bits.end());
+    std::cout << bits << '\n';
+
+    assert(bits == expected);
+  }
+}
+
+int main() {
+  test1();
+  test2();
   return 0;
 }
 
+// CHECK-LABEL: test1
+// CHECK: 00
+// CHECK: 01
+// CHECK: 10
+// CHECK: 11
+// CHECK-LABEL: test2
 // CHECK: 00
 // CHECK: 01
 // CHECK: 10
diff --git a/targettests/execution/state_preparation_vector.cpp b/targettests/execution/state_preparation_vector.cpp
index e3e7c121c0d..ebae7fe9943 100644
--- a/targettests/execution/state_preparation_vector.cpp
+++ b/targettests/execution/state_preparation_vector.cpp
@@ -8,15 +8,7 @@
 
 // clang-format off
 // Simulators
-// RUN: nvq++ %cpp_std %s -o %t && %t | FileCheck %s
-
-// Quantum emulators
-// RUN: if %braket_avail; then nvq++ %cpp_std -target braket -emulate %s -o %t && %t | FileCheck %s ; fi
-// RUN: if %qci_avail; then nvq++ %cpp_std --target qci --emulate %s -o %t && %t | FileCheck %s; fi
-// RUN: nvq++ %cpp_std -target quantinuum -emulate %s -o %t && %t | FileCheck %s
-// RUN: nvq++ %cpp_std -target ionq       -emulate %s -o %t && %t | FileCheck %s
-// RUN: nvq++ %cpp_std -target oqc        -emulate %s -o %t && %t | FileCheck %s
-// RUN: nvq++ %cpp_std --target iqm      --emulate %s -o %t && IQM_QPU_QA=%iqm_tests_dir/Crystal_5.txt  %t | FileCheck %s
+// RUN: nvq++ %s -o %t && %t | FileCheck %s
 // clang-format on
 
 #include <cudaq.h>
@@ -39,10 +31,8 @@ __qpu__ void test_complex_constant_array_floating_point() {
 }
 
 __qpu__ void test_complex_constant_array2() {
-  cudaq::qvector v1(
-      std::vector<cudaq::complex>({M_SQRT1_2, M_SQRT1_2, 0., 0.}));
-  cudaq::qvector v2(
-      std::vector<cudaq::complex>({0., 0., M_SQRT1_2, M_SQRT1_2}));
+  cudaq::qvector v(std::vector<cudaq::complex>{M_SQRT1_2, M_SQRT1_2, 0., 0., 0.,
+                                               0., M_SQRT1_2, M_SQRT1_2});
 }
 
 __qpu__ void test_complex_constant_array3() {
@@ -51,12 +41,12 @@ __qpu__ void test_complex_constant_array3() {
 }
 
 __qpu__ void test_complex_array_param(std::vector<cudaq::complex> inState) {
-  cudaq::qvector q1 = inState;
+  cudaq::qvector q1{cudaq::state(inState)};
 }
 
 __qpu__ void test_complex_array_param_floating_point(
     std::vector<std::complex<cudaq::real>> inState) {
-  cudaq::qvector q1 = inState;
+  cudaq::qvector q1{inState};
 }
 
 __qpu__ void test_real_constant_array() {
@@ -64,28 +54,27 @@ __qpu__ void test_real_constant_array() {
 }
 
 __qpu__ void test_real_constant_array_floating_point() {
-  cudaq::qvector v(std::vector<cudaq::real>({M_SQRT1_2, M_SQRT1_2, 0., 0.}));
+  cudaq::qvector v(
+      cudaq::state{std::vector<cudaq::real>({M_SQRT1_2, M_SQRT1_2, 0., 0.})});
 }
 
 __qpu__ void test_real_array_param(std::vector<cudaq::real> inState) {
-  cudaq::qvector q1 = inState;
+  cudaq::qvector q1{inState};
 }
 
 __qpu__ void
 test_real_array_param_floating_point(std::vector<cudaq::real> inState) {
-  cudaq::qvector q1 = inState;
+  cudaq::qvector q1{inState};
 }
 
 void printCounts(cudaq::sample_result &result) {
   std::vector<std::string> values{};
-  for (auto &&[bits, counts] : result) {
+  for (auto &&[bits, counts] : result)
     values.push_back(bits);
-  }
 
   std::sort(values.begin(), values.end());
-  for (auto &&bits : values) {
+  for (auto &&bits : values)
     std::cout << bits << '\n';
-  }
 }
 
 int main() {
@@ -114,14 +103,16 @@ int main() {
   // CHECK: 10
 
   {
+    std::cout << "test4\n";
     auto counts = cudaq::sample(test_complex_constant_array2);
     printCounts(counts);
   }
 
-  // CHECK: 0001
-  // CHECK: 0011
-  // CHECK: 1001
-  // CHECK: 1011
+  // CHECK-LABEL: test4
+  // CHECK: 000
+  // CHECK: 011
+  // CHECK: 100
+  // CHECK: 111
 
   {
     auto counts = cudaq::sample(test_complex_constant_array3);
diff --git a/targettests/execution/state_preparation_vector_sizes.cpp b/targettests/execution/state_preparation_vector_sizes.cpp
index 97c32ecb8bc..b160cc991a8 100644
--- a/targettests/execution/state_preparation_vector_sizes.cpp
+++ b/targettests/execution/state_preparation_vector_sizes.cpp
@@ -7,21 +7,13 @@
  ******************************************************************************/
 
 // Simulators
-// RUN: nvq++ %cpp_std --enable-mlir  %s                             -o %t && %t | FileCheck %s
-
-// Quantum emulators
-// RUN: nvq++ %cpp_std --target quantinuum --emulate %s -o %t && %t | FileCheck %s
-// RUN: nvq++ %cpp_std --target ionq       --emulate %s -o %t && %t | FileCheck %s
-// RUN: nvq++ %cpp_std --target iqm        --emulate %s -o %t && IQM_QPU_QA=%iqm_tests_dir/Crystal_5.txt  %t | FileCheck %s
-// RUN: nvq++ %cpp_std --target oqc        --emulate %s -o %t && %t | FileCheck %s
-// RUN: if %braket_avail; then nvq++ %cpp_std --target braket --emulate %s -o %t && %t | FileCheck %s; fi
-// RUN: if %qci_avail; then nvq++ %cpp_std --target qci --emulate %s -o %t && %t | FileCheck %s; fi
+// RUN: nvq++ %s -o %t && %t | FileCheck %s
 
 #include <cudaq.h>
 #include <iostream>
 
 __qpu__ void test(std::vector<cudaq::complex> inState) {
-  cudaq::qvector q1 = inState;
+  cudaq::qvector q1{inState};
 }
 
 void printCounts(cudaq::sample_result &result) {
@@ -78,170 +70,234 @@ int main() {
 // CHECK:           state: (size: 4) { (0,0) (0,0) (0,0) (1,0) }
 // CHECK:           11
 
-// CHECK:           state: (size: 8) { (1,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) }
-// CHECK:           000
-
-// CHECK:           state: (size: 8) { (0,0) (1,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) }
-// CHECK:           001
-
-// CHECK:           state: (size: 8) { (0,0) (0,0) (1,0) (0,0) (0,0) (0,0) (0,0) (0,0) }
-// CHECK:           010
-
-// CHECK:           state: (size: 8) { (0,0) (0,0) (0,0) (1,0) (0,0) (0,0) (0,0) (0,0) }
-// CHECK:           011
-
-// CHECK:           state: (size: 8) { (0,0) (0,0) (0,0) (0,0) (1,0) (0,0) (0,0) (0,0) }
-// CHECK:           100
-
-// CHECK:           state: (size: 8) { (0,0) (0,0) (0,0) (0,0) (0,0) (1,0) (0,0) (0,0) }
-// CHECK:           101
-
-// CHECK:           state: (size: 8) { (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (1,0) (0,0) }
-// CHECK:           110
-
-// CHECK:           state: (size: 8) { (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (1,0) }
-// CHECK:           111
-
-// CHECK:           state: (size: 16) { (1,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) }
-// CHECK:           0000
-
-// CHECK:           state: (size: 16) { (0,0) (1,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) }
-// CHECK:           0001
-
-// CHECK:           state: (size: 16) { (0,0) (0,0) (1,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) }
-// CHECK:           0010
-
-// CHECK:           state: (size: 16) { (0,0) (0,0) (0,0) (1,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) }
-// CHECK:           0011
-
-// CHECK:           state: (size: 16) { (0,0) (0,0) (0,0) (0,0) (1,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) }
-// CHECK:           0100
-
-// CHECK:           state: (size: 16) { (0,0) (0,0) (0,0) (0,0) (0,0) (1,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) }
-// CHECK:           0101
-
-// CHECK:           state: (size: 16) { (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (1,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) }
-// CHECK:           0110
-
-// CHECK:           state: (size: 16) { (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (1,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) }
-// CHECK:           0111
-
-// CHECK:           state: (size: 16) { (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (1,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) }
-// CHECK:           1000
-
-// CHECK:           state: (size: 16) { (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (1,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) }
-// CHECK:           1001
-
-// CHECK:           state: (size: 16) { (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (1,0) (0,0) (0,0) (0,0) (0,0) (0,0) }
-// CHECK:           1010
-
-// CHECK:           state: (size: 16) { (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (1,0) (0,0) (0,0) (0,0) (0,0) }
-// CHECK:           1011
-
-// CHECK:           state: (size: 16) { (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (1,0) (0,0) (0,0) (0,0) }
-// CHECK:           1100
-
-// CHECK:           state: (size: 16) { (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (1,0) (0,0) (0,0) }
-// CHECK:           1101
-
-// CHECK:           state: (size: 16) { (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (1,0) (0,0) }
-// CHECK:           1110
-
-// CHECK:           state: (size: 16) { (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (1,0) }
-// CHECK:           1111
-
-// CHECK:           state: (size: 32) { (1,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) }
-// CHECK:           00000
-
-// CHECK:           state: (size: 32) { (0,0) (1,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) }
-// CHECK:           00001
+// CHECK:           state: (size: 8) { (1,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0)
+// (0,0) } CHECK:           000
 
-// CHECK:           state: (size: 32) { (0,0) (0,0) (1,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) }
-// CHECK:           00010
+// CHECK:           state: (size: 8) { (0,0) (1,0) (0,0) (0,0) (0,0) (0,0) (0,0)
+// (0,0) } CHECK:           001
 
-// CHECK:           state: (size: 32) { (0,0) (0,0) (0,0) (1,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) }
-// CHECK:           00011
+// CHECK:           state: (size: 8) { (0,0) (0,0) (1,0) (0,0) (0,0) (0,0) (0,0)
+// (0,0) } CHECK:           010
 
-// CHECK:           state: (size: 32) { (0,0) (0,0) (0,0) (0,0) (1,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) }
-// CHECK:           00100
+// CHECK:           state: (size: 8) { (0,0) (0,0) (0,0) (1,0) (0,0) (0,0) (0,0)
+// (0,0) } CHECK:           011
 
-// CHECK:           state: (size: 32) { (0,0) (0,0) (0,0) (0,0) (0,0) (1,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) }
-// CHECK:           00101
+// CHECK:           state: (size: 8) { (0,0) (0,0) (0,0) (0,0) (1,0) (0,0) (0,0)
+// (0,0) } CHECK:           100
 
-// CHECK:           state: (size: 32) { (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (1,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) }
-// CHECK:           00110
+// CHECK:           state: (size: 8) { (0,0) (0,0) (0,0) (0,0) (0,0) (1,0) (0,0)
+// (0,0) } CHECK:           101
 
-// CHECK:           state: (size: 32) { (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (1,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) }
-// CHECK:           00111
+// CHECK:           state: (size: 8) { (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (1,0)
+// (0,0) } CHECK:           110
 
-// CHECK:           state: (size: 32) { (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (1,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) }
-// CHECK:           01000
+// CHECK:           state: (size: 8) { (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0)
+// (1,0) } CHECK:           111
 
-// CHECK:           state: (size: 32) { (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (1,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) }
-// CHECK:           01001
+// CHECK:           state: (size: 16) { (1,0) (0,0) (0,0) (0,0) (0,0) (0,0)
+// (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) } CHECK: 0000
 
-// CHECK:           state: (size: 32) { (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (1,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) }
-// CHECK:           01010
+// CHECK:           state: (size: 16) { (0,0) (1,0) (0,0) (0,0) (0,0) (0,0)
+// (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) } CHECK: 0001
 
-// CHECK:           state: (size: 32) { (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (1,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) }
-// CHECK:           01011
+// CHECK:           state: (size: 16) { (0,0) (0,0) (1,0) (0,0) (0,0) (0,0)
+// (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) } CHECK: 0010
 
-// CHECK:           state: (size: 32) { (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (1,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) }
-// CHECK:           01100
+// CHECK:           state: (size: 16) { (0,0) (0,0) (0,0) (1,0) (0,0) (0,0)
+// (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) } CHECK: 0011
 
-// CHECK:           state: (size: 32) { (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (1,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) }
-// CHECK:           01101
+// CHECK:           state: (size: 16) { (0,0) (0,0) (0,0) (0,0) (1,0) (0,0)
+// (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) } CHECK: 0100
 
-// CHECK:           state: (size: 32) { (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (1,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) }
-// CHECK:           01110
+// CHECK:           state: (size: 16) { (0,0) (0,0) (0,0) (0,0) (0,0) (1,0)
+// (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) } CHECK: 0101
 
-// CHECK:           state: (size: 32) { (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (1,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) }
-// CHECK:           01111
+// CHECK:           state: (size: 16) { (0,0) (0,0) (0,0) (0,0) (0,0) (0,0)
+// (1,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) } CHECK: 0110
 
-// CHECK:           state: (size: 32) { (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (1,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) }
-// CHECK:           10000
+// CHECK:           state: (size: 16) { (0,0) (0,0) (0,0) (0,0) (0,0) (0,0)
+// (0,0) (1,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) } CHECK: 0111
 
-// CHECK:           state: (size: 32) { (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (1,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) }
-// CHECK:           10001
+// CHECK:           state: (size: 16) { (0,0) (0,0) (0,0) (0,0) (0,0) (0,0)
+// (0,0) (0,0) (1,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) } CHECK: 1000
 
-// CHECK:           state: (size: 32) { (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (1,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) }
-// CHECK:           10010
+// CHECK:           state: (size: 16) { (0,0) (0,0) (0,0) (0,0) (0,0) (0,0)
+// (0,0) (0,0) (0,0) (1,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) } CHECK: 1001
 
-// CHECK:           state: (size: 32) { (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (1,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) }
-// CHECK:           10011
+// CHECK:           state: (size: 16) { (0,0) (0,0) (0,0) (0,0) (0,0) (0,0)
+// (0,0) (0,0) (0,0) (0,0) (1,0) (0,0) (0,0) (0,0) (0,0) (0,0) } CHECK: 1010
 
-// CHECK:           state: (size: 32) { (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (1,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) }
-// CHECK:           10100
+// CHECK:           state: (size: 16) { (0,0) (0,0) (0,0) (0,0) (0,0) (0,0)
+// (0,0) (0,0) (0,0) (0,0) (0,0) (1,0) (0,0) (0,0) (0,0) (0,0) } CHECK: 1011
 
-// CHECK:           state: (size: 32) { (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (1,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) }
-// CHECK:           10101
+// CHECK:           state: (size: 16) { (0,0) (0,0) (0,0) (0,0) (0,0) (0,0)
+// (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (1,0) (0,0) (0,0) (0,0) } CHECK: 1100
 
-// CHECK:           state: (size: 32) { (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (1,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) }
-// CHECK:           10110
+// CHECK:           state: (size: 16) { (0,0) (0,0) (0,0) (0,0) (0,0) (0,0)
+// (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (1,0) (0,0) (0,0) } CHECK: 1101
 
-// CHECK:           state: (size: 32) { (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (1,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) }
-// CHECK:           10111
+// CHECK:           state: (size: 16) { (0,0) (0,0) (0,0) (0,0) (0,0) (0,0)
+// (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (1,0) (0,0) } CHECK: 1110
 
-// CHECK:           state: (size: 32) { (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (1,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) }
-// CHECK:           11000
+// CHECK:           state: (size: 16) { (0,0) (0,0) (0,0) (0,0) (0,0) (0,0)
+// (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (1,0) } CHECK: 1111
 
-// CHECK:           state: (size: 32) { (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (1,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) }
-// CHECK:           11001
+// CHECK:           state: (size: 32) { (1,0) (0,0) (0,0) (0,0) (0,0) (0,0)
+// (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0)
+// (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0)
+// } CHECK:           00000
 
-// CHECK:           state: (size: 32) { (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (1,0) (0,0) (0,0) (0,0) (0,0) (0,0) }
-// CHECK:           11010
+// CHECK:           state: (size: 32) { (0,0) (1,0) (0,0) (0,0) (0,0) (0,0)
+// (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0)
+// (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0)
+// } CHECK:           00001
 
-// CHECK:           state: (size: 32) { (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (1,0) (0,0) (0,0) (0,0) (0,0) }
-// CHECK:           11011
+// CHECK:           state: (size: 32) { (0,0) (0,0) (1,0) (0,0) (0,0) (0,0)
+// (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0)
+// (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0)
+// } CHECK:           00010
 
-// CHECK:           state: (size: 32) { (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (1,0) (0,0) (0,0) (0,0) }
-// CHECK:           11100
+// CHECK:           state: (size: 32) { (0,0) (0,0) (0,0) (1,0) (0,0) (0,0)
+// (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0)
+// (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0)
+// } CHECK:           00011
 
-// CHECK:           state: (size: 32) { (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (1,0) (0,0) (0,0) }
-// CHECK:           11101
+// CHECK:           state: (size: 32) { (0,0) (0,0) (0,0) (0,0) (1,0) (0,0)
+// (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0)
+// (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0)
+// } CHECK:           00100
 
-// CHECK:           state: (size: 32) { (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (1,0) (0,0) }
-// CHECK:           11110
+// CHECK:           state: (size: 32) { (0,0) (0,0) (0,0) (0,0) (0,0) (1,0)
+// (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0)
+// (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0)
+// } CHECK:           00101
 
-// CHECK:           state: (size: 32) { (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (1,0) }
-// CHECK:           11111
+// CHECK:           state: (size: 32) { (0,0) (0,0) (0,0) (0,0) (0,0) (0,0)
+// (1,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0)
+// (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0)
+// } CHECK:           00110
+
+// CHECK:           state: (size: 32) { (0,0) (0,0) (0,0) (0,0) (0,0) (0,0)
+// (0,0) (1,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0)
+// (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0)
+// } CHECK:           00111
+
+// CHECK:           state: (size: 32) { (0,0) (0,0) (0,0) (0,0) (0,0) (0,0)
+// (0,0) (0,0) (1,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0)
+// (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0)
+// } CHECK:           01000
+
+// CHECK:           state: (size: 32) { (0,0) (0,0) (0,0) (0,0) (0,0) (0,0)
+// (0,0) (0,0) (0,0) (1,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0)
+// (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0)
+// } CHECK:           01001
+
+// CHECK:           state: (size: 32) { (0,0) (0,0) (0,0) (0,0) (0,0) (0,0)
+// (0,0) (0,0) (0,0) (0,0) (1,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0)
+// (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0)
+// } CHECK:           01010
+
+// CHECK:           state: (size: 32) { (0,0) (0,0) (0,0) (0,0) (0,0) (0,0)
+// (0,0) (0,0) (0,0) (0,0) (0,0) (1,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0)
+// (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0)
+// } CHECK:           01011
+
+// CHECK:           state: (size: 32) { (0,0) (0,0) (0,0) (0,0) (0,0) (0,0)
+// (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (1,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0)
+// (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0)
+// } CHECK:           01100
+
+// CHECK:           state: (size: 32) { (0,0) (0,0) (0,0) (0,0) (0,0) (0,0)
+// (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (1,0) (0,0) (0,0) (0,0) (0,0) (0,0)
+// (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0)
+// } CHECK:           01101
+
+// CHECK:           state: (size: 32) { (0,0) (0,0) (0,0) (0,0) (0,0) (0,0)
+// (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (1,0) (0,0) (0,0) (0,0) (0,0)
+// (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0)
+// } CHECK:           01110
+
+// CHECK:           state: (size: 32) { (0,0) (0,0) (0,0) (0,0) (0,0) (0,0)
+// (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (1,0) (0,0) (0,0) (0,0)
+// (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0)
+// } CHECK:           01111
+
+// CHECK:           state: (size: 32) { (0,0) (0,0) (0,0) (0,0) (0,0) (0,0)
+// (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (1,0) (0,0) (0,0)
+// (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0)
+// } CHECK:           10000
+
+// CHECK:           state: (size: 32) { (0,0) (0,0) (0,0) (0,0) (0,0) (0,0)
+// (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (1,0) (0,0)
+// (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0)
+// } CHECK:           10001
+
+// CHECK:           state: (size: 32) { (0,0) (0,0) (0,0) (0,0) (0,0) (0,0)
+// (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (1,0)
+// (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0)
+// } CHECK:           10010
+
+// CHECK:           state: (size: 32) { (0,0) (0,0) (0,0) (0,0) (0,0) (0,0)
+// (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0)
+// (1,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0)
+// } CHECK:           10011
+
+// CHECK:           state: (size: 32) { (0,0) (0,0) (0,0) (0,0) (0,0) (0,0)
+// (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0)
+// (0,0) (1,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0)
+// } CHECK:           10100
+
+// CHECK:           state: (size: 32) { (0,0) (0,0) (0,0) (0,0) (0,0) (0,0)
+// (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0)
+// (0,0) (0,0) (1,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0)
+// } CHECK:           10101
+
+// CHECK:           state: (size: 32) { (0,0) (0,0) (0,0) (0,0) (0,0) (0,0)
+// (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0)
+// (0,0) (0,0) (0,0) (1,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0)
+// } CHECK:           10110
+
+// CHECK:           state: (size: 32) { (0,0) (0,0) (0,0) (0,0) (0,0) (0,0)
+// (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0)
+// (0,0) (0,0) (0,0) (0,0) (1,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0)
+// } CHECK:           10111
+
+// CHECK:           state: (size: 32) { (0,0) (0,0) (0,0) (0,0) (0,0) (0,0)
+// (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0)
+// (0,0) (0,0) (0,0) (0,0) (0,0) (1,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0)
+// } CHECK:           11000
+
+// CHECK:           state: (size: 32) { (0,0) (0,0) (0,0) (0,0) (0,0) (0,0)
+// (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0)
+// (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (1,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0)
+// } CHECK:           11001
+
+// CHECK:           state: (size: 32) { (0,0) (0,0) (0,0) (0,0) (0,0) (0,0)
+// (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0)
+// (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (1,0) (0,0) (0,0) (0,0) (0,0) (0,0)
+// } CHECK:           11010
+
+// CHECK:           state: (size: 32) { (0,0) (0,0) (0,0) (0,0) (0,0) (0,0)
+// (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0)
+// (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (1,0) (0,0) (0,0) (0,0) (0,0)
+// } CHECK:           11011
+
+// CHECK:           state: (size: 32) { (0,0) (0,0) (0,0) (0,0) (0,0) (0,0)
+// (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0)
+// (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (1,0) (0,0) (0,0) (0,0)
+// } CHECK:           11100
+
+// CHECK:           state: (size: 32) { (0,0) (0,0) (0,0) (0,0) (0,0) (0,0)
+// (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0)
+// (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (1,0) (0,0) (0,0)
+// } CHECK:           11101
+
+// CHECK:           state: (size: 32) { (0,0) (0,0) (0,0) (0,0) (0,0) (0,0)
+// (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0)
+// (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (1,0) (0,0)
+// } CHECK:           11110
+
+// CHECK:           state: (size: 32) { (0,0) (0,0) (0,0) (0,0) (0,0) (0,0)
+// (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0)
+// (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (1,0)
+// } CHECK:           11111
diff --git a/targettests/infleqtion/state_preparation.cpp b/targettests/infleqtion/state_preparation.cpp
deleted file mode 100644
index 819a4503f37..00000000000
--- a/targettests/infleqtion/state_preparation.cpp
+++ /dev/null
@@ -1,10 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2025 NVIDIA Corporation & Affiliates.                         *
- * All rights reserved.                                                        *
- *                                                                             *
- * This source code and the accompanying materials are made available under    *
- * the terms of the Apache License 2.0 which accompanies this distribution.    *
- ******************************************************************************/
-
-// RUN: echo skipping
-#include "../execution/state_preparation.cpp"
diff --git a/targettests/ionq/state_preparation.cpp b/targettests/ionq/state_preparation.cpp
deleted file mode 100644
index 819a4503f37..00000000000
--- a/targettests/ionq/state_preparation.cpp
+++ /dev/null
@@ -1,10 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2025 NVIDIA Corporation & Affiliates.                         *
- * All rights reserved.                                                        *
- *                                                                             *
- * This source code and the accompanying materials are made available under    *
- * the terms of the Apache License 2.0 which accompanies this distribution.    *
- ******************************************************************************/
-
-// RUN: echo skipping
-#include "../execution/state_preparation.cpp"
diff --git a/targettests/qci/state_preparation.cpp b/targettests/qci/state_preparation.cpp
deleted file mode 100644
index 819a4503f37..00000000000
--- a/targettests/qci/state_preparation.cpp
+++ /dev/null
@@ -1,10 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2025 NVIDIA Corporation & Affiliates.                         *
- * All rights reserved.                                                        *
- *                                                                             *
- * This source code and the accompanying materials are made available under    *
- * the terms of the Apache License 2.0 which accompanies this distribution.    *
- ******************************************************************************/
-
-// RUN: echo skipping
-#include "../execution/state_preparation.cpp"
diff --git a/targettests/quantinuum/state_preparation.cpp b/targettests/quantinuum/state_preparation.cpp
deleted file mode 100644
index 66fad4930e0..00000000000
--- a/targettests/quantinuum/state_preparation.cpp
+++ /dev/null
@@ -1,10 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2025 NVIDIA Corporation & Affiliates.                         *
- * All rights reserved.                                                        *
- *                                                                             *
- * This source code and the accompanying materials are made available under    *
- * the terms of the Apache License 2.0 which accompanies this distribution.    *
- ******************************************************************************/
-
-// RUN: nvq++ %cpp_std --target quantinuum --emulate %s -o %t && echo skipping
-#include "../execution/state_preparation.cpp"
diff --git a/targettests/quantum_machines/state_preparation.cpp b/targettests/quantum_machines/state_preparation.cpp
deleted file mode 100644
index 819a4503f37..00000000000
--- a/targettests/quantum_machines/state_preparation.cpp
+++ /dev/null
@@ -1,10 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2025 NVIDIA Corporation & Affiliates.                         *
- * All rights reserved.                                                        *
- *                                                                             *
- * This source code and the accompanying materials are made available under    *
- * the terms of the Apache License 2.0 which accompanies this distribution.    *
- ******************************************************************************/
-
-// RUN: echo skipping
-#include "../execution/state_preparation.cpp"
diff --git a/test/AST-Quake/initialization_list.cpp b/test/AST-Quake/initialization_list.cpp
index 591a08de5a8..4dfa0770421 100644
--- a/test/AST-Quake/initialization_list.cpp
+++ b/test/AST-Quake/initialization_list.cpp
@@ -6,18 +6,35 @@
  * the terms of the Apache License 2.0 which accompanies this distribution.    *
  ******************************************************************************/
 
-// RUN: cudaq-quake %cpp_std %s | cudaq-opt | FileCheck %s
+// RUN: cudaq-quake %s | cudaq-opt | FileCheck %s
 
 #include <cudaq.h>
 
 __qpu__ void f() {
-   cudaq::qvector v = {1.0, 2.0, 3.0, 4.0};
+   cudaq::qvector v = cudaq::state{1.0, 2.0, 3.0, 4.0};
 }
 
 // CHECK-LABEL:   func.func @__nvqpp__mlirgen__function_f._Z1fv() attributes {"cudaq-entrypoint", "cudaq-kernel", no_this} {
-// CHECK:           %[[VAL_0:.*]] = cc.address_of @__nvqpp__rodata_init_0 : !cc.ptr<!cc.array<f64 x 4>>
-// CHECK:           %[[VAL_1:.*]] = quake.alloca !quake.veq<2>
-// CHECK:           %[[VAL_2:.*]] = quake.init_state %[[VAL_1]], %[[VAL_0]] : (!quake.veq<2>, !cc.ptr<!cc.array<f64 x 4>>) -> !quake.veq<2>
+// CHECK:           %[[VAL_0:.*]] = arith.constant 1.000000e+00 : f64
+// CHECK:           %[[VAL_1:.*]] = arith.constant 2.000000e+00 : f64
+// CHECK:           %[[VAL_2:.*]] = arith.constant 3.000000e+00 : f64
+// CHECK:           %[[VAL_3:.*]] = arith.constant 4.000000e+00 : f64
+// CHECK:           %[[VAL_4:.*]] = arith.constant 4 : i64
+// CHECK:           %[[VAL_5:.*]] = cc.alloca !cc.array<f64 x 4>
+// CHECK:           %[[VAL_6:.*]] = cc.cast %[[VAL_5]] : (!cc.ptr<!cc.array<f64 x 4>>) -> !cc.ptr<!cc.array<f64 x ?>>
+// CHECK:           %[[VAL_7:.*]] = cc.cast %[[VAL_5]] : (!cc.ptr<!cc.array<f64 x 4>>) -> !cc.ptr<f64>
+// CHECK:           cc.store %[[VAL_0]], %[[VAL_7]] : !cc.ptr<f64>
+// CHECK:           %[[VAL_8:.*]] = cc.compute_ptr %[[VAL_5]][1] : (!cc.ptr<!cc.array<f64 x 4>>) -> !cc.ptr<f64>
+// CHECK:           cc.store %[[VAL_1]], %[[VAL_8]] : !cc.ptr<f64>
+// CHECK:           %[[VAL_9:.*]] = cc.compute_ptr %[[VAL_5]][2] : (!cc.ptr<!cc.array<f64 x 4>>) -> !cc.ptr<f64>
+// CHECK:           cc.store %[[VAL_2]], %[[VAL_9]] : !cc.ptr<f64>
+// CHECK:           %[[VAL_10:.*]] = cc.compute_ptr %[[VAL_5]][3] : (!cc.ptr<!cc.array<f64 x 4>>) -> !cc.ptr<f64>
+// CHECK:           cc.store %[[VAL_3]], %[[VAL_10]] : !cc.ptr<f64>
+// CHECK:           %[[VAL_11:.*]] = quake.create_state %[[VAL_6]], %[[VAL_4]] : (!cc.ptr<!cc.array<f64 x ?>>, i64) -> !cc.ptr<!quake.state>
+// CHECK:           %[[VAL_12:.*]] = quake.get_number_of_qubits %[[VAL_11]] : (!cc.ptr<!quake.state>) -> i64
+// CHECK:           %[[VAL_13:.*]] = quake.alloca !quake.veq<?>{{\[}}%[[VAL_12]] : i64]
+// CHECK:           %[[VAL_14:.*]] = quake.init_state %[[VAL_13]], %[[VAL_11]] : (!quake.veq<?>, !cc.ptr<!quake.state>) -> !quake.veq<?>
+// CHECK:           quake.delete_state %[[VAL_11]] : !cc.ptr<!quake.state>
 // CHECK:           return
 // CHECK:         }
 
@@ -44,5 +61,3 @@ __qpu__ void g() {
 // CHECK:           return
 // CHECK:         }
 
-// CHECK:         cc.global constant private @__nvqpp__rodata_init_0 (dense<[1.000000e+00, 2.000000e+00, 3.000000e+00, 4.000000e+00]> : tensor<4xf64>) : !cc.array<f64 x 4>
-
diff --git a/test/AST-Quake/qalloc_initialization.cpp b/test/AST-Quake/qalloc_initialization.cpp
index 649337d2042..2856bd4e475 100644
--- a/test/AST-Quake/qalloc_initialization.cpp
+++ b/test/AST-Quake/qalloc_initialization.cpp
@@ -7,8 +7,8 @@
  ******************************************************************************/
 
 // clang-format off
-// RUN: cudaq-quake -D CUDAQ_SIMULATION_SCALAR_FP64 %cpp_std %s | cudaq-opt | FileCheck %s
-// RUN: cudaq-quake -D CUDAQ_SIMULATION_SCALAR_FP64 %cpp_std %s | cudaq-opt | cudaq-translate --convert-to=qir | FileCheck --check-prefix=QIR %s
+// RUN: cudaq-quake -D CUDAQ_SIMULATION_SCALAR_FP64 %s | cudaq-opt | FileCheck %s
+// RUN: cudaq-quake -D CUDAQ_SIMULATION_SCALAR_FP64 %s | cudaq-opt | cudaq-translate --convert-to=qir | FileCheck --check-prefix=QIR %s
 // clang-format on
 
 // Test various flavors of qubits declared with initial state information.
@@ -17,7 +17,7 @@
 
 struct Vanilla {
   std::vector<bool> operator()() __qpu__ {
-    cudaq::qvector v = {0., 1., 1., 0.};
+    cudaq::qvector v{cudaq::state{0., 1., 1., 0.}};
     h(v);
     return mz(v);
   }
@@ -25,17 +25,71 @@ struct Vanilla {
 
 // clang-format off
 // CHECK-LABEL:   func.func @__nvqpp__mlirgen__Vanilla() -> !cc.stdvec<i1> attributes {"cudaq-entrypoint", "cudaq-kernel"} {
-// CHECK-DAG:       %[[VAL_0:.*]] = arith.constant 1 : i64
-// CHECK-DAG:       %[[VAL_3:.*]] = cc.address_of @__nvqpp__rodata_init_0 : !cc.ptr<!cc.array<f64 x 4>>
-// CHECK:           %[[VAL_4:.*]] = quake.alloca !quake.veq<2>
-// CHECK:           %[[VAL_5:.*]] = quake.init_state %[[VAL_4]], %[[VAL_3]] : (!quake.veq<2>, !cc.ptr<!cc.array<f64 x 4>>) -> !quake.veq<2>
+// CHECK:           %[[VAL_0:.*]] = arith.constant 1 : i64
+// CHECK:           %[[VAL_1:.*]] = arith.constant 0 : i64
+// CHECK:           %[[VAL_2:.*]] = arith.constant 0.000000e+00 : f64
+// CHECK:           %[[VAL_3:.*]] = arith.constant 1.000000e+00 : f64
+// CHECK:           %[[VAL_4:.*]] = arith.constant 4 : i64
+// CHECK:           %[[VAL_5:.*]] = cc.alloca !cc.array<f64 x 4>
+// CHECK:           %[[VAL_6:.*]] = cc.cast %[[VAL_5]] : (!cc.ptr<!cc.array<f64 x 4>>) -> !cc.ptr<!cc.array<f64 x ?>>
+// CHECK:           %[[VAL_7:.*]] = cc.cast %[[VAL_5]] : (!cc.ptr<!cc.array<f64 x 4>>) -> !cc.ptr<f64>
+// CHECK:           cc.store %[[VAL_2]], %[[VAL_7]] : !cc.ptr<f64>
+// CHECK:           %[[VAL_8:.*]] = cc.compute_ptr %[[VAL_5]][1] : (!cc.ptr<!cc.array<f64 x 4>>) -> !cc.ptr<f64>
+// CHECK:           cc.store %[[VAL_3]], %[[VAL_8]] : !cc.ptr<f64>
+// CHECK:           %[[VAL_9:.*]] = cc.compute_ptr %[[VAL_5]][2] : (!cc.ptr<!cc.array<f64 x 4>>) -> !cc.ptr<f64>
+// CHECK:           cc.store %[[VAL_3]], %[[VAL_9]] : !cc.ptr<f64>
+// CHECK:           %[[VAL_10:.*]] = cc.compute_ptr %[[VAL_5]][3] : (!cc.ptr<!cc.array<f64 x 4>>) -> !cc.ptr<f64>
+// CHECK:           cc.store %[[VAL_2]], %[[VAL_10]] : !cc.ptr<f64>
+// CHECK:           %[[VAL_11:.*]] = quake.create_state %[[VAL_6]], %[[VAL_4]] : (!cc.ptr<!cc.array<f64 x ?>>, i64) -> !cc.ptr<!quake.state>
+// CHECK:           %[[VAL_12:.*]] = quake.get_number_of_qubits %[[VAL_11]] : (!cc.ptr<!quake.state>) -> i64
+// CHECK:           %[[VAL_13:.*]] = quake.alloca !quake.veq<?>{{\[}}%[[VAL_12]] : i64]
+// CHECK:           %[[VAL_14:.*]] = quake.init_state %[[VAL_13]], %[[VAL_11]] : (!quake.veq<?>, !cc.ptr<!quake.state>) -> !quake.veq<?>
+// CHECK:           quake.delete_state %[[VAL_11]] : !cc.ptr<!quake.state>
+// CHECK:           %[[VAL_15:.*]] = quake.veq_size %[[VAL_14]] : (!quake.veq<?>) -> i64
+// CHECK:           return %{{.*}} : !cc.stdvec<i1>
+// CHECK:         }
+// clang-format on
+
+struct VanillaBean {
+  std::vector<bool> operator()() __qpu__ {
+    cudaq::qvector v = cudaq::state{0., 1., 1., 0.};
+    h(v);
+    return mz(v);
+  }
+};
+
+// clang-format off
+// CHECK-LABEL:   func.func @__nvqpp__mlirgen__VanillaBean() -> !cc.stdvec<i1> attributes {"cudaq-entrypoint", "cudaq-kernel"} {
+// CHECK:           %[[VAL_0:.*]] = arith.constant 1 : i64
+// CHECK:           %[[VAL_1:.*]] = arith.constant 0 : i64
+// CHECK:           %[[VAL_2:.*]] = arith.constant 0.000000e+00 : f64
+// CHECK:           %[[VAL_3:.*]] = arith.constant 1.000000e+00 : f64
+// CHECK:           %[[VAL_4:.*]] = arith.constant 4 : i64
+// CHECK:           %[[VAL_5:.*]] = cc.alloca !cc.array<f64 x 4>
+// CHECK:           %[[VAL_6:.*]] = cc.cast %[[VAL_5]] : (!cc.ptr<!cc.array<f64 x 4>>) -> !cc.ptr<!cc.array<f64 x ?>>
+// CHECK:           %[[VAL_7:.*]] = cc.cast %[[VAL_5]] : (!cc.ptr<!cc.array<f64 x 4>>) -> !cc.ptr<f64>
+// CHECK:           cc.store %[[VAL_2]], %[[VAL_7]] : !cc.ptr<f64>
+// CHECK:           %[[VAL_8:.*]] = cc.compute_ptr %[[VAL_5]][1] : (!cc.ptr<!cc.array<f64 x 4>>) -> !cc.ptr<f64>
+// CHECK:           cc.store %[[VAL_3]], %[[VAL_8]] : !cc.ptr<f64>
+// CHECK:           %[[VAL_9:.*]] = cc.compute_ptr %[[VAL_5]][2] : (!cc.ptr<!cc.array<f64 x 4>>) -> !cc.ptr<f64>
+// CHECK:           cc.store %[[VAL_3]], %[[VAL_9]] : !cc.ptr<f64>
+// CHECK:           %[[VAL_10:.*]] = cc.compute_ptr %[[VAL_5]][3] : (!cc.ptr<!cc.array<f64 x 4>>) -> !cc.ptr<f64>
+// CHECK:           cc.store %[[VAL_2]], %[[VAL_10]] : !cc.ptr<f64>
+// CHECK:           %[[VAL_11:.*]] = quake.create_state %[[VAL_6]], %[[VAL_4]] : (!cc.ptr<!cc.array<f64 x ?>>, i64) -> !cc.ptr<!quake.state>
+// CHECK:           %[[VAL_12:.*]] = quake.get_number_of_qubits %[[VAL_11]] : (!cc.ptr<!quake.state>) -> i64
+// CHECK:           %[[VAL_13:.*]] = quake.alloca !quake.veq<?>{{\[}}%[[VAL_12]] : i64]
+// CHECK:           %[[VAL_14:.*]] = quake.init_state %[[VAL_13]], %[[VAL_11]] : (!quake.veq<?>, !cc.ptr<!quake.state>) -> !quake.veq<?>
+// CHECK:           quake.delete_state %[[VAL_11]] : !cc.ptr<!quake.state>
+// CHECK:           %[[VAL_15:.*]] = quake.veq_size %[[VAL_14]] : (!quake.veq<?>) -> i64
+// CHECK:           return %{{.*}} : !cc.stdvec<i1>
+// CHECK:         }
 // clang-format on
 
 struct Cherry {
   std::vector<bool> operator()() __qpu__ {
     using namespace std::complex_literals;
-    cudaq::qvector v = std::initializer_list<std::complex<double>>{
-        {0.0, 1.0}, {0.6, 0.4}, {1.0, 0.0}, {0.0, 0.0}};
+    cudaq::qvector v{{std::initializer_list<std::complex<double>>{
+        {0.0, 1.0}, {0.6, 0.4}, {1.0, 0.0}, {0.0, 0.0}}}};
     h(v);
     return mz(v);
   }
@@ -43,32 +97,39 @@ struct Cherry {
 
 // clang-format off
 // CHECK-LABEL:   func.func @__nvqpp__mlirgen__Cherry() -> !cc.stdvec<i1> attributes {"cudaq-entrypoint", "cudaq-kernel"} {
-// CHECK-DAG:       %[[VAL_0:.*]] = arith.constant 2 : i64
-// CHECK-DAG:       %[[VAL_1:.*]] = complex.constant [0.000000e+00, 0.000000e+00] : complex<f64>
-// CHECK-DAG:       %[[VAL_2:.*]] = complex.constant [1.000000e+00, 0.000000e+00] : complex<f64>
-// CHECK-DAG:       %[[VAL_3:.*]] = complex.constant [6.000000e-01, 4.000000e-01] : complex<f64>
-// CHECK-DAG:       %[[VAL_4:.*]] = complex.constant [0.000000e+00, 1.000000e+00] : complex<f64>
-// CHECK-DAG:       %[[VAL_5:.*]] = arith.constant 1 : i64
-// CHECK-DAG:       %[[VAL_6:.*]] = arith.constant 0 : i64
-// CHECK-DAG:       %[[VAL_7:.*]] = cc.alloca !cc.array<complex<f64> x 4>
-// CHECK:           %[[VAL_8:.*]] = cc.cast %[[VAL_7]] : (!cc.ptr<!cc.array<complex<f64> x 4>>) -> !cc.ptr<complex<f64>>
-// CHECK:           cc.store %[[VAL_4]], %[[VAL_8]] : !cc.ptr<complex<f64>>
-// CHECK:           %[[VAL_9:.*]] = cc.compute_ptr %[[VAL_7]][1] : (!cc.ptr<!cc.array<complex<f64> x 4>>) -> !cc.ptr<complex<f64>>
+// CHECK:           %[[VAL_0:.*]] = complex.constant [0.000000e+00, 0.000000e+00] : complex<f64>
+// CHECK:           %[[VAL_1:.*]] = complex.constant [1.000000e+00, 0.000000e+00] : complex<f64>
+// CHECK:           %[[VAL_2:.*]] = complex.constant [6.000000e-01, 4.000000e-01] : complex<f64>
+// CHECK:           %[[VAL_3:.*]] = complex.constant [0.000000e+00, 1.000000e+00] : complex<f64>
+// CHECK:           %[[VAL_4:.*]] = arith.constant 1 : i64
+// CHECK:           %[[VAL_5:.*]] = arith.constant 0 : i64
+// CHECK:           %[[VAL_6:.*]] = arith.constant 4 : i64
+// CHECK:           %[[VAL_7:.*]] = cc.alloca !cc.array<complex<f64> x 4>
+// CHECK:           %[[VAL_8:.*]] = cc.cast %[[VAL_7]] : (!cc.ptr<!cc.array<complex<f64> x 4>>) -> !cc.ptr<!cc.array<complex<f64> x ?>>
+// CHECK:           %[[VAL_9:.*]] = cc.cast %[[VAL_7]] : (!cc.ptr<!cc.array<complex<f64> x 4>>) -> !cc.ptr<complex<f64>>
 // CHECK:           cc.store %[[VAL_3]], %[[VAL_9]] : !cc.ptr<complex<f64>>
-// CHECK:           %[[VAL_10:.*]] = cc.compute_ptr %[[VAL_7]][2] : (!cc.ptr<!cc.array<complex<f64> x 4>>) -> !cc.ptr<complex<f64>>
+// CHECK:           %[[VAL_10:.*]] = cc.compute_ptr %[[VAL_7]][1] : (!cc.ptr<!cc.array<complex<f64> x 4>>) -> !cc.ptr<complex<f64>>
 // CHECK:           cc.store %[[VAL_2]], %[[VAL_10]] : !cc.ptr<complex<f64>>
-// CHECK:           %[[VAL_11:.*]] = cc.compute_ptr %[[VAL_7]][3] : (!cc.ptr<!cc.array<complex<f64> x 4>>) -> !cc.ptr<complex<f64>>
+// CHECK:           %[[VAL_11:.*]] = cc.compute_ptr %[[VAL_7]][2] : (!cc.ptr<!cc.array<complex<f64> x 4>>) -> !cc.ptr<complex<f64>>
 // CHECK:           cc.store %[[VAL_1]], %[[VAL_11]] : !cc.ptr<complex<f64>>
-// CHECK:           %[[VAL_12:.*]] = quake.alloca !quake.veq<2>
-// CHECK:           %[[VAL_13:.*]] = quake.init_state %[[VAL_12]], %[[VAL_7]] : (!quake.veq<2>, !cc.ptr<!cc.array<complex<f64> x 4>>) -> !quake.veq<2>
+// CHECK:           %[[VAL_12:.*]] = cc.compute_ptr %[[VAL_7]][3] : (!cc.ptr<!cc.array<complex<f64> x 4>>) -> !cc.ptr<complex<f64>>
+// CHECK:           cc.store %[[VAL_0]], %[[VAL_12]] : !cc.ptr<complex<f64>>
+// CHECK:           %[[VAL_13:.*]] = quake.create_state %[[VAL_8]], %[[VAL_6]] : (!cc.ptr<!cc.array<complex<f64> x ?>>, i64) -> !cc.ptr<!quake.state>
+// CHECK:           %[[VAL_14:.*]] = quake.get_number_of_qubits %[[VAL_13]] : (!cc.ptr<!quake.state>) -> i64
+// CHECK:           %[[VAL_15:.*]] = quake.alloca !quake.veq<?>{{\[}}%[[VAL_14]] : i64]
+// CHECK:           %[[VAL_16:.*]] = quake.init_state %[[VAL_15]], %[[VAL_13]] : (!quake.veq<?>, !cc.ptr<!quake.state>) -> !quake.veq<?>
+// CHECK:           quake.delete_state %[[VAL_13]] : !cc.ptr<!quake.state>
+// CHECK:           %[[VAL_17:.*]] = quake.veq_size %[[VAL_16]] : (!quake.veq<?>) -> i64
+// CHECK:           return %{{.*}} : !cc.stdvec<i1>
+// CHECK:         }
 // clang-format on
 
 struct MooseTracks {
   std::vector<bool> operator()() __qpu__ {
     using namespace std::complex_literals;
-    cudaq::qvector v = {
-        std::complex<double>{0.0, 1.0}, std::complex<double>{0.75, 0.25},
-        std::complex<double>{1.0, 0.0}, std::complex<double>{0.0, 0.0}};
+    cudaq::qvector v{
+        {std::complex<double>{0.0, 1.0}, std::complex<double>{0.75, 0.25},
+         std::complex<double>{1.0, 0.0}, std::complex<double>{0.0, 0.0}}};
     h(v);
     return mz(v);
   }
@@ -76,31 +137,38 @@ struct MooseTracks {
 
 // clang-format off
 // CHECK-LABEL:   func.func @__nvqpp__mlirgen__MooseTracks() -> !cc.stdvec<i1> attributes {"cudaq-entrypoint", "cudaq-kernel"} {
-// CHECK-DAG:       %[[VAL_0:.*]] = arith.constant 2 : i64
-// CHECK-DAG:       %[[VAL_1:.*]] = complex.constant [0.000000e+00, 0.000000e+00] : complex<f64>
-// CHECK-DAG:       %[[VAL_2:.*]] = complex.constant [1.000000e+00, 0.000000e+00] : complex<f64>
-// CHECK-DAG:       %[[VAL_3:.*]] = complex.constant [7.500000e-01, 2.500000e-01] : complex<f64>
-// CHECK-DAG:       %[[VAL_4:.*]] = complex.constant [0.000000e+00, 1.000000e+00] : complex<f64>
-// CHECK-DAG:       %[[VAL_5:.*]] = arith.constant 1 : i64
-// CHECK-DAG:       %[[VAL_6:.*]] = arith.constant 0 : i64
-// CHECK-DAG:       %[[VAL_7:.*]] = cc.alloca !cc.array<complex<f64> x 4>
-// CHECK:           %[[VAL_8:.*]] = cc.cast %[[VAL_7]] : (!cc.ptr<!cc.array<complex<f64> x 4>>) -> !cc.ptr<complex<f64>>
-// CHECK:           cc.store %[[VAL_4]], %[[VAL_8]] : !cc.ptr<complex<f64>>
-// CHECK:           %[[VAL_9:.*]] = cc.compute_ptr %[[VAL_7]][1] : (!cc.ptr<!cc.array<complex<f64> x 4>>) -> !cc.ptr<complex<f64>>
+// CHECK:           %[[VAL_0:.*]] = complex.constant [0.000000e+00, 0.000000e+00] : complex<f64>
+// CHECK:           %[[VAL_1:.*]] = complex.constant [1.000000e+00, 0.000000e+00] : complex<f64>
+// CHECK:           %[[VAL_2:.*]] = complex.constant [7.500000e-01, 2.500000e-01] : complex<f64>
+// CHECK:           %[[VAL_3:.*]] = complex.constant [0.000000e+00, 1.000000e+00] : complex<f64>
+// CHECK:           %[[VAL_4:.*]] = arith.constant 1 : i64
+// CHECK:           %[[VAL_5:.*]] = arith.constant 0 : i64
+// CHECK:           %[[VAL_6:.*]] = arith.constant 4 : i64
+// CHECK:           %[[VAL_7:.*]] = cc.alloca !cc.array<complex<f64> x 4>
+// CHECK:           %[[VAL_8:.*]] = cc.cast %[[VAL_7]] : (!cc.ptr<!cc.array<complex<f64> x 4>>) -> !cc.ptr<!cc.array<complex<f64> x ?>>
+// CHECK:           %[[VAL_9:.*]] = cc.cast %[[VAL_7]] : (!cc.ptr<!cc.array<complex<f64> x 4>>) -> !cc.ptr<complex<f64>>
 // CHECK:           cc.store %[[VAL_3]], %[[VAL_9]] : !cc.ptr<complex<f64>>
-// CHECK:           %[[VAL_10:.*]] = cc.compute_ptr %[[VAL_7]][2] : (!cc.ptr<!cc.array<complex<f64> x 4>>) -> !cc.ptr<complex<f64>>
+// CHECK:           %[[VAL_10:.*]] = cc.compute_ptr %[[VAL_7]][1] : (!cc.ptr<!cc.array<complex<f64> x 4>>) -> !cc.ptr<complex<f64>>
 // CHECK:           cc.store %[[VAL_2]], %[[VAL_10]] : !cc.ptr<complex<f64>>
-// CHECK:           %[[VAL_11:.*]] = cc.compute_ptr %[[VAL_7]][3] : (!cc.ptr<!cc.array<complex<f64> x 4>>) -> !cc.ptr<complex<f64>>
+// CHECK:           %[[VAL_11:.*]] = cc.compute_ptr %[[VAL_7]][2] : (!cc.ptr<!cc.array<complex<f64> x 4>>) -> !cc.ptr<complex<f64>>
 // CHECK:           cc.store %[[VAL_1]], %[[VAL_11]] : !cc.ptr<complex<f64>>
-// CHECK:           %[[VAL_12:.*]] = quake.alloca !quake.veq<2>
-// CHECK:           %[[VAL_13:.*]] = quake.init_state %[[VAL_12]], %[[VAL_7]] : (!quake.veq<2>, !cc.ptr<!cc.array<complex<f64> x 4>>) -> !quake.veq<2>
+// CHECK:           %[[VAL_12:.*]] = cc.compute_ptr %[[VAL_7]][3] : (!cc.ptr<!cc.array<complex<f64> x 4>>) -> !cc.ptr<complex<f64>>
+// CHECK:           cc.store %[[VAL_0]], %[[VAL_12]] : !cc.ptr<complex<f64>>
+// CHECK:           %[[VAL_13:.*]] = quake.create_state %[[VAL_8]], %[[VAL_6]] : (!cc.ptr<!cc.array<complex<f64> x ?>>, i64) -> !cc.ptr<!quake.state>
+// CHECK:           %[[VAL_14:.*]] = quake.get_number_of_qubits %[[VAL_13]] : (!cc.ptr<!quake.state>) -> i64
+// CHECK:           %[[VAL_15:.*]] = quake.alloca !quake.veq<?>{{\[}}%[[VAL_14]] : i64]
+// CHECK:           %[[VAL_16:.*]] = quake.init_state %[[VAL_15]], %[[VAL_13]] : (!quake.veq<?>, !cc.ptr<!quake.state>) -> !quake.veq<?>
+// CHECK:           quake.delete_state %[[VAL_13]] : !cc.ptr<!quake.state>
+// CHECK:           %[[VAL_17:.*]] = quake.veq_size %[[VAL_16]] : (!quake.veq<?>) -> i64
+// CHECK:           return %{{.*}} : !cc.stdvec<i1>
+// CHECK:         }
 // clang-format on
 
 struct RockyRoad {
   std::vector<bool> operator()() __qpu__ {
     using namespace std::complex_literals;
-    cudaq::qvector v = {0.0 + 1.0i, std::complex<double>{0.8, 0.2}, 1.0 + 0.0i,
-                        std::complex<double>{0.0, 0.0}};
+    cudaq::qvector v{cudaq::state{0.0 + 1.0i, std::complex<double>{0.8, 0.2},
+                                  1.0 + 0.0i, std::complex<double>{0.0, 0.0}}};
     h(v);
     return mz(v);
   }
@@ -108,38 +176,45 @@ struct RockyRoad {
 
 // clang-format off
 // CHECK-LABEL:   func.func @__nvqpp__mlirgen__RockyRoad() -> !cc.stdvec<i1> attributes {"cudaq-entrypoint", "cudaq-kernel"} {
-// CHECK-DAG:       %[[VAL_0:.*]] = arith.constant 2 : i64
-// CHECK-DAG:       %[[VAL_1:.*]] = complex.constant [0.000000e+00, 0.000000e+00] : complex<f64>
-// CHECK-DAG:       %[[VAL_2:.*]] = complex.constant [8.000000e-01, 2.000000e-01] : complex<f64>
-// CHECK-DAG:       %[[VAL_3:.*]] = arith.constant 1 : i64
-// CHECK-DAG:       %[[VAL_4:.*]] = arith.constant 0 : i64
-// CHECK-DAG:       %[[VAL_5:.*]] = arith.constant 0.000000e+00 : f{{[0-9]+}}
-// CHECK-DAG:       %[[VAL_6:.*]] = arith.constant 1.000000e+00 : f64
-// CHECK-DAG:       %[[VAL_7:.*]] = arith.constant 1.000000e+00 : f{{[0-9]+}}
-// CHECK-DAG:       %[[VAL_8:.*]] = arith.constant 0.000000e+00 : f64
-// CHECK-DAG:       %[[VAL_9:.*]] = cc.alloca f64
+// CHECK:           %[[VAL_0:.*]] = complex.constant [0.000000e+00, 0.000000e+00] : complex<f64>
+// CHECK:           %[[VAL_1:.*]] = complex.constant [8.000000e-01, 2.000000e-01] : complex<f64>
+// CHECK:           %[[VAL_2:.*]] = arith.constant 1 : i64
+// CHECK:           %[[VAL_3:.*]] = arith.constant 0 : i64
+// CHECK:           %[[VAL_4:.*]] = arith.constant 4 : i64
+// CHECK:           %[[VAL_5:.*]] = arith.constant 0.000000e+00 : f80
+// CHECK:           %[[VAL_6:.*]] = arith.constant 1.000000e+00 : f64
+// CHECK:           %[[VAL_7:.*]] = arith.constant 1.000000e+00 : f80
+// CHECK:           %[[VAL_8:.*]] = arith.constant 0.000000e+00 : f64
+// CHECK:           %[[VAL_9:.*]] = cc.alloca f64
 // CHECK:           cc.store %[[VAL_8]], %[[VAL_9]] : !cc.ptr<f64>
-// CHECK:           %[[VAL_10:.*]] = call @_ZNSt{{.*}}8literals16complex_literalsli1i{{.*}}Ee(%[[VAL_7]]) : (f{{[0-9]+}}) -> complex<f64>
+// CHECK:           %[[VAL_10:.*]] = call @_ZNSt8literals16complex_literalsli1iEe(%[[VAL_7]]) : (f80) -> complex<f64>
 // CHECK:           %[[VAL_11:.*]] = cc.alloca complex<f64>
 // CHECK:           cc.store %[[VAL_10]], %[[VAL_11]] : !cc.ptr<complex<f64>>
-// CHECK:           %[[VAL_12:.*]] = call @_Z{{.*}}7complexIT_{{.*}}_(%[[VAL_9]], %[[VAL_11]]) : (!cc.ptr<f64>, !cc.ptr<complex<f64>>) -> complex<f64>
+// CHECK:           %[[VAL_12:.*]] = call @_ZStplIdESt7complexIT_ERKS1_RKS2_(%[[VAL_9]], %[[VAL_11]]) : (!cc.ptr<f64>, !cc.ptr<complex<f64>>) -> complex<f64>
 // CHECK:           %[[VAL_13:.*]] = cc.alloca f64
 // CHECK:           cc.store %[[VAL_6]], %[[VAL_13]] : !cc.ptr<f64>
-// CHECK:           %[[VAL_14:.*]] = call @_ZNSt{{.*}}8literals16complex_literalsli1i{{.*}}Ee(%[[VAL_5]]) : (f{{[0-9]+}}) -> complex<f64>
+// CHECK:           %[[VAL_14:.*]] = call @_ZNSt8literals16complex_literalsli1iEe(%[[VAL_5]]) : (f80) -> complex<f64>
 // CHECK:           %[[VAL_15:.*]] = cc.alloca complex<f64>
 // CHECK:           cc.store %[[VAL_14]], %[[VAL_15]] : !cc.ptr<complex<f64>>
-// CHECK:           %[[VAL_16:.*]] = call @_Z{{.*}}7complexIT_{{.*}}_(%[[VAL_13]], %[[VAL_15]]) : (!cc.ptr<f64>, !cc.ptr<complex<f64>>) -> complex<f64>
+// CHECK:           %[[VAL_16:.*]] = call @_ZStplIdESt7complexIT_ERKS1_RKS2_(%[[VAL_13]], %[[VAL_15]]) : (!cc.ptr<f64>, !cc.ptr<complex<f64>>) -> complex<f64>
 // CHECK:           %[[VAL_17:.*]] = cc.alloca !cc.array<complex<f64> x 4>
-// CHECK:           %[[VAL_18:.*]] = cc.cast %[[VAL_17]] : (!cc.ptr<!cc.array<complex<f64> x 4>>) -> !cc.ptr<complex<f64>>
-// CHECK:           cc.store %[[VAL_12]], %[[VAL_18]] : !cc.ptr<complex<f64>>
-// CHECK:           %[[VAL_19:.*]] = cc.compute_ptr %[[VAL_17]][1] : (!cc.ptr<!cc.array<complex<f64> x 4>>) -> !cc.ptr<complex<f64>>
-// CHECK:           cc.store %[[VAL_2]], %[[VAL_19]] : !cc.ptr<complex<f64>>
-// CHECK:           %[[VAL_20:.*]] = cc.compute_ptr %[[VAL_17]][2] : (!cc.ptr<!cc.array<complex<f64> x 4>>) -> !cc.ptr<complex<f64>>
-// CHECK:           cc.store %[[VAL_16]], %[[VAL_20]] : !cc.ptr<complex<f64>>
-// CHECK:           %[[VAL_21:.*]] = cc.compute_ptr %[[VAL_17]][3] : (!cc.ptr<!cc.array<complex<f64> x 4>>) -> !cc.ptr<complex<f64>>
-// CHECK:           cc.store %[[VAL_1]], %[[VAL_21]] : !cc.ptr<complex<f64>>
-// CHECK:           %[[VAL_22:.*]] = quake.alloca !quake.veq<2>
-// CHECK:           %[[VAL_23:.*]] = quake.init_state %[[VAL_22]], %[[VAL_17]] : (!quake.veq<2>, !cc.ptr<!cc.array<complex<f64> x 4>>) -> !quake.veq<2>
+// CHECK:           %[[VAL_18:.*]] = cc.cast %[[VAL_17]] : (!cc.ptr<!cc.array<complex<f64> x 4>>) -> !cc.ptr<!cc.array<complex<f64> x ?>>
+// CHECK:           %[[VAL_19:.*]] = cc.cast %[[VAL_17]] : (!cc.ptr<!cc.array<complex<f64> x 4>>) -> !cc.ptr<complex<f64>>
+// CHECK:           cc.store %[[VAL_12]], %[[VAL_19]] : !cc.ptr<complex<f64>>
+// CHECK:           %[[VAL_20:.*]] = cc.compute_ptr %[[VAL_17]][1] : (!cc.ptr<!cc.array<complex<f64> x 4>>) -> !cc.ptr<complex<f64>>
+// CHECK:           cc.store %[[VAL_1]], %[[VAL_20]] : !cc.ptr<complex<f64>>
+// CHECK:           %[[VAL_21:.*]] = cc.compute_ptr %[[VAL_17]][2] : (!cc.ptr<!cc.array<complex<f64> x 4>>) -> !cc.ptr<complex<f64>>
+// CHECK:           cc.store %[[VAL_16]], %[[VAL_21]] : !cc.ptr<complex<f64>>
+// CHECK:           %[[VAL_22:.*]] = cc.compute_ptr %[[VAL_17]][3] : (!cc.ptr<!cc.array<complex<f64> x 4>>) -> !cc.ptr<complex<f64>>
+// CHECK:           cc.store %[[VAL_0]], %[[VAL_22]] : !cc.ptr<complex<f64>>
+// CHECK:           %[[VAL_23:.*]] = quake.create_state %[[VAL_18]], %[[VAL_4]] : (!cc.ptr<!cc.array<complex<f64> x ?>>, i64) -> !cc.ptr<!quake.state>
+// CHECK:           %[[VAL_24:.*]] = quake.get_number_of_qubits %[[VAL_23]] : (!cc.ptr<!quake.state>) -> i64
+// CHECK:           %[[VAL_25:.*]] = quake.alloca !quake.veq<?>{{\[}}%[[VAL_24]] : i64]
+// CHECK:           %[[VAL_26:.*]] = quake.init_state %[[VAL_25]], %[[VAL_23]] : (!quake.veq<?>, !cc.ptr<!quake.state>) -> !quake.veq<?>
+// CHECK:           quake.delete_state %[[VAL_23]] : !cc.ptr<!quake.state>
+// CHECK:           %[[VAL_27:.*]] = quake.veq_size %[[VAL_26]] : (!quake.veq<?>) -> i64
+// CHECK:           return %{{.*}} : !cc.stdvec<i1>
+// CHECK:         }
 // clang-format on
 
 std::vector<double> getTwoTimesRank();
@@ -154,18 +229,31 @@ struct Pistachio {
 
 // clang-format off
 // CHECK-LABEL:   func.func @__nvqpp__mlirgen__Pistachio() -> i1 attributes {"cudaq-entrypoint", "cudaq-kernel"} {
-// CHECK:           %[[VAL_2:.*]] = call @_Z15getTwoTimesRankv() : () -> !cc.stdvec<f64>
-// CHECK:           %[[VAL_30:.*]] = cc.stdvec_size %[[VAL_2]] : (!cc.stdvec<f64>) -> i64
-// CHECK:           %[[VAL_31:.*]] = cc.alloca f64[%{{.*}} : i64]
-// CHECK:           %[[VAL_3:.*]] = math.cttz %[[VAL_30]] : i64
-// CHECK:           %[[VAL_4:.*]] = cc.cast %[[VAL_31]] : (!cc.ptr<!cc.array<f64 x ?>>) -> !cc.ptr<f64>
-// CHECK:           %[[VAL_5:.*]] = quake.alloca !quake.veq<?>[%[[VAL_3]] : i64]
-// CHECK:           %[[VAL_6:.*]] = quake.init_state %[[VAL_5]], %[[VAL_4]] : (!quake.veq<?>, !cc.ptr<f64>) -> !quake.veq<?>
+// CHECK:           %[[VAL_0:.*]] = arith.constant 8 : i64
+// CHECK:           %[[VAL_1:.*]] = arith.constant 1 : i64
+// CHECK:           %[[VAL_2:.*]] = arith.constant 0 : i64
+// CHECK:           %[[VAL_3:.*]] = call @_Z15getTwoTimesRankv() : () -> !cc.stdvec<f64>
+// CHECK:           %[[VAL_4:.*]] = cc.stdvec_data %[[VAL_3]] : (!cc.stdvec<f64>) -> !cc.ptr<f64>
+// CHECK:           %[[VAL_5:.*]] = cc.stdvec_size %[[VAL_3]] : (!cc.stdvec<f64>) -> i64
+// CHECK:           %[[VAL_6:.*]] = arith.muli %[[VAL_5]], %[[VAL_0]] : i64
+// CHECK:           %[[VAL_7:.*]] = cc.alloca f64{{\[}}%[[VAL_6]] : i64]
+// CHECK:           %[[VAL_8:.*]] = cc.cast %[[VAL_7]] : (!cc.ptr<!cc.array<f64 x ?>>) -> !cc.ptr<i8>
+// CHECK:           %[[VAL_9:.*]] = cc.cast %[[VAL_4]] : (!cc.ptr<f64>) -> !cc.ptr<i8>
+// CHECK:           call @__nvqpp_vectorCopyToStack(%[[VAL_8]], %[[VAL_9]], %[[VAL_6]]) : (!cc.ptr<i8>, !cc.ptr<i8>, i64) -> ()
+// CHECK:           %[[VAL_10:.*]] = cc.cast %[[VAL_7]] : (!cc.ptr<!cc.array<f64 x ?>>) -> !cc.ptr<f64>
+// CHECK:           %[[VAL_11:.*]] = quake.create_state %[[VAL_10]], %[[VAL_5]] : (!cc.ptr<f64>, i64) -> !cc.ptr<!quake.state>
+// CHECK:           %[[VAL_12:.*]] = quake.get_number_of_qubits %[[VAL_11]] : (!cc.ptr<!quake.state>) -> i64
+// CHECK:           %[[VAL_13:.*]] = quake.alloca !quake.veq<?>{{\[}}%[[VAL_12]] : i64]
+// CHECK:           %[[VAL_14:.*]] = quake.init_state %[[VAL_13]], %[[VAL_11]] : (!quake.veq<?>, !cc.ptr<!quake.state>) -> !quake.veq<?>
+// CHECK:           quake.delete_state %[[VAL_11]] : !cc.ptr<!quake.state>
+// CHECK:           %[[VAL_15:.*]] = quake.veq_size %[[VAL_14]] : (!quake.veq<?>) -> i64
+// CHECK:           return %{{.*}} : i1
+// CHECK:         }
 // clang-format on
 
 struct ChocolateMint {
   bool operator()() __qpu__ {
-    cudaq::qvector v = getTwoTimesRank();
+    cudaq::qvector v(getTwoTimesRank());
     h(v);
     return mz(v[0]);
   }
@@ -173,13 +261,26 @@ struct ChocolateMint {
 
 // clang-format off
 // CHECK-LABEL:   func.func @__nvqpp__mlirgen__ChocolateMint() -> i1 attributes {"cudaq-entrypoint", "cudaq-kernel"} {
-// CHECK:           %[[VAL_2:.*]] = call @_Z15getTwoTimesRankv() : () -> !cc.stdvec<f64>
-// CHECK:           %[[VAL_30:.*]] = cc.stdvec_size %[[VAL_2]] : (!cc.stdvec<f64>) -> i64
-// CHECK:           %[[VAL_31:.*]] = cc.alloca f64[%{{.*}} : i64]
-// CHECK:           %[[VAL_3:.*]] = math.cttz %[[VAL_30]] : i64
-// CHECK:           %[[VAL_4:.*]] = cc.cast %[[VAL_31]] : (!cc.ptr<!cc.array<f64 x ?>>) -> !cc.ptr<f64>
-// CHECK:           %[[VAL_5:.*]] = quake.alloca !quake.veq<?>[%[[VAL_3]] : i64]
-// CHECK:           %[[VAL_6:.*]] = quake.init_state %[[VAL_5]], %[[VAL_4]] : (!quake.veq<?>, !cc.ptr<f64>) -> !quake.veq<?>
+// CHECK:           %[[VAL_0:.*]] = arith.constant 8 : i64
+// CHECK:           %[[VAL_1:.*]] = arith.constant 1 : i64
+// CHECK:           %[[VAL_2:.*]] = arith.constant 0 : i64
+// CHECK:           %[[VAL_3:.*]] = call @_Z15getTwoTimesRankv() : () -> !cc.stdvec<f64>
+// CHECK:           %[[VAL_4:.*]] = cc.stdvec_data %[[VAL_3]] : (!cc.stdvec<f64>) -> !cc.ptr<f64>
+// CHECK:           %[[VAL_5:.*]] = cc.stdvec_size %[[VAL_3]] : (!cc.stdvec<f64>) -> i64
+// CHECK:           %[[VAL_6:.*]] = arith.muli %[[VAL_5]], %[[VAL_0]] : i64
+// CHECK:           %[[VAL_7:.*]] = cc.alloca f64{{\[}}%[[VAL_6]] : i64]
+// CHECK:           %[[VAL_8:.*]] = cc.cast %[[VAL_7]] : (!cc.ptr<!cc.array<f64 x ?>>) -> !cc.ptr<i8>
+// CHECK:           %[[VAL_9:.*]] = cc.cast %[[VAL_4]] : (!cc.ptr<f64>) -> !cc.ptr<i8>
+// CHECK:           call @__nvqpp_vectorCopyToStack(%[[VAL_8]], %[[VAL_9]], %[[VAL_6]]) : (!cc.ptr<i8>, !cc.ptr<i8>, i64) -> ()
+// CHECK:           %[[VAL_10:.*]] = cc.cast %[[VAL_7]] : (!cc.ptr<!cc.array<f64 x ?>>) -> !cc.ptr<f64>
+// CHECK:           %[[VAL_11:.*]] = quake.create_state %[[VAL_10]], %[[VAL_5]] : (!cc.ptr<f64>, i64) -> !cc.ptr<!quake.state>
+// CHECK:           %[[VAL_12:.*]] = quake.get_number_of_qubits %[[VAL_11]] : (!cc.ptr<!quake.state>) -> i64
+// CHECK:           %[[VAL_13:.*]] = quake.alloca !quake.veq<?>{{\[}}%[[VAL_12]] : i64]
+// CHECK:           %[[VAL_14:.*]] = quake.init_state %[[VAL_13]], %[[VAL_11]] : (!quake.veq<?>, !cc.ptr<!quake.state>) -> !quake.veq<?>
+// CHECK:           quake.delete_state %[[VAL_11]] : !cc.ptr<!quake.state>
+// CHECK:           %[[VAL_15:.*]] = quake.veq_size %[[VAL_14]] : (!quake.veq<?>) -> i64
+// CHECK:           return %{{.*}} : i1
+// CHECK:         }
 // clang-format on
 
 std::vector<std::complex<double>> getComplexInit();
@@ -194,18 +295,31 @@ struct Neapolitan {
 
 // clang-format off
 // CHECK-LABEL:   func.func @__nvqpp__mlirgen__Neapolitan() -> !cc.stdvec<i1> attributes {"cudaq-entrypoint", "cudaq-kernel"} {
+// CHECK:           %[[VAL_0:.*]] = arith.constant 16 : i64
+// CHECK:           %[[VAL_1:.*]] = arith.constant 1 : i64
+// CHECK:           %[[VAL_2:.*]] = arith.constant 0 : i64
 // CHECK:           %[[VAL_3:.*]] = call @_Z14getComplexInitv() : () -> !cc.stdvec<complex<f64>>
-// CHECK:           %[[VAL_30:.*]] = cc.stdvec_size %[[VAL_3]] : (!cc.stdvec<complex<f64>>) -> i64
-// CHECK:           %[[VAL_31:.*]] = cc.alloca complex<f64>[%{{.*}}]
-// CHECK:           %[[VAL_4:.*]] = math.cttz %[[VAL_30]] : i64
-// CHECK:           %[[VAL_5:.*]] = cc.cast %[[VAL_31]] : (!cc.ptr<!cc.array<complex<f64> x ?>>) -> !cc.ptr<complex<f64>>
-// CHECK:           %[[VAL_6:.*]] = quake.alloca !quake.veq<?>[%[[VAL_4]] : i64]
-// CHECK:           %[[VAL_7:.*]] = quake.init_state %[[VAL_6]], %[[VAL_5]] : (!quake.veq<?>, !cc.ptr<complex<f64>>) -> !quake.veq<?>
+// CHECK:           %[[VAL_4:.*]] = cc.stdvec_data %[[VAL_3]] : (!cc.stdvec<complex<f64>>) -> !cc.ptr<complex<f64>>
+// CHECK:           %[[VAL_5:.*]] = cc.stdvec_size %[[VAL_3]] : (!cc.stdvec<complex<f64>>) -> i64
+// CHECK:           %[[VAL_6:.*]] = arith.muli %[[VAL_5]], %[[VAL_0]] : i64
+// CHECK:           %[[VAL_7:.*]] = cc.alloca complex<f64>{{\[}}%[[VAL_6]] : i64]
+// CHECK:           %[[VAL_8:.*]] = cc.cast %[[VAL_7]] : (!cc.ptr<!cc.array<complex<f64> x ?>>) -> !cc.ptr<i8>
+// CHECK:           %[[VAL_9:.*]] = cc.cast %[[VAL_4]] : (!cc.ptr<complex<f64>>) -> !cc.ptr<i8>
+// CHECK:           call @__nvqpp_vectorCopyToStack(%[[VAL_8]], %[[VAL_9]], %[[VAL_6]]) : (!cc.ptr<i8>, !cc.ptr<i8>, i64) -> ()
+// CHECK:           %[[VAL_10:.*]] = cc.cast %[[VAL_7]] : (!cc.ptr<!cc.array<complex<f64> x ?>>) -> !cc.ptr<complex<f64>>
+// CHECK:           %[[VAL_11:.*]] = quake.create_state %[[VAL_10]], %[[VAL_5]] : (!cc.ptr<complex<f64>>, i64) -> !cc.ptr<!quake.state>
+// CHECK:           %[[VAL_12:.*]] = quake.get_number_of_qubits %[[VAL_11]] : (!cc.ptr<!quake.state>) -> i64
+// CHECK:           %[[VAL_13:.*]] = quake.alloca !quake.veq<?>{{\[}}%[[VAL_12]] : i64]
+// CHECK:           %[[VAL_14:.*]] = quake.init_state %[[VAL_13]], %[[VAL_11]] : (!quake.veq<?>, !cc.ptr<!quake.state>) -> !quake.veq<?>
+// CHECK:           quake.delete_state %[[VAL_11]] : !cc.ptr<!quake.state>
+// CHECK:           %[[VAL_15:.*]] = quake.veq_size %[[VAL_14]] : (!quake.veq<?>) -> i64
+// CHECK:           return %{{.*}} : !cc.stdvec<i1>
+// CHECK:         }
 // clang-format on
 
 struct ButterPecan {
   std::vector<bool> operator()() __qpu__ {
-    cudaq::qvector v = getComplexInit();
+    cudaq::qvector v(getComplexInit());
     h(v);
     return mz(v);
   }
@@ -213,35 +327,52 @@ struct ButterPecan {
 
 // clang-format off
 // CHECK-LABEL:   func.func @__nvqpp__mlirgen__ButterPecan() -> !cc.stdvec<i1> attributes {"cudaq-entrypoint", "cudaq-kernel"} {
+// CHECK:           %[[VAL_0:.*]] = arith.constant 16 : i64
+// CHECK:           %[[VAL_1:.*]] = arith.constant 1 : i64
+// CHECK:           %[[VAL_2:.*]] = arith.constant 0 : i64
 // CHECK:           %[[VAL_3:.*]] = call @_Z14getComplexInitv() : () -> !cc.stdvec<complex<f64>>
-// CHECK:           %[[VAL_30:.*]] = cc.stdvec_size %[[VAL_3]] : (!cc.stdvec<complex<f64>>) -> i64
-// CHECK:           %[[VAL_31:.*]] = cc.alloca complex<f64>[%{{.*}}]
-// CHECK:           %[[VAL_4:.*]] = math.cttz %[[VAL_30]] : i64
-// CHECK:           %[[VAL_5:.*]] = cc.cast %[[VAL_31]] : (!cc.ptr<!cc.array<complex<f64> x ?>>) -> !cc.ptr<complex<f64>>
-// CHECK:           %[[VAL_6:.*]] = quake.alloca !quake.veq<?>[%[[VAL_4]] : i64]
-// CHECK:           %[[VAL_7:.*]] = quake.init_state %[[VAL_6]], %[[VAL_5]] : (!quake.veq<?>, !cc.ptr<complex<f64>>) -> !quake.veq<?>
+// CHECK:           %[[VAL_4:.*]] = cc.stdvec_data %[[VAL_3]] : (!cc.stdvec<complex<f64>>) -> !cc.ptr<complex<f64>>
+// CHECK:           %[[VAL_5:.*]] = cc.stdvec_size %[[VAL_3]] : (!cc.stdvec<complex<f64>>) -> i64
+// CHECK:           %[[VAL_6:.*]] = arith.muli %[[VAL_5]], %[[VAL_0]] : i64
+// CHECK:           %[[VAL_7:.*]] = cc.alloca complex<f64>{{\[}}%[[VAL_6]] : i64]
+// CHECK:           %[[VAL_8:.*]] = cc.cast %[[VAL_7]] : (!cc.ptr<!cc.array<complex<f64> x ?>>) -> !cc.ptr<i8>
+// CHECK:           %[[VAL_9:.*]] = cc.cast %[[VAL_4]] : (!cc.ptr<complex<f64>>) -> !cc.ptr<i8>
+// CHECK:           call @__nvqpp_vectorCopyToStack(%[[VAL_8]], %[[VAL_9]], %[[VAL_6]]) : (!cc.ptr<i8>, !cc.ptr<i8>, i64) -> ()
+// CHECK:           %[[VAL_10:.*]] = cc.cast %[[VAL_7]] : (!cc.ptr<!cc.array<complex<f64> x ?>>) -> !cc.ptr<complex<f64>>
+// CHECK:           %[[VAL_11:.*]] = quake.create_state %[[VAL_10]], %[[VAL_5]] : (!cc.ptr<complex<f64>>, i64) -> !cc.ptr<!quake.state>
+// CHECK:           %[[VAL_12:.*]] = quake.get_number_of_qubits %[[VAL_11]] : (!cc.ptr<!quake.state>) -> i64
+// CHECK:           %[[VAL_13:.*]] = quake.alloca !quake.veq<?>{{\[}}%[[VAL_12]] : i64]
+// CHECK:           %[[VAL_14:.*]] = quake.init_state %[[VAL_13]], %[[VAL_11]] : (!quake.veq<?>, !cc.ptr<!quake.state>) -> !quake.veq<?>
+// CHECK:           quake.delete_state %[[VAL_11]] : !cc.ptr<!quake.state>
+// CHECK:           %[[VAL_15:.*]] = quake.veq_size %[[VAL_14]] : (!quake.veq<?>) -> i64
+// CHECK:           return %{{.*}} : !cc.stdvec<i1>
+// CHECK:         }
 // clang-format on
 
 __qpu__ auto Strawberry() {
-  cudaq::qubit q = {0., 1.};
+  cudaq::qubit q(cudaq::state{0., 1.});
   return mz(q);
 }
 
 // clang-format off
 // CHECK-LABEL:   func.func @__nvqpp__mlirgen__function_Strawberry._Z10Strawberryv() -> i1 attributes {"cudaq-entrypoint", "cudaq-kernel", no_this} {
-// CHECK:           %[[VAL_0:.*]] = complex.constant [1.000000e+00, 0.000000e+00] : complex<f64>
-// CHECK:           %[[VAL_1:.*]] = complex.constant [0.000000e+00, 0.000000e+00] : complex<f64>
-// CHECK:           %[[VAL_2:.*]] = cc.alloca !cc.array<complex<f64> x 2>
-// CHECK:           %[[VAL_3:.*]] = cc.cast %[[VAL_2]] : (!cc.ptr<!cc.array<complex<f64> x 2>>) -> !cc.ptr<complex<f64>>
-// CHECK:           cc.store %[[VAL_1]], %[[VAL_3]] : !cc.ptr<complex<f64>>
-// CHECK:           %[[VAL_4:.*]] = cc.compute_ptr %[[VAL_2]][1] : (!cc.ptr<!cc.array<complex<f64> x 2>>) -> !cc.ptr<complex<f64>>
-// CHECK:           cc.store %[[VAL_0]], %[[VAL_4]] : !cc.ptr<complex<f64>>
-// CHECK:           %[[VAL_5:.*]] = quake.alloca !quake.veq<1>
-// CHECK:           %[[VAL_6:.*]] = quake.init_state %[[VAL_5]], %[[VAL_2]] : (!quake.veq<1>, !cc.ptr<!cc.array<complex<f64> x 2>>) -> !quake.veq<1>
-// CHECK:           %[[VAL_7:.*]] = quake.extract_ref %[[VAL_6]][0] : (!quake.veq<1>) -> !quake.ref
-// CHECK:           %[[VAL_8:.*]] = quake.mz %[[VAL_7]] : (!quake.ref) -> !quake.measure
-// CHECK:           %[[VAL_9:.*]] = quake.discriminate %[[VAL_8]] : (!quake.measure) -> i1
-// CHECK:           return %[[VAL_9]] : i1
+// CHECK:           %[[VAL_0:.*]] = arith.constant 0.000000e+00 : f64
+// CHECK:           %[[VAL_1:.*]] = arith.constant 1.000000e+00 : f64
+// CHECK:           %[[VAL_2:.*]] = arith.constant 2 : i64
+// CHECK:           %[[VAL_3:.*]] = cc.alloca !cc.array<f64 x 2>
+// CHECK:           %[[VAL_4:.*]] = cc.cast %[[VAL_3]] : (!cc.ptr<!cc.array<f64 x 2>>) -> !cc.ptr<!cc.array<f64 x ?>>
+// CHECK:           %[[VAL_5:.*]] = cc.cast %[[VAL_3]] : (!cc.ptr<!cc.array<f64 x 2>>) -> !cc.ptr<f64>
+// CHECK:           cc.store %[[VAL_0]], %[[VAL_5]] : !cc.ptr<f64>
+// CHECK:           %[[VAL_6:.*]] = cc.compute_ptr %[[VAL_3]][1] : (!cc.ptr<!cc.array<f64 x 2>>) -> !cc.ptr<f64>
+// CHECK:           cc.store %[[VAL_1]], %[[VAL_6]] : !cc.ptr<f64>
+// CHECK:           %[[VAL_7:.*]] = quake.create_state %[[VAL_4]], %[[VAL_2]] : (!cc.ptr<!cc.array<f64 x ?>>, i64) -> !cc.ptr<!quake.state>
+// CHECK:           %[[VAL_8:.*]] = quake.alloca !quake.ref
+// CHECK:           %[[VAL_9:.*]] = quake.init_state %[[VAL_8]], %[[VAL_7]] : (!quake.ref, !cc.ptr<!quake.state>) -> !quake.veq<1>
+// CHECK:           quake.delete_state %[[VAL_7]] : !cc.ptr<!quake.state>
+// CHECK:           %[[VAL_10:.*]] = quake.extract_ref %[[VAL_9]][0] : (!quake.veq<1>) -> !quake.ref
+// CHECK:           %[[VAL_11:.*]] = quake.mz %[[VAL_10]] : (!quake.ref) -> !quake.measure
+// CHECK:           %[[VAL_12:.*]] = quake.discriminate %[[VAL_11]] : (!quake.measure) -> i1
+// CHECK:           return %[[VAL_12]] : i1
 // CHECK:         }
 // clang-format on
 
@@ -253,25 +384,29 @@ __qpu__ auto GoldRibbon() {
 }
 #endif
 
-__qpu__ bool Peppermint() { 
-  cudaq::qubit q = {M_SQRT1_2, M_SQRT1_2};
+__qpu__ bool Peppermint() {
+  cudaq::qubit q{{M_SQRT1_2, M_SQRT1_2}};
   return mz(q);
 }
 
 // clang-format off
 // CHECK-LABEL:   func.func @__nvqpp__mlirgen__function_Peppermint._Z10Peppermintv() -> i1 attributes {"cudaq-entrypoint", "cudaq-kernel", no_this} {
-// CHECK:           %[[VAL_0:.*]] = complex.constant [0.70710678118654757, 0.000000e+00] : complex<f64>
-// CHECK:           %[[VAL_1:.*]] = cc.alloca !cc.array<complex<f64> x 2>
-// CHECK:           %[[VAL_2:.*]] = cc.cast %[[VAL_1]] : (!cc.ptr<!cc.array<complex<f64> x 2>>) -> !cc.ptr<complex<f64>>
-// CHECK:           cc.store %[[VAL_0]], %[[VAL_2]] : !cc.ptr<complex<f64>>
-// CHECK:           %[[VAL_3:.*]] = cc.compute_ptr %[[VAL_1]][1] : (!cc.ptr<!cc.array<complex<f64> x 2>>) -> !cc.ptr<complex<f64>>
-// CHECK:           cc.store %[[VAL_0]], %[[VAL_3]] : !cc.ptr<complex<f64>>
-// CHECK:           %[[VAL_4:.*]] = quake.alloca !quake.veq<1>
-// CHECK:           %[[VAL_5:.*]] = quake.init_state %[[VAL_4]], %[[VAL_1]] : (!quake.veq<1>, !cc.ptr<!cc.array<complex<f64> x 2>>) -> !quake.veq<1>
-// CHECK:           %[[VAL_6:.*]] = quake.extract_ref %[[VAL_5]][0] : (!quake.veq<1>) -> !quake.ref
-// CHECK:           %[[VAL_7:.*]] = quake.mz %[[VAL_6]] : (!quake.ref) -> !quake.measure
-// CHECK:           %[[VAL_8:.*]] = quake.discriminate %[[VAL_7]] : (!quake.measure) -> i1
-// CHECK:           return %[[VAL_8]] : i1
+// CHECK:           %[[VAL_0:.*]] = arith.constant 0.70710678118654757 : f64
+// CHECK:           %[[VAL_1:.*]] = arith.constant 2 : i64
+// CHECK:           %[[VAL_2:.*]] = cc.alloca !cc.array<f64 x 2>
+// CHECK:           %[[VAL_3:.*]] = cc.cast %[[VAL_2]] : (!cc.ptr<!cc.array<f64 x 2>>) -> !cc.ptr<!cc.array<f64 x ?>>
+// CHECK:           %[[VAL_4:.*]] = cc.cast %[[VAL_2]] : (!cc.ptr<!cc.array<f64 x 2>>) -> !cc.ptr<f64>
+// CHECK:           cc.store %[[VAL_0]], %[[VAL_4]] : !cc.ptr<f64>
+// CHECK:           %[[VAL_5:.*]] = cc.compute_ptr %[[VAL_2]][1] : (!cc.ptr<!cc.array<f64 x 2>>) -> !cc.ptr<f64>
+// CHECK:           cc.store %[[VAL_0]], %[[VAL_5]] : !cc.ptr<f64>
+// CHECK:           %[[VAL_6:.*]] = quake.create_state %[[VAL_3]], %[[VAL_1]] : (!cc.ptr<!cc.array<f64 x ?>>, i64) -> !cc.ptr<!quake.state>
+// CHECK:           %[[VAL_7:.*]] = quake.alloca !quake.ref
+// CHECK:           %[[VAL_8:.*]] = quake.init_state %[[VAL_7]], %[[VAL_6]] : (!quake.ref, !cc.ptr<!quake.state>) -> !quake.veq<1>
+// CHECK:           quake.delete_state %[[VAL_6]] : !cc.ptr<!quake.state>
+// CHECK:           %[[VAL_9:.*]] = quake.extract_ref %[[VAL_8]][0] : (!quake.veq<1>) -> !quake.ref
+// CHECK:           %[[VAL_10:.*]] = quake.mz %[[VAL_9]] : (!quake.ref) -> !quake.measure
+// CHECK:           %[[VAL_11:.*]] = quake.discriminate %[[VAL_10]] : (!quake.measure) -> i1
+// CHECK:           return %[[VAL_11]] : i1
 // CHECK:         }
 // clang-format on
 
@@ -282,397 +417,251 @@ __qpu__ bool Peppermint() {
 //===----------------------------------------------------------------------===//
 
 // clang-format off
+// QIR-LABEL: define { i1*, i64 } @__nvqpp__mlirgen__Vanilla() local_unnamed_addr {
+// QIR:         %[[VAL_0:.*]] = alloca [4 x double], align 8
+// QIR:         %[[VAL_1:.*]] = getelementptr inbounds [4 x double], [4 x double]* %[[VAL_0]], i64 0, i64 0
+// QIR:         store double 0.000000e+00, double* %[[VAL_1]], align 8
+// QIR:         %[[VAL_2:.*]] = getelementptr inbounds [4 x double], [4 x double]* %[[VAL_0]], i64 0, i64 1
+// QIR:         store double 1.000000e+00, double* %[[VAL_2]], align 8
+// QIR:         %[[VAL_3:.*]] = getelementptr inbounds [4 x double], [4 x double]* %[[VAL_0]], i64 0, i64 2
+// QIR:         store double 1.000000e+00, double* %[[VAL_3]], align 8
+// QIR:         %[[VAL_4:.*]] = getelementptr inbounds [4 x double], [4 x double]* %[[VAL_0]], i64 0, i64 3
+// QIR:         store double 0.000000e+00, double* %[[VAL_4]], align 8
+// QIR:         %[[VAL_5:.*]] = bitcast [4 x double]* %[[VAL_0]] to i8*
+// QIR:         %[[VAL_6:.*]] = call i8** @__nvqpp_cudaq_state_createFromData_f64(i8* nonnull %[[VAL_5]], i64 4)
+// QIR:         %[[VAL_7:.*]] = call i64 @__nvqpp_cudaq_state_numberOfQubits(i8** %[[VAL_6]])
+// QIR:         %[[VAL_8:.*]] = call %[[VAL_9:.*]]* @__quantum__rt__qubit_allocate_array_with_cudaq_state_ptr(i64 %[[VAL_7]], i8** %[[VAL_6]])
+// QIR:         call void @__nvqpp_cudaq_state_delete(i8** %[[VAL_6]])
+// QIR:        %[[VAL_10:.*]] = call i64 @__quantum__rt__array_get_size_1d(%[[VAL_9]]* %[[VAL_8]])
+// QIR:         %[[VAL_11:.*]] = icmp sgt i64 %[[VAL_10]], 0
+// QIR:         br i1 %[[VAL_11]], label %[[VAL_12:.*]], label %[[VAL_13:.*]]
 
-// QIR-LABEL: define { i1*, i64 } @__nvqpp__mlirgen__Vanilla()
-// QIR:         %[[VAL_0:.*]] = tail call %[[VAL_1:.*]]* @__quantum__rt__qubit_allocate_array_with_state_fp64(i64 2, double* {{.*}}getelementptr inbounds ([4 x double], [4 x double]* @__nvqpp__rodata_init_0, i64 0, i64 0))
-// QIR:         %[[VAL_2:.*]] = tail call %[[VAL_3:.*]]** @__quantum__rt__array_get_element_ptr_1d(%[[VAL_1]]* %[[VAL_0]], i64 0)
-// QIR:         %[[VAL_4:.*]] = load %[[VAL_3]]*, %[[VAL_3]]** %[[VAL_2]]
-// QIR:         tail call void @__quantum__qis__h(%[[VAL_3]]* %[[VAL_4]])
-// QIR:         %[[VAL_5:.*]] = tail call %[[VAL_3]]** @__quantum__rt__array_get_element_ptr_1d(%[[VAL_1]]* %[[VAL_0]], i64 1)
-// QIR:         %[[VAL_6:.*]] = load %[[VAL_3]]*, %[[VAL_3]]** %[[VAL_5]]
-// QIR:         tail call void @__quantum__qis__h(%[[VAL_3]]* %[[VAL_6]])
-// QIR:         %[[VAL_7:.*]] = tail call %[[VAL_8:.*]]* @__quantum__qis__mz(%[[VAL_3]]* %[[VAL_4]])
-// QIR:         %[[VAL_9:.*]] = bitcast %[[VAL_8]]* %[[VAL_7]] to i1*
-// QIR:         %[[VAL_10:.*]] = load i1, i1* %[[VAL_9]]
-// QIR:         %[[VAL_11:.*]] = zext i1 %[[VAL_10]] to i8
-// QIR:         %[[VAL_12:.*]] = tail call %[[VAL_8]]* @__quantum__qis__mz(%[[VAL_3]]* %[[VAL_6]])
-// QIR:         %[[VAL_13:.*]] = bitcast %[[VAL_8]]* %[[VAL_12]] to i1*
-// QIR:         %[[VAL_14:.*]] = load i1, i1* %[[VAL_13]]
-// QIR:         %[[VAL_15:.*]] = zext i1 %[[VAL_14]] to i8
-// QIR:         %[[VAL_16:.*]] = tail call dereferenceable_or_null(2) i8* @malloc(i64 2)
-// QIR:         store i8 %[[VAL_11]], i8* %[[VAL_16]]
-// QIR:         %[[VAL_17:.*]] = getelementptr inbounds i8, i8* %[[VAL_16]], i64 1
-// QIR:         store i8 %[[VAL_15]], i8* %[[VAL_17]]
-// QIR:         %[[VAL_18:.*]] = bitcast i8* %[[VAL_16]] to i1*
-// QIR:         %[[VAL_19:.*]] = insertvalue { i1*, i64 } undef, i1* %[[VAL_18]], 0
-// QIR:         %[[VAL_20:.*]] = insertvalue { i1*, i64 } %[[VAL_19]], i64 2, 1
-// QIR:         tail call void @__quantum__rt__qubit_release_array(%[[VAL_1]]* %[[VAL_0]])
-// QIR:         ret { i1*, i64 } %[[VAL_20]]
-// QIR:       }
-
-// QIR-LABEL: define { i1*, i64 } @__nvqpp__mlirgen__Cherry()
-// QIR:         %[[VAL_0:.*]] = alloca [4 x { double, double }]
-// QIR:         %[[VAL_1:.*]] = getelementptr inbounds [4 x { double, double }], [4 x { double, double }]* %[[VAL_0]], i64 0, i64 0
-// QIR:         %[[VAL_2:.*]] = getelementptr inbounds [4 x { double, double }], [4 x { double, double }]* %[[VAL_0]], i64 0, i64 0, i32 0
-// QIR:         store double 0.000000e+00, double* %[[VAL_2]]
-// QIR:         %[[VAL_3:.*]] = getelementptr inbounds [4 x { double, double }], [4 x { double, double }]* %[[VAL_0]], i64 0, i64 0, i32 1
-// QIR:         store double 1.000000e+00, double* %[[VAL_3]]
-// QIR:         %[[VAL_4:.*]] = getelementptr inbounds [4 x { double, double }], [4 x { double, double }]* %[[VAL_0]], i64 0, i64 1, i32 0
-// QIR:         store double 6.000000e-01, double* %[[VAL_4]]
-// QIR:         %[[VAL_5:.*]] = getelementptr inbounds [4 x { double, double }], [4 x { double, double }]* %[[VAL_0]], i64 0, i64 1, i32 1
-// QIR:         store double 4.000000e-01, double* %[[VAL_5]]
-// QIR:         %[[VAL_6:.*]] = getelementptr inbounds [4 x { double, double }], [4 x { double, double }]* %[[VAL_0]], i64 0, i64 2, i32 0
-// QIR:         store double 1.000000e+00, double* %[[VAL_6]]
-// QIR:         %[[VAL_7:.*]] = getelementptr inbounds [4 x { double, double }], [4 x { double, double }]* %[[VAL_0]], i64 0, i64 2, i32 1
-// QIR:         %[[VAL_8:.*]] = bitcast double* %[[VAL_7]] to i8*
-// QIR:         call void @llvm.memset.p0i8.i64(i8* {{.*}}%[[VAL_8]], i8 0, i64 24, i1 false)
-// QIR:         %[[VAL_9:.*]] = call %[[VAL_10:.*]]* @__quantum__rt__qubit_allocate_array_with_state_complex64(i64 2, { double, double }* {{.*}}%[[VAL_1]])
-// QIR:         %[[VAL_11:.*]] = call %[[VAL_12:.*]]** @__quantum__rt__array_get_element_ptr_1d(%[[VAL_10]]* %[[VAL_9]], i64 0)
-// QIR:         %[[VAL_13:.*]] = load %[[VAL_12]]*, %[[VAL_12]]** %[[VAL_11]]
-// QIR:         call void @__quantum__qis__h(%[[VAL_12]]* %[[VAL_13]])
-// QIR:         %[[VAL_14:.*]] = call %[[VAL_12]]** @__quantum__rt__array_get_element_ptr_1d(%[[VAL_10]]* %[[VAL_9]], i64 1)
-// QIR:         %[[VAL_15:.*]] = load %[[VAL_12]]*, %[[VAL_12]]** %[[VAL_14]]
-// QIR:         call void @__quantum__qis__h(%[[VAL_12]]* %[[VAL_15]])
-// QIR:         %[[VAL_16:.*]] = call %[[VAL_17:.*]]* @__quantum__qis__mz(%[[VAL_12]]* %[[VAL_13]])
-// QIR:         %[[VAL_18:.*]] = bitcast %[[VAL_17]]* %[[VAL_16]] to i1*
-// QIR:         %[[VAL_19:.*]] = load i1, i1* %[[VAL_18]]
-// QIR:         %[[VAL_20:.*]] = zext i1 %[[VAL_19]] to i8
-// QIR:         %[[VAL_21:.*]] = call %[[VAL_17]]* @__quantum__qis__mz(%[[VAL_12]]* %[[VAL_15]])
-// QIR:         %[[VAL_22:.*]] = bitcast %[[VAL_17]]* %[[VAL_21]] to i1*
-// QIR:         %[[VAL_23:.*]] = load i1, i1* %[[VAL_22]]
-// QIR:         %[[VAL_24:.*]] = zext i1 %[[VAL_23]] to i8
-// QIR:         %[[VAL_25:.*]] = call dereferenceable_or_null(2) i8* @malloc(i64 2)
-// QIR:         store i8 %[[VAL_20]], i8* %[[VAL_25]]
-// QIR:         %[[VAL_26:.*]] = getelementptr inbounds i8, i8* %[[VAL_25]], i64 1
-// QIR:         store i8 %[[VAL_24]], i8* %[[VAL_26]]
-// QIR:         %[[VAL_27:.*]] = bitcast i8* %[[VAL_25]] to i1*
-// QIR:         %[[VAL_28:.*]] = insertvalue { i1*, i64 } undef, i1* %[[VAL_27]], 0
-// QIR:         %[[VAL_29:.*]] = insertvalue { i1*, i64 } %[[VAL_28]], i64 2, 1
-// QIR:         call void @__quantum__rt__qubit_release_array(%[[VAL_10]]* %[[VAL_9]])
-// QIR:         ret { i1*, i64 } %[[VAL_29]]
-// QIR:       }
-
-// QIR-LABEL: define { i1*, i64 } @__nvqpp__mlirgen__MooseTracks()
-// QIR:         %[[VAL_0:.*]] = alloca [4 x { double, double }]
-// QIR:         %[[VAL_1:.*]] = getelementptr inbounds [4 x { double, double }], [4 x { double, double }]* %[[VAL_0]], i64 0, i64 0
-// QIR:         %[[VAL_2:.*]] = getelementptr inbounds [4 x { double, double }], [4 x { double, double }]* %[[VAL_0]], i64 0, i64 0, i32 0
-// QIR:         store double 0.000000e+00, double* %[[VAL_2]]
-// QIR:         %[[VAL_3:.*]] = getelementptr inbounds [4 x { double, double }], [4 x { double, double }]* %[[VAL_0]], i64 0, i64 0, i32 1
-// QIR:         store double 1.000000e+00, double* %[[VAL_3]]
-// QIR:         %[[VAL_4:.*]] = getelementptr inbounds [4 x { double, double }], [4 x { double, double }]* %[[VAL_0]], i64 0, i64 1, i32 0
-// QIR:         store double 7.500000e-01, double* %[[VAL_4]]
-// QIR:         %[[VAL_5:.*]] = getelementptr inbounds [4 x { double, double }], [4 x { double, double }]* %[[VAL_0]], i64 0, i64 1, i32 1
-// QIR:         store double 2.500000e-01, double* %[[VAL_5]]
-// QIR:         %[[VAL_6:.*]] = getelementptr inbounds [4 x { double, double }], [4 x { double, double }]* %[[VAL_0]], i64 0, i64 2, i32 0
-// QIR:         store double 1.000000e+00, double* %[[VAL_6]]
-// QIR:         %[[VAL_7:.*]] = getelementptr inbounds [4 x { double, double }], [4 x { double, double }]* %[[VAL_0]], i64 0, i64 2, i32 1
-// QIR:         %[[VAL_8:.*]] = bitcast double* %[[VAL_7]] to i8*
-// QIR:         call void @llvm.memset.p0i8.i64(i8* {{.*}}%[[VAL_8]], i8 0, i64 24, i1 false)
-// QIR:         %[[VAL_9:.*]] = call %[[VAL_10:.*]]* @__quantum__rt__qubit_allocate_array_with_state_complex64(i64 2, { double, double }* {{.*}}%[[VAL_1]])
-// QIR:         %[[VAL_11:.*]] = call %[[VAL_12:.*]]** @__quantum__rt__array_get_element_ptr_1d(%[[VAL_10]]* %[[VAL_9]], i64 0)
-// QIR:         %[[VAL_13:.*]] = load %[[VAL_12]]*, %[[VAL_12]]** %[[VAL_11]]
-// QIR:         call void @__quantum__qis__h(%[[VAL_12]]* %[[VAL_13]])
-// QIR:         %[[VAL_14:.*]] = call %[[VAL_12]]** @__quantum__rt__array_get_element_ptr_1d(%[[VAL_10]]* %[[VAL_9]], i64 1)
-// QIR:         %[[VAL_15:.*]] = load %[[VAL_12]]*, %[[VAL_12]]** %[[VAL_14]]
-// QIR:         call void @__quantum__qis__h(%[[VAL_12]]* %[[VAL_15]])
-// QIR:         %[[VAL_16:.*]] = call %[[VAL_17:.*]]* @__quantum__qis__mz(%[[VAL_12]]* %[[VAL_13]])
-// QIR:         %[[VAL_18:.*]] = bitcast %[[VAL_17]]* %[[VAL_16]] to i1*
-// QIR:         %[[VAL_19:.*]] = load i1, i1* %[[VAL_18]]
-// QIR:         %[[VAL_20:.*]] = zext i1 %[[VAL_19]] to i8
-// QIR:         %[[VAL_21:.*]] = call %[[VAL_17]]* @__quantum__qis__mz(%[[VAL_12]]* %[[VAL_15]])
-// QIR:         %[[VAL_22:.*]] = bitcast %[[VAL_17]]* %[[VAL_21]] to i1*
-// QIR:         %[[VAL_23:.*]] = load i1, i1* %[[VAL_22]]
-// QIR:         %[[VAL_24:.*]] = zext i1 %[[VAL_23]] to i8
-// QIR:         %[[VAL_25:.*]] = call dereferenceable_or_null(2) i8* @malloc(i64 2)
-// QIR:         store i8 %[[VAL_20]], i8* %[[VAL_25]]
-// QIR:         %[[VAL_26:.*]] = getelementptr inbounds i8, i8* %[[VAL_25]], i64 1
-// QIR:         store i8 %[[VAL_24]], i8* %[[VAL_26]]
-// QIR:         %[[VAL_27:.*]] = bitcast i8* %[[VAL_25]] to i1*
-// QIR:         %[[VAL_28:.*]] = insertvalue { i1*, i64 } undef, i1* %[[VAL_27]], 0
-// QIR:         %[[VAL_29:.*]] = insertvalue { i1*, i64 } %[[VAL_28]], i64 2, 1
-// QIR:         call void @__quantum__rt__qubit_release_array(%[[VAL_10]]* %[[VAL_9]])
-// QIR:         ret { i1*, i64 } %[[VAL_29]]
-// QIR:       }
+// QIR-LABEL: define { i1*, i64 } @__nvqpp__mlirgen__VanillaBean() local_unnamed_addr {
+// QIR:         %[[VAL_0:.*]] = alloca [4 x double], align 8
+// QIR:         %[[VAL_1:.*]] = getelementptr inbounds [4 x double], [4 x double]* %[[VAL_0]], i64 0, i64 0
+// QIR:         store double 0.000000e+00, double* %[[VAL_1]], align 8
+// QIR:         %[[VAL_2:.*]] = getelementptr inbounds [4 x double], [4 x double]* %[[VAL_0]], i64 0, i64 1
+// QIR:         store double 1.000000e+00, double* %[[VAL_2]], align 8
+// QIR:         %[[VAL_3:.*]] = getelementptr inbounds [4 x double], [4 x double]* %[[VAL_0]], i64 0, i64 2
+// QIR:         store double 1.000000e+00, double* %[[VAL_3]], align 8
+// QIR:         %[[VAL_4:.*]] = getelementptr inbounds [4 x double], [4 x double]* %[[VAL_0]], i64 0, i64 3
+// QIR:         store double 0.000000e+00, double* %[[VAL_4]], align 8
+// QIR:         %[[VAL_5:.*]] = bitcast [4 x double]* %[[VAL_0]] to i8*
+// QIR:         %[[VAL_6:.*]] = call i8** @__nvqpp_cudaq_state_createFromData_f64(i8* nonnull %[[VAL_5]], i64 4)
+// QIR:         %[[VAL_7:.*]] = call i64 @__nvqpp_cudaq_state_numberOfQubits(i8** %[[VAL_6]])
+// QIR:         %[[VAL_8:.*]] = call %[[VAL_9:.*]]* @__quantum__rt__qubit_allocate_array_with_cudaq_state_ptr(i64 %[[VAL_7]], i8** %[[VAL_6]])
+// QIR:         call void @__nvqpp_cudaq_state_delete(i8** %[[VAL_6]])
+// QIR:         %[[VAL_10:.*]] = call i64 @__quantum__rt__array_get_size_1d(%[[VAL_9]]* %[[VAL_8]])
+// QIR:         %[[VAL_11:.*]] = icmp sgt i64 %[[VAL_10]], 0
+// QIR:         br i1 %[[VAL_11]], label %[[VAL_12:.*]], label %[[VAL_13:.*]]
 
-// QIR-LABEL: define { i1*, i64 } @__nvqpp__mlirgen__RockyRoad()
-// QIR:         %[[VAL_0:.*]] = alloca double
-// QIR:         store double 0.000000e+00, double* %[[VAL_0]]
-// QIR:         %[[VAL_1:.*]] = tail call { double, double } @_ZNSt{{.*}}8literals16complex_literalsli1i{{.*}}Ee(
-// QIR:         %[[VAL_2:.*]] = alloca { double, double }
+// QIR-LABEL: define { i1*, i64 } @__nvqpp__mlirgen__Cherry() local_unnamed_addr {
+// QIR:         %[[VAL_0:.*]] = alloca [4 x { double, double }], align 8
+// QIR:         %[[VAL_1:.*]] = getelementptr inbounds [4 x { double, double }], [4 x { double, double }]* %[[VAL_0]], i64 0, i64 0, i32 0
+// QIR:         store double 0.000000e+00, double* %[[VAL_1]], align 8
+// QIR:         %[[VAL_2:.*]] = getelementptr inbounds [4 x { double, double }], [4 x { double, double }]* %[[VAL_0]], i64 0, i64 0, i32 1
+// QIR:         store double 1.000000e+00, double* %[[VAL_2]], align 8
+// QIR:         %[[VAL_3:.*]] = getelementptr inbounds [4 x { double, double }], [4 x { double, double }]* %[[VAL_0]], i64 0, i64 1, i32 0
+// QIR:         store double 6.000000e-01, double* %[[VAL_3]], align 8
+// QIR:         %[[VAL_4:.*]] = getelementptr inbounds [4 x { double, double }], [4 x { double, double }]* %[[VAL_0]], i64 0, i64 1, i32 1
+// QIR:         store double 4.000000e-01, double* %[[VAL_4]], align 8
+// QIR:         %[[VAL_5:.*]] = getelementptr inbounds [4 x { double, double }], [4 x { double, double }]* %[[VAL_0]], i64 0, i64 2, i32 0
+// QIR:         store double 1.000000e+00, double* %[[VAL_5]], align 8
+// QIR:         %[[VAL_6:.*]] = getelementptr inbounds [4 x { double, double }], [4 x { double, double }]* %[[VAL_0]], i64 0, i64 2, i32 1
+// QIR:         %[[VAL_7:.*]] = bitcast [4 x { double, double }]* %[[VAL_0]] to i8*
+// QIR:         %[[VAL_8:.*]] = bitcast double* %[[VAL_6]] to i8*
+// QIR:         call void @llvm.memset.p0i8.i64(i8* noundef nonnull align 8 dereferenceable(24) %[[VAL_8]], i8 0, i64 24, i1 false)
+// QIR:         %[[VAL_9:.*]] = call i8** @__nvqpp_cudaq_state_createFromData_complex_f64(i8* nonnull %[[VAL_7]], i64 4)
+// QIR:         %[[VAL_10:.*]] = call i64 @__nvqpp_cudaq_state_numberOfQubits(i8** %[[VAL_9]])
+// QIR:         %[[VAL_11:.*]] = call %[[VAL_12:.*]]* @__quantum__rt__qubit_allocate_array_with_cudaq_state_ptr(i64 %[[VAL_10]], i8** %[[VAL_9]])
+// QIR:         call void @__nvqpp_cudaq_state_delete(i8** %[[VAL_9]])
+// QIR:         %[[VAL_13:.*]] = call i64 @__quantum__rt__array_get_size_1d(%[[VAL_12]]* %[[VAL_11]])
+// QIR:         %[[VAL_14:.*]] = icmp sgt i64 %[[VAL_13]], 0
+// QIR:         br i1 %[[VAL_14]], label %[[VAL_15:.*]], label %[[VAL_16:.*]]
+
+// QIR-LABEL: define { i1*, i64 } @__nvqpp__mlirgen__MooseTracks() local_unnamed_addr {
+// QIR:         %[[VAL_0:.*]] = alloca [4 x { double, double }], align 8
+// QIR:         %[[VAL_1:.*]] = getelementptr inbounds [4 x { double, double }], [4 x { double, double }]* %[[VAL_0]], i64 0, i64 0, i32 0
+// QIR:         store double 0.000000e+00, double* %[[VAL_1]], align 8
+// QIR:         %[[VAL_2:.*]] = getelementptr inbounds [4 x { double, double }], [4 x { double, double }]* %[[VAL_0]], i64 0, i64 0, i32 1
+// QIR:         store double 1.000000e+00, double* %[[VAL_2]], align 8
+// QIR:         %[[VAL_3:.*]] = getelementptr inbounds [4 x { double, double }], [4 x { double, double }]* %[[VAL_0]], i64 0, i64 1, i32 0
+// QIR:         store double 7.500000e-01, double* %[[VAL_3]], align 8
+// QIR:         %[[VAL_4:.*]] = getelementptr inbounds [4 x { double, double }], [4 x { double, double }]* %[[VAL_0]], i64 0, i64 1, i32 1
+// QIR:         store double 2.500000e-01, double* %[[VAL_4]], align 8
+// QIR:         %[[VAL_5:.*]] = getelementptr inbounds [4 x { double, double }], [4 x { double, double }]* %[[VAL_0]], i64 0, i64 2, i32 0
+// QIR:         store double 1.000000e+00, double* %[[VAL_5]], align 8
+// QIR:         %[[VAL_6:.*]] = getelementptr inbounds [4 x { double, double }], [4 x { double, double }]* %[[VAL_0]], i64 0, i64 2, i32 1
+// QIR:         %[[VAL_7:.*]] = bitcast [4 x { double, double }]* %[[VAL_0]] to i8*
+// QIR:         %[[VAL_8:.*]] = bitcast double* %[[VAL_6]] to i8*
+// QIR:         call void @llvm.memset.p0i8.i64(i8* noundef nonnull align 8 dereferenceable(24) %[[VAL_8]], i8 0, i64 24, i1 false)
+// QIR:         %[[VAL_9:.*]] = call i8** @__nvqpp_cudaq_state_createFromData_complex_f64(i8* nonnull %[[VAL_7]], i64 4)
+// QIR:         %[[VAL_10:.*]] = call i64 @__nvqpp_cudaq_state_numberOfQubits(i8** %[[VAL_9]])
+// QIR:         %[[VAL_11:.*]] = call %[[VAL_12:.*]]* @__quantum__rt__qubit_allocate_array_with_cudaq_state_ptr(i64 %[[VAL_10]], i8** %[[VAL_9]])
+// QIR:         call void @__nvqpp_cudaq_state_delete(i8** %[[VAL_9]])
+// QIR:         %[[VAL_13:.*]] = call i64 @__quantum__rt__array_get_size_1d(%[[VAL_12]]* %[[VAL_11]])
+// QIR:         %[[VAL_14:.*]] = icmp sgt i64 %[[VAL_13]], 0
+// QIR:         br i1 %[[VAL_14]], label %[[VAL_15:.*]], label %[[VAL_16:.*]]
+
+// QIR-LABEL: define { i1*, i64 } @__nvqpp__mlirgen__RockyRoad() local_unnamed_addr {
+// QIR:         %[[VAL_0:.*]] = alloca double, align 8
+// QIR:         store double 0.000000e+00, double* %[[VAL_0]], align 8
+// QIR:         %[[VAL_1:.*]] = tail call { double, double } @_ZNSt8literals16complex_literalsli1iEe(x86_fp80 0xK3FFF8000000000000000)
+// QIR:         %[[VAL_2:.*]] = alloca { double, double }, align 8
 // QIR:         %[[VAL_3:.*]] = extractvalue { double, double } %[[VAL_1]], 0
 // QIR:         %[[VAL_4:.*]] = getelementptr inbounds { double, double }, { double, double }* %[[VAL_2]], i64 0, i32 0
-// QIR:         store double %[[VAL_3]], double* %[[VAL_4]]
+// QIR:         store double %[[VAL_3]], double* %[[VAL_4]], align 8
 // QIR:         %[[VAL_5:.*]] = extractvalue { double, double } %[[VAL_1]], 1
 // QIR:         %[[VAL_6:.*]] = getelementptr inbounds { double, double }, { double, double }* %[[VAL_2]], i64 0, i32 1
-// QIR:         store double %[[VAL_5]], double* %[[VAL_6]]
-// QIR:         %[[VAL_7:.*]] = call { double, double } @_Z{{.*}}7complex{{.*}}(double* {{.*}}%[[VAL_0]], { double, double }* {{.*}}%[[VAL_2]])
-// QIR:         %[[VAL_8:.*]] = alloca double
-// QIR:         store double 1.000000e+00, double* %[[VAL_8]]
-// QIR:         %[[VAL_9:.*]] = call { double, double } @_ZNSt{{.*}}8literals16complex_literalsli1i{{.*}}Ee(
-// QIR:         %[[VAL_10:.*]] = alloca { double, double }
+// QIR:         store double %[[VAL_5]], double* %[[VAL_6]], align 8
+// QIR:         %[[VAL_7:.*]] = call { double, double } @_ZStplIdESt7complexIT_ERKS1_RKS2_(double* nonnull %[[VAL_0]], { double, double }* nonnull %[[VAL_2]])
+// QIR:         %[[VAL_8:.*]] = alloca double, align 8
+// QIR:         store double 1.000000e+00, double* %[[VAL_8]], align 8
+// QIR:         %[[VAL_9:.*]] = call { double, double } @_ZNSt8literals16complex_literalsli1iEe(x86_fp80 0xK00000000000000000000)
+// QIR:         %[[VAL_10:.*]] = alloca { double, double }, align 8
 // QIR:         %[[VAL_11:.*]] = extractvalue { double, double } %[[VAL_9]], 0
 // QIR:         %[[VAL_12:.*]] = getelementptr inbounds { double, double }, { double, double }* %[[VAL_10]], i64 0, i32 0
-// QIR:         store double %[[VAL_11]], double* %[[VAL_12]]
+// QIR:         store double %[[VAL_11]], double* %[[VAL_12]], align 8
 // QIR:         %[[VAL_13:.*]] = extractvalue { double, double } %[[VAL_9]], 1
 // QIR:         %[[VAL_14:.*]] = getelementptr inbounds { double, double }, { double, double }* %[[VAL_10]], i64 0, i32 1
-// QIR:         store double %[[VAL_13]], double* %[[VAL_14]]
-// QIR:         %[[VAL_15:.*]] = call { double, double } @_Z{{.*}}7complex{{.*}}(double* {{.*}}%[[VAL_8]], { double, double }* {{.*}}%[[VAL_10]])
-// QIR:         %[[VAL_16:.*]] = alloca [4 x { double, double }]
-// QIR:         %[[VAL_17:.*]] = getelementptr inbounds [4 x { double, double }], [4 x { double, double }]* %[[VAL_16]], i64 0, i64 0
-// QIR:         %[[VAL_18:.*]] = extractvalue { double, double } %[[VAL_7]], 0
-// QIR:         %[[VAL_19:.*]] = getelementptr inbounds [4 x { double, double }], [4 x { double, double }]* %[[VAL_16]], i64 0, i64 0, i32 0
-// QIR:         store double %[[VAL_18]], double* %[[VAL_19]]
-// QIR:         %[[VAL_20:.*]] = extractvalue { double, double } %[[VAL_7]], 1
-// QIR:         %[[VAL_21:.*]] = getelementptr inbounds [4 x { double, double }], [4 x { double, double }]* %[[VAL_16]], i64 0, i64 0, i32 1
-// QIR:         store double %[[VAL_20]], double* %[[VAL_21]]
-// QIR:         %[[VAL_22:.*]] = getelementptr inbounds [4 x { double, double }], [4 x { double, double }]* %[[VAL_16]], i64 0, i64 1, i32 0
-// QIR:         store double 8.000000e-01, double* %[[VAL_22]]
-// QIR:         %[[VAL_23:.*]] = getelementptr inbounds [4 x { double, double }], [4 x { double, double }]* %[[VAL_16]], i64 0, i64 1, i32 1
-// QIR:         store double 2.000000e-01, double* %[[VAL_23]]
-// QIR:         %[[VAL_24:.*]] = extractvalue { double, double } %[[VAL_15]], 0
-// QIR:         %[[VAL_25:.*]] = getelementptr inbounds [4 x { double, double }], [4 x { double, double }]* %[[VAL_16]], i64 0, i64 2, i32 0
-// QIR:         store double %[[VAL_24]], double* %[[VAL_25]]
-// QIR:         %[[VAL_26:.*]] = extractvalue { double, double } %[[VAL_15]], 1
-// QIR:         %[[VAL_27:.*]] = getelementptr inbounds [4 x { double, double }], [4 x { double, double }]* %[[VAL_16]], i64 0, i64 2, i32 1
-// QIR:         store double %[[VAL_26]], double* %[[VAL_27]]
-// QIR:         %[[VAL_28:.*]] = getelementptr inbounds [4 x { double, double }], [4 x { double, double }]* %[[VAL_16]], i64 0, i64 3, i32 0
-// QIR:         %[[VAL_29:.*]] = bitcast double* %[[VAL_28]] to i8*
-// QIR:         call void @llvm.memset.p0i8.i64(i8* {{.*}}%[[VAL_29]], i8 0, i64 16, i1 false)
-// QIR:         %[[VAL_30:.*]] = call %[[VAL_31:.*]]* @__quantum__rt__qubit_allocate_array_with_state_complex64(i64 2, { double, double }* {{.*}}%[[VAL_17]])
-// QIR:         %[[VAL_32:.*]] = call %[[VAL_33:.*]]** @__quantum__rt__array_get_element_ptr_1d(%[[VAL_31]]* %[[VAL_30]], i64 0)
-// QIR:         %[[VAL_34:.*]] = load %[[VAL_33]]*, %[[VAL_33]]** %[[VAL_32]]
-// QIR:         call void @__quantum__qis__h(%[[VAL_33]]* %[[VAL_34]])
-// QIR:         %[[VAL_35:.*]] = call %[[VAL_33]]** @__quantum__rt__array_get_element_ptr_1d(%[[VAL_31]]* %[[VAL_30]], i64 1)
-// QIR:         %[[VAL_36:.*]] = load %[[VAL_33]]*, %[[VAL_33]]** %[[VAL_35]]
-// QIR:         call void @__quantum__qis__h(%[[VAL_33]]* %[[VAL_36]])
-// QIR:         %[[VAL_37:.*]] = call %[[VAL_38:.*]]* @__quantum__qis__mz(%[[VAL_33]]* %[[VAL_34]])
-// QIR:         %[[VAL_39:.*]] = bitcast %[[VAL_38]]* %[[VAL_37]] to i1*
-// QIR:         %[[VAL_40:.*]] = load i1, i1* %[[VAL_39]]
-// QIR:         %[[VAL_41:.*]] = zext i1 %[[VAL_40]] to i8
-// QIR:         %[[VAL_42:.*]] = call %[[VAL_38]]* @__quantum__qis__mz(%[[VAL_33]]* %[[VAL_36]])
-// QIR:         %[[VAL_43:.*]] = bitcast %[[VAL_38]]* %[[VAL_42]] to i1*
-// QIR:         %[[VAL_44:.*]] = load i1, i1* %[[VAL_43]]
-// QIR:         %[[VAL_45:.*]] = zext i1 %[[VAL_44]] to i8
-// QIR:         %[[VAL_46:.*]] = call dereferenceable_or_null(2) i8* @malloc(i64 2)
-// QIR:         store i8 %[[VAL_41]], i8* %[[VAL_46]]
-// QIR:         %[[VAL_47:.*]] = getelementptr inbounds i8, i8* %[[VAL_46]], i64 1
-// QIR:         store i8 %[[VAL_45]], i8* %[[VAL_47]]
-// QIR:         %[[VAL_48:.*]] = bitcast i8* %[[VAL_46]] to i1*
-// QIR:         %[[VAL_49:.*]] = insertvalue { i1*, i64 } undef, i1* %[[VAL_48]], 0
-// QIR:         %[[VAL_50:.*]] = insertvalue { i1*, i64 } %[[VAL_49]], i64 2, 1
-// QIR:         call void @__quantum__rt__qubit_release_array(%[[VAL_31]]* %[[VAL_30]])
-// QIR:         ret { i1*, i64 } %[[VAL_50]]
-// QIR:       }
-
-// QIR-LABEL: define i1 @__nvqpp__mlirgen__Pistachio()
+// QIR:         store double %[[VAL_13]], double* %[[VAL_14]], align 8
+// QIR:         %[[VAL_15:.*]] = call { double, double } @_ZStplIdESt7complexIT_ERKS1_RKS2_(double* nonnull %[[VAL_8]], { double, double }* nonnull %[[VAL_10]])
+// QIR:         %[[VAL_16:.*]] = alloca [4 x { double, double }], align 8
+// QIR:         %[[VAL_17:.*]] = extractvalue { double, double } %[[VAL_7]], 0
+// QIR:         %[[VAL_18:.*]] = getelementptr inbounds [4 x { double, double }], [4 x { double, double }]* %[[VAL_16]], i64 0, i64 0, i32 0
+// QIR:         store double %[[VAL_17]], double* %[[VAL_18]], align 8
+// QIR:         %[[VAL_19:.*]] = extractvalue { double, double } %[[VAL_7]], 1
+// QIR:         %[[VAL_20:.*]] = getelementptr inbounds [4 x { double, double }], [4 x { double, double }]* %[[VAL_16]], i64 0, i64 0, i32 1
+// QIR:         store double %[[VAL_19]], double* %[[VAL_20]], align 8
+// QIR:         %[[VAL_21:.*]] = getelementptr inbounds [4 x { double, double }], [4 x { double, double }]* %[[VAL_16]], i64 0, i64 1, i32 0
+// QIR:         store double 8.000000e-01, double* %[[VAL_21]], align 8
+// QIR:         %[[VAL_22:.*]] = getelementptr inbounds [4 x { double, double }], [4 x { double, double }]* %[[VAL_16]], i64 0, i64 1, i32 1
+// QIR:         store double 2.000000e-01, double* %[[VAL_22]], align 8
+// QIR:         %[[VAL_23:.*]] = extractvalue { double, double } %[[VAL_15]], 0
+// QIR:         %[[VAL_24:.*]] = getelementptr inbounds [4 x { double, double }], [4 x { double, double }]* %[[VAL_16]], i64 0, i64 2, i32 0
+// QIR:         store double %[[VAL_23]], double* %[[VAL_24]], align 8
+// QIR:         %[[VAL_25:.*]] = extractvalue { double, double } %[[VAL_15]], 1
+// QIR:         %[[VAL_26:.*]] = getelementptr inbounds [4 x { double, double }], [4 x { double, double }]* %[[VAL_16]], i64 0, i64 2, i32 1
+// QIR:         store double %[[VAL_25]], double* %[[VAL_26]], align 8
+// QIR:         %[[VAL_27:.*]] = getelementptr inbounds [4 x { double, double }], [4 x { double, double }]* %[[VAL_16]], i64 0, i64 3, i32 0
+// QIR:         %[[VAL_28:.*]] = bitcast [4 x { double, double }]* %[[VAL_16]] to i8*
+// QIR:         %[[VAL_29:.*]] = bitcast double* %[[VAL_27]] to i8*
+// QIR:         call void @llvm.memset.p0i8.i64(i8* noundef nonnull align 8 dereferenceable(16) %[[VAL_29]], i8 0, i64 16, i1 false)
+// QIR:         %[[VAL_30:.*]] = call i8** @__nvqpp_cudaq_state_createFromData_complex_f64(i8* nonnull %[[VAL_28]], i64 4)
+// QIR:         %[[VAL_31:.*]] = call i64 @__nvqpp_cudaq_state_numberOfQubits(i8** %[[VAL_30]])
+// QIR:         %[[VAL_32:.*]] = call %[[VAL_33:.*]]* @__quantum__rt__qubit_allocate_array_with_cudaq_state_ptr(i64 %[[VAL_31]], i8** %[[VAL_30]])
+// QIR:         call void @__nvqpp_cudaq_state_delete(i8** %[[VAL_30]])
+// QIR:         %[[VAL_34:.*]] = call i64 @__quantum__rt__array_get_size_1d(%[[VAL_33]]* %[[VAL_32]])
+// QIR:         %[[VAL_35:.*]] = icmp sgt i64 %[[VAL_34]], 0
+// QIR:         br i1 %[[VAL_35]], label %[[VAL_36:.*]], label %[[VAL_37:.*]]
+
+// QIR-LABEL: define i1 @__nvqpp__mlirgen__Pistachio() local_unnamed_addr {
 // QIR:         %[[VAL_0:.*]] = tail call { double*, i64 } @_Z15getTwoTimesRankv()
 // QIR:         %[[VAL_1:.*]] = extractvalue { double*, i64 } %[[VAL_0]], 0
 // QIR:         %[[VAL_2:.*]] = extractvalue { double*, i64 } %[[VAL_0]], 1
 // QIR:         %[[VAL_3:.*]] = shl i64 %[[VAL_2]], 3
-// QIR:         %[[VAL_4:.*]] = alloca double, i64 %[[VAL_3]]
+// QIR:         %[[VAL_4:.*]] = alloca double, i64 %[[VAL_3]], align 8
 // QIR:         %[[VAL_5:.*]] = bitcast double* %[[VAL_4]] to i8*
 // QIR:         %[[VAL_6:.*]] = bitcast double* %[[VAL_1]] to i8*
-// QIR:         call void @llvm.memcpy.p0i8.p0i8.i64(i8* {{.*}}%[[VAL_6]], i64 %[[VAL_3]], i1 false)
+// QIR:         call void @llvm.memcpy.p0i8.p0i8.i64(i8* nonnull align 8 %[[VAL_5]], i8* align 1 %[[VAL_6]], i64 %[[VAL_3]], i1 false)
 // QIR:         tail call void @free(i8* %[[VAL_6]])
-// QIR:         %[[VAL_7:.*]] = tail call i64 @llvm.cttz.i64(i64 %[[VAL_2]], i1 false), !range !1
-// QIR:         %[[VAL_8:.*]] = call %[[VAL_9:.*]]* @__quantum__rt__qubit_allocate_array_with_state_fp64(i64 %[[VAL_7]], double* {{.*}}%[[VAL_4]])
-// QIR:         %[[VAL_10:.*]] = call i64 @__quantum__rt__array_get_size_1d(%[[VAL_9]]* %[[VAL_8]])
-// QIR:         %[[VAL_11:.*]] = icmp sgt i64 %[[VAL_10]], 0
-// QIR:         br i1 %[[VAL_11]], label %[[VAL_12:.*]], label %[[VAL_13:.*]]
-// QIR:       .lr.ph:                                           ; preds = %[[VAL_14:.*]], %[[VAL_12]]
-// QIR:         %[[VAL_15:.*]] = phi i64 [ %[[VAL_16:.*]], %[[VAL_12]] ], [ 0, %[[VAL_14]] ]
-// QIR:         %[[VAL_17:.*]] = call %[[VAL_18:.*]]** @__quantum__rt__array_get_element_ptr_1d(%[[VAL_9]]* %[[VAL_8]], i64 %[[VAL_15]])
-// QIR:         %[[VAL_19:.*]] = load %[[VAL_18]]*, %[[VAL_18]]** %[[VAL_17]]
-// QIR:         call void @__quantum__qis__h(%[[VAL_18]]* %[[VAL_19]])
-// QIR:         %[[VAL_16]] = add nuw nsw i64 %[[VAL_15]], 1
-// QIR:         %[[VAL_20:.*]] = icmp eq i64 %[[VAL_16]], %[[VAL_10]]
-// QIR:         br i1 %[[VAL_20]], label %[[VAL_13]], label %[[VAL_12]]
-// QIR:       ._crit_edge:                                      ; preds = %[[VAL_12]], %[[VAL_14]]
-// QIR:         %[[VAL_21:.*]] = call %[[VAL_18]]** @__quantum__rt__array_get_element_ptr_1d(%[[VAL_9]]* %[[VAL_8]], i64 0)
-// QIR:         %[[VAL_22:.*]] = load %[[VAL_18]]*, %[[VAL_18]]** %[[VAL_21]]
-// QIR:         %[[VAL_23:.*]] = call %[[VAL_24:.*]]* @__quantum__qis__mz(%[[VAL_18]]* %[[VAL_22]])
-// QIR:         %[[VAL_25:.*]] = bitcast %[[VAL_24]]* %[[VAL_23]] to i1*
-// QIR:         %[[VAL_26:.*]] = load i1, i1* %[[VAL_25]]
-// QIR:         call void @__quantum__rt__qubit_release_array(%[[VAL_9]]* %[[VAL_8]])
-// QIR:         ret i1 %[[VAL_26]]
-// QIR:       }
-
-// QIR-LABEL: define i1 @__nvqpp__mlirgen__ChocolateMint()
+// QIR:         %[[VAL_8:.*]] = call i8** @__nvqpp_cudaq_state_createFromData_f64(i8* nonnull %[[VAL_5]], i64 %
+// QIR:         %[[VAL_9:.*]] = call i64 @__nvqpp_cudaq_state_numberOfQubits(i8** %[[VAL_8]])
+// QIR:         %[[VAL_10:.*]] = call %[[VAL_11:.*]]* @__quantum__rt__qubit_allocate_array_with_cudaq_state_ptr(i64 %[[VAL_9]], i8** %[[VAL_8]])
+// QIR:         call void @__nvqpp_cudaq_state_delete(i8** %[[VAL_8]])
+// QIR:         %[[VAL_12:.*]] = call i64 @__quantum__rt__array_get_size_1d(%[[VAL_11]]* %[[VAL_10]])
+// QIR:         %[[VAL_13:.*]] = icmp sgt i64 %[[VAL_12]], 0
+// QIR:         br i1 %[[VAL_13]], label %[[VAL_14:.*]], label %[[VAL_15:.*]]
+
+// QIR-LABEL: define i1 @__nvqpp__mlirgen__ChocolateMint() local_unnamed_addr {
 // QIR:         %[[VAL_0:.*]] = tail call { double*, i64 } @_Z15getTwoTimesRankv()
 // QIR:         %[[VAL_1:.*]] = extractvalue { double*, i64 } %[[VAL_0]], 0
 // QIR:         %[[VAL_2:.*]] = extractvalue { double*, i64 } %[[VAL_0]], 1
 // QIR:         %[[VAL_3:.*]] = shl i64 %[[VAL_2]], 3
-// QIR:         %[[VAL_4:.*]] = alloca double, i64 %[[VAL_3]]
+// QIR:         %[[VAL_4:.*]] = alloca double, i64 %[[VAL_3]], align 8
 // QIR:         %[[VAL_5:.*]] = bitcast double* %[[VAL_4]] to i8*
 // QIR:         %[[VAL_6:.*]] = bitcast double* %[[VAL_1]] to i8*
-// QIR:         call void @llvm.memcpy.p0i8.p0i8.i64(i8* {{.*}}%[[VAL_5]], i8* {{.*}}%[[VAL_6]], i64 %[[VAL_3]], i1 false)
+// QIR:         call void @llvm.memcpy.p0i8.p0i8.i64(i8* nonnull align 8 %[[VAL_5]], i8* align 1 %[[VAL_6]], i64 %[[VAL_3]], i1 false)
 // QIR:         tail call void @free(i8* %[[VAL_6]])
-// QIR:         %[[VAL_7:.*]] = tail call i64 @llvm.cttz.i64(i64 %[[VAL_2]], i1 false), !range !1
-// QIR:         %[[VAL_8:.*]] = call %[[VAL_9:.*]]* @__quantum__rt__qubit_allocate_array_with_state_fp64(i64 %[[VAL_7]], double* {{.*}}%[[VAL_4]])
-// QIR:         %[[VAL_10:.*]] = call i64 @__quantum__rt__array_get_size_1d(%[[VAL_9]]* %[[VAL_8]])
-// QIR:         %[[VAL_11:.*]] = icmp sgt i64 %[[VAL_10]], 0
-// QIR:         br i1 %[[VAL_11]], label %[[VAL_12:.*]], label %[[VAL_13:.*]]
-// QIR:       .lr.ph:                                           ; preds = %[[VAL_14:.*]], %[[VAL_12]]
-// QIR:         %[[VAL_15:.*]] = phi i64 [ %[[VAL_16:.*]], %[[VAL_12]] ], [ 0, %[[VAL_14]] ]
-// QIR:         %[[VAL_17:.*]] = call %[[VAL_18:.*]]** @__quantum__rt__array_get_element_ptr_1d(%[[VAL_9]]* %[[VAL_8]], i64 %[[VAL_15]])
-// QIR:         %[[VAL_19:.*]] = load %[[VAL_18]]*, %[[VAL_18]]** %[[VAL_17]]
-// QIR:         call void @__quantum__qis__h(%[[VAL_18]]* %[[VAL_19]])
-// QIR:         %[[VAL_16]] = add nuw nsw i64 %[[VAL_15]], 1
-// QIR:         %[[VAL_20:.*]] = icmp eq i64 %[[VAL_16]], %[[VAL_10]]
-// QIR:         br i1 %[[VAL_20]], label %[[VAL_13]], label %[[VAL_12]]
-// QIR:       ._crit_edge:                                      ; preds = %[[VAL_12]], %[[VAL_14]]
-// QIR:         %[[VAL_21:.*]] = call %[[VAL_18]]** @__quantum__rt__array_get_element_ptr_1d(%[[VAL_9]]* %[[VAL_8]], i64 0)
-// QIR:         %[[VAL_22:.*]] = load %[[VAL_18]]*, %[[VAL_18]]** %[[VAL_21]]
-// QIR:         %[[VAL_23:.*]] = call %[[VAL_24:.*]]* @__quantum__qis__mz(%[[VAL_18]]* %[[VAL_22]])
-// QIR:         %[[VAL_25:.*]] = bitcast %[[VAL_24]]* %[[VAL_23]] to i1*
-// QIR:         %[[VAL_26:.*]] = load i1, i1* %[[VAL_25]]
-// QIR:         call void @__quantum__rt__qubit_release_array(%[[VAL_9]]* %[[VAL_8]])
-// QIR:         ret i1 %[[VAL_26]]
-// QIR:       }
-
-// QIR-LABEL: define { i1*, i64 } @__nvqpp__mlirgen__Neapolitan()
+// QIR:         %[[VAL_8:.*]] = call i8** @__nvqpp_cudaq_state_createFromData_f64(i8* nonnull %[[VAL_5]], i64 %
+// QIR:         %[[VAL_9:.*]] = call i64 @__nvqpp_cudaq_state_numberOfQubits(i8** %[[VAL_8]])
+// QIR:         %[[VAL_10:.*]] = call %[[VAL_11:.*]]* @__quantum__rt__qubit_allocate_array_with_cudaq_state_ptr(i64 %[[VAL_9]], i8** %[[VAL_8]])
+// QIR:         call void @__nvqpp_cudaq_state_delete(i8** %[[VAL_8]])
+// QIR:         %[[VAL_12:.*]] = call i64 @__quantum__rt__array_get_size_1d(%[[VAL_11]]* %[[VAL_10]])
+// QIR:         %[[VAL_13:.*]] = icmp sgt i64 %[[VAL_12]], 0
+// QIR:         br i1 %[[VAL_13]], label %[[VAL_14:.*]], label %[[VAL_15:.*]]
+
+// QIR-LABEL: define { i1*, i64 } @__nvqpp__mlirgen__Neapolitan() local_unnamed_addr {
 // QIR:         %[[VAL_0:.*]] = tail call { { double, double }*, i64 } @_Z14getComplexInitv()
 // QIR:         %[[VAL_1:.*]] = extractvalue { { double, double }*, i64 } %[[VAL_0]], 0
 // QIR:         %[[VAL_2:.*]] = extractvalue { { double, double }*, i64 } %[[VAL_0]], 1
 // QIR:         %[[VAL_3:.*]] = shl i64 %[[VAL_2]], 4
-// QIR:         %[[VAL_4:.*]] = alloca { double, double }, i64 %[[VAL_3]]
+// QIR:         %[[VAL_4:.*]] = alloca { double, double }, i64 %[[VAL_3]], align 8
 // QIR:         %[[VAL_5:.*]] = bitcast { double, double }* %[[VAL_4]] to i8*
 // QIR:         %[[VAL_6:.*]] = bitcast { double, double }* %[[VAL_1]] to i8*
-// QIR:         call void @llvm.memcpy.p0i8.p0i8.i64(i8* {{.*}}%[[VAL_5]], i8* {{.*}}%[[VAL_6]], i64 %[[VAL_3]], i1 false)
+// QIR:         call void @llvm.memcpy.p0i8.p0i8.i64(i8* nonnull align 8 %[[VAL_5]], i8* align 1 %[[VAL_6]], i64 %[[VAL_3]], i1 false)
 // QIR:         tail call void @free(i8* %[[VAL_6]])
-// QIR:         %[[VAL_7:.*]] = tail call i64 @llvm.cttz.i64(i64 %[[VAL_2]], i1 false), !range !1
-// QIR:         %[[VAL_8:.*]] = call %[[VAL_9:.*]]* @__quantum__rt__qubit_allocate_array_with_state_complex64(i64 %[[VAL_7]], { double, double }* {{.*}}%[[VAL_4]])
-// QIR:         %[[VAL_10:.*]] = call i64 @__quantum__rt__array_get_size_1d(%[[VAL_9]]* %[[VAL_8]])
-// QIR:         %[[VAL_11:.*]] = icmp sgt i64 %[[VAL_10]], 0
-// QIR:         br i1 %[[VAL_11]], label %[[VAL_12:.*]], label %[[VAL_13:.*]]
-// QIR:       ._crit_edge.thread:                               ; preds = %[[VAL_14:.*]]
-// QIR:         %[[VAL_15:.*]] = alloca i8, i64 %[[VAL_10]]
-// QIR:         br label %[[VAL_16:.*]]
-// QIR:       .lr.ph:                                           ; preds = %[[VAL_14]], %[[VAL_12]]
-// QIR:         %[[VAL_17:.*]] = phi i64 [ %[[VAL_18:.*]], %[[VAL_12]] ], [ 0, %[[VAL_14]] ]
-// QIR:         %[[VAL_19:.*]] = call %[[VAL_20:.*]]** @__quantum__rt__array_get_element_ptr_1d(%[[VAL_9]]* %[[VAL_8]], i64 %[[VAL_17]])
-// QIR:         %[[VAL_21:.*]] = load %[[VAL_20]]*, %[[VAL_20]]** %[[VAL_19]]
-// QIR:         call void @__quantum__qis__h(%[[VAL_20]]* %[[VAL_21]])
-// QIR:         %[[VAL_18]] = add nuw nsw i64 %[[VAL_17]], 1
-// QIR:         %[[VAL_22:.*]] = icmp eq i64 %[[VAL_18]], %[[VAL_10]]
-// QIR:         br i1 %[[VAL_22]], label %[[VAL_23:.*]], label %[[VAL_12]]
-// QIR:       ._crit_edge:                                      ; preds = %[[VAL_12]]
-// QIR:         %[[VAL_24:.*]] = alloca i8, i64 %[[VAL_10]]
-// QIR:         br i1 %[[VAL_11]], label %[[VAL_25:.*]], label %[[VAL_16]]
-// QIR:       .lr.ph4:                                          ; preds = %[[VAL_23]], %[[VAL_25]]
-// QIR:         %[[VAL_26:.*]] = phi i64 [ %[[VAL_27:.*]], %[[VAL_25]] ], [ 0, %[[VAL_23]] ]
-// QIR:         %[[VAL_28:.*]] = call %[[VAL_20]]** @__quantum__rt__array_get_element_ptr_1d(%[[VAL_9]]* %[[VAL_8]], i64 %[[VAL_26]])
-// QIR:         %[[VAL_29:.*]] = load %[[VAL_20]]*, %[[VAL_20]]** %[[VAL_28]]
-// QIR:         %[[VAL_30:.*]] = call %[[VAL_31:.*]]* @__quantum__qis__mz(%[[VAL_20]]* %[[VAL_29]])
-// QIR:         %[[VAL_32:.*]] = bitcast %[[VAL_31]]* %[[VAL_30]] to i1*
-// QIR:         %[[VAL_33:.*]] = load i1, i1* %[[VAL_32]]
-// QIR:         %[[VAL_34:.*]] = getelementptr i8, i8* %[[VAL_24]], i64 %[[VAL_26]]
-// QIR:         %[[VAL_35:.*]] = zext i1 %[[VAL_33]] to i8
-// QIR:         store i8 %[[VAL_35]], i8* %[[VAL_34]]
-// QIR:         %[[VAL_27]] = add nuw nsw i64 %[[VAL_26]], 1
-// QIR:         %[[VAL_36:.*]] = icmp eq i64 %[[VAL_27]], %[[VAL_10]]
-// QIR:         br i1 %[[VAL_36]], label %[[VAL_16]], label %[[VAL_25]]
-// QIR:       ._crit_edge5:                                     ; preds = %[[VAL_25]], %[[VAL_13]], %[[VAL_23]]
-// QIR:         %[[VAL_37:.*]] = phi i8* [ %[[VAL_15]], %[[VAL_13]] ], [ %[[VAL_24]], %[[VAL_23]] ], [ %[[VAL_24]], %[[VAL_25]] ]
-// QIR:         %[[VAL_38:.*]] = call i8* @malloc(i64 %[[VAL_10]])
-// QIR:         call void @llvm.memcpy.p0i8.p0i8.i64(i8* {{.*}}%[[VAL_38]], i8* {{.*}}%[[VAL_37]], i64 %[[VAL_10]], i1 false)
-// QIR:         %[[VAL_39:.*]] = bitcast i8* %[[VAL_38]] to i1*
-// QIR:         %[[VAL_40:.*]] = insertvalue { i1*, i64 } undef, i1* %[[VAL_39]], 0
-// QIR:         %[[VAL_41:.*]] = insertvalue { i1*, i64 } %[[VAL_40]], i64 %[[VAL_10]], 1
-// QIR:         call void @__quantum__rt__qubit_release_array(%[[VAL_9]]* %[[VAL_8]])
-// QIR:         ret { i1*, i64 } %[[VAL_41]]
-// QIR:       }
-
-// QIR-LABEL: define { i1*, i64 } @__nvqpp__mlirgen__ButterPecan()
+// QIR:         %[[VAL_8:.*]] = call i8** @__nvqpp_cudaq_state_createFromData_complex_f64(i8* nonnull %[[VAL_5]], i64 %
+// QIR:         %[[VAL_9:.*]] = call i64 @__nvqpp_cudaq_state_numberOfQubits(i8** %[[VAL_8]])
+// QIR:         %[[VAL_10:.*]] = call %[[VAL_11:.*]]* @__quantum__rt__qubit_allocate_array_with_cudaq_state_ptr(i64 %[[VAL_9]], i8** %[[VAL_8]])
+// QIR:         call void @__nvqpp_cudaq_state_delete(i8** %[[VAL_8]])
+// QIR:         %[[VAL_12:.*]] = call i64 @__quantum__rt__array_get_size_1d(%[[VAL_11]]* %[[VAL_10]])
+// QIR:         %[[VAL_13:.*]] = icmp sgt i64 %[[VAL_12]], 0
+// QIR:         br i1 %[[VAL_13]], label %[[VAL_14:.*]], label %[[VAL_15:.*]]
+
+// QIR-LABEL: define { i1*, i64 } @__nvqpp__mlirgen__ButterPecan() local_unnamed_addr {
 // QIR:         %[[VAL_0:.*]] = tail call { { double, double }*, i64 } @_Z14getComplexInitv()
 // QIR:         %[[VAL_1:.*]] = extractvalue { { double, double }*, i64 } %[[VAL_0]], 0
 // QIR:         %[[VAL_2:.*]] = extractvalue { { double, double }*, i64 } %[[VAL_0]], 1
 // QIR:         %[[VAL_3:.*]] = shl i64 %[[VAL_2]], 4
-// QIR:         %[[VAL_4:.*]] = alloca { double, double }, i64 %[[VAL_3]]
+// QIR:         %[[VAL_4:.*]] = alloca { double, double }, i64 %[[VAL_3]], align 8
 // QIR:         %[[VAL_5:.*]] = bitcast { double, double }* %[[VAL_4]] to i8*
 // QIR:         %[[VAL_6:.*]] = bitcast { double, double }* %[[VAL_1]] to i8*
-// QIR:         call void @llvm.memcpy.p0i8.p0i8.i64(i8* {{.*}}%[[VAL_5]], i8* {{.*}}%[[VAL_6]], i64 %[[VAL_3]], i1 false)
+// QIR:         call void @llvm.memcpy.p0i8.p0i8.i64(i8* nonnull align 8 %[[VAL_5]], i8* align 1 %[[VAL_6]], i64 %[[VAL_3]], i1 false)
 // QIR:         tail call void @free(i8* %[[VAL_6]])
-// QIR:         %[[VAL_7:.*]] = tail call i64 @llvm.cttz.i64(i64 %[[VAL_2]], i1 false), !range !1
-// QIR:         %[[VAL_8:.*]] = call %[[VAL_9:.*]]* @__quantum__rt__qubit_allocate_array_with_state_complex64(i64 %[[VAL_7]], { double, double }* {{.*}}%[[VAL_4]])
-// QIR:         %[[VAL_10:.*]] = call i64 @__quantum__rt__array_get_size_1d(%[[VAL_9]]* %[[VAL_8]])
-// QIR:         %[[VAL_11:.*]] = icmp sgt i64 %[[VAL_10]], 0
-// QIR:         br i1 %[[VAL_11]], label %[[VAL_12:.*]], label %[[VAL_13:.*]]
-// QIR:       ._crit_edge.thread:                               ; preds = %[[VAL_14:.*]]
-// QIR:         %[[VAL_15:.*]] = alloca i8, i64 %[[VAL_10]]
-// QIR:         br label %[[VAL_16:.*]]
-// QIR:       .lr.ph:                                           ; preds = %[[VAL_14]], %[[VAL_12]]
-// QIR:         %[[VAL_17:.*]] = phi i64 [ %[[VAL_18:.*]], %[[VAL_12]] ], [ 0, %[[VAL_14]] ]
-// QIR:         %[[VAL_19:.*]] = call %[[VAL_20:.*]]** @__quantum__rt__array_get_element_ptr_1d(%[[VAL_9]]* %[[VAL_8]], i64 %[[VAL_17]])
-// QIR:         %[[VAL_21:.*]] = load %[[VAL_20]]*, %[[VAL_20]]** %[[VAL_19]]
-// QIR:         call void @__quantum__qis__h(%[[VAL_20]]* %[[VAL_21]])
-// QIR:         %[[VAL_18]] = add nuw nsw i64 %[[VAL_17]], 1
-// QIR:         %[[VAL_22:.*]] = icmp eq i64 %[[VAL_18]], %[[VAL_10]]
-// QIR:         br i1 %[[VAL_22]], label %[[VAL_23:.*]], label %[[VAL_12]]
-// QIR:       ._crit_edge:                                      ; preds = %[[VAL_12]]
-// QIR:         %[[VAL_24:.*]] = alloca i8, i64 %[[VAL_10]]
-// QIR:         br i1 %[[VAL_11]], label %[[VAL_25:.*]], label %[[VAL_16]]
-// QIR:       .lr.ph4:                                          ; preds = %[[VAL_23]], %[[VAL_25]]
-// QIR:         %[[VAL_26:.*]] = phi i64 [ %[[VAL_27:.*]], %[[VAL_25]] ], [ 0, %[[VAL_23]] ]
-// QIR:         %[[VAL_28:.*]] = call %[[VAL_20]]** @__quantum__rt__array_get_element_ptr_1d(%[[VAL_9]]* %[[VAL_8]], i64 %[[VAL_26]])
-// QIR:         %[[VAL_29:.*]] = load %[[VAL_20]]*, %[[VAL_20]]** %[[VAL_28]]
-// QIR:         %[[VAL_30:.*]] = call %[[VAL_31:.*]]* @__quantum__qis__mz(%[[VAL_20]]* %[[VAL_29]])
-// QIR:         %[[VAL_32:.*]] = bitcast %[[VAL_31]]* %[[VAL_30]] to i1*
-// QIR:         %[[VAL_33:.*]] = load i1, i1* %[[VAL_32]]
-// QIR:         %[[VAL_34:.*]] = getelementptr i8, i8* %[[VAL_24]], i64 %[[VAL_26]]
-// QIR:         %[[VAL_35:.*]] = zext i1 %[[VAL_33]] to i8
-// QIR:         store i8 %[[VAL_35]], i8* %[[VAL_34]]
-// QIR:         %[[VAL_27]] = add nuw nsw i64 %[[VAL_26]], 1
-// QIR:         %[[VAL_36:.*]] = icmp eq i64 %[[VAL_27]], %[[VAL_10]]
-// QIR:         br i1 %[[VAL_36]], label %[[VAL_16]], label %[[VAL_25]]
-// QIR:       ._crit_edge5:                                     ; preds = %[[VAL_25]], %[[VAL_13]], %[[VAL_23]]
-// QIR:         %[[VAL_37:.*]] = phi i8* [ %[[VAL_15]], %[[VAL_13]] ], [ %[[VAL_24]], %[[VAL_23]] ], [ %[[VAL_24]], %[[VAL_25]] ]
-// QIR:         %[[VAL_38:.*]] = call i8* @malloc(i64 %[[VAL_10]])
-// QIR:         call void @llvm.memcpy.p0i8.p0i8.i64(i8* {{.*}}%[[VAL_38]], i8* {{.*}}%[[VAL_37]], i64 %[[VAL_10]], i1 false)
-// QIR:         %[[VAL_39:.*]] = bitcast i8* %[[VAL_38]] to i1*
-// QIR:         %[[VAL_40:.*]] = insertvalue { i1*, i64 } undef, i1* %[[VAL_39]], 0
-// QIR:         %[[VAL_41:.*]] = insertvalue { i1*, i64 } %[[VAL_40]], i64 %[[VAL_10]], 1
-// QIR:         call void @__quantum__rt__qubit_release_array(%[[VAL_9]]* %[[VAL_8]])
-// QIR:         ret { i1*, i64 } %[[VAL_41]]
-// QIR:       }
-
-// QIR-LABEL: define i1 @__nvqpp__mlirgen__function_Strawberry._Z10Strawberryv()
-// QIR:         %[[VAL_0:.*]] = alloca [2 x { double, double }]
-// QIR:         %[[VAL_1:.*]] = getelementptr inbounds [2 x { double, double }], [2 x { double, double }]* %[[VAL_0]], i64 0, i64 0
-// QIR:         %[[VAL_2:.*]] = getelementptr inbounds [2 x { double, double }], [2 x { double, double }]* %[[VAL_0]], i64 0, i64 1, i32 0
-// QIR:         %[[VAL_3:.*]] = bitcast [2 x { double, double }]* %[[VAL_0]] to i8*
-// QIR:         call void @llvm.memset.p0i8.i64(i8* {{.*}}%[[VAL_3]], i8 0, i64 16, i1 false)
-// QIR:         store double 1.000000e+00, double* %[[VAL_2]]
-// QIR:         %[[VAL_4:.*]] = getelementptr inbounds [2 x { double, double }], [2 x { double, double }]* %[[VAL_0]], i64 0, i64 1, i32 1
-// QIR:         store double 0.000000e+00, double* %[[VAL_4]]
-// QIR:         %[[VAL_5:.*]] = call %[[VAL_6:.*]]* @__quantum__rt__qubit_allocate_array_with_state_complex64(i64 1, { double, double }* {{.*}}%[[VAL_1]])
+// QIR:         %[[VAL_8:.*]] = call i8** @__nvqpp_cudaq_state_createFromData_complex_f64(i8* nonnull %[[VAL_5]], i64 %
+// QIR:         %[[VAL_9:.*]] = call i64 @__nvqpp_cudaq_state_numberOfQubits(i8** %[[VAL_8]])
+// QIR:         %[[VAL_10:.*]] = call %[[VAL_11:.*]]* @__quantum__rt__qubit_allocate_array_with_cudaq_state_ptr(i64 %[[VAL_9]], i8** %[[VAL_8]])
+// QIR:         call void @__nvqpp_cudaq_state_delete(i8** %[[VAL_8]])
+// QIR:         %[[VAL_12:.*]] = call i64 @__quantum__rt__array_get_size_1d(%[[VAL_11]]* %[[VAL_10]])
+// QIR:         %[[VAL_13:.*]] = icmp sgt i64 %[[VAL_12]], 0
+// QIR:         br i1 %[[VAL_13]], label %[[VAL_14:.*]], label %[[VAL_15:.*]]
+
+// QIR-LABEL: define i1 @__nvqpp__mlirgen__function_Strawberry._Z10Strawberryv() local_unnamed_addr {
+// QIR:         %[[VAL_0:.*]] = alloca [2 x double], align 8
+// QIR:         %[[VAL_1:.*]] = getelementptr inbounds [2 x double], [2 x double]* %[[VAL_0]], i64 0, i64 0
+// QIR:         store double 0.000000e+00, double* %[[VAL_1]], align 8
+// QIR:         %[[VAL_2:.*]] = getelementptr inbounds [2 x double], [2 x double]* %[[VAL_0]], i64 0, i64 1
+// QIR:         store double 1.000000e+00, double* %[[VAL_2]], align 8
+// QIR:         %[[VAL_3:.*]] = bitcast [2 x double]* %[[VAL_0]] to i8*
+// QIR:         %[[VAL_4:.*]] = call i8** @__nvqpp_cudaq_state_createFromData_f64(i8* nonnull %[[VAL_3]], i64 2)
+// QIR:         %[[VAL_5:.*]] = call %[[VAL_6:.*]]* @__quantum__rt__qubit_allocate_array_with_cudaq_state_ptr(i64 1, i8** %[[VAL_4]])
+// QIR:         call void @__nvqpp_cudaq_state_delete(i8** %[[VAL_4]])
 // QIR:         %[[VAL_7:.*]] = call %[[VAL_8:.*]]** @__quantum__rt__array_get_element_ptr_1d(%[[VAL_6]]* %[[VAL_5]], i64 0)
-// QIR:         %[[VAL_9:.*]] = load %[[VAL_8]]*, %[[VAL_8]]** %[[VAL_7]]
+// QIR:         %[[VAL_9:.*]] = load %[[VAL_8]]*, %[[VAL_8]]** %[[VAL_7]], align 8
 // QIR:         %[[VAL_10:.*]] = call %[[VAL_11:.*]]* @__quantum__qis__mz(%[[VAL_8]]* %[[VAL_9]])
 // QIR:         %[[VAL_12:.*]] = bitcast %[[VAL_11]]* %[[VAL_10]] to i1*
-// QIR:         %[[VAL_13:.*]] = load i1, i1* %[[VAL_12]]
+// QIR:         %[[VAL_13:.*]] = load i1, i1* %[[VAL_12]], align 1
 // QIR:         call void @__quantum__rt__qubit_release_array(%[[VAL_6]]* %[[VAL_5]])
 // QIR:         ret i1 %[[VAL_13]]
 // QIR:       }
 
-// QIR-LABEL: define i1 @__nvqpp__mlirgen__function_Peppermint._Z10Peppermintv()
-// QIR:         %[[VAL_0:.*]] = alloca [2 x { double, double }]
-// QIR:         %[[VAL_1:.*]] = getelementptr inbounds [2 x { double, double }], [2 x { double, double }]* %[[VAL_0]], i64 0, i64 0
-// QIR:         %[[VAL_2:.*]] = getelementptr inbounds [2 x { double, double }], [2 x { double, double }]* %[[VAL_0]], i64 0, i64 0, i32 0
-// QIR:         store double 0x3FE6A09E667F3BCD, double* %[[VAL_2]]
-// QIR:         %[[VAL_3:.*]] = getelementptr inbounds [2 x { double, double }], [2 x { double, double }]* %[[VAL_0]], i64 0, i64 0, i32 1
-// QIR:         store double 0.000000e+00, double* %[[VAL_3]]
-// QIR:         %[[VAL_4:.*]] = getelementptr inbounds [2 x { double, double }], [2 x { double, double }]* %[[VAL_0]], i64 0, i64 1, i32 0
-// QIR:         store double 0x3FE6A09E667F3BCD, double* %[[VAL_4]]
-// QIR:         %[[VAL_5:.*]] = getelementptr inbounds [2 x { double, double }], [2 x { double, double }]* %[[VAL_0]], i64 0, i64 1, i32 1
-// QIR:         store double 0.000000e+00, double* %[[VAL_5]]
-// QIR:         %[[VAL_6:.*]] = call %[[VAL_7:.*]]* @__quantum__rt__qubit_allocate_array_with_state_complex64(i64 1, { double, double }* {{.*}}%[[VAL_1]])
-// QIR:         %[[VAL_8:.*]] = call %[[VAL_9:.*]]** @__quantum__rt__array_get_element_ptr_1d(%[[VAL_7]]* %[[VAL_6]], i64 0)
-// QIR:         %[[VAL_10:.*]] = load %[[VAL_9]]*, %[[VAL_9]]** %[[VAL_8]]
-// QIR:         %[[VAL_11:.*]] = call %[[VAL_12:.*]]* @__quantum__qis__mz(%[[VAL_9]]* %[[VAL_10]])
-// QIR:         %[[VAL_13:.*]] = bitcast %[[VAL_12]]* %[[VAL_11]] to i1*
-// QIR:         %[[VAL_14:.*]] = load i1, i1* %[[VAL_13]]
-// QIR:         call void @__quantum__rt__qubit_release_array(%[[VAL_7]]* %[[VAL_6]])
-// QIR:         ret i1 %[[VAL_14]]
+// QIR-LABEL: define i1 @__nvqpp__mlirgen__function_Peppermint._Z10Peppermintv() local_unnamed_addr {
+// QIR:         %[[VAL_0:.*]] = alloca [2 x double], align 8
+// QIR:         %[[VAL_1:.*]] = getelementptr inbounds [2 x double], [2 x double]* %[[VAL_0]], i64 0, i64 0
+// QIR:         store double 0x3FE6A09E667F3BCD, double* %[[VAL_1]], align 8
+// QIR:         %[[VAL_2:.*]] = getelementptr inbounds [2 x double], [2 x double]* %[[VAL_0]], i64 0, i64 1
+// QIR:         store double 0x3FE6A09E667F3BCD, double* %[[VAL_2]], align 8
+// QIR:         %[[VAL_3:.*]] = bitcast [2 x double]* %[[VAL_0]] to i8*
+// QIR:         %[[VAL_4:.*]] = call i8** @__nvqpp_cudaq_state_createFromData_f64(i8* nonnull %[[VAL_3]], i64 2)
+// QIR:         %[[VAL_5:.*]] = call %[[VAL_6:.*]]* @__quantum__rt__qubit_allocate_array_with_cudaq_state_ptr(i64 1, i8** %[[VAL_4]])
+// QIR:         call void @__nvqpp_cudaq_state_delete(i8** %[[VAL_4]])
+// QIR:         %[[VAL_7:.*]] = call %[[VAL_8:.*]]** @__quantum__rt__array_get_element_ptr_1d(%[[VAL_6]]* %[[VAL_5]], i64 0)
+// QIR:         %[[VAL_9:.*]] = load %[[VAL_8]]*, %[[VAL_8]]** %[[VAL_7]], align 8
+// QIR:         %[[VAL_10:.*]] = call %[[VAL_11:.*]]* @__quantum__qis__mz(%[[VAL_8]]* %[[VAL_9]])
+// QIR:         %[[VAL_12:.*]] = bitcast %[[VAL_11]]* %[[VAL_10]] to i1*
+// QIR:         %[[VAL_13:.*]] = load i1, i1* %[[VAL_12]], align 1
+// QIR:         call void @__quantum__rt__qubit_release_array(%[[VAL_6]]* %[[VAL_5]])
+// QIR:         ret i1 %[[VAL_13]]
 // QIR:       }
 
diff --git a/test/AST-Quake/veq_size_init_state.cpp b/test/AST-Quake/veq_size_init_state.cpp
index 1a30ca4f151..d65e91a9924 100644
--- a/test/AST-Quake/veq_size_init_state.cpp
+++ b/test/AST-Quake/veq_size_init_state.cpp
@@ -19,25 +19,42 @@ struct kernel {
   }
 };
 
-// CHECK-LABEL:   func.func @__nvqpp__mlirgen__kernel() attributes
-// CHECK:           %[[VAL_0:.*]] = complex.constant [0.000000e+00, 0.000000e+00] : complex<f64>
-// CHECK:           %[[VAL_1:.*]] = complex.constant [1.000000e+00, 0.000000e+00] : complex<f64>
-// CHECK:           %[[VAL_2:.*]] = cc.alloca !cc.array<complex<f64> x 4>
-// CHECK:           %[[VAL_3:.*]] = cc.cast %[[VAL_2]] : (!cc.ptr<!cc.array<complex<f64> x 4>>) -> !cc.ptr<complex<f64>>
-// CHECK:           cc.store %[[VAL_1]], %[[VAL_3]] : !cc.ptr<complex<f64>>
-// CHECK:           %[[VAL_4:.*]] = cc.compute_ptr %[[VAL_2]][1] : (!cc.ptr<!cc.array<complex<f64> x 4>>) -> !cc.ptr<complex<f64>>
-// CHECK:           cc.store %[[VAL_0]], %[[VAL_4]] : !cc.ptr<complex<f64>>
-// CHECK:           %[[VAL_5:.*]] = cc.compute_ptr %[[VAL_2]][2] : (!cc.ptr<!cc.array<complex<f64> x 4>>) -> !cc.ptr<complex<f64>>
-// CHECK:           cc.store %[[VAL_0]], %[[VAL_5]] : !cc.ptr<complex<f64>>
-// CHECK:           %[[VAL_6:.*]] = cc.compute_ptr %[[VAL_2]][3] : (!cc.ptr<!cc.array<complex<f64> x 4>>) -> !cc.ptr<complex<f64>>
-// CHECK:           cc.store %[[VAL_0]], %[[VAL_6]] : !cc.ptr<complex<f64>>
-// CHECK:           %[[VAL_7:.*]] = cc.cast %[[VAL_2]] : (!cc.ptr<!cc.array<complex<f64> x 4>>) -> !cc.ptr<complex<f64>>
-// CHECK:           %[[VAL_8:.*]] = quake.alloca !quake.veq<2>
-// CHECK:           %[[VAL_9:.*]] = quake.init_state %[[VAL_8]], %[[VAL_7]] : (!quake.veq<2>, !cc.ptr<complex<f64>>) -> !quake.veq<2>
-// CHECK:           %[[VAL_10:.*]] = quake.extract_ref %[[VAL_9]][0] : (!quake.veq<2>) -> !quake.ref
-// CHECK:           quake.h %[[VAL_10]] : (!quake.ref) -> ()
-// CHECK:           %[[VAL_11:.*]] = quake.extract_ref %[[VAL_9]][1] : (!quake.veq<2>) -> !quake.ref
-// CHECK:           quake.h %[[VAL_11]] : (!quake.ref) -> ()
-// CHECK:           %[[VAL_12:.*]] = quake.mz %[[VAL_9]] : (!quake.veq<2>) -> !cc.stdvec<!quake.measure>
+// CHECK-LABEL:   func.func @__nvqpp__mlirgen__kernel() attributes {"cudaq-entrypoint", "cudaq-kernel"} {
+// CHECK-DAG:       %[[VAL_0:.*]] = complex.constant [0.000000e+00, 0.000000e+00] : complex<f64>
+// CHECK-DAG:       %[[VAL_1:.*]] = complex.constant [1.000000e+00, 0.000000e+00] : complex<f64>
+// CHECK-DAG:       %[[VAL_2:.*]] = arith.constant 1 : i64
+// CHECK-DAG:       %[[VAL_3:.*]] = arith.constant 0 : i64
+// CHECK-DAG:       %[[VAL_4:.*]] = arith.constant 4 : i64
+// CHECK-DAG:       %[[VAL_5:.*]] = cc.alloca !cc.array<complex<f64> x 4>
+// CHECK:           %[[VAL_6:.*]] = cc.cast %[[VAL_5]] : (!cc.ptr<!cc.array<complex<f64> x 4>>) -> !cc.ptr<complex<f64>>
+// CHECK:           cc.store %[[VAL_1]], %[[VAL_6]] : !cc.ptr<complex<f64>>
+// CHECK:           %[[VAL_7:.*]] = cc.compute_ptr %[[VAL_5]][1] : (!cc.ptr<!cc.array<complex<f64> x 4>>) -> !cc.ptr<complex<f64>>
+// CHECK:           cc.store %[[VAL_0]], %[[VAL_7]] : !cc.ptr<complex<f64>>
+// CHECK:           %[[VAL_8:.*]] = cc.compute_ptr %[[VAL_5]][2] : (!cc.ptr<!cc.array<complex<f64> x 4>>) -> !cc.ptr<complex<f64>>
+// CHECK:           cc.store %[[VAL_0]], %[[VAL_8]] : !cc.ptr<complex<f64>>
+// CHECK:           %[[VAL_9:.*]] = cc.compute_ptr %[[VAL_5]][3] : (!cc.ptr<!cc.array<complex<f64> x 4>>) -> !cc.ptr<complex<f64>>
+// CHECK:           cc.store %[[VAL_0]], %[[VAL_9]] : !cc.ptr<complex<f64>>
+// CHECK:           %[[VAL_10:.*]] = cc.cast %[[VAL_5]] : (!cc.ptr<!cc.array<complex<f64> x 4>>) -> !cc.ptr<complex<f64>>
+// CHECK:           %[[VAL_11:.*]] = quake.create_state %[[VAL_10]], %[[VAL_4]] : (!cc.ptr<complex<f64>>, i64) -> !cc.ptr<!quake.state>
+// CHECK:           %[[VAL_12:.*]] = quake.get_number_of_qubits %[[VAL_11]] : (!cc.ptr<!quake.state>) -> i64
+// CHECK:           %[[VAL_13:.*]] = quake.alloca !quake.veq<?>{{\[}}%[[VAL_12]] : i64]
+// CHECK:           %[[VAL_14:.*]] = quake.init_state %[[VAL_13]], %[[VAL_11]] : (!quake.veq<?>, !cc.ptr<!quake.state>) -> !quake.veq<?>
+// CHECK:           quake.delete_state %[[VAL_11]] : !cc.ptr<!quake.state>
+// CHECK:           %[[VAL_15:.*]] = quake.veq_size %[[VAL_14]] : (!quake.veq<?>) -> i64
+// CHECK:           %[[VAL_16:.*]] = cc.loop while ((%[[VAL_17:.*]] = %[[VAL_3]]) -> (i64)) {
+// CHECK:             %[[VAL_18:.*]] = arith.cmpi slt, %[[VAL_17]], %[[VAL_15]] : i64
+// CHECK:             cc.condition %[[VAL_18]](%[[VAL_17]] : i64)
+// CHECK:           } do {
+// CHECK:           ^bb0(%[[VAL_19:.*]]: i64):
+// CHECK:             %[[VAL_20:.*]] = quake.extract_ref %[[VAL_14]]{{\[}}%[[VAL_19]]] : (!quake.veq<?>, i64) -> !quake.ref
+// CHECK:             quake.h %[[VAL_20]] : (!quake.ref) -> ()
+// CHECK:             cc.continue %[[VAL_19]] : i64
+// CHECK:           } step {
+// CHECK:           ^bb0(%[[VAL_21:.*]]: i64):
+// CHECK:             %[[VAL_22:.*]] = arith.addi %[[VAL_21]], %[[VAL_2]] : i64
+// CHECK:             cc.continue %[[VAL_22]] : i64
+// CHECK:           } {invariant}
+// CHECK:           %[[VAL_23:.*]] = quake.mz %[[VAL_14]] : (!quake.veq<?>) -> !cc.stdvec<!quake.measure>
 // CHECK:           return
 // CHECK:         }
+
diff --git a/test/NVQPP/qir_range_err_compiler.cpp b/test/NVQPP/qir_range_err_compiler.cpp
index 0e47f762189..7a3a7842fcf 100644
--- a/test/NVQPP/qir_range_err_compiler.cpp
+++ b/test/NVQPP/qir_range_err_compiler.cpp
@@ -6,9 +6,7 @@
  * the terms of the Apache License 2.0 which accompanies this distribution.    *
  ******************************************************************************/
 
-// Note: change |& to 2>&1| if running in bash
-// RUN: cudaq-quake %cpp_std %s |& FileCheck %s
-// RUN: cudaq-quake -std=c++17 %s |& FileCheck %s
+// RUN: cudaq-quake %s |& FileCheck %s
 
 #include <cudaq.h>
 #include <iostream>
diff --git a/test/Translate/openqasm2_vector.cpp b/test/Translate/openqasm2_vector.cpp
deleted file mode 100644
index a71c1e71d23..00000000000
--- a/test/Translate/openqasm2_vector.cpp
+++ /dev/null
@@ -1,44 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2022 - 2025 NVIDIA Corporation & Affiliates.                  *
- * All rights reserved.                                                        *
- *                                                                             *
- * This source code and the accompanying materials are made available under    *
- * the terms of the Apache License 2.0 which accompanies this distribution.    *
- ******************************************************************************/
-
-// clang-format off
-// RUN: cudaq-quake  %s | cudaq-opt -canonicalize -cse -lift-array-alloc -globalize-array-values -canonicalize -state-prep | cudaq-translate --convert-to=openqasm2 | FileCheck %s
-// clang-format on
-
-#include <cudaq.h>
-#include <fstream>
-
-struct kernel {
-
-  void operator()() __qpu__ {
-    cudaq::qvector q(std::vector<cudaq::complex>({ M_SQRT1_2, M_SQRT1_2, 0., 0.}));
-    auto result = mz(q);
-  }
-};
-
-int main() {
-  auto counts = cudaq::sample(kernel{});
-  counts.dump();
-}
-
-// CHECK:  // Code generated by NVIDIA's nvq++ compiler
-// CHECK:  OPENQASM 2.0;
-
-// CHECK:  include "qelib1.inc";
-
-// CHECK:  gate ZN6kernelclEv(param0)  {
-// CHECK:  }
-
-// CHECK:  qreg var0[2];
-// CHECK:  ry(0.000000e+00) var0[1];
-// CHECK:  ry(7.853982e-01) var0[0];
-// CHECK:  cx var0[1], var0[0];
-// CHECK:  ry(7.853982e-01) var0[0];
-// CHECK:  cx var0[1], var0[0];
-// CHECK:  creg var3[2];
-// CHECK:  measure var0 -> var3;
diff --git a/unittests/integration/qubit_allocation.cpp b/unittests/integration/qubit_allocation.cpp
index 33a300109e8..a5f02c80ce9 100644
--- a/unittests/integration/qubit_allocation.cpp
+++ b/unittests/integration/qubit_allocation.cpp
@@ -14,7 +14,7 @@
 #ifndef CUDAQ_BACKEND_STIM
 
 std::vector<cudaq::complex> randomState(int numQubits) {
-  std::vector<cudaq::complex> stateVec(1ULL << numQubits);
+  std::vector<cudaq::complex> stateVec(2 * numQubits);
   std::generate(stateVec.begin(), stateVec.end(), []() -> cudaq::complex {
     thread_local std::default_random_engine
         generator; // thread_local so we don't have to do any locking