diff --git a/a.out b/a.out
deleted file mode 100755
index 0abd102..0000000
Binary files a/a.out and /dev/null differ
diff --git a/src/codegen.cpp b/src/codegen.cpp
index 5d11dea..df4c8fa 100644
--- a/src/codegen.cpp
+++ b/src/codegen.cpp
@@ -158,23 +158,41 @@ namespace AST {
     }
 
     codegen::StackValue CastExpression::codegen(codegen::Builder& builder, codegen::Scope& scope) {
-        auto expr = this->m_expr->codegen(builder, scope);
-        auto cast = types::find_cast(scope.casts, expr.ty, this->m_ty);
-        if (cast) {
-            if (cast->target_ty->m_kind == types::TypeKind::Pointer && cast->casted_ty->m_kind == types::TypeKind::Array) {
-                auto allocated = builder.builder->CreateAlloca(cast->casted_ty->codegen(builder));
-                builder.builder->CreateStore(expr.value, allocated);
+        auto expr_ty = this->m_expr->get_codegen_type(scope);
+        if (expr_ty->m_kind == types::TypeKind::Pointer && this->m_ty->m_kind == types::TypeKind::Pointer) {
+            std::cout << expr_ty->formatted() << std::endl;
+            auto lvalued = scope.with_lvalue();
+            auto expr = this->m_expr->codegen(builder, lvalued);
+            auto cast = types::find_cast(scope.casts, expr.ty, this->m_ty);
+            if (cast) {
                 return codegen::StackValue{
-                    cast->codegen(builder, cast->target_ty, allocated),
+                    cast->codegen(builder, cast->target_ty, expr.value),
                     cast->target_ty
                 };
             }
-            return codegen::StackValue{
-                cast->codegen(builder, cast->target_ty, expr.value),
-                cast->target_ty
-            };
+            else {
+                return expr;
+            }
+        }
+        else {
+            auto expr = this->m_expr->codegen(builder, scope);
+            auto cast = types::find_cast(scope.casts, expr.ty, this->m_ty);
+            if (cast) {
+                // if (cast->target_ty->m_kind == types::TypeKind::Pointer && cast->casted_ty->m_kind == types::TypeKind::Array) {
+                //     auto allocated = builder.builder->CreateAlloca(cast->casted_ty->codegen(builder));
+                //     builder.builder->CreateStore(expr.value, allocated);
+                //     return codegen::StackValue{
+                //         cast->codegen(builder, cast->target_ty, allocated),
+                //         cast->target_ty
+                //     };
+                // }
+                return codegen::StackValue{
+                    cast->codegen(builder, cast->target_ty, expr.value),
+                    cast->target_ty
+                };
+            }
+            return expr;
         }
-        return expr;
     }
 
     std::shared_ptr<types::Type> RefExpression::get_codegen_type(codegen::Scope& scope) {
@@ -258,23 +276,42 @@ namespace AST {
                     };
                 }
             }
+            else if (ptr_ty->m_inner->m_kind == types::TypeKind::Array) {
+                std::cout << ptr_ty->m_inner->formatted() << std::endl;
 
-            // Must be an array otherwise
-            auto arr_ty = dynamic_cast<types::ArrayType*>(ptr_ty->m_inner.get());
-            auto gep_value = builder.builder->CreateGEP(arr_ty->m_inner->codegen(builder), value.value, idx_list, "GEP");
-            if (scope.is_lvalue) {
-                return codegen::StackValue{
-                    gep_value,
-                    value.ty,
-                };
+                // Must be an array otherwise
+                auto arr_ty = dynamic_cast<types::ArrayType*>(ptr_ty->m_inner.get());
+                auto gep_value = builder.builder->CreateGEP(arr_ty->m_inner->codegen(builder), value.value, idx_list, "GEP");
+                if (scope.is_lvalue) {
+                    return codegen::StackValue{
+                        gep_value,
+                        value.ty,
+                    };
+                }
+                else {
+                    auto inner_ptr_ty = types::PointerType{ arr_ty->m_inner };
+                    auto loaded = inner_ptr_ty.load(builder, gep_value);
+                    return codegen::StackValue{
+                        loaded.first,
+                        loaded.second
+                    };
+                }
             }
             else {
-                auto inner_ptr_ty = types::PointerType{ arr_ty->m_inner };
-                auto loaded = inner_ptr_ty.load(builder, gep_value);
-                return codegen::StackValue{
-                    loaded.first,
-                    loaded.second
-                };
+                auto gep_value = builder.builder->CreateGEP(ptr_ty->m_inner->codegen(builder), value.value, idx_list, "GEP");
+                if (scope.is_lvalue) {
+                    return codegen::StackValue{
+                        gep_value,
+                        value.ty,
+                    };
+                }
+                else {
+                    auto loaded = value.ty->load(builder, gep_value);
+                    return codegen::StackValue{
+                        loaded.first,
+                        loaded.second
+                    };
+                }
             }
         }
 
@@ -382,19 +419,32 @@ namespace AST {
 
             int counter = 0;
             for (auto& param : this->m_params) {
-                builder.builder->SetInsertPoint(BB);
-                auto arg_ptr = builder.builder->CreateAlloca(param_ty_ptrs[counter]->codegen(builder));
-                auto param_ty_ptr = std::shared_ptr<types::Type>{
-                    new types::PointerType { param_ty_ptrs[counter]}
-                };
-                auto arg = function->getArg(counter++);
-                builder.builder->CreateStore(arg, arg_ptr);
-                if (param.first) {
-                    arg->setName(*param.first);
-                    inner_scope.values[*param.first] = codegen::StackValue{
-                        arg_ptr,
-                        param_ty_ptr,
+                if (param.second->m_kind == types::TypeKind::Pointer) {
+                    auto ty = param_ty_ptrs[counter];
+                    auto arg = function->getArg(counter++);
+                    if (param.first) {
+                        arg->setName(*param.first);
+                        inner_scope.values[*param.first] = codegen::StackValue{
+                            arg,
+                            ty,
+                        };
+                    }
+                }
+                else {
+                    builder.builder->SetInsertPoint(BB);
+                    auto arg_ptr = builder.builder->CreateAlloca(param_ty_ptrs[counter]->codegen(builder));
+                    auto param_ty_ptr = std::shared_ptr<types::Type>{
+                        new types::PointerType { param_ty_ptrs[counter]}
                     };
+                    auto arg = function->getArg(counter++);
+                    builder.builder->CreateStore(arg, arg_ptr);
+                    if (param.first) {
+                        arg->setName(*param.first);
+                        inner_scope.values[*param.first] = codegen::StackValue{
+                            arg_ptr,
+                            param_ty_ptr,
+                        };
+                    }
                 }
             }
 
diff --git a/src/parsing.cpp b/src/parsing.cpp
index b356a5a..bcc68cd 100644
--- a/src/parsing.cpp
+++ b/src/parsing.cpp
@@ -398,7 +398,7 @@ namespace parsing {
                         auto array_postfix = postfix.unwrap();
                         if (array_postfix) {
                             param_ty = std::shared_ptr<types::Type>{
-                                new types::ArrayType(param_ty, *array_postfix)
+                                new types::PointerType(param_ty)
                             };
                         }
                         else {