diff --git a/integration_tests/CMakeLists.txt b/integration_tests/CMakeLists.txt
index b854115b4b..8535c83194 100644
--- a/integration_tests/CMakeLists.txt
+++ b/integration_tests/CMakeLists.txt
@@ -574,6 +574,7 @@ RUN(NAME test_unary_op_05    LABELS cpython llvm c) # unsigned unary minus, plus
 RUN(NAME test_unary_op_06    LABELS cpython llvm c) # unsigned unary bitnot
 RUN(NAME test_unsigned_01    LABELS cpython llvm c) # unsigned bitshift left, right
 RUN(NAME test_unsigned_02    LABELS cpython llvm c)
+RUN(NAME test_unsigned_03    LABELS cpython llvm c)
 RUN(NAME test_bool_binop     LABELS cpython llvm c)
 RUN(NAME test_issue_518      LABELS cpython llvm c NOFAST)
 RUN(NAME structs_01          LABELS cpython llvm c)
@@ -615,6 +616,7 @@ RUN(NAME structs_30          LABELS cpython llvm c)
 RUN(NAME structs_31          LABELS cpython llvm c)
 RUN(NAME structs_32          LABELS cpython llvm c)
 RUN(NAME structs_33          LABELS cpython llvm c)
+RUN(NAME structs_34          LABELS cpython llvm c)
 
 RUN(NAME symbolics_01        LABELS cpython_sym c_sym)
 RUN(NAME symbolics_02        LABELS cpython_sym c_sym)
@@ -694,7 +696,8 @@ RUN(NAME global_syms_04    LABELS cpython llvm c wasm wasm_x64)
 RUN(NAME global_syms_05    LABELS cpython llvm c)
 RUN(NAME global_syms_06    LABELS cpython llvm c)
 
-RUN(NAME callback_01       LABELS cpython llvm)
+RUN(NAME callback_01       LABELS cpython llvm c)
+RUN(NAME callback_02       LABELS cpython llvm c)
 
 # Intrinsic Functions
 RUN(NAME intrinsics_01     LABELS cpython llvm NOFAST) # any
diff --git a/integration_tests/callback_02.py b/integration_tests/callback_02.py
new file mode 100644
index 0000000000..330f75cbbf
--- /dev/null
+++ b/integration_tests/callback_02.py
@@ -0,0 +1,18 @@
+from lpython import ccallback, i32, Callable
+
+# test issue 2169
+
+def foo(x : i32) -> i32:
+    return x**2
+
+def bar(func : Callable[[i32], i32], arg : i32) -> i32:
+    return func(arg)
+
+@ccallback
+def entry_point() -> None:
+    z: i32 = 5
+    x: i32 = bar(foo, z)
+    assert z**2 == x
+
+
+entry_point()
diff --git a/integration_tests/structs_34.py b/integration_tests/structs_34.py
new file mode 100644
index 0000000000..f69d6d5f6a
--- /dev/null
+++ b/integration_tests/structs_34.py
@@ -0,0 +1,24 @@
+from lpython import packed, dataclass, ccallable, i32, ccallback
+
+@ccallable
+@packed
+@dataclass
+class struct_0:
+    val_0 : i32 = 613
+
+@ccallable
+@packed
+@dataclass
+class struct_1:
+    val_1 : struct_0 = struct_0()
+
+def print_val_0_in_struct_0(struct_0_instance : struct_0) -> i32:
+    print(struct_0_instance.val_0)
+    return 0
+
+@ccallback
+def entry_point() -> i32:
+    struct_1_instance : struct_1 = struct_1()
+    return print_val_0_in_struct_0(struct_1_instance.val_1)
+
+assert entry_point() == 0
diff --git a/integration_tests/test_unsigned_02.py b/integration_tests/test_unsigned_02.py
index d880ff9193..ad7f938249 100644
--- a/integration_tests/test_unsigned_02.py
+++ b/integration_tests/test_unsigned_02.py
@@ -1,10 +1,15 @@
-from lpython import u16, i32
+from lpython import u16, i32, u8, u32, u64
 
 # test issue 2170
 
-i : i32
-u : u16 = u16(32768)
-x : i32
+u_1 : u16 = u16(32768)
+u_2 : u8 = u8(24)
+u_3 : u32 = u32(32768)
+u_4 : u64 = u64(32768)
 
