diff --git a/CMakeLists.txt b/CMakeLists.txt
index db1eb784..6ca6c6dc 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -12,8 +12,9 @@ set(CATCH_ENABLE_REPRODUCIBLE_BUILD OFF CACHE INTERNAL "Turn off tests")
 
 
 set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -Wall -Werror -Wunused -Werror=vla -Wnarrowing -pedantic")
-set(CMAKE_CXX_FLAGS "-fpermissive -fPIC -g")
+set(CMAKE_CXX_FLAGS "-fpermissive -fPIC -g  -fno-omit-frame-pointer")
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
+set(CMAKE_CXX_FLAGS_RELEASE "-O3 -fstandalone-debug -fdebug-default-version=4  -fno-omit-frame-pointer")
 
 
 include(cmake/macros.cmake)
diff --git a/nautilus-api/include/Interface/DataTypes/Val.hpp b/nautilus-api/include/Interface/DataTypes/Val.hpp
index eed4eff5..530dd9f5 100644
--- a/nautilus-api/include/Interface/DataTypes/Val.hpp
+++ b/nautilus-api/include/Interface/DataTypes/Val.hpp
@@ -157,12 +157,13 @@ namespace nautilus {
             //  tracing::traceAssignment(other.state, other.state);
         };
 
+        /*
         val<ValueType>(val<ValueType> &&other) noexcept // move constructor
                 : value(other.value), loc(other.loc), state(other.state) {
          //   auto tag = tracing::getTag();
             tracing::getVarRefMap()[state]++;
             //std::cout << "move constructor " << other.state << " - " << tag << std::endl;
-        }
+        }*/
 
 #else
 