-for i in range(i32(u)):
-    x = i * 2
+assert u_1 == u16(32768)
+assert u_2 == u8(24)
+assert u_3 == u32(32768)
+assert u_4 == u64(32768)
+
+print(u_1, u_2, u_3, u_4)
diff --git a/integration_tests/test_unsigned_03.py b/integration_tests/test_unsigned_03.py
new file mode 100644
index 0000000000..2bc0eaeac2
--- /dev/null
+++ b/integration_tests/test_unsigned_03.py
@@ -0,0 +1,19 @@
+from lpython import u16, i32, u8, u16, u64, i64, u32, i8
+
+# test issue 2174
+
+def f():
+    u: u16 = u16(32768)
+    assert i32(u) == 32768
+    u1: u8 = u8(23)
+    assert i8(u1) == i8(23)
+    assert u16(u1) == u16(23)
+    assert u32(u1) == u32(23)
+    assert u64(u1) == u64(23)
+    print(i8(u1), u16(u1), u32(u1), u64(u1))
+    assert i64(u1) == i64(23)
+    assert i64(u) == i64(32768)
+    assert i32(u1) == 23
+    print(i64(u), i32(u))
+
+f()
diff --git a/src/libasr/codegen/asr_to_c.cpp b/src/libasr/codegen/asr_to_c.cpp
index a63f5098c3..f25d565c46 100644
--- a/src/libasr/codegen/asr_to_c.cpp
+++ b/src/libasr/codegen/asr_to_c.cpp
@@ -739,8 +739,8 @@ R"(
             array_types_decls.insert(0, "struct dimension_descriptor\n"
                 "{\n    int32_t lower_bound, length;\n};\n");
         }
-
-        src = to_include + head + array_types_decls + unit_src +
+        forward_decl_functions += "\n\n";
+        src = to_include + head + array_types_decls + forward_decl_functions + unit_src +
               ds_funcs_defined + util_funcs_defined;
         if (!emit_headers.empty()) {
             std::string to_includes_1 = "";
diff --git a/src/libasr/codegen/asr_to_c_cpp.h b/src/libasr/codegen/asr_to_c_cpp.h
index e4b631d7a1..2619823590 100644
--- a/src/libasr/codegen/asr_to_c_cpp.h
+++ b/src/libasr/codegen/asr_to_c_cpp.h
@@ -137,6 +137,7 @@ class BaseCCPPVisitor : public ASR::BaseVisitor<Struct>
     std::map<int32_t, std::string> gotoid2name;
     std::map<std::string, std::string> emit_headers;
     std::string array_types_decls;
+    std::string forward_decl_functions;
 
     // Output configuration:
     // Use std::string or char*
@@ -493,7 +494,7 @@ R"(#include <stdio.h>
     }
 
     // Returns the declaration, no semi colon at the end