@@ -173,7 +174,7 @@ namespace nautilus {
 
 #ifdef ENABLE_TRACING
 
-        explicit inline val<ValueType>(tracing::value_ref &tc) : state(tc) {
+         inline val<ValueType>(ValueType, tracing::value_ref &tc) : state(tc) {
            // auto tag = tracing::getTag();
             tracing::getVarRefMap()[state]++;
            // std::cout << "trace constructor " << state << " - " << tag << std::endl;
@@ -181,7 +182,7 @@ namespace nautilus {
 #endif
 
 
-        ~val<ValueType>() {
+        ~val() {
            // auto tag = tracing::getTag();
             tracing::getVarRefMap()[state]--;
             if (tracing::getVarRefMap()[state] == 0) {
@@ -352,7 +353,7 @@ namespace nautilus {
 #define TRAC_BINARY_OP(OP) \
              if (tracing::inTracer()) {\
                     auto tc = tracing::traceBinaryOp<tracing::OP, commonType>(lValue.state, rValue.state);\
-                    return val<commonType>((tracing::value_ref)tc);\
+                    return val<commonType>((commonType)0, tc);\
              }
 #else
 #define TRAC_OP(OP)
@@ -362,7 +363,7 @@ namespace nautilus {
 #define TRAC_LOGICAL_BINARY_OP(OP) \
              if (tracing::inTracer()) {\
                     auto tc = tracing::traceBinaryOp<tracing::OP, commonType>(lValue.state, rValue.state);\
-                    return val<bool>(tc);\
+                    return val<bool>(lValue.value, tc);\
              }
 #else
 #define TRAC_LOGICAL_BINARY_OP(OP)
@@ -461,7 +462,7 @@ namespace nautilus {
         val<bool> inline lOr(val<bool> &left, val<bool> &right) {
             if (tracing::inTracer()) {
                 auto tc = tracing::traceBinaryOp<tracing::OR, bool>(left.state, right.state);
-                return val<bool>{tc};
+                return val<bool>{true, tc};
             }
             return left.value || right.value;
         }
@@ -469,7 +470,7 @@ namespace nautilus {
         val<bool> inline lAnd(val<bool> &left, val<bool> &right) {
             if (tracing::inTracer()) {
                 auto tc = tracing::traceBinaryOp<tracing::AND, bool>(left.state, right.state);
-                return val<bool>{tc};
+                return val<bool>{true,tc};
             }
             return left.value && right.value;
         }
@@ -477,7 +478,7 @@ namespace nautilus {
         val<bool> inline lNot(val<bool> &val) {
             if (tracing::inTracer()) {
                 auto tc = tracing::traceUnaryOp<tracing::NOT, bool>(val.state);
-                return ::nautilus::val<bool>{tc};
+                return ::nautilus::val<bool>{true,tc};
             }
             return !val.value;
         }
@@ -881,7 +882,7 @@ template<typename T> requires std::is_integral_v<T>
 class sval {
 public:
 
-    sval<T>(T value) : value(value) {};
+    sval(T v) : value(v) {};
 
     const auto &operator++() {
         nautilus::tracing::getVarRefMap()[54]++;
diff --git a/nautilus-api/include/Interface/DataTypes/ValPtr.hpp b/nautilus-api/include/Interface/DataTypes/ValPtr.hpp
index 00048891..a1895a0a 100644
--- a/nautilus-api/include/Interface/DataTypes/ValPtr.hpp
+++ b/nautilus-api/include/Interface/DataTypes/ValPtr.hpp
@@ -22,14 +22,14 @@ namespace nautilus {
             auto value = make_value<baseType>(other);
             // store value
             *ptr = details::getRawValue(value);
-        };
+        }
 
         template<class T>
         requires std::is_convertible_v<T, baseType>
         void operator=(val<T> other) noexcept {
             // store value
             *ptr = details::getRawValue(other);
-        };
+        }
 
         operator val<baseType>() const {
             // load
diff --git a/nautilus-api/include/engine/engine.hpp b/nautilus-api/include/engine/engine.hpp
index 6e2bd1a4..5de65ccb 100644
--- a/nautilus-api/include/engine/engine.hpp
+++ b/nautilus-api/include/engine/engine.hpp
@@ -11,9 +11,10 @@ namespace nautilus::engine {
 
         template<typename Arg>
         auto createTraceArgument() {
+            auto defaultVal = (typename Arg::basic_type) 0;
             auto type = tracing::to_type<typename Arg::basic_type>();
             auto valueRef = tracing::registerFunctionArgument(type);
-            return Arg(valueRef);
+            return Arg(defaultVal,valueRef);
         }
 
         template<typename Arg>
diff --git a/nautilus-jit/include/Tracing/trace_operation.hpp b/nautilus-jit/include/Tracing/trace_operation.hpp
index 2c34a29c..97be878b 100644
--- a/nautilus-jit/include/Tracing/trace_operation.hpp
+++ b/nautilus-jit/include/Tracing/trace_operation.hpp
@@ -68,9 +68,10 @@ namespace nautilus::tracing {
                     os << *inputRef << "\t";
                 } else if (auto blockRef = std::get_if<BlockRef>(&opInput)) {
                     os << *blockRef << "\t";
-                } else if (auto anyRef = std::get_if<std::any>(&opInput)) {
-                    //os << anyRef << "\t";
                 }
+                //else if (auto anyRef = std::get_if<std::any>(&opInput)) {
+                    //os << anyRef << "\t";
+                //}
                 //else if (auto ref = std::get_if<FunctionCallTarget>(&input)) {
                 //    os << ref->mangledName << "\t";
                 //}
diff --git a/nautilus-jit/src/Tracing/tag/tag_recorder.cpp b/nautilus-jit/src/Tracing/tag/tag_recorder.cpp
index 786c7363..0718d366 100644
--- a/nautilus-jit/src/Tracing/tag/tag_recorder.cpp
+++ b/nautilus-jit/src/Tracing/tag/tag_recorder.cpp
@@ -39,7 +39,7 @@ namespace nautilus::tracing {
        // throw NotImplementedException("No plugin registered that can handle this operation between");
         [[maybe_unused]] void* root = __builtin_thread_pointer();
         std::vector<TagAddress> addresses;
-        for (int i = 0; i < MAX_TAG_SIZE; i++) {
+        for (size_t i = 0; i < MAX_TAG_SIZE; i++) {
             auto address = getReturnAddress(i);
             [[maybe_unused]]   void *addr = __builtin_extract_return_addr (address);
             addresses.emplace_back((TagAddress) address);
@@ -69,6 +69,11 @@ namespace nautilus::tracing {
 
     Tag *TagRecorder::createReferenceTag() {
         auto *currentTagNode = &rootTagThreeNode;
+#pragma GCC diagnostic ignored "-Wframe-address"
+        [[maybe_unused]] auto tag1 = __builtin_return_address(0);
+        [[maybe_unused]] auto tag2 =  __builtin_return_address(1);
+        [[maybe_unused]] auto tag3 = __builtin_return_address(1);
+
         for (size_t i = 0; i <= MAX_TAG_SIZE; i++) {
             auto tagAddress = (TagAddress) getReturnAddress(i);
             if (tagAddress == startAddress) {
diff --git a/nautilus-jit/src/Tracing/tracing.cpp b/nautilus-jit/src/Tracing/tracing.cpp
index 71073e0f..049fc300 100644
--- a/nautilus-jit/src/Tracing/tracing.cpp
+++ b/nautilus-jit/src/Tracing/tracing.cpp
@@ -7,8 +7,8 @@
 
 namespace nautilus::tracing {
 
-    std::array<uint8_t, 256>& getVarRefMap(){
-       return TraceContext::get()->getVarRefMap();
+    std::array<uint8_t, 256> &getVarRefMap() {
+        return TraceContext::get()->getVarRefMap();
     }
 
     void traceAssignment(value_ref target, value_ref source) {
@@ -63,6 +63,8 @@ namespace nautilus::tracing {
         return TraceContext::get()->traceUnaryOperation(op, leftState);
     }
 
+
+#if __APPLE__
 #define INSTANTIATE_TRACE_FUNC(OP) \
 template value_ref traceBinaryOp<OP, int8_t>(value_ref leftState, value_ref rightState); \
 template value_ref traceBinaryOp<OP, int16_t>(value_ref leftState, value_ref rightState); \
@@ -76,6 +78,21 @@ template value_ref traceBinaryOp<OP, float>(value_ref leftState, value_ref right
 template value_ref traceBinaryOp<OP, double>(value_ref leftState, value_ref rightState); \
 template value_ref traceBinaryOp<OP, size_t>(value_ref leftState, value_ref rightState); \
 
+#else
+#define INSTANTIATE_TRACE_FUNC(OP) \
+    template value_ref traceBinaryOp<OP, int8_t>(value_ref leftState, value_ref rightState); \
+    template value_ref traceBinaryOp<OP, int16_t>(value_ref leftState, value_ref rightState); \
+template value_ref traceBinaryOp<OP, int32_t>(value_ref leftState, value_ref rightState); \
+template value_ref traceBinaryOp<OP, int64_t>(value_ref leftState, value_ref rightState); \
+template value_ref traceBinaryOp<OP, uint8_t>(value_ref leftState, value_ref rightState); \
+template value_ref traceBinaryOp<OP, uint16_t>(value_ref leftState, value_ref rightState); \
+template value_ref traceBinaryOp<OP, uint32_t>(value_ref leftState, value_ref rightState); \
+template value_ref traceBinaryOp<OP, uint64_t>(value_ref leftState, value_ref rightState); \
+template value_ref traceBinaryOp<OP, float>(value_ref leftState, value_ref rightState); \
+template value_ref traceBinaryOp<OP, double>(value_ref leftState, value_ref rightState);
+#endif
+
+
 #define INSTANTIATE_TRACE_UN_FUNC(OP) \
 template value_ref traceUnaryOp<OP, int8_t>(value_ref leftState); \
 template value_ref traceUnaryOp<OP, int16_t>(value_ref leftState); \
@@ -181,10 +198,13 @@ template value_ref traceUnaryOp<OP, double>(value_ref leftState); \
     template value_ref traceConstant<uint16_t>(uint16_t value);
 
     template value_ref traceConstant<uint32_t>(uint32_t value);
+
     template value_ref traceConstant<uint64_t>(uint64_t value);
+
 #if __APPLE__
     template value_ref traceConstant<size_t>(size_t value);
 #endif
+
     template value_ref traceConstant<float>(float value);
 
     template value_ref traceConstant<double>(double value);