-    std::string get_function_declaration(const ASR::Function_t &x, bool &has_typevar) {
+    std::string get_function_declaration(const ASR::Function_t &x, bool &has_typevar, bool is_pointer=false) {
         template_for_Kokkos.clear();
         template_number = 0;
         std::string sub, inl, static_attr;
@@ -501,10 +502,10 @@ R"(#include <stdio.h>
         // This helps to check if the function is generic.
         // If it is generic we skip the codegen for that function.
         has_typevar = false;
-        if (ASRUtils::get_FunctionType(x)->m_inline) {
+        if (ASRUtils::get_FunctionType(x)->m_inline && !is_pointer) {
             inl = "inline __attribute__((always_inline)) ";
         }
-        if( ASRUtils::get_FunctionType(x)->m_static ) {
+        if( ASRUtils::get_FunctionType(x)->m_static && !is_pointer) {
             static_attr = "static ";
         }
         if (x.m_return_var) {
@@ -526,30 +527,47 @@ R"(#include <stdio.h>
                 f_type->m_deftype == ASR::deftypeType::Implementation) {
             sym_name = "_xx_internal_" + sym_name + "_xx";
         }
-        std::string func = static_attr + inl + sub + sym_name + "(";
+        std::string func = static_attr + inl + sub;
+        if (is_pointer) {
+            func += "(*" + sym_name + ")(";
+        } else {
+            func += sym_name + "(";
+        }
         bracket_open++;
         for (size_t i=0; i<x.n_args; i++) {
-            ASR::Variable_t *arg = ASRUtils::EXPR2VAR(x.m_args[i]);
-            LCOMPILERS_ASSERT(ASRUtils::is_arg_dummy(arg->m_intent));
-            if (ASR::is_a<ASR::TypeParameter_t>(*arg->m_type)) {
-                has_typevar = true;
-                bracket_open--;
-                return "";
-            }
-            if( is_c ) {
-                CDeclarationOptions c_decl_options;
-                c_decl_options.pre_initialise_derived_type = false;
-                func += self().convert_variable_decl(*arg, &c_decl_options);
+            ASR::symbol_t *sym = ASRUtils::symbol_get_past_external(
+                ASR::down_cast<ASR::Var_t>(x.m_args[i])->m_v);
+            if (ASR::is_a<ASR::Variable_t>(*sym)) {
+                ASR::Variable_t *arg = ASR::down_cast<ASR::Variable_t>(sym);
+                LCOMPILERS_ASSERT(ASRUtils::is_arg_dummy(arg->m_intent));
+                if( is_c ) {
+                    CDeclarationOptions c_decl_options;
+                    c_decl_options.pre_initialise_derived_type = false;
+                    func += self().convert_variable_decl(*arg, &c_decl_options);
+                } else {
+                    CPPDeclarationOptions cpp_decl_options;
+                    cpp_decl_options.use_static = false;
+                    cpp_decl_options.use_templates_for_arrays = true;
+                    func += self().convert_variable_decl(*arg, &cpp_decl_options);
+                }
+                if (ASR::is_a<ASR::TypeParameter_t>(*arg->m_type)) {
+                    has_typevar = true;
+                    bracket_open--;
+                    return "";
+                }
+            } else if (ASR::is_a<ASR::Function_t>(*sym)) {
+                ASR::Function_t *fun = ASR::down_cast<ASR::Function_t>(sym);
+                func += get_function_declaration(*fun, has_typevar, true);
             } else {
-                CPPDeclarationOptions cpp_decl_options;
-                cpp_decl_options.use_static = false;
-                cpp_decl_options.use_templates_for_arrays = true;
-                func += self().convert_variable_decl(*arg, &cpp_decl_options);
+                throw CodeGenError("Unsupported function argument");
             }
             if (i < x.n_args-1) func += ", ";
         }
         func += ")";
         bracket_open--;
+        if (f_type->m_abi == ASR::abiType::Source) {
+            forward_decl_functions += func + ";\n";
+        }
         if( is_c || template_for_Kokkos.empty() ) {
             return func;
         }
@@ -1012,6 +1030,32 @@ PyMODINIT_FUNC PyInit_lpython_module_)" + fn_name + R"((void) {
          this->visit_expr(*x.m_arg);
      }
 
+    std::string construct_call_args(size_t n_args, ASR::call_arg_t* m_args) {
+        bracket_open++;
+        std::string args = "";
+        for (size_t i=0; i<n_args; i++) {
+            self().visit_expr(*m_args[i].m_value);
+            ASR::ttype_t* type = ASRUtils::expr_type(m_args[i].m_value);
+            if (ASR::is_a<ASR::Var_t>(*m_args[i].m_value)) {
+                if( ASRUtils::is_array(type) &&
+                    ASRUtils::is_pointer(type) ) {
+                    args += "&" + src;
+                } else {
+                    args += src;
+                }
+            } else {
+                if( ASR::is_a<ASR::Struct_t>(*type) ) {
+                    args += "&" + src;
+                } else {
+                    args += src;
+                }
+            }
+            if (i < n_args-1) args += ", ";
+        }
+        bracket_open--;
+        return args;
+    }
+
     void visit_FunctionCall(const ASR::FunctionCall_t &x) {
         CHECK_FAST_C_CPP(compiler_options, x)
         ASR::Function_t *fn = ASR::down_cast<ASR::Function_t>(
@@ -1052,15 +1096,7 @@ PyMODINIT_FUNC PyInit_lpython_module_)" + fn_name + R"((void) {
                         + "' not implemented");
             }
         } else {
-            std::string args;
-            bracket_open++;
-            for (size_t i=0; i<x.n_args; i++) {
-                self().visit_expr(*x.m_args[i].m_value);
-                args += src;
-                if (i < x.n_args-1) args += ", ";
-            }
-            bracket_open--;
-            src = fn_name + "(" + args + ")";
+            src = fn_name + "(" + construct_call_args(x.n_args, x.m_args) + ")";
         }
         last_expr_precedence = 2;
         if( ASR::is_a<ASR::List_t>(*x.m_type) ) {
@@ -1716,6 +1752,10 @@ PyMODINIT_FUNC PyInit_lpython_module_)" + fn_name + R"((void) {
 
     void visit_Var(const ASR::Var_t &x) {
         const ASR::symbol_t *s = ASRUtils::symbol_get_past_external(x.m_v);
+        if (ASR::is_a<ASR::Function_t>(*s)) {
+            src = ASRUtils::symbol_name(s);
+            return;
+        }
         ASR::Variable_t* sv = ASR::down_cast<ASR::Variable_t>(s);
         if( (sv->m_intent == ASRUtils::intent_in ||
             sv->m_intent == ASRUtils::intent_inout) &&
@@ -2739,30 +2779,7 @@ PyMODINIT_FUNC PyInit_lpython_module_)" + fn_name + R"((void) {
         if (sym_name == "main") {
             sym_name = "_xx_lcompilers_changed_main_xx";
         }
-        std::string out = indent + sym_name + "(";
-        for (size_t i=0; i<x.n_args; i++) {
-            if (ASR::is_a<ASR::Var_t>(*x.m_args[i].m_value)) {
-                ASR::Variable_t *arg = ASRUtils::EXPR2VAR(x.m_args[i].m_value);
-                std::string arg_name = arg->m_name;
-                if( ASRUtils::is_array(arg->m_type) &&
-                    ASRUtils::is_pointer(arg->m_type) ) {
-                    out += "&" + arg_name;
-                } else {
-                    out += arg_name;
-                }
-            } else {
-                self().visit_expr(*x.m_args[i].m_value);
-                if( ASR::is_a<ASR::ArrayItem_t>(*x.m_args[i].m_value) ||
-                    ASR::is_a<ASR::Struct_t>(*ASRUtils::expr_type(x.m_args[i].m_value)) ) {
-                    out += "&" + src;
-                } else {
-                    out += src;
-                }
-            }
-            if (i < x.n_args-1) out += ", ";
-        }
-        out += ");\n";
-        src = out;
+        src = indent + sym_name + "(" + construct_call_args(x.n_args, x.m_args) + ");\n";
     }
 
     #define SET_INTRINSIC_NAME(X, func_name)                             \
diff --git a/src/libasr/codegen/asr_to_llvm.cpp b/src/libasr/codegen/asr_to_llvm.cpp
index 8648ecb027..f451d55eb0 100644
--- a/src/libasr/codegen/asr_to_llvm.cpp
+++ b/src/libasr/codegen/asr_to_llvm.cpp
@@ -6329,7 +6329,7 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor<ASRToLLVMVisitor>
                     arg_kind != dest_kind )
                 {
                     if (dest_kind > arg_kind) {
-                        tmp = builder->CreateSExt(tmp, llvm_utils->getIntType(dest_kind));
+                        tmp = builder->CreateZExt(tmp, llvm_utils->getIntType(dest_kind));
                     } else {
                         tmp = builder->CreateTrunc(tmp, llvm_utils->getIntType(dest_kind));
                     }
diff --git a/src/runtime/lpython/lpython.py b/src/runtime/lpython/lpython.py
index 8817b63ae3..ac1453260b 100644
--- a/src/runtime/lpython/lpython.py
+++ b/src/runtime/lpython/lpython.py
@@ -773,10 +773,10 @@ def __repr__(self):
     return ctypes_c_void_p()
 
 def cptr_to_u64(cptr):
-    return ctypes.addressof(cptr)
+    return u64(ctypes.cast(cptr, ctypes.c_void_p).value)
 
 def u64_to_cptr(ivalue):
-    return ctypes.c_void_p(ivalue)
+    return ctypes.c_void_p(i64(ivalue))
 
 def sizeof(arg):
     return ctypes.sizeof(convert_type_to_ctype(arg))
diff --git a/tests/reference/c-c_interop1-e215531.json b/tests/reference/c-c_interop1-e215531.json
index 8728b3498c..9cd8533dac 100644
--- a/tests/reference/c-c_interop1-e215531.json
+++ b/tests/reference/c-c_interop1-e215531.json
@@ -6,7 +6,7 @@
     "outfile": null,
     "outfile_hash": null,
     "stdout": "c-c_interop1-e215531.stdout",
-    "stdout_hash": "31d7d540adfef1263741e1b9709e4a2a73c6208147d735906dbf233e",
+    "stdout_hash": "9d9dd1715b625024203f8b4de330a936a806c5e8031ae7b643c23e71",
     "stderr": null,
     "stderr_hash": null,
     "returncode": 0
diff --git a/tests/reference/c-c_interop1-e215531.stdout b/tests/reference/c-c_interop1-e215531.stdout
index 3086db2be0..60c6da2270 100644
--- a/tests/reference/c-c_interop1-e215531.stdout
+++ b/tests/reference/c-c_interop1-e215531.stdout
@@ -7,6 +7,8 @@
 #include <lfortran_intrinsics.h>
 
 
+
+
 // Implementations
 double f(double x);
 
diff --git a/tests/reference/c-expr7-bb2692a.json b/tests/reference/c-expr7-bb2692a.json
index 550f459161..036167509f 100644
--- a/tests/reference/c-expr7-bb2692a.json
+++ b/tests/reference/c-expr7-bb2692a.json
@@ -6,7 +6,7 @@
     "outfile": null,
     "outfile_hash": null,
     "stdout": "c-expr7-bb2692a.stdout",
-    "stdout_hash": "be3bac9bcf7f1fab11741c22151820f60793d5afc670486e9d0913aa",
+    "stdout_hash": "11026dff0f543f773698075edb3d690f8a475e8639124f1e1dcaef6a",
     "stderr": "c-expr7-bb2692a.stderr",
     "stderr_hash": "6e9790ac88db1a9ead8f64a91ba8a6605de67167037908a74b77be0c",
     "returncode": 0
diff --git a/tests/reference/c-expr7-bb2692a.stdout b/tests/reference/c-expr7-bb2692a.stdout
index b0535e0a22..11b1ed1456 100644
--- a/tests/reference/c-expr7-bb2692a.stdout
+++ b/tests/reference/c-expr7-bb2692a.stdout
@@ -8,6 +8,12 @@
 #include <string.h>
 #include <lfortran_intrinsics.h>
 
+void test_pow();
+int32_t test_pow_1(int32_t a, int32_t b);
+void main0();
+void __main____global_statements();
+
+
 
 // Implementations
 double __lpython_overloaded_0__pow(int32_t x, int32_t y)
diff --git a/tests/reference/c-expr_01-28f449f.json b/tests/reference/c-expr_01-28f449f.json
index baa657a5d0..e825e50b18 100644
--- a/tests/reference/c-expr_01-28f449f.json
+++ b/tests/reference/c-expr_01-28f449f.json
@@ -6,7 +6,7 @@
     "outfile": null,
     "outfile_hash": null,
     "stdout": "c-expr_01-28f449f.stdout",
-    "stdout_hash": "21755da8aacbb21ee5a5229c8f47f7ba40c36d942af84f848e36bd5b",
+    "stdout_hash": "b9e6df09a73026d76ea9eefed3e2b211476b1ac55956ee8150a4a417",
     "stderr": null,
     "stderr_hash": null,
     "returncode": 0
diff --git a/tests/reference/c-expr_01-28f449f.stdout b/tests/reference/c-expr_01-28f449f.stdout
index 3a608760f9..11fd1f1ff2 100644
--- a/tests/reference/c-expr_01-28f449f.stdout
+++ b/tests/reference/c-expr_01-28f449f.stdout
@@ -6,6 +6,12 @@
 #include <string.h>
 #include <lfortran_intrinsics.h>
 
+inline __attribute__((always_inline)) int32_t add(int32_t x, int32_t y);
+inline __attribute__((always_inline)) int32_t and_op(int32_t x, int32_t y);
+void main0();
+void __main____global_statements();
+
+
 
 // Implementations
 inline __attribute__((always_inline)) int32_t add(int32_t x, int32_t y)
diff --git a/tests/reference/c-expr_11-c452314.json b/tests/reference/c-expr_11-c452314.json
index add507f463..1393264d39 100644
--- a/tests/reference/c-expr_11-c452314.json
+++ b/tests/reference/c-expr_11-c452314.json
@@ -6,7 +6,7 @@
     "outfile": null,
     "outfile_hash": null,
     "stdout": "c-expr_11-c452314.stdout",
-    "stdout_hash": "3566609825322587b3a725aa627c191e47e28835a78f182bb95546ab",
+    "stdout_hash": "828e55148962eac31cff8246dbf28003a81b9852481aa1e584128ecb",
     "stderr": null,
     "stderr_hash": null,
     "returncode": 0
diff --git a/tests/reference/c-expr_11-c452314.stdout b/tests/reference/c-expr_11-c452314.stdout
index 4b9efc3750..81a2868d08 100644
--- a/tests/reference/c-expr_11-c452314.stdout
+++ b/tests/reference/c-expr_11-c452314.stdout
@@ -6,6 +6,10 @@
 #include <string.h>
 #include <lfortran_intrinsics.h>
 
+void f();
+void __main____global_statements();
+
+
 
 // Implementations
 void f()
diff --git a/tests/reference/c-expr_12-93c7780.json b/tests/reference/c-expr_12-93c7780.json
index ecf8b69e35..11969c5667 100644
--- a/tests/reference/c-expr_12-93c7780.json
+++ b/tests/reference/c-expr_12-93c7780.json
@@ -6,7 +6,7 @@
     "outfile": null,
     "outfile_hash": null,
     "stdout": "c-expr_12-93c7780.stdout",
-    "stdout_hash": "094a6e7284485e456d1ff691266f3ab0400f2893e1e7670fb186cf6b",
+    "stdout_hash": "4ff750b49402a8f60ae61abdc16289388dfb3230995dda8b75fcd8cd",
     "stderr": null,
     "stderr_hash": null,
     "returncode": 0
diff --git a/tests/reference/c-expr_12-93c7780.stdout b/tests/reference/c-expr_12-93c7780.stdout
index 1a6a72ed9c..567498a526 100644
--- a/tests/reference/c-expr_12-93c7780.stdout
+++ b/tests/reference/c-expr_12-93c7780.stdout
@@ -19,6 +19,12 @@ struct i16
     bool is_allocated;
 };
 
+void g(struct i16* *x, struct i16* y);
+void check(struct i16* *ptr);
+void f();
+void __main____global_statements();
+
+
 
 // Implementations
 void g(struct i16* *x, struct i16* y)
diff --git a/tests/reference/c-func_static_01-fc146ec.json b/tests/reference/c-func_static_01-fc146ec.json
index fd78ebffa1..a115a734b8 100644
--- a/tests/reference/c-func_static_01-fc146ec.json
+++ b/tests/reference/c-func_static_01-fc146ec.json
@@ -6,7 +6,7 @@
     "outfile": null,
     "outfile_hash": null,
     "stdout": "c-func_static_01-fc146ec.stdout",
-    "stdout_hash": "ee924027aed46d89fab1ee33f7bb07aa925c27f272bb7e8766e9f63d",
+    "stdout_hash": "77431288e9f3af7e7f5d2a2859ade52772a79789337db403b3dc9943",
     "stderr": null,
     "stderr_hash": null,
     "returncode": 0
diff --git a/tests/reference/c-func_static_01-fc146ec.stdout b/tests/reference/c-func_static_01-fc146ec.stdout
index 7b80ac8575..71e33ca7e4 100644
--- a/tests/reference/c-func_static_01-fc146ec.stdout
+++ b/tests/reference/c-func_static_01-fc146ec.stdout
@@ -6,6 +6,11 @@
 #include <string.h>
 #include <lfortran_intrinsics.h>
 
+static int64_t fib(int64_t n);
+void main0();
+void __main____global_statements();
+
+
 
 // Implementations
 static int64_t fib(int64_t n)
diff --git a/tests/reference/c-import_order_01-3ebf3c3.json b/tests/reference/c-import_order_01-3ebf3c3.json
index 4d63dfe8f5..8a602aa1fc 100644
--- a/tests/reference/c-import_order_01-3ebf3c3.json
+++ b/tests/reference/c-import_order_01-3ebf3c3.json
@@ -6,7 +6,7 @@
     "outfile": null,
     "outfile_hash": null,
     "stdout": "c-import_order_01-3ebf3c3.stdout",
-    "stdout_hash": "63a56ec5425b877465861abc207045ed30f150f6ab78004a2243433d",
+    "stdout_hash": "f3e4798c2ffb4df885977927d38d89b0354c812264ae40b4e7103ced",
     "stderr": null,
     "stderr_hash": null,
     "returncode": 0
diff --git a/tests/reference/c-import_order_01-3ebf3c3.stdout b/tests/reference/c-import_order_01-3ebf3c3.stdout
index b398b0346a..3a50069788 100644
--- a/tests/reference/c-import_order_01-3ebf3c3.stdout
+++ b/tests/reference/c-import_order_01-3ebf3c3.stdout
@@ -6,6 +6,9 @@
 #include <string.h>
 #include <lfortran_intrinsics.h>
 
+int32_t f();
+
+
 
 // Implementations
 int32_t f()
diff --git a/tests/reference/c-loop1-3e341c7.json b/tests/reference/c-loop1-3e341c7.json
index 71b0449c8b..48914d1096 100644
--- a/tests/reference/c-loop1-3e341c7.json
+++ b/tests/reference/c-loop1-3e341c7.json
@@ -6,7 +6,7 @@
     "outfile": null,
     "outfile_hash": null,
     "stdout": "c-loop1-3e341c7.stdout",
-    "stdout_hash": "63eae4287cec6a9ae5a1b3f5aacaddc08eb7edc0fa9ff7589c3ebc31",
+    "stdout_hash": "241f7395d191f7dd26195e71200be7e23a30969f2cca993137eb8b2d",
     "stderr": null,
     "stderr_hash": null,
     "returncode": 0
diff --git a/tests/reference/c-loop1-3e341c7.stdout b/tests/reference/c-loop1-3e341c7.stdout
index e27b8cfd45..a6666fb464 100644
--- a/tests/reference/c-loop1-3e341c7.stdout
+++ b/tests/reference/c-loop1-3e341c7.stdout
@@ -6,6 +6,13 @@
 #include <string.h>
 #include <lfortran_intrinsics.h>
 
+int32_t test_factorial_1(int32_t x);
+int32_t test_factorial_2(int32_t x);
+int64_t test_factorial_3(int32_t x);
+void main0();
+void __main____global_statements();
+
+
 
 // Implementations
 int32_t test_factorial_1(int32_t x)
diff --git a/tests/reference/c-loop4-eec10d3.json b/tests/reference/c-loop4-eec10d3.json
index 66986ff877..053e2c96ab 100644
--- a/tests/reference/c-loop4-eec10d3.json
+++ b/tests/reference/c-loop4-eec10d3.json
@@ -6,7 +6,7 @@
     "outfile": null,
     "outfile_hash": null,
     "stdout": "c-loop4-eec10d3.stdout",
-    "stdout_hash": "dd37ec60eb4710dc87766a78d83b77dcb982672d291848eb82c45814",
+    "stdout_hash": "9c6c8fd97e7c24685ba75f6037f45993f3f739817b4fb6650cd9cab8",
     "stderr": null,
     "stderr_hash": null,
     "returncode": 0
diff --git a/tests/reference/c-loop4-eec10d3.stdout b/tests/reference/c-loop4-eec10d3.stdout
index fb68fc33ba..2b73748426 100644
--- a/tests/reference/c-loop4-eec10d3.stdout
+++ b/tests/reference/c-loop4-eec10d3.stdout
@@ -6,6 +6,10 @@
 #include <string.h>
 #include <lfortran_intrinsics.h>
 
+void test_for();
+void __main____global_statements();
+
+
 
 // Implementations
 void test_for()
diff --git a/tests/reference/c-print_01-4d44628.json b/tests/reference/c-print_01-4d44628.json
index 9ce64802c0..46a9147135 100644
--- a/tests/reference/c-print_01-4d44628.json
+++ b/tests/reference/c-print_01-4d44628.json
@@ -6,7 +6,7 @@
     "outfile": null,
     "outfile_hash": null,
     "stdout": "c-print_01-4d44628.stdout",
-    "stdout_hash": "a42a087d40d750b53b9bc6ac7c8248c05b5adb253addd2c0a0d47550",
+    "stdout_hash": "eeedca2639797a26c43f22383f01cdd16382d27921d87a70687c44d9",
     "stderr": null,
     "stderr_hash": null,
     "returncode": 0
diff --git a/tests/reference/c-print_01-4d44628.stdout b/tests/reference/c-print_01-4d44628.stdout
index 028516f5e9..a01b63f3f0 100644
--- a/tests/reference/c-print_01-4d44628.stdout
+++ b/tests/reference/c-print_01-4d44628.stdout
@@ -5,6 +5,10 @@
 #include <string.h>
 #include <lfortran_intrinsics.h>
 
+void f();
+void __main____global_statements();
+
+
 
 // Implementations
 void f()
diff --git a/tests/reference/c-test_import_02-d2c54c4.json b/tests/reference/c-test_import_02-d2c54c4.json
index 6f8396ea92..860ef73744 100644
--- a/tests/reference/c-test_import_02-d2c54c4.json
+++ b/tests/reference/c-test_import_02-d2c54c4.json
@@ -6,7 +6,7 @@
     "outfile": null,
     "outfile_hash": null,
     "stdout": "c-test_import_02-d2c54c4.stdout",
-    "stdout_hash": "62cb9cf8e988af42d9375f49577532a91ab0c9bde8f9a9ce62c3f691",
+    "stdout_hash": "96649585d0a2f2f8e55f872b58bb924983457db3679b43525112a3ec",
     "stderr": null,
     "stderr_hash": null,
     "returncode": 0
diff --git a/tests/reference/c-test_import_02-d2c54c4.stdout b/tests/reference/c-test_import_02-d2c54c4.stdout
index d8f2b6e7c1..5a00396496 100644
--- a/tests/reference/c-test_import_02-d2c54c4.stdout
+++ b/tests/reference/c-test_import_02-d2c54c4.stdout
@@ -6,6 +6,12 @@
 #include <string.h>
 #include <lfortran_intrinsics.h>
 
+int32_t add(int32_t x, int32_t y);
+int32_t multiply(int32_t x, int32_t y);
+void f();
+void __main____global_statements();
+
+
 
 // Implementations
 const double μ =   1.45136923488338110e+00;
diff --git a/tests/reference/c-test_issue_518-fbbd299.json b/tests/reference/c-test_issue_518-fbbd299.json
index 82b2e470c5..49d711d264 100644
--- a/tests/reference/c-test_issue_518-fbbd299.json
+++ b/tests/reference/c-test_issue_518-fbbd299.json
@@ -6,7 +6,7 @@
     "outfile": null,
     "outfile_hash": null,
     "stdout": "c-test_issue_518-fbbd299.stdout",
-    "stdout_hash": "f744351df831c8870f53e3a5eefbdf47df6716a1152b2f0bda2c2cfd",
+    "stdout_hash": "651a207e618ca25fb733b618072bd3586b652da51a824ddd03d681d1",
     "stderr": null,
     "stderr_hash": null,
     "returncode": 0
diff --git a/tests/reference/c-test_issue_518-fbbd299.stdout b/tests/reference/c-test_issue_518-fbbd299.stdout
index 8dd3ea99b2..017b91c120 100644
--- a/tests/reference/c-test_issue_518-fbbd299.stdout
+++ b/tests/reference/c-test_issue_518-fbbd299.stdout
@@ -6,6 +6,12 @@
 #include <string.h>
 #include <lfortran_intrinsics.h>
 
+int64_t fib(int64_t n);
+void main0();
+void _xx_lcompilers_changed_main_xx();
+void __main____global_statements();
+
+
 
 // Implementations
 int64_t fib(int64_t n)
diff --git a/tests/reference/c-variable_decl_03-fa1823b.json b/tests/reference/c-variable_decl_03-fa1823b.json
index fe83d99fe6..a6b8f62335 100644
--- a/tests/reference/c-variable_decl_03-fa1823b.json
+++ b/tests/reference/c-variable_decl_03-fa1823b.json
@@ -6,7 +6,7 @@
     "outfile": null,
     "outfile_hash": null,
     "stdout": "c-variable_decl_03-fa1823b.stdout",
-    "stdout_hash": "6b7c50e825519137edd2df53a8926974c90b3dd88697761cd640f449",
+    "stdout_hash": "c6088ef2edb0ff2113dad651f6f782fb8dfdbe32a563d25eaa8eb0b4",
     "stderr": null,
     "stderr_hash": null,
     "returncode": 0
diff --git a/tests/reference/c-variable_decl_03-fa1823b.stdout b/tests/reference/c-variable_decl_03-fa1823b.stdout
index 87b23fad4d..a2ef090474 100644
--- a/tests/reference/c-variable_decl_03-fa1823b.stdout
+++ b/tests/reference/c-variable_decl_03-fa1823b.stdout
@@ -5,6 +5,12 @@
 #include <string.h>
 #include <lfortran_intrinsics.h>
 
+double _lcompilers_abs_f64(double x);
+double f();
+void _xx_lcompilers_changed_main_xx();
+void __main____global_statements();
+
+
 
 // Implementations
 double _lcompilers_abs_f64(double x)