diff --git a/.gitignore b/.gitignore
index 96fc89e..cce68ad 100644
--- a/.gitignore
+++ b/.gitignore
@@ -14,3 +14,5 @@ tests/object/
 
 **.obj
 **.exe
+
+zlang-support/
diff --git a/.vscode/settings.json b/.vscode/settings.json
index c835cf1..59164ed 100644
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -97,5 +97,8 @@
         "xtree": "cpp",
         "xutility": "cpp"
     },
-    "C_Cpp.default.compilerPath": "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.44.35207\\bin\\Hostx86\\x64\\cl.exe"
+    "C_Cpp.formatting": "clangFormat",
+    "C_Cpp.clang_format_style": "{ BasedOnStyle: Google, IndentWidth: 4, AllowShortIfStatementsOnASingleLine: false, IndentCaseLabels: false, ColumnLimit: 0, AccessModifierOffset: -4, NamespaceIndentation: All, FixNamespaceComments: false}",
+    "C_Cpp.clang_format_fallbackStyle": "{ BasedOnStyle: Google, IndentWidth: 4, AllowShortIfStatementsOnASingleLine: false, IndentCaseLabels: false, ColumnLimit: 0, AccessModifierOffset: -4, NamespaceIndentation: All, FixNamespaceComments: false}",
+    "C_Cpp.clang_format_path": "/usr/bin/clang-format",
 }
\ No newline at end of file
diff --git a/examples/functions.zz b/examples/functions.zz
new file mode 100644
index 0000000..a820007
--- /dev/null
+++ b/examples/functions.zz
@@ -0,0 +1,17 @@
+
+extern fn printf(fmt: string, ...) -> int32_t;
+
+let a: int64_t = 10;
+let f: float = 20.5;
+let u: uint8_t = 10;
+
+fn print_int(x: int64_t) -> none {
+    printf("%d\n", x);
+}
+
+fn main() {
+    if (a > 100) {
+        let res: int64_t = a * 2;
+        print_int(res);
+    }
+}
diff --git a/include/all.hpp b/include/all.hpp
index f48b408..9d1bc2e 100644
--- a/include/all.hpp
+++ b/include/all.hpp
@@ -1,4 +1,5 @@
 #pragma once
+
 #include "common/Colors.hpp"
 #include "common/Errors.hpp"
 #include "common/Logging.hpp"
@@ -11,6 +12,7 @@
 
 #include "parser/Parser.hpp"
 #include "parser/ScopeContext.hpp"
+#include "parser/NameMapper.hpp"
 
 #include "lexer/Lexer.hpp"
 
@@ -18,6 +20,7 @@
 
 #include "codegen/CodeGen.hpp"
 #include "codegen/RegisterAllocator.hpp"
+#include "codegen/Canaries.hpp"
 
 #include <sstream>
 #include <map>
@@ -25,4 +28,6 @@
 #include <memory>
 #include <fstream>
 #include <assert.h>
-#include <iomanip>
\ No newline at end of file
+#include <iomanip>
+
+static NameMapper GLOBAL_NAME_MAPPER;
\ No newline at end of file
diff --git a/include/ast/ASTNode.hpp b/include/ast/ASTNode.hpp
index e45256d..f98b88f 100644
--- a/include/ast/ASTNode.hpp
+++ b/include/ast/ASTNode.hpp
@@ -1,20 +1,19 @@
 #pragma once
 
+#include <iostream>
+#include <memory>
 #include <string>
 #include <vector>
-#include <memory>
-#include <iostream>
+
 #include "parser/ScopeContext.hpp"
 
-namespace zlang
-{
-    enum class NodeType
-    {
+namespace zlang {
+    enum class NodeType {
         Program,
-        VariableDeclaration,  // let x: int; or let x = 10;
-        VariableReassignment, // x = 42;
-        VariableAccess,       // just x
-        IntegerLiteral,       // 10, 42
+        VariableDeclaration,   // let x: int; or let x = 10;
+        VariableReassignment,  // x = 42;
+        VariableAccess,        // just x
+        IntegerLiteral,        // 10, 42
         FloatLiteral,
         StringLiteral,
         BooleanLiteral,
@@ -24,26 +23,30 @@ namespace zlang
         BinaryOp,
         UnaryOp,
         Symbol,
+        Function,
+        ExternFunction,
+        FunctionParameter,
+        FunctionParameterList,
+        FunctionReturnType,
+        ReturnStatement,
+        FunctionCall,
+        FunctionCallArgumentList
     };
 
-    class ASTNode
-    {
+    class ASTNode {
     public:
         NodeType type;
         std::string value;
         std::vector<std::unique_ptr<ASTNode>> children;
         std::shared_ptr<ScopeContext> scope;
-
         ASTNode() = default;
         ASTNode(NodeType t, const std::string &val = "", std::shared_ptr<ScopeContext> sc = nullptr)
             : type(t), value(val), scope(sc) {}
-
         static std::unique_ptr<ASTNode> makeProgramNode(const std::shared_ptr<ScopeContext> scope);
         static std::optional<std::unique_ptr<ASTNode>> makeVariableDeclarationNode(
             const std::string &name,
             std::unique_ptr<ASTNode> typeAnnotation,
             std::unique_ptr<ASTNode> initializer, const std::shared_ptr<ScopeContext> scope);
-
         static std::unique_ptr<ASTNode> makeVariableReassignmentNode(
             const std::string &name,
             std::unique_ptr<ASTNode> expr, const std::shared_ptr<ScopeContext> scope);
@@ -58,9 +61,16 @@ namespace zlang
         static std::unique_ptr<ASTNode> makeIfStatement(std::unique_ptr<ASTNode> condition, std::unique_ptr<ASTNode> program, const std::shared_ptr<ScopeContext> scope);
         static std::unique_ptr<ASTNode> makeElseIfStatement(std::unique_ptr<ASTNode> condition, std::unique_ptr<ASTNode> program, const std::shared_ptr<ScopeContext> scope);
         static std::unique_ptr<ASTNode> makeElseStatement(std::unique_ptr<ASTNode> program, const std::shared_ptr<ScopeContext> scope);
+        static std::unique_ptr<ASTNode> makeExternFunctionDeclaration(std::string name, const std::shared_ptr<ScopeContext> scope, std::vector<ParamInfo> params, std::string returnType, bool isVariadic);
+        static std::unique_ptr<ASTNode> makeFunctionDeclaration(std::string name, const std::shared_ptr<ScopeContext> scope, std::vector<ParamInfo> params, std::string returnType, std::unique_ptr<ASTNode> body, bool isVariadic);
+        static std::unique_ptr<ASTNode> makeFunctionCall(std::string name, std::vector<std::unique_ptr<ASTNode>> arguments, const std::shared_ptr<ScopeContext> scope);
+        static std::unique_ptr<ASTNode> makeFunctionParameterList(const std::vector<ParamInfo> params, const std::shared_ptr<ScopeContext> scope);
         void addChild(std::unique_ptr<ASTNode> child);
         void setElseBranch(std::unique_ptr<ASTNode> elseNode);
         ASTNode *getElseBranch() const;
+        ASTNode *getFunctionParamList() const;
+        ASTNode *getFunctionParamReturnType() const;
+        ASTNode *getFunctionBody() const;
         void print(std::ostream &out, int indent = 0) const;
     };
-}
+}  // namespace zlang
diff --git a/include/codegen/Canaries.hpp b/include/codegen/Canaries.hpp
new file mode 100644
index 0000000..a0dcd8e
--- /dev/null
+++ b/include/codegen/Canaries.hpp
@@ -0,0 +1,12 @@
+#include <cstdint>
+#include <random>
+
+class CanaryGenerator {
+public:
+    static std::uint64_t generate() {
+        std::random_device rd;  // Cryptographically secure random source
+        std::mt19937_64 gen(rd());
+        std::uniform_int_distribution<std::uint64_t> dis;
+        return dis(gen);
+    }
+};
\ No newline at end of file
diff --git a/include/codegen/CodeGen.hpp b/include/codegen/CodeGen.hpp
index 53f396a..6cabc18 100644
--- a/include/codegen/CodeGen.hpp
+++ b/include/codegen/CodeGen.hpp
@@ -1,25 +1,24 @@
 #pragma once
 
+#include <array>
+#include <functional>
+#include <map>
 #include <memory>
 #include <ostream>
-#include <map>
-#include <array>
+#include <sstream>
+
 #include "ast/ASTNode.hpp"
 #include "codegen/RegisterAllocator.hpp"
 #include "typechecker/TypeChecker.hpp"
-#include <sstream>
 
-namespace zlang
-{
-    enum class TargetTriple
-    {
+namespace zlang {
+    enum class TargetTriple {
         X86_64_LINUX,
         X86_64_WINDOWS,
         LLVM_IR
     };
 
-    class CodeGen
-    {
+    class CodeGen {
     protected:
         std::map<std::string, std::string> assembly_comparison_operations = {
             {">=", "setge"},
@@ -37,11 +36,10 @@ namespace zlang
         RegisterAllocator alloc;
         std::ostream &outfinal;
 
-        std::ostringstream outGlobal;
-        std::ostringstream out;
+        std::ostringstream outGlobalStream;
+        std::ostringstream outStream;
 
-        std::string adjustReg(const std::string &r64, uint64_t bits)
-        {
+        std::string adjustReg(const std::string &r64, uint64_t bits) {
             std::string baseRegister = RegisterAllocator::getBaseReg(r64);
             static const std::unordered_map<std::string, std::array<std::string, 4>> registers_based_on_bytes = {
                 {"rax", {"rax", "eax", "ax", "al"}},
@@ -63,11 +61,10 @@ namespace zlang
 
             auto it = registers_based_on_bytes.find(baseRegister);
             if (it == registers_based_on_bytes.end())
-                throw std::runtime_error("Unknown register '" + baseRegister + "'\n\n" + out.str());
+                throw std::runtime_error("Unknown register '" + baseRegister + "'\n\n");
             const auto &ents = it->second;
 
-            switch (bits)
-            {
+            switch (bits) {
             case 64:
                 return ents[0];
             case 32:
@@ -81,21 +78,16 @@ namespace zlang
             }
         }
 
-        static std::string getCorrectMove(uint64_t size_bytes, bool isfloat)
-        {
-            if (isfloat)
-            {
+        static std::string getCorrectMove(uint64_t size_bytes, bool isfloat) {
+            if (isfloat) {
                 if (size_bytes == 4)
                     return "movss";
                 else if (size_bytes == 8)
                     return "movsd";
                 else
                     throw std::runtime_error("Bad float move size");
-            }
-            else
-            {
-                switch (size_bytes)
-                {
+            } else {
+                switch (size_bytes) {
                 case 8:
                     return "movq";
                 case 4:
@@ -111,23 +103,29 @@ namespace zlang
 
         void noteType(const std::string &register_, const TypeInfo &type_) { regType[register_] = type_; }
 
-        virtual void generateStatement(std::unique_ptr<ASTNode> statement) = 0;
+        virtual void generateStatement(std::unique_ptr<ASTNode> statement, std::ostringstream &out) = 0;
+
+        virtual std::string emitExpression(std::unique_ptr<ASTNode> node, std::ostringstream &out) = 0;
 
-        virtual std::string emitExpression(std::unique_ptr<ASTNode> node) = 0;
+        virtual void emitEpilogue(std::shared_ptr<ScopeContext> scope, std::ostringstream &out, bool clearRax = false) = 0;
+        virtual void emitPrologue(std::shared_ptr<ScopeContext> scope, std::ostringstream &out) = 0;
 
-        virtual void emitEpilogue() = 0;
-        virtual void emitPrologue(std::unique_ptr<ASTNode> blockNode) = 0;
+        virtual std::string generateIntegerLiteral(std::unique_ptr<ASTNode> node, std::ostringstream &out) = 0;
+        virtual std::string generateFloatLiteral(std::unique_ptr<ASTNode> node, std::ostringstream &out) = 0;
+        virtual std::string generateStringLiteral(std::unique_ptr<ASTNode> node, std::ostringstream &out) = 0;
+        virtual std::string generateBooleanLiteral(std::unique_ptr<ASTNode> node, std::ostringstream &out) = 0;
+        virtual std::string generateVariableAccess(std::unique_ptr<ASTNode> node, std::ostringstream &out) = 0;
 
-        virtual std::string generateIntegerLiteral(std::unique_ptr<ASTNode> node) = 0;
-        virtual std::string generateFloatLiteral(std::unique_ptr<ASTNode> node) = 0;
-        virtual std::string generateStringLiteral(std::unique_ptr<ASTNode> node) = 0;
-        virtual std::string generateBooleanLiteral(std::unique_ptr<ASTNode> node) = 0;
-        virtual std::string generateVariableAccess(std::unique_ptr<ASTNode> node) = 0;
-        virtual void generateVariableReassignment(std::unique_ptr<ASTNode> node) = 0;
-        virtual void generateVariableDeclaration(std::unique_ptr<ASTNode> node) = 0;
-        virtual void generateIfStatement(std::unique_ptr<ASTNode> node) = 0;
-        virtual std::string generateBinaryOperation(std::unique_ptr<ASTNode> node) = 0;
-        virtual std::string generateUnaryOperation(std::unique_ptr<ASTNode> node) = 0;
+        virtual void generateVariableReassignment(std::unique_ptr<ASTNode> node, std::ostringstream &out) = 0;
+        virtual void generateVariableDeclaration(std::unique_ptr<ASTNode> node, std::ostringstream &out) = 0;
+        virtual void generateIfStatement(std::unique_ptr<ASTNode> node, std::ostringstream &out) = 0;
+
+        virtual std::string generateBinaryOperation(std::unique_ptr<ASTNode> node, std::ostringstream &out) = 0;
+        virtual std::string generateUnaryOperation(std::unique_ptr<ASTNode> node, std::ostringstream &out) = 0;
+
+        virtual std::string generateFunctionCall(std::unique_ptr<ASTNode> node, std::ostringstream &out) = 0;                      // Expression
+        virtual void generateFunctionDeclaration(std::unique_ptr<ASTNode> node, std::ostringstream &out, bool force = false) = 0;  // Statement
+        virtual void generateExternFunctionDeclaration(std::unique_ptr<ASTNode> node, std::ostringstream &out) = 0;                // Statement
 
     public:
         CodeGen(RegisterAllocator alloc, std::ostream &outstream) : stringLabelCount(0), blockLabelCount(0), doubleLabelCount(0), floatLabelCount(0), alloc(alloc), outfinal(outstream) {}
@@ -136,25 +134,39 @@ namespace zlang
         static std::unique_ptr<CodeGen> create(TargetTriple target, std::ostream &outstream);
     };
 
-    class CodeGenLinux : public CodeGen
-    {
+    class CodeGenLinux : public CodeGen {
     private:
         std::unordered_map<std::uint32_t, char> integer_suffixes = {{8, 'b'}, {16, 'w'}, {32, 'l'}, {64, 'q'}};
-        void generateStatement(std::unique_ptr<ASTNode> statement) override;
-        std::string emitExpression(std::unique_ptr<ASTNode> node) override;
-        void emitEpilogue() override;
-        void emitPrologue(std::unique_ptr<ASTNode> blockNode) override;
-        std::string generateIntegerLiteral(std::unique_ptr<ASTNode> node) override;
-        std::string generateFloatLiteral(std::unique_ptr<ASTNode> node) override;
-        std::string generateStringLiteral(std::unique_ptr<ASTNode> node) override;
-        std::string generateBooleanLiteral(std::unique_ptr<ASTNode> node) override;
-        std::string generateVariableAccess(std::unique_ptr<ASTNode> node) override;
-        void generateVariableReassignment(std::unique_ptr<ASTNode> node) override;
-        void generateVariableDeclaration(std::unique_ptr<ASTNode> node) override;
-        void generateIfStatement(std::unique_ptr<ASTNode> node) override;
-        std::string generateBinaryOperation(std::unique_ptr<ASTNode> node) override;
-        std::string generateUnaryOperation(std::unique_ptr<ASTNode> node) override;
-        std::string castValue(const std::string &val, const TypeInfo &fromType, const TypeInfo &toType);
+
+        std::string allocateOrSpill(bool isXMM, std::shared_ptr<ScopeContext> scope, std::ostringstream &out);
+        void restoreIfSpilled(const std::string &reg, std::shared_ptr<ScopeContext> scope, std::ostringstream &out);
+
+        void generateStatement(std::unique_ptr<ASTNode> statement, std::ostringstream &out) override;
+
+        std::string emitExpression(std::unique_ptr<ASTNode> node, std::ostringstream &out) override;
+
+        void emitEpilogue(std::shared_ptr<ScopeContext> scope, std::ostringstream &out, bool clearRax = false) override;
+        void emitPrologue(std::shared_ptr<ScopeContext> scope, std::ostringstream &out) override;
+
+        std::string generateIntegerLiteral(std::unique_ptr<ASTNode> node, std::ostringstream &out) override;
+        std::string generateFloatLiteral(std::unique_ptr<ASTNode> node, std::ostringstream &out) override;
+        std::string generateStringLiteral(std::unique_ptr<ASTNode> node, std::ostringstream &out) override;
+        std::string generateBooleanLiteral(std::unique_ptr<ASTNode> node, std::ostringstream &out) override;
+        std::string generateVariableAccess(std::unique_ptr<ASTNode> node, std::ostringstream &out) override;
+
+        void generateVariableReassignment(std::unique_ptr<ASTNode> node, std::ostringstream &out) override;
+        void generateVariableDeclaration(std::unique_ptr<ASTNode> node, std::ostringstream &out) override;
+        void generateIfStatement(std::unique_ptr<ASTNode> node, std::ostringstream &out) override;
+
+        std::string generateBinaryOperation(std::unique_ptr<ASTNode> node, std::ostringstream &out) override;
+        std::string generateUnaryOperation(std::unique_ptr<ASTNode> node, std::ostringstream &out) override;
+
+        std::string castValue(const std::string &val, const TypeInfo &fromType, const TypeInfo &toType, const std::shared_ptr<ScopeContext> currentScope, std::ostringstream &out);
+
+        std::string generateFunctionCall(std::unique_ptr<ASTNode> node, std::ostringstream &out) override;                      // Expression
+        void generateFunctionDeclaration(std::unique_ptr<ASTNode> node, std::ostringstream &out, bool force = false) override;  // Statement
+        void generateExternFunctionDeclaration(std::unique_ptr<ASTNode> node, std::ostringstream &out) override;                // Statement
+        void generateReturnstatement(std::unique_ptr<ASTNode> node, std::ostringstream &out);                                   // Statement
 
     public:
         ~CodeGenLinux() override = default;
@@ -162,26 +174,38 @@ namespace zlang
         void generate(std::unique_ptr<ASTNode> program) override;
     };
 
-    class CodeGenWindows : public CodeGen
-    {
+    class CodeGenWindows : public CodeGen {
     private:
         std::unordered_map<std::uint32_t, char> integer_suffixes = {{8, 'b'}, {16, 'w'}, {32, 'l'}, {64, 'q'}};
-        void generateStatement(std::unique_ptr<ASTNode> statement) override;
-        std::string emitExpression(std::unique_ptr<ASTNode> node) override;
-        void emitEpilogue() override;
-        void emitPrologue(std::unique_ptr<ASTNode> blockNode) override;
-        std::string generateIntegerLiteral(std::unique_ptr<ASTNode> node) override;
-        std::string generateFloatLiteral(std::unique_ptr<ASTNode> node) override;
-        std::string generateStringLiteral(std::unique_ptr<ASTNode> node) override;
-        std::string generateBooleanLiteral(std::unique_ptr<ASTNode> node) override;
-        std::string generateVariableAccess(std::unique_ptr<ASTNode> node) override;
-        void generateVariableReassignment(std::unique_ptr<ASTNode> node) override;
-        void generateVariableDeclaration(std::unique_ptr<ASTNode> node) override;
-        void generateIfStatement(std::unique_ptr<ASTNode> node) override;
-        std::string generateBinaryOperation(std::unique_ptr<ASTNode> node) override;
-        std::string generateUnaryOperation(std::unique_ptr<ASTNode> node) override;
-        std::string castValue(const std::string &reg, const TypeInfo &fromType, const TypeInfo &toType);
-        std::string getVariableAddress(const ScopeContext &scope, const std::string &name) const;
+
+        std::string allocateOrSpill(bool isXMM, std::shared_ptr<ScopeContext> scope, std::ostringstream &out);
+        void restoreIfSpilled(const std::string &reg, std::shared_ptr<ScopeContext> scope, std::ostringstream &out);
+
+        void generateStatement(std::unique_ptr<ASTNode> statement, std::ostringstream &out) override;
+        std::string emitExpression(std::unique_ptr<ASTNode> node, std::ostringstream &out) override;
+
+        void emitEpilogue(std::shared_ptr<ScopeContext> scope, std::ostringstream &out, bool clearRax = false) override;
+        void emitPrologue(std::shared_ptr<ScopeContext> scope, std::ostringstream &out) override;
+
+        std::string generateIntegerLiteral(std::unique_ptr<ASTNode> node, std::ostringstream &out) override;
+        std::string generateFloatLiteral(std::unique_ptr<ASTNode> node, std::ostringstream &out) override;
+        std::string generateStringLiteral(std::unique_ptr<ASTNode> node, std::ostringstream &out) override;
+        std::string generateBooleanLiteral(std::unique_ptr<ASTNode> node, std::ostringstream &out) override;
+        std::string generateVariableAccess(std::unique_ptr<ASTNode> node, std::ostringstream &out) override;
+
+        void generateVariableReassignment(std::unique_ptr<ASTNode> node, std::ostringstream &out) override;
+        void generateVariableDeclaration(std::unique_ptr<ASTNode> node, std::ostringstream &out) override;
+        void generateIfStatement(std::unique_ptr<ASTNode> node, std::ostringstream &out) override;
+
+        std::string generateBinaryOperation(std::unique_ptr<ASTNode> node, std::ostringstream &out) override;
+        std::string generateUnaryOperation(std::unique_ptr<ASTNode> node, std::ostringstream &out) override;
+
+        std::string castValue(const std::string &val, const TypeInfo &fromType, const TypeInfo &toType, const std::shared_ptr<ScopeContext> currentScope, std::ostringstream &out);
+
+        std::string generateFunctionCall(std::unique_ptr<ASTNode> node, std::ostringstream &out) override;                      // Expression
+        void generateFunctionDeclaration(std::unique_ptr<ASTNode> node, std::ostringstream &out, bool force = false) override;  // Statement
+        void generateExternFunctionDeclaration(std::unique_ptr<ASTNode> node, std::ostringstream &out) override;                // Statement
+        void generateReturnstatement(std::unique_ptr<ASTNode> node, std::ostringstream &out);                                   // Statement
 
     public:
         ~CodeGenWindows() override = default;
@@ -189,30 +213,38 @@ namespace zlang
         void generate(std::unique_ptr<ASTNode> program) override;
     };
 
-    class CodeGenLLVM : public CodeGen
-    {
+    class CodeGenLLVM : public CodeGen {
     private:
-        std::unordered_map<std::uint32_t, char> integer_suffixes = {{8, 'b'}, {16, 'w'}, {32, 'l'}, {64, 'q'}};
         std::unordered_map<std::string, std::string> stringLiterals;
-        void generateStatement(std::unique_ptr<ASTNode> statement) override;
-        std::string emitExpression(std::unique_ptr<ASTNode> node) override;
-        void emitEpilogue() override;
-        void emitPrologue(std::unique_ptr<ASTNode> blockNode) override;
-        std::string generateIntegerLiteral(std::unique_ptr<ASTNode> node) override;
-        std::string generateFloatLiteral(std::unique_ptr<ASTNode> node) override;
-        std::string generateStringLiteral(std::unique_ptr<ASTNode> node) override;
-        std::string generateBooleanLiteral(std::unique_ptr<ASTNode> node) override;
-        std::string generateVariableAccess(std::unique_ptr<ASTNode> node) override;
-        void generateVariableReassignment(std::unique_ptr<ASTNode> node) override;
-        void generateVariableDeclaration(std::unique_ptr<ASTNode> node) override;
-        void generateIfStatement(std::unique_ptr<ASTNode> node) override;
-        std::string generateBinaryOperation(std::unique_ptr<ASTNode> node) override;
-        std::string generateUnaryOperation(std::unique_ptr<ASTNode> node) override;
-        std::string castValue(const std::string &val, const TypeInfo &fromType, const TypeInfo &toType);
+
+        void generateStatement(std::unique_ptr<ASTNode> statement, std::ostringstream &out) override;
+        std::string emitExpression(std::unique_ptr<ASTNode> node, std::ostringstream &out) override;
+
+        void emitEpilogue(std::shared_ptr<ScopeContext> scope, std::ostringstream &out, bool clearRax = false) override;
+        void emitPrologue(std::shared_ptr<ScopeContext> scope, std::ostringstream &out) override;
+
+        std::string generateIntegerLiteral(std::unique_ptr<ASTNode> node, std::ostringstream &out) override;
+        std::string generateFloatLiteral(std::unique_ptr<ASTNode> node, std::ostringstream &out) override;
+        std::string generateStringLiteral(std::unique_ptr<ASTNode> node, std::ostringstream &out) override;
+        std::string generateBooleanLiteral(std::unique_ptr<ASTNode> node, std::ostringstream &out) override;
+        std::string generateVariableAccess(std::unique_ptr<ASTNode> node, std::ostringstream &out) override;
+
+        void generateVariableReassignment(std::unique_ptr<ASTNode> node, std::ostringstream &out) override;
+        void generateVariableDeclaration(std::unique_ptr<ASTNode> node, std::ostringstream &out) override;
+        void generateIfStatement(std::unique_ptr<ASTNode> node, std::ostringstream &out) override;
+
+        std::string generateBinaryOperation(std::unique_ptr<ASTNode> node, std::ostringstream &out) override;
+        std::string generateUnaryOperation(std::unique_ptr<ASTNode> node, std::ostringstream &out) override;
+        std::string castValue(const std::string &val, const TypeInfo &fromType, const TypeInfo &toType, std::ostringstream &out);
+
+        std::string generateFunctionCall(std::unique_ptr<ASTNode> node, std::ostringstream &out) override;                      // Expression
+        void generateFunctionDeclaration(std::unique_ptr<ASTNode> node, std::ostringstream &out, bool force = false) override;  // Statement
+        void generateExternFunctionDeclaration(std::unique_ptr<ASTNode> node, std::ostringstream &out) override;                // Statement
+        void generateReturnstatement(std::unique_ptr<ASTNode> node, std::ostringstream &out);                                   // Statement
 
     public:
         ~CodeGenLLVM() override = default;
         CodeGenLLVM(std::ostream &outstream) : CodeGen(RegisterAllocator(), outstream) {};
         void generate(std::unique_ptr<ASTNode> program) override;
     };
-} // namespace zlang
\ No newline at end of file
+}  // namespace zlang
\ No newline at end of file
diff --git a/include/codegen/RegisterAllocator.hpp b/include/codegen/RegisterAllocator.hpp
index 5415961..a4345a8 100644
--- a/include/codegen/RegisterAllocator.hpp
+++ b/include/codegen/RegisterAllocator.hpp
@@ -1,45 +1,105 @@
 #pragma once
 
+#include <list>
+#include <optional>
+#include <stdexcept>
 #include <string>
-#include <vector>
 #include <unordered_set>
-#include <stdexcept>
+#include <vector>
+
+namespace zlang {
+
+    // Tips for noobs: CALLER saved are saved by the caller, CALLEE saved are restored by the function/routine
+    // So CALLER Union CALLEE should be equal to the set of all the registers, so the current state will never be corrupted.
+
+    // Time wasted here: 3days and still counting.. And I am still unemployed.
+
+    // GPRs on LINUX (SysV ABI)
+    static const std::vector<std::string> SCRATCH_GPR_LINUX = {"rax", "rcx", "rdx", "rsi", "rdi", "r8", "r9", "r10", "r11"};
+    static const std::vector<std::string> ARG_GPR_LINUX = {"rdi", "rsi", "rdx", "rcx", "r8", "r9"};
+    static const std::vector<std::string> CALLER_GPR_LINUX = {"rax", "rcx", "rdx", "rsi", "rdi", "r8", "r9", "r10", "r11"};
+    static const std::vector<std::string> CALLEE_GPR_LINUX = {"rbx", "r12", "r13", "r14", "r15"};
+    // XMMs on LINUX (SysV ABI)
+    static const std::vector<std::string> SCRATCH_XMM_LINUX = {"xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7",
+                                                               "xmm8", "xmm9", "xmm10", "xmm11", "xmm12", "xmm13", "xmm14", "xmm15"};
+    static const std::vector<std::string> ARG_XMM_LINUX = {"xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7"};
+    static const std::vector<std::string> CALLER_XMM_LINUX = {"xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7",
+                                                              "xmm8", "xmm9", "xmm10", "xmm11", "xmm12", "xmm13", "xmm14", "xmm15"};  // Will be used freely by function
+    static const std::vector<std::string> CALLEE_XMM_LINUX = {/* None */};                                                            // Why would you do this linus ?                                                                                                                         // The function is responsible to restore the state
+    // GPRs on WINDOWS (MSVC)
+    static const std::vector<std::string> SCRATCH_GPR_MSVC = {"rax", "rcx", "rdx", "r8", "r9", "r10", "r11"};
+    static const std::vector<std::string> ARG_GPR_MSVC = {"rcx", "rdx", "r8", "r9"};
+    static const std::vector<std::string> CALLER_GPR_MSVC = {"rax", "rcx", "rdx", "r8", "r9", "r10", "r11"};
+    static const std::vector<std::string> CALLEE_GPR_MSVC = {"rbx", "rdi", "rsi", "r12", "r13", "r14", "r15"};
+    // XMMs on WINDOWS (MSVC)
+    static const std::vector<std::string> SCRATCH_XMM_MSVC = {"xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5"};
+    static const std::vector<std::string> ARG_XMM_MSVC = {"xmm0", "xmm1", "xmm2", "xmm3"};
+    static const std::vector<std::string> CALLER_XMM_MSVC = {"xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5"};
+    static const std::vector<std::string> CALLEE_XMM_MSVC = {"xmm6", "xmm7", "xmm8", "xmm9", "xmm10", "xmm11", "xmm12", "xmm13", "xmm14", "xmm15"};
+
+    class RegisterAllocator {
+        struct SpillInfo {
+            std::string spillSlot;  // e.g. -16(%rbp) or [rbp - 16]
+            bool isXMM;
+        };
+
+        std::unordered_map<std::string, SpillInfo> spilledRegs;
+        std::unordered_map<std::string, SpillInfo> spilledArgumentRegs;
 
-namespace zlang
-{
-    /// Simple register allocator for x86_64
-    class RegisterAllocator
-    {
     public:
         /// Initialize allocator with target-specific registers
-        static RegisterAllocator forSysV(); // Linux ABI
-        static RegisterAllocator forMSVC(); // Windows ABI
+        static RegisterAllocator forSysV();  // Linux ABI
+        static RegisterAllocator forMSVC();  // Windows ABI
 
-        /// Allocate a free register; throws if none available
         std::string allocate();
+        bool isInUse(std::string reg);
+        bool isInUseXMM(std::string reg);
 
-        /// Free a previously allocated register; throws if invalid
         void free(const std::string &reg);
 
-        /// Allocate a free XMM register; throws if none available
         std::string allocateXMM();
 
-        /// Free a previously allocated XMM register; throws if invalid
         bool freeXMM(const std::string &reg);
 
-        /// Reset allocator state (mark all as free)
+        std::string allocateArgument(uint8_t position);
+        std::string allocateArgumentXMM(uint8_t position);
+        void freeArgument(const std::string &reg);
+        bool freeArgumentXMM(const std::string &reg);
+        bool isInUseArgument(const std::string &reg) const;
+        bool isInUseArgumentXMM(const std::string &reg) const;
+
         void reset();
         RegisterAllocator() = default;
         static std::string getBaseReg(const std::string &reg);
 
+        std::string pickVictimXMM();
+        std::string pickVictim();
+        void markSpilledXMM(const std::string &reg, const std::string &spillSlot);
+        void markSpilled(const std::string &reg, const std::string &spillSlot);
+        bool isSpilled(const std::string &reg) const;
+        std::string spillSlotFor(const std::string &reg) const;
+        void unSpillXMM(const std::string &reg, zlang::CodegenOutputFormat format, std::ostream &out);
+        void unSpill(const std::string &reg, zlang::CodegenOutputFormat format, std::ostream &out);
+        void touch(const std::string &reg);
+        void touchXMM(const std::string &reg);
+        void emitSpillRestore(const std::string &reg, const std::string &slot, bool isXMM, zlang::CodegenOutputFormat format, std::ostream &out);
+
     private:
-        RegisterAllocator(std::vector<std::string> regs);
+        RegisterAllocator(std::vector<std::string> regs, std::vector<std::string> XMMregs, std::vector<std::string> argumentRegs, std::vector<std::string> argumentXMMRegs);
         std::vector<std::string> available;
         std::unordered_set<std::string> inUse;
 
-        std::vector<std::string> availableXMM = { // Default XMMs
-            "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7",
-            "xmm8", "xmm9", "xmm10", "xmm11", "xmm12", "xmm13", "xmm14", "xmm15"};
+        std::vector<std::string> availableXMM;
         std::unordered_set<std::string> inUseXMM;
+
+        std::unordered_set<std::string> inUseArgumentXMM;
+        std::unordered_set<std::string> inUseArgument;
+
+        std::list<std::string> lruRegs;
+        std::list<std::string> lruXMMRegs;
+
+    public:
+        const std::vector<std::string> availableArgumentRegs;
+        const std::vector<std::string> availableArgumentRegsXMM;
     };
 }
diff --git a/include/lexer/Lexer.hpp b/include/lexer/Lexer.hpp
index a136567..d1fb69f 100644
--- a/include/lexer/Lexer.hpp
+++ b/include/lexer/Lexer.hpp
@@ -1,14 +1,12 @@
 #pragma once
 #include <string>
 #include <vector>
+
 #include "../common/Errors.hpp"
 
-namespace zlang
-{
-    struct Token
-    {
-        enum class Kind
-        {
+namespace zlang {
+    struct Token {
+        enum class Kind {
             Let,
             Identifier,
             Colon,
@@ -17,15 +15,20 @@ namespace zlang
             StringLiteral,
             BoolLiteral,
             Symbol,
-            Keyword,
+            Comma,
+            Arrow,
             EndOfFile,
             SemiColon,
             Equal,
+            Return,
+            Dot,
+            Ellipsis,
             If,
             ElseIf,
             Else,
             LeftBrace,
             RightBrace,
+            Function,
             LeftParen,
             RightParen,
             Unknown
@@ -35,8 +38,7 @@ namespace zlang
         size_t line;
         size_t column;
 
-        std::string to_string() const
-        {
+        std::string to_string() const {
             return "Token { kind = " + kindToString(kind) +
                    ", text = \"" + text +
                    "\", line = " + std::to_string(line) +
@@ -44,10 +46,8 @@ namespace zlang
         }
 
     private:
-        static std::string kindToString(Kind k)
-        {
-            switch (k)
-            {
+        static std::string kindToString(Kind k) {
+            switch (k) {
             case Kind::Equal:
                 return "Equal";
             case Kind::Colon:
@@ -64,8 +64,6 @@ namespace zlang
                 return "StringLiteral";
             case Kind::Symbol:
                 return "Symbol";
-            case Kind::Keyword:
-                return "Keyword";
             case Kind::EndOfFile:
                 return "EndOfFile";
             case Kind::SemiColon:
@@ -88,18 +86,28 @@ namespace zlang
                 return "RightParen";
             case Kind::LeftParen:
                 return "LeftParen";
+            case Kind::Arrow:
+                return "Arrow";
+            case Kind::Comma:
+                return "Comma";
+            case Kind::Function:
+                return "Function";
+            case Kind::Return:
+                return "Return";
+            case Kind::Dot:
+                return "Dot";
+            case Kind::Ellipsis:
+                return "Ellipsis";
             }
             return "Invalid";
         }
     };
 
-    inline std::ostream &operator<<(std::ostream &os, const Token &token)
-    {
+    inline std::ostream &operator<<(std::ostream &os, const Token &token) {
         return os << token.to_string();
     }
     using Error = zlang::Error;
-    class Lexer
-    {
+    class Lexer {
     public:
         explicit Lexer(const std::string &source);
 
@@ -122,4 +130,4 @@ namespace zlang
         Token scanSymbol();
     };
 
-} // namespace zlang
+}  // namespace zlang
diff --git a/include/parser/NameMapper.hpp b/include/parser/NameMapper.hpp
new file mode 100644
index 0000000..afd8b8e
--- /dev/null
+++ b/include/parser/NameMapper.hpp
@@ -0,0 +1,30 @@
+#pragma once
+
+#include <string>
+
+class NameMapper
+    {
+    public:
+        inline std::string mapVariable(const std::string &name, const std::string &scopeName)
+        {
+            std::string mangled = scopeName + "___" + name + "___v" + std::to_string(varCounter_++);
+            return mangled;
+        }
+
+        inline std::string mapFunction(const std::string &name, const std::string &scopeName)
+        {
+            std::string mangled = scopeName + "___" + name + "___f" + std::to_string(funcCounter_++);
+            return mangled;
+        }
+
+        inline std::string mapType(const std::string &name, const std::string &scopeName)
+        {
+            std::string mangled = scopeName + "___" + name + "___t" + std::to_string(typeCounter_++);
+            return mangled;
+        }
+
+    private:
+        size_t varCounter_ = 0;
+        size_t funcCounter_ = 0;
+        size_t typeCounter_ = 0;
+    };
diff --git a/include/parser/Parser.hpp b/include/parser/Parser.hpp
index 0f93a1e..decbbfe 100644
--- a/include/parser/Parser.hpp
+++ b/include/parser/Parser.hpp
@@ -1,20 +1,18 @@
 #pragma once
 #include <memory>
-#include "parser/ScopeContext.hpp"
-#include "../lexer/Lexer.hpp"
+
 #include "../ast/ASTNode.hpp"
+#include "../lexer/Lexer.hpp"
 #include "common/Errors.hpp"
 #include "common/Logging.hpp"
+#include "parser/ScopeContext.hpp"
 
-namespace zlang
-{
-    class Parser
-    {
+namespace zlang {
+    class Parser {
     public:
         explicit Parser(Lexer &lexer);
         std::unique_ptr<ASTNode> parse();
-        bool isCorrect()
-        {
+        bool isCorrect() {
             return shouldTypecheck;
         }
 
@@ -35,12 +33,13 @@ namespace zlang
         std::unique_ptr<ASTNode> parseConditionals();
         std::unique_ptr<ASTNode> parseExpression(bool expect_exclaim = false);
         std::unique_ptr<ASTNode> parsePrimary();
+        std::unique_ptr<ASTNode> parseFunctionDeclaration();
 
         int getPrecedence(const std::string &op) const;
         std::unique_ptr<ASTNode> parseUnary();
         std::unique_ptr<ASTNode> parseBinaryRHS(int exprPrec, std::unique_ptr<ASTNode> lhs);
 
-        void enterScope(std::string name);
+        void enterScope(const std::string &name, bool isFunction);
         void exitScope();
         std::unique_ptr<ASTNode> parseBlock();
     };
diff --git a/include/parser/ScopeContext.hpp b/include/parser/ScopeContext.hpp
index f76cadf..e40df1c 100644
--- a/include/parser/ScopeContext.hpp
+++ b/include/parser/ScopeContext.hpp
@@ -1,117 +1,174 @@
 #pragma once
-#include <string>
-#include <unordered_map>
+#include <map>
 #include <memory>
+#include <optional>
 #include <stdexcept>
+#include <string>
+#include <unordered_map>
 #include <vector>
-#include <optional>
-#include <map>
 
-namespace zlang
-{
+namespace zlang {
+    struct VariableInfo {
+        std::string type;
+    };
+
+    struct TypeInfo {
+        std::uint32_t bits = 0;
+        std::uint32_t align = 0;
+        bool isFloat = false;
+        bool isSigned = false;
+        bool isString = false;
+        bool isBoolean = false;
+        bool isPointer = false;
+        bool isUserDefined = false;
+        bool isFunction = false;
 
-    struct VariableInfo
-    {
+        std::string name;
+
+        std::string to_string() const;
+    };
+
+    struct ParamInfo {
+        std::string name;
         std::string type;
+        std::string to_string() const;
     };
 
-    struct FunctionInfo
-    {
-        std::vector<std::string> paramTypes;
+    inline std::string ParamInfo::to_string() const {
+        std::string ret = "ParamInfo( .name: " + name + ", .type: " + type + ")";
+        return ret;
+    }
+
+    struct FunctionInfo {
+        std::vector<ParamInfo> paramTypes;
         std::string returnType;
+        std::string name;
+        std::string label;
+        bool isExtern;
+        bool isVariadic;
+        std::string to_string() const;
     };
 
-    struct TypeInfo
-    {
-        // details of user-defined types (e.g., struct/class definitions)
-        // TODO
-        std::uint32_t bits;
-        std::uint32_t align;
-        bool isFloat;
-        bool isSigned;
-
-        std::string to_string() const
-        {
-            std::string ret = "";
-            ret += "TypeInfo( .bits: " + std::to_string(bits) + ", .align: " + std::to_string(align) + ", .isFloat: " + (isFloat ? "true" : "false") + ", .isSigned: " + (isSigned ? "true" : "false") + " )\n";
-            return ret;
+    inline std::string FunctionInfo::to_string() const {
+        std::string ret = "FunctionInfo( params: (";
+        for (size_t i = 0; i < paramTypes.size(); ++i) {
+            ret += paramTypes[i].to_string();
+            if (i != paramTypes.size() - 1)
+                ret += ", ";
         }
-    };
+        ret += "), return: " + returnType + " )";
+        return ret;
+    }
+
+    inline std::string TypeInfo::to_string() const {
+        std::string ret =
+            "TypeInfo( .name: " + name + ", .bits: " + std::to_string(bits) +
+            ", .align: " + std::to_string(align) +
+            ", .isFloat: " + (isFloat ? "true" : "false") +
+            ", .isSigned: " + (isSigned ? "true" : "false") +
+            ", .isBoolean: " + (isBoolean ? "true" : "false") +
+            ", .isString: " + (isString ? "true" : "false") +
+            ", .isPointer: " + (isPointer ? "true" : "false") +
+            ", .isUserDefined: " + (isUserDefined ? "true" : "false") +
+            ", .isFunction: " + (isFunction ? "true" : "false") + " )";
+        return ret;
+    }
 
-    static int variableNumber = 0;
+    class FunctionScope;
 
-    class ScopeContext
-    {
+    class ScopeContext : public std::enable_shared_from_this<ScopeContext> {
     public:
-        std::string name;
-        ScopeContext(std::shared_ptr<ScopeContext> parent = nullptr) : stackOffset(0), parent_(parent){};
-        ScopeContext(std::shared_ptr<ScopeContext> parent = nullptr, std::string name = "") : name(name), stackOffset(0), parent_(parent){};
-        std::unordered_map<std::string, std::string> name_mappings;
-        std::int64_t stackOffset;
-        std::shared_ptr<ScopeContext> parent_;
+        ScopeContext(std::string name,
+                     std::shared_ptr<ScopeContext> parent = nullptr)
+            : name_(std::move(name)), parent_(std::move(parent)) {}
+        virtual ~ScopeContext() = default;
+        virtual std::string kind() const = 0;
         bool defineVariable(const std::string &name, const VariableInfo &info);
-        void defineFunction(const std::string &name, const FunctionInfo &info);
+        void defineFunction(const std::string &name, FunctionInfo info);
         void defineType(const std::string &name, const TypeInfo &info);
-        std::string getMapping(std::string varName);
         VariableInfo lookupVariable(const std::string &name) const;
         FunctionInfo lookupFunction(const std::string &name) const;
         TypeInfo lookupType(const std::string &name) const;
-        std::unordered_map<std::string, std::int64_t> offsetTable;
+        std::optional<VariableInfo>
+        lookupVariableInCurrentContext(const std::string &name) const;
+        virtual std::int64_t allocateStack(const std::string &varName,
+                                           const TypeInfo &type);
         std::int64_t getVariableOffset(const std::string &name) const;
         bool isGlobalScope() const;
         bool isGlobalVariable(const std::string &name) const;
-        void printGlobalContext() const
-        {
-            const ScopeContext *ctx = this;
-            while (ctx->parent_)
-                ctx = ctx->parent_.get();
-
-            std::cout << "=== Global Scope ===\n";
-            // Variables
-            if (!ctx->vars_.empty())
-            {
-                std::cout << "Variables:\n";
-                for (auto &kv : ctx->vars_)
-                {
-                    std::cout << "  " << kv.first << ": "
-                              << kv.second.type << "\n";
-                }
-            }
-            // Functions
-            if (!ctx->funcs_.empty())
-            {
-                std::cout << "Functions:\n";
-                for (auto &kv : ctx->funcs_)
-                {
-                    std::cout << "  " << kv.first << "(\n";
-                    for (size_t i = 0; i < kv.second.paramTypes.size(); ++i)
-                    {
-                        std::cout << kv.second.paramTypes[i];
-                        if (i + 1 < kv.second.paramTypes.size())
-                            std::cout << ", ";
-                    }
-                    std::cout << ") -> " << kv.second.returnType << "\n";
-                }
-            }
-            // Types
-            if (!ctx->types_.empty())
-            {
-                std::cout << "Types:\n";
-                for (auto &kv : ctx->types_)
-                {
-                    std::cout << "  " << kv.first
-                              << " (" << kv.second.bits << " bits, align=" << kv.second.align
-                              << ", " << (kv.second.isFloat ? "float" : "int")
-                              << ")\n";
-                }
-            }
-            std::cout << std::endl;
-        }
-        std::optional<VariableInfo> lookupVariableInCurrentContext(const std::string &name) const;
+        std::shared_ptr<ScopeContext> parent() const { return parent_; }
+        const std::string &name() const { return name_; }
+        std::string getMapping(std::string name);
+        void setMapping(const std::string &name, const std::string &llvmName);
+        virtual void printScope(std::ostream &out, int indent = 0) const;
+        std::shared_ptr<FunctionScope> findEnclosingFunctionScope();
+        std::shared_ptr<ScopeContext> getGlobal();
+        std::string returnType = "none";
 
-    private:
+    protected:
+        std::string name_;
+        std::shared_ptr<ScopeContext> parent_;
         std::unordered_map<std::string, VariableInfo> vars_;
         std::unordered_map<std::string, FunctionInfo> funcs_;
         std::unordered_map<std::string, TypeInfo> types_;
+        std::unordered_map<std::string, std::int64_t> offsetTable_;
+        std::unordered_map<std::string, std::string> variable_name_mappings;
+    };
+
+    class FunctionScope : public ScopeContext {
+    public:
+        FunctionScope(std::string name,
+                      std::shared_ptr<ScopeContext> parent = nullptr);
+        ~FunctionScope() override;
+        void printScope(std::ostream &out, int indent = 0) const override;
+        inline std::string kind() const override { return "Function"; }
+        std::int64_t allocateStack(const std::string &varName,
+                                   const TypeInfo &type) override;
+        std::int64_t getStackOffset() const;
+        void setCanary(std::uint64_t canary_) {
+            this->canary = canary_;
+        }
+        std::uint64_t getCanary() {
+            return this->canary;
+        }
+        std::string allocateSpillSlot(std::int64_t size, CodegenOutputFormat format);
+        std::int64_t getSpillSize() const;
+        void freeSpillSlot(const std::string &slot, std::int64_t size);
+
+    private:
+        std::int64_t stackOffset_;
+        std::uint64_t canary;
+        std::int64_t nextSpillOffset_ = 0;
+        std::vector<std::pair<std::int64_t, std::int64_t>> freeSpillSlots_;
+        inline static std::int64_t alignSize(const TypeInfo &type) {
+            return std::max<std::uint32_t>(type.align, 8);
+        }
     };
-}
+    class BlockScope : public ScopeContext {
+    public:
+        BlockScope(std::string name, std::shared_ptr<FunctionScope> funcScope,
+                   std::shared_ptr<ScopeContext> parent);
+        ~BlockScope() override;
+        void printScope(std::ostream &out, int indent = 0) const override;
+        inline std::string kind() const override { return "Block"; }
+        std::int64_t allocateStack(const std::string &varName,
+                                   const TypeInfo &type) override;
+
+    private:
+        std::shared_ptr<FunctionScope> funcScope_;
+    };
+
+    class NamespaceScope : public ScopeContext {
+    public:
+        NamespaceScope(std::string name, std::shared_ptr<ScopeContext> parent = nullptr)
+            : ScopeContext(std::move(name), std::move(parent)) {}
+
+        std::string kind() const override { return "Namespace"; }
+
+        std::int64_t allocateStack(const std::string &, const TypeInfo &) override {
+            // namespaces don’t allocate stack space
+            throw std::runtime_error("Namespaces cannot define stack variables");
+        }
+    };
+
+}  // namespace zlang
diff --git a/include/typechecker/TypeChecker.hpp b/include/typechecker/TypeChecker.hpp
index f88e2cd..94f8951 100644
--- a/include/typechecker/TypeChecker.hpp
+++ b/include/typechecker/TypeChecker.hpp
@@ -1,64 +1,81 @@
 #pragma once
 
 #include <memory>
+#include <set>
 #include <string>
+
 #include "ast/ASTNode.hpp"
-#include "parser/ScopeContext.hpp"
 #include "common/Errors.hpp"
-#include <set>
+#include "parser/ScopeContext.hpp"
+
+// TODO: Check that all paths inside the function return appropriate value.
 
-namespace zlang
-{
+namespace zlang {
     static const std::set<std::string> numeric_types = {"integer", "size_t", "uint8_t", "uint16_t", "uint32_t", "uint64_t", "int8_t", "int16_t", "int32_t", "int64_t", "float", "double"};
     static const std::set<std::string> integral_types = {"integer", "size_t", "uint8_t", "uint16_t", "uint32_t", "uint64_t", "int8_t", "int16_t", "int32_t", "int64_t"};
 
-    class TypeChecker
-    {
+    class TypeChecker {
     public:
-        /// Walks the whole AST, logs any errors found.
         void check(const std::unique_ptr<ASTNode> &program);
-        bool shouldCodegen()
-        {
+        bool shouldCodegen() {
             return shouldCodegen_;
         }
-
-        static inline std::string typeName(const TypeInfo &info)
-        {
-            if (info.isFloat)
-                return info.bits == 32 ? "float" : "double";
-            return (info.isSigned ? "int" : "uint") + std::to_string(info.bits) + "_t";
+        static inline std::string typeName(const TypeInfo &info) {
+            return info.name;
         }
-        static inline TypeInfo promoteType(const TypeInfo &a, const TypeInfo &b)
-        {
-            if (a.isFloat || b.isFloat)
-            {
+        static inline TypeInfo promoteType(const TypeInfo &a, const TypeInfo &b) {
+            if (a.isString || b.isString ||
+                a.isPointer || b.isPointer ||
+                a.isUserDefined || b.isUserDefined) {
+                throw std::runtime_error(
+                    "Invalid type promotion between: " + typeName(a) + " and " + typeName(b));
+            }
+
+            if (a.isFloat || b.isFloat) {
                 if (a.isFloat && b.isFloat)
                     return a.bits > b.bits ? a : b;
-                if (a.isFloat)
-                {
+
+                if (a.isFloat) {
                     if (b.bits > a.bits)
-                    {
-                        return {b.bits, b.bits / 8, true, true};
-                    }
+                        return TypeInfo{
+                            .bits = b.bits,
+                            .align = b.bits / 8,
+                            .isFloat = true,
+                            .isSigned = true,
+                            .isString = false,
+                            .isBoolean = false,
+                            .isPointer = false,
+                            .isUserDefined = false,
+                            .isFunction = false,
+                            .name = (b.bits == 64 ? "double" : "float")};
                     else
-                    {
                         return a;
-                    }
-                }
-                else
-                {
+                } else {
                     if (a.bits > b.bits)
-                    {
-                        return {a.bits, a.bits / 8, true, true};
-                    }
+                        return TypeInfo{
+                            .bits = a.bits,
+                            .align = a.bits / 8,
+                            .isFloat = true,
+                            .isSigned = true,
+                            .isString = false,
+                            .isBoolean = false,
+                            .isPointer = false,
+                            .isUserDefined = false,
+                            .isFunction = false,
+                            .name = (a.bits == 64 ? "double" : "float")};
                     else
-                    {
                         return b;
-                    }
                 }
             }
+
             if (a.bits != b.bits)
                 return a.bits > b.bits ? a : b;
+
+            if (a.isSigned && !b.isSigned)
+                return a;
+            if (!a.isSigned && b.isSigned)
+                return b;
+
             return a;
         }
 
@@ -72,4 +89,4 @@ namespace zlang
         bool shouldCodegen_ = true;
     };
 
-} // namespace zlang
\ No newline at end of file
+}  // namespace zlang
\ No newline at end of file
diff --git a/main.cpp b/main.cpp
index d39b1a9..c268145 100644
--- a/main.cpp
+++ b/main.cpp
@@ -2,28 +2,24 @@
 
 using namespace zlang;
 
-int main(int argc, char *argv[])
-{
-    if (argc < 2)
-    {
+int main(int argc, char *argv[]) {
+    if (argc < 2) {
         CommandLine::printUsage(argv[0]);
         return 0;
     }
 
     CommandLine cli(argc, argv);
-    if (cli.hasError())
-    {
+
+    if (cli.hasError()) {
         return 1;
     }
 
-    if (cli.showHelp())
-    {
+    if (cli.showHelp()) {
         CommandLine::printUsage(argv[0]);
         return 0;
     }
 
-    if (cli.showFormats())
-    {
+    if (cli.showFormats()) {
         CommandLine::printFormats();
         return 0;
     }
@@ -32,16 +28,14 @@ int main(int argc, char *argv[])
 
     assert(inputFile.ends_with(".zz"));
 
-    if (inputFile.empty())
-    {
+    if (inputFile.empty()) {
         logError(zlang::Error(zlang::ErrorType::Generic, "No input files."));
         CommandLine::printUsage(argv[0]);
         return 1;
     }
 
     std::optional<std::string> source = zlang::File::readAllText(inputFile);
-    if (!source)
-    {
+    if (!source) {
         logError(zlang::Error(zlang::ErrorType::Generic,
                               "Failed to read from " + inputFile));
         return 1;
@@ -50,52 +44,56 @@ int main(int argc, char *argv[])
     // Parse source
     Lexer lexer(source.value());
     Parser parser(lexer);
-
+    logMessage("Parsing");
     std::unique_ptr<ASTNode> program = parser.parse();
 
-    if (!parser.isCorrect())
-    {
+    if (!parser.isCorrect()) {
         return 1;
     }
 
-    if (!program.get())
-    {
+    if (!program.get()) {
         zlang::logError(Error(ErrorType::Generic, "Parsing Failed"));
         return 1;
     }
-    if (cli.printAST())
-    {
+    if (cli.printAST()) {
         program.get()->print(std::cout);
     }
 
+    logMessage("TypeChecking");
+
     // Type checking
     TypeChecker typeChecker;
     typeChecker.check(program);
 
+    logMessage("Code Genning");
+
     if (!typeChecker.shouldCodegen())
         return 1;
 
+    try {
+        program->scope->lookupFunction("main");
+    } catch (...) {
+        logError(Error(ErrorType::Generic, "Main Function does'nt exist in program scope (GLOBALLY)"));
+        exit(1);
+    }
     std::ostream *outstream = &std::cout;
     std::ofstream ofs;
 
     // Only open the file if requested:
-    if (!cli.getOutputFile().empty())
-    {
+    if (!cli.getOutputFile().empty()) {
         ofs.open(cli.getOutputFile());
-        if (!ofs)
-        {
+        if (!ofs) {
             std::cerr << "Error: cannot open output file: "
                       << cli.getOutputFile() << "\n";
             std::exit(1);
         }
-        outstream = &ofs; // now point at the file
+        outstream = &ofs;  // now point at the file
     }
 
     std::unique_ptr<zlang::CodeGen> cg =
         CodeGen::create(TargetTriple::X86_64_LINUX, *outstream);
 
-    switch (cli.getFormat())
-    {
+    switch (cli.getFormat()) {
     case CodegenOutputFormat::Default:
 #ifdef _WIN64
         cg = CodeGen::create(TargetTriple::X86_64_WINDOWS, *outstream);
@@ -105,20 +103,17 @@ int main(int argc, char *argv[])
 #endif
         break;
 
-    case CodegenOutputFormat::X86_64_MSWIN:
-    {
+    case CodegenOutputFormat::X86_64_MSWIN: {
         cg = CodeGen::create(TargetTriple::X86_64_WINDOWS, *outstream);
         break;
     }
 
-    case CodegenOutputFormat::X86_64_LINUX:
-    {
+    case CodegenOutputFormat::X86_64_LINUX: {
         cg = CodeGen::create(TargetTriple::X86_64_LINUX, *outstream);
         break;
     }
 
-    case CodegenOutputFormat::LLVM_IR:
-    {
+    case CodegenOutputFormat::LLVM_IR: {
         cg = CodeGen::create(TargetTriple::LLVM_IR, *outstream);
         break;
     }
@@ -127,12 +122,9 @@ int main(int argc, char *argv[])
         std::cerr << "This should not happen, ACP Pradhyumn...\n";
         exit(1);
     }
-    try
-    {
+    try {
         cg->generate(std::move(program));
-    }
-    catch (std::exception const &exc)
-    {
+    } catch (std::exception const &exc) {
         std::cerr << "ERROR: " << exc.what() << "\n";
     }
 
diff --git a/src/ast/ASTNode.cpp b/src/ast/ASTNode.cpp
index ec9187f..94961db 100644
--- a/src/ast/ASTNode.cpp
+++ b/src/ast/ASTNode.cpp
@@ -1,46 +1,36 @@
 #include "all.hpp"
 
-namespace zlang
-{
-    std::unique_ptr<ASTNode> ASTNode::makeProgramNode(const std::shared_ptr<ScopeContext> scope)
-    {
+namespace zlang {
+    std::unique_ptr<ASTNode> ASTNode::makeProgramNode(const std::shared_ptr<ScopeContext> scope) {
         return std::make_unique<ASTNode>(NodeType::Program, "", scope);
     }
 
     std::unique_ptr<ASTNode> ASTNode::makeVariableReassignmentNode(
         const std::string &name,
-        std::unique_ptr<ASTNode> expr, const std::shared_ptr<ScopeContext> scope)
-    {
+        std::unique_ptr<ASTNode> expr, const std::shared_ptr<ScopeContext> scope) {
         auto node = std::make_unique<ASTNode>(NodeType::VariableReassignment, name, scope);
         if (expr)
             node->addChild(std::move(expr));
         return node;
     }
 
-    std::unique_ptr<ASTNode> ASTNode::makeVariableAccessNode(const std::string &name, const std::shared_ptr<ScopeContext> scope)
-    {
+    std::unique_ptr<ASTNode> ASTNode::makeVariableAccessNode(const std::string &name, const std::shared_ptr<ScopeContext> scope) {
         return std::make_unique<ASTNode>(NodeType::VariableAccess, name, scope);
     }
 
-    std::unique_ptr<ASTNode> ASTNode::makeIntegerLiteralNode(const std::string &literal, const std::shared_ptr<ScopeContext> scope)
-    {
+    std::unique_ptr<ASTNode> ASTNode::makeIntegerLiteralNode(const std::string &literal, const std::shared_ptr<ScopeContext> scope) {
         return std::make_unique<ASTNode>(NodeType::IntegerLiteral, literal, scope);
     }
 
-    void ASTNode::setElseBranch(std::unique_ptr<ASTNode> elseNode)
-    {
-        if (children.size() < 2)
-        {
+    void ASTNode::setElseBranch(std::unique_ptr<ASTNode> elseNode) {
+        if (children.size() < 2) {
             throw std::logic_error("setElseBranch on a non‑conditional node");
         }
 
-        if (children.size() == 2)
-        {
+        if (children.size() == 2) {
             // no else/elif attached yet: attach here
             children.push_back(std::move(elseNode));
-        }
-        else
-        {
+        } else {
             // we already have an elseBranch in children[2]:
             // forward the new elseNode into _that_ node
             ASTNode *existing = children[2].get();
@@ -48,8 +38,7 @@ namespace zlang
         }
     }
 
-    ASTNode *ASTNode::getElseBranch() const
-    {
+    ASTNode *ASTNode::getElseBranch() const {
         if (children.size() < 3 || children[2] == nullptr)
             return nullptr;
 
@@ -65,45 +54,34 @@ namespace zlang
         const std::string &name,
         std::unique_ptr<ASTNode> typeAnnotation,
         std::unique_ptr<ASTNode> initializer,
-        const std::shared_ptr<ScopeContext> scope)
-    {
+        const std::shared_ptr<ScopeContext> scope) {
         auto node = std::make_unique<ASTNode>(NodeType::VariableDeclaration, name, scope);
         bool result = scope.get()->defineVariable(name, {typeAnnotation.get()->value});
-        if (result)
-        {
+        if (result) {
             if (typeAnnotation)
                 node->addChild(std::move(typeAnnotation));
             if (initializer)
                 node->addChild(std::move(initializer));
             return node;
-        }
-        else
-        {
+        } else {
             return std::nullopt;
         }
     }
 
-    std::unique_ptr<ASTNode> ASTNode::makeSymbolNode(const std::string &name, const std::shared_ptr<ScopeContext> scope)
-    {
+    std::unique_ptr<ASTNode> ASTNode::makeSymbolNode(const std::string &name, const std::shared_ptr<ScopeContext> scope) {
         return std::make_unique<ASTNode>(NodeType::Symbol, name, scope);
     }
 
-    std::unique_ptr<ASTNode> ASTNode::makeFloatLiteralNode(const std::string &lit, const std::shared_ptr<ScopeContext> scope)
-    {
+    std::unique_ptr<ASTNode> ASTNode::makeFloatLiteralNode(const std::string &lit, const std::shared_ptr<ScopeContext> scope) {
         return std::make_unique<ASTNode>(NodeType::FloatLiteral, lit, scope);
     }
-    std::unique_ptr<ASTNode> ASTNode::makeStringLiteralNode(const std::string &lit, const std::shared_ptr<ScopeContext> scope)
-    {
+    std::unique_ptr<ASTNode> ASTNode::makeStringLiteralNode(const std::string &lit, const std::shared_ptr<ScopeContext> scope) {
         return std::make_unique<ASTNode>(NodeType::StringLiteral, lit, scope);
     }
-    std::unique_ptr<ASTNode> ASTNode::makeBooleanLiteralNode(const bool value, const std::shared_ptr<ScopeContext> scope)
-    {
-        if (value)
-        {
+    std::unique_ptr<ASTNode> ASTNode::makeBooleanLiteralNode(const bool value, const std::shared_ptr<ScopeContext> scope) {
+        if (value) {
             return std::make_unique<ASTNode>(NodeType::BooleanLiteral, "true", scope);
-        }
-        else
-        {
+        } else {
             return std::make_unique<ASTNode>(NodeType::BooleanLiteral, "false", scope);
         }
     }
@@ -111,8 +89,7 @@ namespace zlang
     std::unique_ptr<ASTNode> ASTNode::makeBinaryOp(
         const std::string &op,
         std::unique_ptr<ASTNode> lhs,
-        std::unique_ptr<ASTNode> rhs, const std::shared_ptr<ScopeContext> scope)
-    {
+        std::unique_ptr<ASTNode> rhs, const std::shared_ptr<ScopeContext> scope) {
         auto node = std::make_unique<ASTNode>(NodeType::BinaryOp, op, scope);
         node->addChild(std::move(lhs));
         node->addChild(std::move(rhs));
@@ -121,16 +98,14 @@ namespace zlang
 
     std::unique_ptr<ASTNode> ASTNode::makeUnaryOp(
         const std::string &op,
-        std::unique_ptr<ASTNode> operand, const std::shared_ptr<ScopeContext> scope)
-    {
+        std::unique_ptr<ASTNode> operand, const std::shared_ptr<ScopeContext> scope) {
         auto node = std::make_unique<ASTNode>(NodeType::UnaryOp, op, scope);
         node->addChild(std::move(operand));
         return node;
     }
 
     std::unique_ptr<ASTNode> ASTNode::makeIfStatement(std::unique_ptr<ASTNode> cond,
-                                                      std::unique_ptr<ASTNode> thenBlock, const std::shared_ptr<ScopeContext> scope)
-    {
+                                                      std::unique_ptr<ASTNode> thenBlock, const std::shared_ptr<ScopeContext> scope) {
         auto node = std::make_unique<ASTNode>(NodeType::IfStatement, "", scope);
         node->addChild(std::move(cond));
         node->addChild(std::move(thenBlock));
@@ -138,33 +113,89 @@ namespace zlang
     }
 
     std::unique_ptr<ASTNode> ASTNode::makeElseIfStatement(std::unique_ptr<ASTNode> cond,
-                                                          std::unique_ptr<ASTNode> thenBlock, const std::shared_ptr<ScopeContext> scope)
-    {
+                                                          std::unique_ptr<ASTNode> thenBlock, const std::shared_ptr<ScopeContext> scope) {
         auto node = std::make_unique<ASTNode>(NodeType::ElseIfStatement, "", scope);
         node->addChild(std::move(cond));
         node->addChild(std::move(thenBlock));
         return node;
     }
 
-    std::unique_ptr<ASTNode> ASTNode::makeElseStatement(std::unique_ptr<ASTNode> elseBlock, const std::shared_ptr<ScopeContext> scope)
-    {
+    std::unique_ptr<ASTNode> ASTNode::makeElseStatement(std::unique_ptr<ASTNode> elseBlock, const std::shared_ptr<ScopeContext> scope) {
         auto node = std::make_unique<ASTNode>(NodeType::ElseStatement, "", scope);
         node->addChild(std::move(elseBlock));
         return node;
     }
 
-    void ASTNode::addChild(std::unique_ptr<ASTNode> child)
-    {
+    std::unique_ptr<ASTNode> ASTNode::makeFunctionParameterList(const std::vector<ParamInfo> params, std::shared_ptr<ScopeContext> scope) {
+        auto node = std::make_unique<ASTNode>(NodeType::FunctionParameterList, "", scope);
+        for (ParamInfo pi : params) {
+            auto child = std::make_unique<ASTNode>(NodeType::FunctionParameter, "", scope);
+            auto name = std::make_unique<ASTNode>(NodeType::Symbol, pi.name, scope);
+            auto type = std::make_unique<ASTNode>(NodeType::Symbol, pi.type, scope);
+            child->children.push_back(std::move(name));
+            child->children.push_back(std::move(type));
+            node->children.push_back(std::move(child));
+        }
+        return node;
+    }
+
+    std::unique_ptr<ASTNode> ASTNode::makeExternFunctionDeclaration(std::string name, const std::shared_ptr<ScopeContext> scope, std::vector<ParamInfo> params, std::string returnType, bool isVariadic) {
+        auto node = std::make_unique<ASTNode>(NodeType::ExternFunction, name, scope);
+        auto paramsList = ASTNode::makeFunctionParameterList(params, scope);
+        auto returnType_ = std::make_unique<ASTNode>(NodeType::FunctionReturnType, returnType, scope);
+        node->children.push_back(std::move(paramsList));
+        node->children.push_back(std::move(returnType_));
+        scope->defineFunction(name, FunctionInfo{.paramTypes = params, .returnType = returnType, .name = name, .label = "", .isExtern = true, .isVariadic = isVariadic});
+        return node;
+    }
+
+    std::unique_ptr<ASTNode> ASTNode::makeFunctionDeclaration(std::string name, const std::shared_ptr<ScopeContext> scope, std::vector<ParamInfo> params, std::string returnType, std::unique_ptr<ASTNode> body, bool isVariadic) {
+        auto node = std::make_unique<ASTNode>(NodeType::Function, name, scope);
+        auto paramsList = ASTNode::makeFunctionParameterList(params, scope);
+        auto returnType_ = std::make_unique<ASTNode>(NodeType::FunctionReturnType, returnType, scope);
+        node->children.push_back(std::move(paramsList));
+        node->children.push_back(std::move(returnType_));
+        body->scope->returnType = returnType;
+        for (ParamInfo pi : params) {
+            body->scope->defineVariable(pi.name, VariableInfo{.type = pi.type});
+        }
+        node->children.push_back(std::move(body));
+        scope->defineFunction(name, FunctionInfo{.paramTypes = params, .returnType = returnType, .name = name, .label = "", .isExtern = false, .isVariadic = isVariadic});
+        return node;
+    }
+
+    ASTNode *ASTNode::getFunctionParamList() const {
+        assert(type == NodeType::Function || type == NodeType::ExternFunction);
+        return children[0].get();
+    }
+    ASTNode *ASTNode::getFunctionParamReturnType() const {
+        assert(type == NodeType::Function || type == NodeType::ExternFunction);
+        return children[1].get();
+    }
+    ASTNode *ASTNode::getFunctionBody() const {
+        assert(type == NodeType::Function);
+        return children[2].get();
+    }
+
+    std::unique_ptr<ASTNode> ASTNode::makeFunctionCall(std::string name, std::vector<std::unique_ptr<ASTNode>> arguments, const std::shared_ptr<ScopeContext> scope) {
+        auto node = std::make_unique<ASTNode>(NodeType::FunctionCall, name, scope);
+        auto args = std::make_unique<ASTNode>(NodeType::FunctionCallArgumentList, "", scope);
+        for (auto &arg : arguments) {
+            args->addChild(std::move(arg));
+        }
+        node->addChild(std::move(args));
+        return node;
+    }
+
+    void ASTNode::addChild(std::unique_ptr<ASTNode> child) {
         children.push_back(std::move(child));
     }
 
-    void ASTNode::print(std::ostream &out, int indent) const
-    {
+    void ASTNode::print(std::ostream &out, int indent) const {
         for (int i = 0; i < indent; ++i)
             out << ' ';
 
-        switch (type)
-        {
+        switch (type) {
         case NodeType::Program:
             out << "Program";
             break;
@@ -207,13 +238,36 @@ namespace zlang
         case NodeType::ElseStatement:
             out << "Else(" << value << ")";
             break;
+        case NodeType::ExternFunction:
+            out << "ExternFunction(" << value << ")";
+            break;
+        case NodeType::Function:
+            out << "Functions(" << value << ")";
+            break;
+        case NodeType::FunctionParameterList:
+            out << "ParameterList(" << value << ")";
+            break;
+        case NodeType::FunctionParameter:
+            out << "Parameter(" << value << ")";
+            break;
+        case NodeType::FunctionReturnType:
+            out << "ReturnType(" << value << ")";
+            break;
+        case NodeType::FunctionCall:
+            out << "FunctionCall(" << value << ")";
+            break;
+        case NodeType::FunctionCallArgumentList:
+            out << "Arguments(" << value << ")";
+            break;
+        case NodeType::ReturnStatement:
+            out << "Return(" << value << ")";
+            break;
         default:
             out << "Unknown";
         }
 
         out << '\n';
-        for (const auto &child : children)
-        {
+        for (const auto &child : children) {
             child->print(out, indent + 2);
         }
     }
diff --git a/src/codegen/CodeGen.cpp b/src/codegen/CodeGen.cpp
index ed2d78d..bff6770 100644
--- a/src/codegen/CodeGen.cpp
+++ b/src/codegen/CodeGen.cpp
@@ -1,12 +1,9 @@
 #include "all.hpp"
 
-namespace zlang
-{
+namespace zlang {
     CodeGen::~CodeGen() = default;
-    std::unique_ptr<CodeGen> CodeGen::create(TargetTriple target, std::ostream &outstream)
-    {
-        switch (target)
-        {
+    std::unique_ptr<CodeGen> CodeGen::create(TargetTriple target, std::ostream &outstream) {
+        switch (target) {
         case TargetTriple::X86_64_LINUX:
             return std::make_unique<CodeGenLinux>(outstream);
         case TargetTriple::X86_64_WINDOWS:
diff --git a/src/codegen/CodeGenLLVM.cpp b/src/codegen/CodeGenLLVM.cpp
index 20f256d..4704735 100644
--- a/src/codegen/CodeGenLLVM.cpp
+++ b/src/codegen/CodeGenLLVM.cpp
@@ -1,178 +1,217 @@
 #include "all.hpp"
 
-namespace zlang
-{
-    static std::string fresh()
-    {
+namespace zlang {
+
+    std::string llvmTypeName(const std::string &typeName) {
+        if (typeName == "boolean")
+            return "i8";  // Boolean as 1-bit integer
+        if (typeName == "none")
+            return "void";  // No type
+        if (typeName == "string")
+            return "i8*";  // Pointer to characters
+        if (typeName == "size_t")
+            return "i64";  // Platform word size
+        if (typeName == "integer")
+            return "i64";  // Default signed integer
+
+        // Unsigned integers
+        if (typeName == "uint8_t")
+            return "i8";
+        if (typeName == "uint16_t")
+            return "i16";
+        if (typeName == "uint32_t")
+            return "i32";
+        if (typeName == "uint64_t")
+            return "i64";
+
+        // Signed integers
+        if (typeName == "int8_t")
+            return "i8";
+        if (typeName == "int16_t")
+            return "i16";
+        if (typeName == "int32_t")
+            return "i32";
+        if (typeName == "int64_t")
+            return "i64";
+
+        // Floating-point types
+        if (typeName == "float")
+            return "float";
+        if (typeName == "double")
+            return "double";
+
+        // Fallback for user-defined or pointer types
+        return typeName;
+    }
+
+    std::string unescapeString(const std::string &input) {
+        std::string result;
+        result.reserve(input.size());
+
+        for (size_t i = 0; i < input.size(); ++i) {
+            if (input[i] == '\\' && i + 1 < input.size()) {
+                switch (input[++i]) {
+                case 'n':
+                    result += '\n';
+                    break;
+                case 't':
+                    result += '\t';
+                    break;
+                case 'r':
+                    result += '\r';
+                    break;
+                case '\\':
+                    result += '\\';
+                    break;
+                case '"':
+                    result += '"';
+                    break;
+                case '0':
+                    result += '\0';
+                    break;  // Null byte
+                default:    // Keep unrecognized escapes as-is
+                    result += '\\';
+                    result += input[i];
+                    break;
+                }
+            } else {
+                result += input[i];
+            }
+        }
+        return result;
+    }
+
+    static std::string fresh() {
         static int cnt = 0;
         return "%tmp" + std::to_string(cnt++);
     }
-    std::string toHexFloatFromStr(const std::string &valStr, bool isF32)
-    {
+    std::string toHexFloatFromStr(const std::string &valStr, bool isF32, std::ostringstream &out) {
         std::ostringstream oss;
         oss << std::scientific << std::setprecision(16);
-        if (isF32)
-        {
+        if (isF32) {
             float v = std::stof(valStr);
             oss << v;
-        }
-        else
-        {
+        } else {
             double v = std::stod(valStr);
             oss << v;
         }
         return oss.str();
     }
-    std::string CodeGenLLVM::castValue(const std::string &val, const TypeInfo &fromType, const TypeInfo &toType)
-    {
-        if (fromType.isFloat == toType.isFloat && fromType.bits == toType.bits)
+    std::string CodeGenLLVM::castValue(const std::string &val, const TypeInfo &fromType, const TypeInfo &toType, std::ostringstream &out) {
+        if (fromType.isFloat == toType.isFloat && fromType.bits == toType.bits) {
             return val;
+        }
 
         std::string tmp = fresh();
 
-        if (!fromType.isFloat && toType.isFloat)
-        {
+        if (!fromType.isFloat && toType.isFloat) {
             std::string intTy = "i" + std::to_string(fromType.bits);
             std::string floatTy = (toType.bits == 64 ? "double" : "float");
             std::string instr = fromType.isSigned ? "sitofp" : "uitofp";
             out << "  " << tmp << " = " << instr << " " << intTy << " " << val << " to " << floatTy << "\n";
-        }
-        else if (fromType.isFloat && !toType.isFloat)
-        {
+        } else if (fromType.isFloat && !toType.isFloat) {
             std::string floatTy = (fromType.bits == 64 ? "double" : "float");
             std::string intTy = "i" + std::to_string(toType.bits);
             std::string instr = toType.isSigned ? "fptosi" : "fptoui";
             out << "  " << tmp << " = " << instr << " " << floatTy << " " << val << " to " << intTy << "\n";
-        }
-        else if (!fromType.isFloat && !toType.isFloat)
-        {
+        } else if (!fromType.isFloat && !toType.isFloat) {
             std::string fromTy = "i" + std::to_string(fromType.bits);
             std::string toTy = "i" + std::to_string(toType.bits);
-            if (fromType.bits < toType.bits)
-            {
+            if (fromType.bits < toType.bits) {
                 std::string instr = fromType.isSigned ? "sext" : "zext";
                 out << "  " << tmp << " = " << instr << " " << fromTy << " " << val << " to " << toTy << "\n";
-            }
-            else if (fromType.bits > toType.bits)
-            {
+            } else if (fromType.bits > toType.bits) {
                 out << "  " << tmp << " = trunc " << fromTy << " " << val << " to " << toTy << "\n";
-            }
-            else if (fromType.isSigned != toType.isSigned)
-            {
+            } else if (fromType.isSigned != toType.isSigned) {
                 // Retag value if signedness differs but bit-width is the same
                 out << "  " << tmp << " = add " << fromTy << " " << val << ", 0\n";
-            }
-            else
-            {
+            } else {
                 return val;
             }
-        }
-        else if (fromType.isFloat && toType.isFloat)
-        {
+        } else if (fromType.isFloat && toType.isFloat) {
             std::string fromTy = (fromType.bits == 64 ? "double" : "float");
             std::string toTy = (toType.bits == 64 ? "double" : "float");
-            if (fromType.bits < toType.bits)
-            {
+            if (fromType.bits < toType.bits) {
                 out << "  " << tmp << " = fpext " << fromTy << " " << val << " to " << toTy << "\n";
-            }
-            else if (fromType.bits > toType.bits)
-            {
+            } else if (fromType.bits > toType.bits) {
                 out << "  " << tmp << " = fptrunc " << fromTy << " " << val << " to " << toTy << "\n";
-            }
-            else
-            {
+            } else {
                 return val;
             }
-        }
-        else
-        {
+        } else {
             throw std::runtime_error("Unsupported cast from type to type");
         }
 
         noteType(tmp, toType);
         return tmp;
     }
-    std::string CodeGenLLVM::generateIntegerLiteral(std::unique_ptr<ASTNode> node)
-    {
+    std::string CodeGenLLVM::generateIntegerLiteral(std::unique_ptr<ASTNode> node, std::ostringstream &out) {
         std::string name = fresh();
         out << "  " << name << " = add i64 0, " << node->value << "\n";
         noteType(name, node->scope->lookupType("int64_t"));
         return name;
     }
-    std::string CodeGenLLVM::generateFloatLiteral(std::unique_ptr<ASTNode> node)
-    {
+    std::string CodeGenLLVM::generateFloatLiteral(std::unique_ptr<ASTNode> node, std::ostringstream &out) {
         std::string tmp = fresh();
         std::string val = node->value;
         bool isF32 = (!val.empty() && (val.back() == 'f' || val.back() == 'F'));
         if (isF32)
             val.pop_back();
 
-        std::string hexVal = toHexFloatFromStr(val, isF32);
+        std::string hexVal = toHexFloatFromStr(val, isF32, out);
 
-        if (isF32)
-        {
+        if (isF32) {
             out << "  " << tmp << " = fadd float 0.0, " << hexVal << "\n";
             noteType(tmp, node->scope->lookupType("float"));
-        }
-        else
-        {
+        } else {
             out << "  " << tmp << " = fadd double 0.0, " << hexVal << "\n";
             noteType(tmp, node->scope->lookupType("double"));
         }
         return tmp;
     }
-    std::string CodeGenLLVM::generateStringLiteral(std::unique_ptr<ASTNode> node)
-    {
+    std::string CodeGenLLVM::generateStringLiteral(std::unique_ptr<ASTNode> node, std::ostringstream &out) {
         std::string value = node->value;
 
-        auto it = stringLiterals.find(value);
-        if (it != stringLiterals.end())
-            return it->second;
-
         std::string name = "@.str" + std::to_string(stringLabelCount++);
-        size_t len = value.size() + 1; // Include null terminator
-        std::string llvmEscaped;
+        std::string unescaped = unescapeString(value);
+        size_t total_bytes = unescaped.size() + 1;  // +1 for null terminator
 
-        for (unsigned char c : value)
-        {
-            if (isprint(c) && c != '"' && c != '\\')
-            {
+        std::string llvmEscaped;
+        for (unsigned char c : unescaped) {
+            if (isprint(c) && c != '"' && c != '\\') {
                 llvmEscaped += c;
-            }
-            else
-            {
+            } else {
                 char buf[5];
-                snprintf(buf, sizeof(buf), "\\%02X", c); // Use uppercase hex
+                snprintf(buf, sizeof(buf), "\\%02x", c);
                 llvmEscaped += buf;
             }
         }
         llvmEscaped += "\\00";
-        outGlobal << name << " = private unnamed_addr constant ["
-                  << len << " x i8] c\"" << llvmEscaped << "\"\n";
+
+        outGlobalStream << name << " = private unnamed_addr constant ["
+                        << total_bytes << " x i8] c\"" << llvmEscaped << "\"\n";
 
         std::string ptr = fresh();
         out << "  " << ptr << " = getelementptr inbounds ["
-            << len << " x i8], [" << len << " x i8]* "
+            << total_bytes << " x i8], [" << total_bytes << " x i8]* "
             << name << ", i64 0, i64 0\n";
 
         // Cast pointer to i64 if storing in i64* variable
         std::string casted = fresh();
         out << "  " << casted << " = ptrtoint i8* " << ptr << " to i64\n";
 
-        noteType(casted, node->scope->lookupType("int64_t")); // casted is now i64
+        noteType(casted, node->scope->lookupType("int64_t"));  // casted is now i64
         stringLiterals[value] = casted;
         return casted;
     }
-    std::string CodeGenLLVM::generateBooleanLiteral(std::unique_ptr<ASTNode> node)
-    {
+    std::string CodeGenLLVM::generateBooleanLiteral(std::unique_ptr<ASTNode> node, std::ostringstream &out) {
         std::string name = fresh();
         out << "  " << name << " = add i8 0, "
             << (node->value == "true" ? "1" : "0") << "\n";
         noteType(name, node->scope->lookupType("boolean"));
         return name;
     }
-    std::string CodeGenLLVM::generateVariableAccess(std::unique_ptr<ASTNode> node)
-    {
+    std::string CodeGenLLVM::generateVariableAccess(std::unique_ptr<ASTNode> node, std::ostringstream &out) {
         auto &scope = *node->scope;
         auto name = node->value;
 
@@ -185,12 +224,9 @@ namespace zlang
         // Determine if it's a global or local variable
         bool isGlobal = scope.isGlobalVariable(name);
         std::string ptr;
-        if (!isGlobal)
-        {
+        if (!isGlobal) {
             ptr = "%" + node->scope->getMapping(name);
-        }
-        else
-        {
+        } else {
             ptr = "@" + name;
         }
 
@@ -201,31 +237,26 @@ namespace zlang
         noteType(loaded, ti);
         return loaded;
     }
-    std::string CodeGenLLVM::generateBinaryOperation(std::unique_ptr<ASTNode> node)
-    {
-        auto lhs = emitExpression(std::move(node->children[0]));
-        auto rhs = emitExpression(std::move(node->children[1]));
+    std::string CodeGenLLVM::generateBinaryOperation(std::unique_ptr<ASTNode> node, std::ostringstream &out) {
+        auto lhs = emitExpression(std::move(node->children[0]), out);
+        auto rhs = emitExpression(std::move(node->children[1]), out);
         TypeInfo t1 = regType[lhs];
         TypeInfo t2 = regType[rhs];
         TypeInfo tr = TypeChecker::promoteType(t1, t2);
-        std::string L = castValue(lhs, t1, tr);
-        std::string R = castValue(rhs, t2, tr);
+        std::string L = castValue(lhs, t1, tr, out);
+        std::string R = castValue(rhs, t2, tr, out);
         std::string res = fresh();
 
-        if (tr.isFloat)
-        {
+        if (tr.isFloat) {
             std::string target = (tr.bits == 64 ? "double" : "float");
             static const std::unordered_map<std::string, std::string> fp_ops = {{"+", "fadd"}, {"-", "fsub"}, {"*", "fmul"}, {"/", "fdiv"}};
             static const std::unordered_map<std::string, std::string> fcmp_ops = {{"==", "oeq"}, {"!=", "one"}, {"<", "olt"}, {"<=", "ole"}, {">", "ogt"}, {">=", "oge"}};
 
-            if (fp_ops.count(node->value))
-            {
+            if (fp_ops.count(node->value)) {
                 out << "  " << res << " = " << fp_ops.at(node->value) << " " << target << " " << L << ", " << R << "\n";
                 noteType(res, tr);
                 return res;
-            }
-            else
-            {
+            } else {
                 std::string cmpop = fcmp_ops.at(node->value);
                 out << "  " << res << " = fcmp " << cmpop << " " << target << " " << L << ", " << R << "\n";
                 std::string zext = fresh();
@@ -233,14 +264,11 @@ namespace zlang
                 noteType(zext, node->scope->lookupType("boolean"));
                 return zext;
             }
-        }
-        else
-        {
+        } else {
             std::string intTy = "i" + std::to_string(tr.bits);
             bool isSigned = tr.isSigned;
 
-            if (node->value == "+" || node->value == "-" || node->value == "*" || node->value == "/")
-            {
+            if (node->value == "+" || node->value == "-" || node->value == "*" || node->value == "/") {
                 std::string op;
                 if (node->value == "+")
                     op = "add";
@@ -260,8 +288,7 @@ namespace zlang
                 {"==", {"eq", "eq"}}, {"!=", {"ne", "ne"}}, {"<", {"slt", "ult"}}, {"<=", {"sle", "ule"}}, {">", {"sgt", "ugt"}}, {">=", {"sge", "uge"}}};
 
             auto it = cmp_map.find(node->value);
-            if (it != cmp_map.end())
-            {
+            if (it != cmp_map.end()) {
                 std::string signedOp = it->second.first;
                 std::string unsignedOp = it->second.second;
                 std::string cmpop = isSigned ? signedOp : unsignedOp;
@@ -276,13 +303,12 @@ namespace zlang
             throw std::runtime_error("Unsupported integer op " + node->value);
         }
     }
-    std::string CodeGenLLVM::generateUnaryOperation(std::unique_ptr<ASTNode> node)
-    {
+    std::string CodeGenLLVM::generateUnaryOperation(std::unique_ptr<ASTNode> node, std::ostringstream &out) {
         auto &scope = *node->children[0]->scope;
         auto varName = node->children[0]->value;
         TypeInfo ti = scope.lookupType(scope.lookupVariable(varName).type);
         NodeType child_type = node->children[0]->type;
-        auto val = emitExpression(std::move(node->children[0]));
+        auto val = emitExpression(std::move(node->children[0]), out);
 
         std::string llvmType;
         if (ti.isFloat)
@@ -290,19 +316,16 @@ namespace zlang
         else
             llvmType = "i" + std::to_string(ti.bits);
 
-        if (node->value == "!")
-        {
+        if (node->value == "!") {
             TypeInfo boolType = node->scope->lookupType("boolean");
-            val = castValue(val, regType.at(val), boolType);
+            val = castValue(val, regType.at(val), boolType, out);
             std::string res = fresh();
             out << "  " << res << " = icmp eq " << llvmType << " " << val << ", 0\n";
             std::string zero = fresh();
             out << "  " << zero << " = zext i1 " << res << " to i8\n";
             noteType(zero, node->scope->lookupType("boolean"));
             return zero;
-        }
-        else if (node->value == "++" || node->value == "--")
-        {
+        } else if (node->value == "++" || node->value == "--") {
             if (child_type != NodeType::VariableAccess)
                 throw std::runtime_error(node->value + " can only be applied to variables");
 
@@ -324,72 +347,83 @@ namespace zlang
 
             noteType(updated, ti);
             return updated;
-        }
-        else
-        {
+        } else {
             throw std::runtime_error("Unsupported unary: " + node->value);
         }
     }
-    std::string CodeGenLLVM::emitExpression(std::unique_ptr<ASTNode> node)
-    {
-        switch (node->type)
-        {
+    std::string CodeGenLLVM::emitExpression(std::unique_ptr<ASTNode> node, std::ostringstream &out) {
+        switch (node->type) {
         case NodeType::IntegerLiteral:
-            return generateIntegerLiteral(std::move(node));
+            return generateIntegerLiteral(std::move(node), out);
         case NodeType::FloatLiteral:
-            return generateFloatLiteral(std::move(node));
+            return generateFloatLiteral(std::move(node), out);
         case NodeType::StringLiteral:
-            return generateStringLiteral(std::move(node));
+            return generateStringLiteral(std::move(node), out);
         case NodeType::BooleanLiteral:
-            return generateBooleanLiteral(std::move(node));
+            return generateBooleanLiteral(std::move(node), out);
         case NodeType::VariableAccess:
-            return generateVariableAccess(std::move(node));
+            return generateVariableAccess(std::move(node), out);
         case NodeType::BinaryOp:
-            return generateBinaryOperation(std::move(node));
+            return generateBinaryOperation(std::move(node), out);
         case NodeType::UnaryOp:
-            return generateUnaryOperation(std::move(node));
+            return generateUnaryOperation(std::move(node), out);
+        case NodeType::FunctionCall:
+            return generateFunctionCall(std::move(node), out);
         default:
-            node->print(std::cout, 0);
-            throw std::runtime_error("Unknown expression encountered.");
+            throw std::runtime_error("Unknown statement encountered.");
         }
     }
-    void CodeGenLLVM::emitEpilogue()
-    {
+    void CodeGenLLVM::emitEpilogue(std::shared_ptr<ScopeContext> scope, std::ostringstream &out, bool clearRax) {
         out << "    ; Block ends\n";
     }
-    void CodeGenLLVM::emitPrologue(std::unique_ptr<ASTNode> blockNode)
-    {
+    void CodeGenLLVM::emitPrologue(std::shared_ptr<ScopeContext> scope, std::ostringstream &out) {
     }
-    void CodeGenLLVM::generateStatement(std::unique_ptr<ASTNode> statement)
-    {
-        switch (statement->type)
-        {
-        case NodeType::VariableReassignment:
-        {
-            generateVariableReassignment(std::move(statement));
+    void CodeGenLLVM::generateStatement(std::unique_ptr<ASTNode> statement, std::ostringstream &out) {
+        switch (statement->type) {
+        case NodeType::VariableReassignment: {
+            generateVariableReassignment(std::move(statement), out);
+            out << "\n";
             break;
         }
-        case NodeType::VariableDeclaration:
-        {
-            generateVariableDeclaration(std::move(statement));
+        case NodeType::VariableDeclaration: {
+            generateVariableDeclaration(std::move(statement), out);
+            out << "\n";
             break;
         }
-        case NodeType::IfStatement:
-        {
-            generateIfStatement(std::move(statement));
+        case NodeType::IfStatement: {
+            generateIfStatement(std::move(statement), out);
+            out << "\n";
             break;
         }
-        case NodeType::UnaryOp:
-        {
-            if (statement->value == "--" or statement->value == "++")
-            {
-                std::string reg = emitExpression(std::move(statement));
-            }
+        case NodeType::UnaryOp: {
+            std::string op = statement->value;
+            std::string reg = emitExpression(std::move(statement), out);
+            out << "\n";
             break;
         }
-        case NodeType::BinaryOp:
-        {
-            std::string reg = emitExpression(std::move(statement)); // I am doing this just so the increments/decrements work in x + y-- -> this itself must not have any result, but y-- should still be effective.
+        case NodeType::BinaryOp: {
+            std::string reg = emitExpression(std::move(statement), out);  // I am doing this just so the increments/decrements work in x + y-- -> this itself must not have any result, but y-- should still be effective.
+            out << "\n";
+            break;
+        }
+        case NodeType::FunctionCall: {
+            std::string reg = generateFunctionCall(std::move(statement), out);
+            out << "\n";
+            break;
+        }
+        case NodeType::Function: {
+            generateFunctionDeclaration(std::move(statement), out);
+            out << "\n";
+            break;
+        }
+        case NodeType::ExternFunction: {
+            generateExternFunctionDeclaration(std::move(statement), out);
+            out << "\n";
+            break;
+        }
+        case NodeType::ReturnStatement: {
+            generateReturnstatement(std::move(statement), out);
+            out << "\n";
             break;
         }
         default:
@@ -397,73 +431,61 @@ namespace zlang
             throw std::runtime_error("Unknown statement encountered.");
         }
     }
-    void CodeGenLLVM::generateVariableReassignment(std::unique_ptr<ASTNode> node)
-    {
+    void CodeGenLLVM::generateVariableReassignment(std::unique_ptr<ASTNode> node, std::ostringstream &out) {
         auto &scope = *node->scope;
         auto name = node->value;
         TypeInfo ti = scope.lookupType(scope.lookupVariable(name).type);
         bool isGlobal = scope.isGlobalVariable(name);
 
         // 1) Compute the RHS expression
-        std::string val = emitExpression(std::move(node->children.back()));
+        std::string val = emitExpression(std::move(node->children.back()), out);
         TypeInfo tr = regType[val];
 
         // 2) Convert value to target type (ti) using castValue
-        std::string castedVal = castValue(val, tr, ti);
+        std::string castedVal = castValue(val, tr, ti, out);
 
         // 3) Emit the store to the correct location
         std::string ty = ti.isFloat
                              ? (ti.bits == 32 ? "float" : "double")
                              : "i" + std::to_string(ti.bits);
 
-        if (isGlobal)
-        {
+        if (isGlobal) {
             out << "  store " << ty << " " << castedVal << ", " << ty << "* @" << name << "\n";
-        }
-        else
-        {
+        } else {
             out << "  store " << ty << " " << castedVal << ", " << ty << "* %" << node->scope->getMapping(name) << "\n";
         }
     }
-    void CodeGenLLVM::generateVariableDeclaration(std::unique_ptr<ASTNode> node)
-    {
+    void CodeGenLLVM::generateVariableDeclaration(std::unique_ptr<ASTNode> node, std::ostringstream &out) {
         bool isGlobal = node->scope->isGlobalVariable(node->value);
         TypeInfo ti = node->scope->lookupType(node->scope->lookupVariable(node->value).type);
         std::string ty = ti.isFloat
                              ? (ti.bits == 32 ? "float" : "double")
                              : "i" + std::to_string(ti.bits);
 
-        if (!isGlobal)
-        {
+        if (!isGlobal) {
             out << "  %" << node->scope->getMapping(node->value) << " = alloca " << ty << "\n";
         }
 
-        if (node->children.size() >= 2)
-        {
-            auto val = emitExpression(std::move(node->children.back()));
+        if (node->children.size() >= 2) {
+            auto val = emitExpression(std::move(node->children.back()), out);
             TypeInfo tr = regType[val];
 
-            // Use castValue for all type conversions
-            std::string castedVal = castValue(val, tr, ti);
+            std::string castedVal = castValue(val, tr, ti, out);
 
-            if (isGlobal)
-            {
+            if (isGlobal) {
                 out << "  store " << ty << " " << castedVal << ", " << ty << "* @" << node->value << "\n";
-            }
-            else
-            {
+            } else {
                 out << "  store " << ty << " " << castedVal << ", " << ty << "* %" << node->scope->getMapping(node->value) << "\n";
             }
         }
     }
-    void CodeGenLLVM::generateIfStatement(std::unique_ptr<ASTNode> statement)
-    {
+    void CodeGenLLVM::generateIfStatement(std::unique_ptr<ASTNode> statement, std::ostringstream &out) {
         int id = blockLabelCount++;
         std::string thenLbl = "if.then" + std::to_string(id);
         std::string elseLbl = "if.else" + std::to_string(id);
         std::string endLbl = "if.end" + std::to_string(id);
 
-        auto condVal = emitExpression(std::move(statement->children[0]));
+        auto condVal = emitExpression(std::move(statement->children[0]), out);
         TypeInfo condTi = regType[condVal];
 
         std::string condBool = fresh();
@@ -481,27 +503,24 @@ namespace zlang
         {
             auto ifBlock = std::move(statement->children[1]);
             auto children = std::move(ifBlock->children);
-            emitPrologue(std::move(ifBlock));
+            emitPrologue(ifBlock->scope, out);
             for (auto &stmt : children)
-                generateStatement(std::move(stmt));
-            emitEpilogue();
+                generateStatement(std::move(stmt), out);
+            emitEpilogue(ifBlock->scope, out);
         }
         out << "    br label %" << endLbl << "\n\n";
 
         ASTNode *branch = statement->getElseBranch();
-        if (branch)
-        {
+        if (branch) {
             out << elseLbl << ":\n";
 
-            while (branch)
-            {
-                if (branch->type == NodeType::ElseIfStatement)
-                {
+            while (branch) {
+                if (branch->type == NodeType::ElseIfStatement) {
                     int elifId = blockLabelCount++;
                     std::string elifThen = "elif.then" + std::to_string(elifId);
                     std::string elifNext = "elif.next" + std::to_string(elifId);
 
-                    auto elifCond = emitExpression(std::move(branch->children[0]));
+                    auto elifCond = emitExpression(std::move(branch->children[0]), out);
                     TypeInfo elifTi = regType[elifCond];
                     std::string elifBool = fresh();
                     out << "    " << elifBool
@@ -516,32 +535,27 @@ namespace zlang
                     {
                         auto elifBlock = std::move(branch->children[1]);
                         auto elifChildren = std::move(elifBlock->children);
-                        emitPrologue(std::move(elifBlock));
+                        emitPrologue(elifBlock->scope, out);
                         for (auto &stmt : elifChildren)
-                            generateStatement(std::move(stmt));
-                        emitEpilogue();
+                            generateStatement(std::move(stmt), out);
+                        emitEpilogue(elifBlock->scope, out);
                     }
                     out << "    br label %" << endLbl << "\n\n";
                     out << elifNext << ":\n";
                     branch = branch->getElseBranch();
-                    if (!branch)
-                    {
+                    if (!branch) {
                         out << "    br label %" << endLbl << "\n\n";
                     }
-                }
-                else if (branch->type == NodeType::ElseStatement)
-                {
+                } else if (branch->type == NodeType::ElseStatement) {
                     auto elseBlock = std::move(branch->children[0]);
                     auto elseChildren = std::move(elseBlock->children);
-                    emitPrologue(std::move(elseBlock));
+                    emitPrologue(elseBlock->scope, out);
                     for (auto &stmt : elseChildren)
-                        generateStatement(std::move(stmt));
-                    emitEpilogue();
+                        generateStatement(std::move(stmt), out);
+                    emitEpilogue(elseBlock->scope, out);
                     out << "    br label %" << endLbl << "\n\n";
                     branch = nullptr;
-                }
-                else
-                {
+                } else {
                     throw std::runtime_error("Unexpected node type in else chain");
                 }
             }
@@ -550,40 +564,225 @@ namespace zlang
         // 5) end label
         out << endLbl << ":\n";
     }
-    void CodeGenLLVM::generate(std::unique_ptr<ASTNode> program)
-    {
-        outGlobal << "; ModuleID = 'zlang'\n";
-        outGlobal << "source_filename = \"zlang\"\n";
-        // Emit global variable definitions
-        for (auto &statement : program->children)
-        {
-            if (statement->type == NodeType::VariableDeclaration)
-            {
-                auto &name = statement->value;
-                auto ti = statement->scope->lookupType(
-                    statement->scope->lookupVariable(name).type);
-                std::string ty = ti.isFloat
-                                     ? (ti.bits == 32 ? "float" : "double")
-                                     : "i" + std::to_string(ti.bits);
-                outGlobal << "@" << name << " = global " << ty << (ti.isFloat ? " 0.0" : " 0") << "\n";
+    void CodeGenLLVM::generate(std::unique_ptr<ASTNode> program) {
+        outGlobalStream << "; ModuleID = 'zlang'\n"
+                        << "source_filename = \"zlang\"\n\n";
+
+        // Globals
+        for (auto &stmt : program->children) {
+            if (stmt->type == NodeType::VariableDeclaration) {
+                const auto &name = stmt->value;
+                auto vi = stmt->scope->lookupVariable(name);
+                TypeInfo ti = stmt->scope->lookupType(vi.type);
+                std::string ty = llvmTypeName(ti.name);
+                outGlobalStream << "@" << name << " = global " << ty
+                                << (ti.isFloat ? " 0.0" : (ti.name == "string" ? " null" : " 0"))
+                                << "\n";
+            }
+        }
+        outGlobalStream << "\n";
+
+        // Split main and decls
+        std::unique_ptr<ASTNode> mainFunction;
+        std::vector<std::unique_ptr<ASTNode>> declarationsAndReassignments;
+        for (auto &stmt : program->children) {
+            if (stmt->type == NodeType::Function && stmt->value == "main") {
+                mainFunction = std::move(stmt);
+            } else if (stmt->type == NodeType::VariableDeclaration || stmt->type == NodeType::VariableReassignment || (stmt->type == NodeType::UnaryOp and (stmt->value == "++" || stmt->value == "--"))) {
+                declarationsAndReassignments.push_back(std::move(stmt));
+            } else {
+                generateStatement(std::move(stmt), outStream);
             }
         }
-        outGlobal << "\n";
 
-        // Define main function
-        out
-            << "define i32 @main() {\n";
-        emitPrologue(nullptr);
-        // Generate each top-level statement
-        for (auto &stmt : program->children)
-        {
-            generateStatement(std::move(stmt));
+        // Emit main
+        outStream << "define i32 @main() {\n";
+        // Decls in main
+        for (auto &s : declarationsAndReassignments) {
+            generateStatement(std::move(s), outStream);
         }
-        out << "  ret i32 0\n";
-        out
-            << "}\n";
 
-        outfinal << outGlobal.str() + "\n\n"
-                 << out.str() << "\n\n";
+        for (auto &c : mainFunction->getFunctionBody()->children) generateStatement(std::move(c), outStream);
+        outStream << "  ret i32 0\n";
+        outStream << "}\n";
+
+        outfinal << outGlobalStream.str() << "\n"
+                 << outStream.str() << "\n";
+    }
+
+    std::string CodeGenLLVM::generateFunctionCall(std::unique_ptr<ASTNode> node, std::ostringstream &out) {
+        // Lookup function metadata
+        auto fnInfo = node->scope->lookupFunction(node->value);
+        const std::string &funcName = fnInfo.isExtern ? node->value : fnInfo.label;
+        auto &args = node->children[0]->children;
+        const auto &paramTypes = fnInfo.paramTypes;
+
+        // Emit each argument, casting to expected type
+        std::vector<std::pair<std::string, std::string>> argList;
+        for (size_t i = 0; i < args.size(); ++i) {
+            // Evaluate expression
+            std::string src = emitExpression(std::move(args[i]), out);
+
+            out << "; Source: " << src << " \n";
+
+            // Determine types
+            TypeInfo passed = regType.at(src);
+            bool passedIsFloat = passed.isFloat;
+            TypeInfo expect;
+            if (i < paramTypes.size()) {
+                expect = node->scope->lookupType(paramTypes[i].type);
+            } else if (fnInfo.isVariadic) {
+                expect = node->scope->lookupType(passedIsFloat ? "double" : "int64_t");
+            } else {
+                throw std::runtime_error("Too many arguments for function '" + node->value + "'");
+            }
+
+            // Cast value
+            std::string cvt = castValue(src, passed, expect, out);
+
+            // Determine LLVM type
+            std::string ty = llvmTypeName(expect.name);
+            if (expect.isPointer) {
+                std::string tmpPtr = fresh();
+                out << "  " << tmpPtr << " = inttoptr i64 " << cvt << " to " << llvmTypeName(expect.name) << "\n";
+                cvt = tmpPtr;
+            }
+
+            argList.emplace_back(ty, cvt);
+        }
+
+        // Prepare call result
+        TypeInfo rti = node->scope->lookupType(fnInfo.returnType);
+        std::string retTy = llvmTypeName(rti.name);
+        bool isVariadic = fnInfo.isVariadic;
+
+        std::string callRes;
+        if (retTy != "void") {
+            callRes = fresh();
+            out << "  " << callRes << " = ";
+        } else {
+            out << "  ";
+        }
+
+        // Emit call
+        out << "call " << retTy;
+        if (isVariadic && !argList.empty()) {
+            out << " (" << argList[0].first << ", ...)";
+        }
+        out << " @" << funcName << "(";
+        for (size_t i = 0; i < argList.size(); ++i) {
+            if (i)
+                out << ", ";
+            out << argList[i].first << " " << argList[i].second;
+        }
+        out << ")\n";
+
+        noteType(callRes, node->scope->lookupType(fnInfo.returnType));
+
+        return callRes;
+    }
+    void CodeGenLLVM::generateFunctionDeclaration(std::unique_ptr<ASTNode> node, std::ostringstream &out, bool force) {
+        const std::string &name = node->value;
+        bool isMain = (name == "main");
+        if (isMain && !force)
+            return;  // skip main if not forced
+        node->print(std::cout, 0);
+        auto fnInfo = node->scope->lookupFunction(name);
+        auto bodyNode = node->getFunctionBody();
+        auto funcScope = std::static_pointer_cast<FunctionScope>(bodyNode->scope->findEnclosingFunctionScope());
+
+        // Function signature
+        TypeInfo rti = node->scope->lookupType(fnInfo.returnType);
+        std::string retTy = llvmTypeName(rti.name);
+        out << "define " << retTy << " @" << fnInfo.label << "(";
+        // Parameters
+        for (size_t i = 0; i < fnInfo.paramTypes.size(); ++i) {
+            const auto &p = fnInfo.paramTypes[i];
+            TypeInfo pti = node->scope->lookupType(p.type);
+            out << llvmTypeName(pti.name) << " %" << bodyNode->scope->getMapping(p.name);
+            if (i + 1 < fnInfo.paramTypes.size())
+                out << ", ";
+        }
+        out << ") {\n";
+
+        // Emit prologue
+        emitPrologue(funcScope, out);
+
+        // TODO: We were here last night, now we take one day break.
+
+        // Map arguments into LLVM locals
+        for (const auto &p : fnInfo.paramTypes) {
+            TypeInfo pti = node->scope->lookupType(p.type);
+            std::string allocaReg = fresh() + "___arg___";
+            out << "  " << allocaReg << " = alloca "
+                << llvmTypeName(pti.name) << "\n";
+            out << "  store " << llvmTypeName(pti.name)
+                << " %" << bodyNode->scope->getMapping(p.name)
+                << ", " << llvmTypeName(pti.name)
+                << "* " << allocaReg << "\n";
+            funcScope->setMapping(p.name, allocaReg.substr(1));  // or pass without '%' if your getMapping adds it
+        }
+
+        // Function body
+        std::ostringstream body;
+        std::vector<std::unique_ptr<ASTNode>> nested;
+        for (auto &stmt : bodyNode->children) {
+            if (stmt->type == NodeType::Function) {
+                nested.push_back(std::move(stmt));
+            } else {
+                generateStatement(std::move(stmt), body);
+            }
+        }
+        out << body.str();
+
+        // Return or void
+        if (retTy != "void") {
+        } else {
+            out << "  ret void\n";
+        }
+        out << "}\n\n";
+
+        // Nested functions
+        for (auto &nf : nested) {
+            generateFunctionDeclaration(std::move(nf), out, false);
+        }
+    }
+    void CodeGenLLVM::generateExternFunctionDeclaration(std::unique_ptr<ASTNode> node, std::ostringstream &out) {
+        auto fnInfo = node->scope->lookupFunction(node->value);
+        // Build a `declare` line:
+        //   declare <retTy> @<label>(<argTys>)
+        TypeInfo rti = node->scope->lookupType(fnInfo.returnType);
+        std::string retTy = llvmTypeName(rti.name);
+
+        outGlobalStream << "declare " << retTy
+                        << " @" << node->value << "(";
+        for (size_t i = 0; i < fnInfo.paramTypes.size(); ++i) {
+            const auto &p = fnInfo.paramTypes[i];
+            TypeInfo pti = node->scope->lookupType(p.type);
+            outGlobalStream << llvmTypeName(pti.name);
+            if (i + 1 < fnInfo.paramTypes.size())
+                outGlobalStream << ", ";
+        }
+        outGlobalStream << ")\n";
+    }
+    void CodeGenLLVM::generateReturnstatement(std::unique_ptr<ASTNode> node, std::ostringstream &out) {
+        // If there's no child, it's a void return
+        if (node->children.empty()) {
+            out << "  ret void\n";
+            return;
+        }
+
+        // 1) Evaluate the expression
+        std::string result = emitExpression(std::move(node->children[0]), out);
+
+        // 2) Cast to the function’s return type if needed
+        auto funcScope = node->scope->findEnclosingFunctionScope();
+        TypeInfo expected = funcScope->lookupType(funcScope->returnType);
+        TypeInfo actual = regType.at(result);
+        std::string casted = castValue(result, actual, expected, out);
+
+        // 3) Emit the LLVM `ret` instruction
+        std::string llvmTy = llvmTypeName(expected.name);
+        out << "  ret " << llvmTy << " " << casted << "\n";
     }
-} // namespace zlang
\ No newline at end of file
+}  // namespace zlang
\ No newline at end of file
diff --git a/src/codegen/CodeGenLinux.cpp b/src/codegen/CodeGenLinux.cpp
index 78ca774..e78f582 100644
--- a/src/codegen/CodeGenLinux.cpp
+++ b/src/codegen/CodeGenLinux.cpp
@@ -1,18 +1,19 @@
 #include "all.hpp"
 
-namespace zlang
-{
+namespace zlang {
     std::string CodeGenLinux::castValue(
         const std::string &val,
         const TypeInfo &fromType,
-        const TypeInfo &toType)
-    {
-        if (fromType.bits == toType.bits && fromType.isFloat == toType.isFloat)
-        {
-            if (!fromType.isFloat && fromType.isSigned != toType.isSigned)
-            {
-                std::string dst = alloc.allocate();
-                // AT&T: source, destination
+        const TypeInfo &toType, const std::shared_ptr<ScopeContext> currentScope, std::ostringstream &out) {
+        // Ensure input value is in a register (restore if previously spilled)
+        restoreIfSpilled(val, currentScope, out);
+
+        // No-op cast except sign adjustment
+        if (fromType.bits == toType.bits && fromType.isFloat == toType.isFloat) {
+            if (!fromType.isFloat && fromType.isSigned != toType.isSigned) {
+                // Allocate or spill an integer register
+                std::string dst = allocateOrSpill(false, currentScope, out);
+                // AT&T syntax: source, destination
                 out << "    mov %" << adjustReg(val, fromType.bits)
                     << ", %" << adjustReg(dst, fromType.bits) << "\n";
                 alloc.free(val);
@@ -22,20 +23,19 @@ namespace zlang
             return RegisterAllocator::getBaseReg(val);
         }
 
-        if (fromType.isFloat && toType.isFloat)
-        {
-            std::string dstX = alloc.allocateXMM();
+        // Float-to-float conversion
+        if (fromType.isFloat && toType.isFloat) {
+            std::string dstX = allocateOrSpill(true, currentScope, out);
             auto instr = (fromType.bits < toType.bits) ? "cvtss2sd" : "cvtsd2ss";
-            // AT&T: source, destination
             out << "    " << instr << " %" << val << ", %" << dstX << "\n";
             alloc.free(val);
             noteType(dstX, toType);
             return dstX;
         }
 
-        if (!fromType.isFloat && toType.isFloat)
-        {
-            std::string dstX = alloc.allocateXMM();
+        // Integer-to-float conversion
+        if (!fromType.isFloat && toType.isFloat) {
+            std::string dstX = allocateOrSpill(true, currentScope, out);
             auto instr = (toType.bits == 32) ? "cvtsi2ss" : "cvtsi2sd";
             out << "    " << instr << " %" << adjustReg(val, fromType.bits)
                 << ", %" << dstX << "\n";
@@ -44,9 +44,9 @@ namespace zlang
             return dstX;
         }
 
-        if (fromType.isFloat && !toType.isFloat)
-        {
-            std::string dstG = alloc.allocate();
+        // Float-to-integer conversion
+        if (fromType.isFloat && !toType.isFloat) {
+            std::string dstG = allocateOrSpill(false, currentScope, out);
             auto instr = (fromType.bits == 32) ? "cvttss2si" : "cvttsd2si";
             out << "    " << instr << " %" << val
                 << ", %" << adjustReg(dstG, toType.bits) << "\n";
@@ -55,53 +55,33 @@ namespace zlang
             return dstG;
         }
 
-        // Integer casts
-        if (!fromType.isFloat && !toType.isFloat)
-        {
-            std::string dstG = alloc.allocate();
+        // Integer-to-integer cast (extend/truncate/move)
+        if (!fromType.isFloat && !toType.isFloat) {
+            std::string dstG = allocateOrSpill(false, currentScope, out);
             std::string srcAdj = adjustReg(val, fromType.bits);
             std::string dstAdj = adjustReg(dstG, toType.bits);
 
-            if (toType.bits > fromType.bits)
-            {
-                // Extension
-                if (fromType.isSigned)
-                {
-                    if (fromType.bits == 32 && toType.bits == 64)
-                    {
-                        // AT&T: source, destination
+            if (toType.bits > fromType.bits) {
+                if (fromType.isSigned) {
+                    if (fromType.bits == 32 && toType.bits == 64) {
                         out << "    movsxd %" << srcAdj << ", %" << dstAdj << "\n";
-                    }
-                    else
-                    {
-                        // movsx for 8/16 -> larger
+                    } else {
                         out << "    movsx %" << srcAdj << ", %" << dstAdj << "\n";
                     }
-                }
-                else
-                {
-                    if (fromType.bits == 8 || fromType.bits == 16)
-                    {
-                        // AT&T: source, destination
+                } else {
+                    if (fromType.bits == 8 || fromType.bits == 16) {
                         out << "    movzx %" << srcAdj << ", %" << dstAdj << "\n";
-                    }
-                    else
-                    {
-                        // 32->64: normal mov zero-extends
+                    } else {
                         out << "    movl %" << adjustReg(val, 32)
                             << ", %" << adjustReg(dstG, 32) << "\n";
                     }
                 }
-            }
-            else if (toType.bits < fromType.bits)
-            {
-                // Truncation: move smaller portion
+            } else if (toType.bits < fromType.bits) {
+                // Truncate
                 out << "    mov %" << adjustReg(val, toType.bits)
                     << ", %" << dstAdj << "\n";
-            }
-            else
-            {
-                // Same size: simple move
+            } else {
+                // Simple move
                 out << "    mov %" << srcAdj << ", %" << dstAdj << "\n";
             }
 
@@ -115,268 +95,301 @@ namespace zlang
             " to " + toType.to_string());
     }
 
-    std::string CodeGenLinux::generateIntegerLiteral(std::unique_ptr<ASTNode> node)
-    {
-        auto r = alloc.allocate();
+    std::string CodeGenLinux::allocateOrSpill(bool isXMM, std::shared_ptr<ScopeContext> scope, std::ostringstream &out) {
+        try {
+            std::string reg = isXMM ? alloc.allocateXMM() : alloc.allocate();
+            if (!reg.empty())
+                return reg;
+        } catch (...) {
+            auto result_scope = scope->findEnclosingFunctionScope();
+            if (!result_scope) {
+                throw std::runtime_error("Cannot spill in global context");
+            }
+
+            std::shared_ptr<FunctionScope> funcScope = std::static_pointer_cast<FunctionScope>(result_scope);
+
+            std::string victim = isXMM ? alloc.pickVictimXMM() : alloc.pickVictim();
+            if (victim.empty())
+                throw std::runtime_error("No available registers and no victim found");
+
+            std::string spillSlot = funcScope->allocateSpillSlot(isXMM ? 16 : 8, CodegenOutputFormat::X86_64_LINUX);
+
+            if (isXMM) {
+                alloc.markSpilledXMM(victim, spillSlot);
+                out << "    movdqu " << victim << ", " << spillSlot << "    # Spill XMM\n";
+            } else {
+                char suffix = integer_suffixes.at(64);
+                out << "    mov" << suffix << " " << victim << ", " << spillSlot << "    # Spill GPR\n";
+                alloc.markSpilled(victim, spillSlot);
+            }
+
+            return victim;
+        }
+        return "";
+    }
+    void CodeGenLinux::restoreIfSpilled(const std::string &reg, std::shared_ptr<ScopeContext> scope, std::ostringstream &out) {
+        if (!alloc.isSpilled(reg))
+            return;
+
+        std::string slot = alloc.spillSlotFor(reg);
+
+        if (reg.starts_with("xm")) {
+            alloc.unSpillXMM(reg, zlang::CodegenOutputFormat::X86_64_LINUX, out);
+        } else {
+            alloc.unSpill(reg, zlang::CodegenOutputFormat::X86_64_LINUX, out);
+        }
+
+        auto result_scope = scope->findEnclosingFunctionScope();
+        if (result_scope) {
+            std::shared_ptr<FunctionScope> funcScope = std::static_pointer_cast<FunctionScope>(result_scope);
+            funcScope->freeSpillSlot(slot, reg.starts_with("xm") ? 16 : 8);
+        }
+    }
+
+    std::string CodeGenLinux::generateIntegerLiteral(std::unique_ptr<ASTNode> node, std::ostringstream &out) {
+        TypeInfo intType = node->scope->lookupType("int64_t");
+        std::string r = allocateOrSpill(false, node->scope, out);
         out << "    movq $" << node->value << ", %" << r << "\n";
-        noteType(r, node->scope->lookupType("int64_t"));
+        noteType(r, intType);
         return r;
     }
-    std::string CodeGenLinux::generateFloatLiteral(std::unique_ptr<ASTNode> node)
-    {
+    std::string CodeGenLinux::generateFloatLiteral(std::unique_ptr<ASTNode> node, std::ostringstream &out) {
         std::string lbl = ".Lfloat" + std::to_string(floatLabelCount++);
         std::string val = node->value;
         bool isF32 = (!val.empty() && (val.back() == 'f' || val.back() == 'F'));
-
         if (isF32)
             val.pop_back();
-
-        outGlobal << lbl << ": ." << (isF32 ? "float" : "double") << " " << val << "\n";
-
-        auto r_xmm = alloc.allocateXMM();
-        out << "    " << (isF32 ? "movss " : "movsd ") << lbl << "(%rip), %" << r_xmm << "\n";
-        noteType(r_xmm, (isF32 ? node->scope->lookupType("float")
-                               : node->scope->lookupType("double")));
+        outGlobalStream << "    .align " << (isF32 ? 4 : 8) << "\n"
+                        << lbl << ": ." << (isF32 ? "float" : "double")
+                        << " " << val << "\n";
+        TypeInfo floatType = isF32
+                                 ? node->scope->lookupType("float")
+                                 : node->scope->lookupType("double");
+        std::string r_xmm = allocateOrSpill(true, node->scope, out);
+        out << "    " << (isF32 ? "movss" : "movsd")
+            << " " << lbl << "(%rip), %" << r_xmm << "\n";
+        noteType(r_xmm, floatType);
         return r_xmm;
     }
-    std::string CodeGenLinux::generateStringLiteral(std::unique_ptr<ASTNode> node)
-    {
+    std::string CodeGenLinux::generateStringLiteral(std::unique_ptr<ASTNode> node, std::ostringstream &out) {
         std::string lbl = ".Lstr" + std::to_string(stringLabelCount++);
-
         std::string str = node->value;
-
-        outGlobal << lbl << ": .string \"" << str << "\"\n";
-
-        auto r = alloc.allocate();
+        outGlobalStream << "    .align 1\n"
+                        << lbl << ": .asciz \"" << str << "\"\n";
+        TypeInfo strType = node->scope->lookupType("string");
+        std::string r = allocateOrSpill(false, node->scope, out);
         out << "    leaq " << lbl << "(%rip), %" << r << "\n";
-        noteType(r, node->scope->lookupType("string"));
+        noteType(r, strType);
         return r;
     }
-    std::string CodeGenLinux::generateBooleanLiteral(std::unique_ptr<ASTNode> node)
-    {
-        auto r = alloc.allocate();
-        out << "    movq $" << (node->value == "true" ? "1" : "0") << ", %" << r
-            << "\n";
-        noteType(r, node->scope->lookupType("boolean"));
+    std::string CodeGenLinux::generateBooleanLiteral(std::unique_ptr<ASTNode> node, std::ostringstream &out) {
+        TypeInfo boolType = node->scope->lookupType("boolean");
+        std::string r = allocateOrSpill(false, node->scope, out);
+
+        // Move immediate 1 or 0
+        out << "    movq $" << (node->value == "true" ? "1" : "0")
+            << ", %" << r << "\n";
+        noteType(r, boolType);
         return r;
     }
-    std::string CodeGenLinux::generateVariableAccess(std::unique_ptr<ASTNode> node)
-    {
+    std::string CodeGenLinux::generateVariableAccess(std::unique_ptr<ASTNode> node, std::ostringstream &out) {
         auto &scope = *node->scope;
-        auto name = node->value;
-        auto ti = scope.lookupType(scope.lookupVariable(name).type);
+        std::string name = node->value;
+        TypeInfo ti = scope.lookupType(scope.lookupVariable(name).type);
         uint64_t sz = ti.bits / 8;
 
-        if (scope.isGlobalVariable(name))
-        {
-            if (ti.isFloat)
-            {
-                std::string r_xmm = alloc.allocateXMM();
-                out << "    " << (sz == 4 ? "movss " : "movsd ") << name
-                    << "(%rip), %" << r_xmm << "\n";
+        if (scope.isGlobalVariable(name)) {
+            if (ti.isFloat) {
+                // Allocate or spill an XMM reg
+                std::string r_xmm = allocateOrSpill(true, node->scope, out);
+                out << "    " << (sz == 4 ? "movss" : "movsd")
+                    << " " << name << "(%rip), %" << r_xmm << "\n";
                 noteType(r_xmm, ti);
                 return r_xmm;
-            }
-            else
-            {
-                std::string r = alloc.allocate();
+            } else {
+                // Allocate or spill a GPR
+                std::string r = allocateOrSpill(false, node->scope, out);
                 std::string adj = adjustReg(r, ti.bits);
-                out << "    " << getCorrectMove(sz, false) << " " << name
-                    << "(%rip), %" << adj << "\n";
+                out << "    " << getCorrectMove(sz, false)
+                    << " " << name << "(%rip), %" << adj << "\n";
                 noteType(r, ti);
                 return r;
             }
-        }
-        else
-        {
+        } else {
             int64_t off = scope.getVariableOffset(name);
-            if (ti.isFloat)
-            {
-                std::string r = alloc.allocateXMM();
-                out << "    " << (sz == 4 ? "movss " : "movsd ") << off
-                    << "(%rbp), %" << r << "\n";
-                noteType(r, (sz == 4 ? node->scope->lookupType("float")
-                                     : node->scope->lookupType("double")));
-                return r;
-            }
-            else
-            {
-                std::string r = alloc.allocate();
+            if (ti.isFloat) {
+                std::string r_xmm = allocateOrSpill(true, node->scope, out);
+                out << "    " << (sz == 4 ? "movss" : "movsd")
+                    << " " << std::to_string(off) << "(%rbp), %" << r_xmm << "\n";
+                noteType(r_xmm, ti);
+                return r_xmm;
+            } else {
+                std::string r = allocateOrSpill(false, node->scope, out);
                 std::string adj = adjustReg(r, ti.bits);
-                out << "    " << getCorrectMove(sz, false) << " " << off
-                    << "(%rbp), %" << adj << "\n";
+                out << "    " << getCorrectMove(sz, false)
+                    << " " << std::to_string(off) << "(%rbp), %" << adj << "\n";
                 noteType(r, ti);
                 return r;
             }
         }
     }
-    std::string CodeGenLinux::generateBinaryOperation(std::unique_ptr<ASTNode> node)
-    {
-        auto rl = emitExpression(std::move(node->children[0]));
-        auto rr = emitExpression(std::move(node->children[1]));
-
-        auto t1 = regType.at(rl);
-        auto t2 = regType.at(rr);
-        auto tr = TypeChecker::promoteType(t1, t2);
-        const auto &op = node->value;
+    std::string CodeGenLinux::generateBinaryOperation(std::unique_ptr<ASTNode> node, std::ostringstream &out) {
+        // Evaluate operands
+        std::string rl = emitExpression(std::move(node->children[0]), out);
+        restoreIfSpilled(rl, node->scope, out);
 
-        rl = castValue(rl, t1, tr);
-        rr = castValue(rr, t2, tr);
+        std::string rr = emitExpression(std::move(node->children[1]), out);
+        restoreIfSpilled(rr, node->scope, out);
 
-        if (tr.isFloat)
-        {
+        // Determine promoted type and operator
+        TypeInfo t1 = regType.at(rl);
+        TypeInfo t2 = regType.at(rr);
+        TypeInfo tr = TypeChecker::promoteType(t1, t2);
+        const std::string &op = node->value;
+
+        // Cast operands to common type
+        rl = castValue(rl, t1, tr, node->scope, out);
+        restoreIfSpilled(rl, node->scope, out);
+        rr = castValue(rr, t2, tr, node->scope, out);
+        restoreIfSpilled(rl, node->scope, out);
+
+        if (tr.isFloat) {
             bool isF32 = (tr.bits == 32);
             std::string vsuf = isF32 ? "ss" : "sd";
-            std::string xl = rl, xr = rr;
-
+            // Perform floating-point operation
             if (op == "+")
-                out << "    add" << vsuf << " %" << xr << ", %" << xl << "\n";
+                out << "    add" << vsuf << " %" << rr << ", %" << rl << "\n";
             else if (op == "-")
-                out << "    sub" << vsuf << " %" << xr << ", %" << xl << "\n";
+                out << "    sub" << vsuf << " %" << rr << ", %" << rl << "\n";
             else if (op == "*")
-                out << "    mul" << vsuf << " %" << xr << ", %" << xl << "\n";
+                out << "    mul" << vsuf << " %" << rr << ", %" << rl << "\n";
             else if (op == "/")
-                out << "    div" << vsuf << " %" << xr << ", %" << xl << "\n";
-            else if (assembly_comparison_operations.count(op))
-            {
-                out << "    ucomi" << vsuf << " %" << xr << ", %" << xl << "\n"
+                out << "    div" << vsuf << " %" << rr << ", %" << rl << "\n";
+            else if (assembly_comparison_operations.count(op)) {
+                out << "    ucomi" << vsuf << " %" << rr << ", %" << rl << "\n"
                     << "    " << assembly_comparison_operations.at(op) << " %al\n";
-                auto r_bool = alloc.allocate();
+                // Allocate boolean result
+                TypeInfo boolType = node->scope->lookupType("boolean");
+                std::string r_bool = allocateOrSpill(false, node->scope, out);
                 out << "    movzbq %al, %" << r_bool << "\n";
-                noteType(r_bool, node->scope->lookupType("boolean"));
-                alloc.free(xr);
-                alloc.free(xl);
+                noteType(r_bool, boolType);
+                // Free operand regs
+                alloc.free(rr);
+                alloc.free(rl);
                 return r_bool;
-            }
-            else
-            {
+            } else {
                 throw std::runtime_error("Unsupported FP op " + op);
             }
+            // Free right operand, result in rl
+            alloc.free(rr);
+            noteType(rl, tr);
+            return rl;
+        }
 
-            noteType(xl, tr);
-            alloc.free(xr);
-            return xl;
-        }
-
-        char suf = integer_suffixes[tr.bits];
-        auto r_l = adjustReg(rl, tr.bits);
-        auto r_r = adjustReg(rr, tr.bits);
-
-        if (op == "+")
-        {
-            out << "    add" << suf << " %" << r_r << ", %" << r_l << "\n";
-        }
-        else if (op == "-")
-        {
-            out << "    sub" << suf << " %" << r_r << ", %" << r_l << "\n";
-        }
-        else if (op == "*")
-        {
-            out << "    imul" << suf << " %" << r_r << ", %" << r_l << "\n";
-        }
-        else if (op == "/")
-        {
-            if (tr.isSigned)
-            {
-                if (tr.bits == 32)
-                {
-                    out << "    movl %" << r_l << ", %eax\n"
-                        << "    cltd\n"
-                        << "    idivl %" << r_r << "\n"
-                        << "    movl %eax, %" << r_l << "\n";
-                }
-                else
-                {
-                    out << "    movq %" << r_l << ", %rax\n"
-                        << "    cqo\n"
-                        << "    idivq %" << r_r << "\n"
-                        << "    movq %rax, %" << r_l << "\n";
-                }
-            }
-            else
-            {
-                if (tr.bits == 32)
-                {
-                    out << "    movl %" << r_l << ", %eax\n"
-                        << "    clrl %edx\n"
-                        << "    divl %" << r_r << "\n"
-                        << "    movl %eax, %" << r_l << "\n";
-                }
-                else
-                {
-                    out << "    movq %" << r_l << ", %rax\n"
-                        << "    xorq %rdx, %rdx\n"
-                        << "    divq %" << r_r << "\n"
-                        << "    movq %rax, %" << r_l << "\n";
+        // Integer operations
+        char suf = integer_suffixes.at(tr.bits);
+        std::string adj_l = adjustReg(rl, tr.bits);
+        std::string adj_r = adjustReg(rr, tr.bits);
+
+        if (op == "+" || op == "-" || op == "*" || op == "/") {
+            if (op == "+")
+                out << "    add" << suf << " %" << adj_r << ", %" << adj_l << "\n";
+            else if (op == "-")
+                out << "    sub" << suf << " %" << adj_r << ", %" << adj_l << "\n";
+            else if (op == "*")
+                out << "    imul" << suf << " %" << adj_r << ", %" << adj_l << "\n";
+            else /* div */ {
+                // division requires special setup
+                if (tr.isSigned) {
+                    if (tr.bits == 32) {
+                        out << "    movl %" << adj_l << ", %eax\n"
+                            << "    cltd\n"
+                            << "    idivl %" << adj_r << "\n"
+                            << "    movl %eax, %" << adj_l << "\n";
+                    } else {
+                        out << "    movq %" << adj_l << ", %rax\n"
+                            << "    cqo\n"
+                            << "    idivq %" << adj_r << "\n"
+                            << "    movq %rax, %" << adj_l << "\n";
+                    }
+                } else {
+                    if (tr.bits == 32) {
+                        out << "    movl %" << adj_l << ", %eax\n"
+                            << "    clrl %edx\n"
+                            << "    divl %" << adj_r << "\n"
+                            << "    movl %eax, %" << adj_l << "\n";
+                    } else {
+                        out << "    movq %" << adj_l << ", %rax\n"
+                            << "    xorq %rdx, %rdx\n"
+                            << "    divq %" << adj_r << "\n"
+                            << "    movq %rax, %" << adj_l << "\n";
+                    }
                 }
+                alloc.free(rr);
+                noteType(rl, tr);
+                return rl;
             }
             alloc.free(rr);
-            noteType(r_l, tr);
+            noteType(rl, tr);
             return rl;
         }
-        else if (assembly_comparison_operations.count(op))
-        {
-            static const std::unordered_map<std::string, std::string> signedMap = {
-                {"==", "sete"}, {"!=", "setne"}, {"<", "setl"}, {"<=", "setle"}, {">", "setg"}, {">=", "setge"}};
-            static const std::unordered_map<std::string, std::string> unsignedMap = {
-                {"==", "sete"}, {"!=", "setne"}, {"<", "setb"}, {"<=", "setbe"}, {">", "seta"}, {">=", "setae"}};
-            auto &map = tr.isSigned ? signedMap : unsignedMap;
-            auto r_bool = alloc.allocate();
-            out << "    cmp" << suf << " %" << r_r << ", %" << r_l << "\n"
-                << "    " << map.at(op) << " %al\n"
-                << "    movzbq %al, %" << r_bool << "\n";
+
+        // Integer comparison
+        if (assembly_comparison_operations.count(op)) {
+            auto &map = tr.isSigned ? assembly_comparison_operations : /* unsigned map here */ assembly_comparison_operations;
+            out << "    cmp" << suf << " %" << adj_r << ", %" << adj_l << "\n"
+                << "    " << map.at(op) << " %al\n";
+            TypeInfo boolType = node->scope->lookupType("boolean");
+            std::string r_bool = allocateOrSpill(false, node->scope, out);
+            out << "    movzbq %al, %" << r_bool << "\n";
+            noteType(r_bool, boolType);
             alloc.free(rr);
             alloc.free(rl);
-            noteType(r_bool, node->scope->lookupType("boolean"));
             return r_bool;
         }
-        else if (op == "&&" || op == "||" || op == "&" || op == "|")
-        {
-            std::string instr;
-            if (op == "&&")
-                instr = "and";
-            else if (op == "||")
-                instr = "or";
-            else
-                instr = op;
-            out << "    " << instr << suf << " %" << r_r << ", %" << r_l << "\n";
-        }
-        else
-        {
-            throw std::runtime_error("Unsupported int op " + op);
-        }
-
-        alloc.free(rr);
-        noteType(rl, tr);
-        return rl;
+
+        // Bitwise/logical ops: &&, ||, &, |
+        if (op == "&&" || op == "||" || op == "&" || op == "|") {
+            std::string instr = (op == "&&") ? "and" : (op == "||") ? "or"
+                                                                    : op;
+            out << "    " << instr << suf << " %" << adj_r << ", %" << adj_l << "\n";
+            alloc.free(rr);
+            noteType(rl, tr);
+            return rl;
+        }
+
+        throw std::runtime_error("Unsupported int op " + op);
     }
-    std::string CodeGenLinux::generateUnaryOperation(std::unique_ptr<ASTNode> node)
-    {
+    std::string CodeGenLinux::generateUnaryOperation(std::unique_ptr<ASTNode> node, std::ostringstream &out) {
         const auto &op = node->value;
         if (op != "!" && op != "++" && op != "--")
             throw std::runtime_error("Unsupported unary operator: " + op);
 
         auto child = std::move(node->children[0]);
 
-        const std::string varName = child->value;
-        auto &scp = *child->scope;
-        TypeInfo ti = scp.lookupType(scp.lookupVariable(varName).type);
-
-        if (op == "!")
-        {
-            auto r = emitExpression(std::move(child));
+        if (op == "!") {
+            auto r = emitExpression(std::move(child), out);
+            restoreIfSpilled(r, node->scope, out);
             TypeInfo boolType = node->scope->lookupType("boolean");
-            r = castValue(r, regType.at(r), boolType);
-            std::string res = alloc.allocate();
-            out << "    cmpq $0, %" << r << "\n"
+            r = castValue(r, regType.at(r), boolType, node->scope, out);
+            restoreIfSpilled(r, node->scope, out);
+
+            auto res = allocateOrSpill(false, node->scope, out);
+            out << "    cmpb $0, %" << adjustReg(r, 8) << "\n"
                 << "    sete %al\n"
                 << "    movzbq %al, %" << res << "\n";
             noteType(res, boolType);
+
+            alloc.free(r);
             return res;
         }
 
         if (child->type != NodeType::VariableAccess)
             throw std::runtime_error(op + " can only be applied to variables");
+
+        auto &scp = *child->scope;
+        const std::string varName = child->value;
+        TypeInfo ti = scp.lookupType(scp.lookupVariable(varName).type);
         if (ti.isFloat)
             throw std::runtime_error(op + " not supported on float");
 
@@ -384,275 +397,305 @@ namespace zlang
                               ? varName + "(%rip)"
                               : std::to_string(scp.getVariableOffset(varName)) + "(%rbp)";
         uint64_t sz = ti.bits / 8;
-        char suf = integer_suffixes[ti.bits];
+        char suf = integer_suffixes.at(ti.bits);
 
-        std::string r = alloc.allocate();
+        auto r = allocateOrSpill(false, node->scope, out);
         std::string adj = adjustReg(r, ti.bits);
-        out << "    " << getCorrectMove(sz, /*isFloat=*/false)
-            << " " << ptr << ", %" << adj << "\n";
+        out << "    " << getCorrectMove(sz, false) << " " << ptr << ", %" << adj << "\n";
 
-        out << "    " << (op == "++" ? "inc" : "dec") << suf
-            << " %" << adj << "\n";
+        out << "    " << (op == "++" ? "inc" : "dec") << suf << " %" << adj << "\n";
 
-        out << "    " << getCorrectMove(sz, /*isFloat=*/false)
-            << " %" << adj << ", " << ptr << "\n";
+        out << "    " << getCorrectMove(sz, false) << " %" << adj << ", " << ptr << "\n";
 
         noteType(adj, ti);
         return adj;
     }
-    std::string CodeGenLinux::emitExpression(std::unique_ptr<ASTNode> node)
-    {
-        switch (node->type)
-        {
+    std::string CodeGenLinux::emitExpression(std::unique_ptr<ASTNode> node, std::ostringstream &out) {
+        switch (node->type) {
         case NodeType::IntegerLiteral:
-            return generateIntegerLiteral(std::move(node));
+            return generateIntegerLiteral(std::move(node), out);
         case NodeType::FloatLiteral:
-            return generateFloatLiteral(std::move(node));
+            return generateFloatLiteral(std::move(node), out);
         case NodeType::StringLiteral:
-            return generateStringLiteral(std::move(node));
+            return generateStringLiteral(std::move(node), out);
         case NodeType::BooleanLiteral:
-            return generateBooleanLiteral(std::move(node));
+            return generateBooleanLiteral(std::move(node), out);
         case NodeType::VariableAccess:
-            return generateVariableAccess(std::move(node));
+            return generateVariableAccess(std::move(node), out);
         case NodeType::BinaryOp:
-            return generateBinaryOperation(std::move(node));
+            return generateBinaryOperation(std::move(node), out);
         case NodeType::UnaryOp:
-            return generateUnaryOperation(std::move(node));
+            return generateUnaryOperation(std::move(node), out);
+        case NodeType::FunctionCall:
+            return generateFunctionCall(std::move(node), out);
         default:
             throw std::runtime_error("Unknown statement encountered.");
         }
     }
-    void CodeGenLinux::emitEpilogue()
-    {
-        out << "    # Block Ends (scope exit)\n";
-        out << "    leave\n";
+
+    void CodeGenLinux::emitPrologue(std::shared_ptr<ScopeContext> scope, std::ostringstream &out) {
+        if (scope->kind() == "Function") {
+            out << "    # Function Prologue\n";
+            out << "    push   %rbp\n";
+            out << "    mov    %rsp, %rbp\n";
+
+            auto funcScope = std::dynamic_pointer_cast<FunctionScope>(scope);
+            if (!funcScope)
+                throw std::runtime_error("Expected FunctionScope for function prologue");
+
+            size_t regsCount = CALLEE_GPR_LINUX.size();
+            std::uint64_t spillSize = std::abs(funcScope->getSpillSize());
+            std::uint64_t localSize = std::abs(funcScope->getStackOffset());
+            std::uint64_t rawSize = 8 + localSize + spillSize;
+            std::uint64_t stackReserve = (rawSize + 15) & ~15ULL;
+
+            std::string canaryReg = allocateOrSpill(false, scope, out);
+            out << std::hex
+                << "    movabs $0x" << funcScope->getCanary() << ", %" << canaryReg << "    # load canary\n"
+                << std::dec
+                << "    movq   %" << canaryReg << ", -8(%rbp)    # store canary at [rbp - 8]\n";
+            alloc.free(canaryReg);
+
+            if (stackReserve > 0) {
+                out << "    sub    $" << stackReserve << ", %rsp    # reserve locals + spills\n";
+            }
+
+            for (const auto &reg : CALLEE_GPR_LINUX) {
+                out << "    push   %" << reg << "    # save callee-saved GPR\n";
+            }
+            if (regsCount & 1) {
+                out << "    push   %" << CALLEE_GPR_LINUX.back() << "    # just for alignment\n";
+            }
+        }
     }
-    void CodeGenLinux::emitPrologue(std::unique_ptr<ASTNode> blockNode)
-    {
-        auto blkScope = blockNode->scope;
-        int allocSize = -blkScope->stackOffset + 8;
-        // +8 to cover the pushed RBP
-        out << "    # Block Starts (scope enter)\n";
-        out << "    push   %rbp\n";
-        out << "    mov    %rsp, %rbp\n";
-        out << "    sub    $" << allocSize << ", %rsp\n";
+    void CodeGenLinux::emitEpilogue(std::shared_ptr<ScopeContext> scope, std::ostringstream &out, bool clearRax) {
+        if (scope->kind() == "Function") {
+            out << "    # Function Epilogue with Canary Check\n";
+
+            auto funcScope = std::dynamic_pointer_cast<FunctionScope>(scope);
+            if (!funcScope)
+                throw std::runtime_error("Expected FunctionScope for function epilogue");
+
+            size_t regsCount = CALLEE_GPR_LINUX.size();
+            std::uint64_t spillSize = std::abs(funcScope->getSpillSize());
+            std::uint64_t localSize = std::abs(funcScope->getStackOffset());
+            std::uint64_t rawSize = 8 + localSize + spillSize;
+            std::uint64_t stackReserve = (rawSize + 15) & ~15ULL;
+
+            std::string regStored = allocateOrSpill(false, scope, out);
+            std::string regExpected = allocateOrSpill(false, scope, out);
+            out << "    movq   -8(%rbp), %" << regStored << "    # load stored canary\n"
+                << std::hex
+                << "    movabs $0x" << funcScope->getCanary() << ", %" << regExpected << "    # load expected canary\n"
+                << std::dec
+                << "    cmp    %" << regExpected << ", %" << regStored << "    # compare canary\n"
+                << "    jne    __stack_smash_detected    # abort on mismatch\n";
+            alloc.free(regStored);
+            alloc.free(regExpected);
+
+            if (stackReserve > 0) {
+                out << "    add    $" << stackReserve << ", %rsp    # free locals + spills\n";
+            }
+
+            if (regsCount & 1) {
+                out << "    pop    %" << CALLEE_GPR_LINUX.back() << "    # pop alignment\n";
+            }
+
+            for (auto it = CALLEE_GPR_LINUX.rbegin(); it != CALLEE_GPR_LINUX.rend(); ++it) {
+                out << "    pop    %" << *it << "    # restore callee-saved GPR\n";
+            }
+
+            if (clearRax) {
+                out << "    xor    %rax, %rax\n";
+            }
+
+            out << "    leave    # restore RSP, pop RBP\n";
+            out << "    ret\n";
+        }
     }
-    void CodeGenLinux::generateStatement(std::unique_ptr<ASTNode> statement)
-    {
-        switch (statement->type)
-        {
-        case NodeType::VariableReassignment:
-        {
-            generateVariableReassignment(std::move(statement));
+
+    void CodeGenLinux::generateStatement(std::unique_ptr<ASTNode> statement, std::ostringstream &out) {
+        switch (statement->type) {
+        case NodeType::VariableReassignment: {
+            generateVariableReassignment(std::move(statement), out);
+            out << "\n";
             break;
         }
-        case NodeType::VariableDeclaration:
-        {
-            generateVariableDeclaration(std::move(statement));
+        case NodeType::VariableDeclaration: {
+            generateVariableDeclaration(std::move(statement), out);
+            out << "\n";
             break;
         }
-        case NodeType::IfStatement:
-        {
-            generateIfStatement(std::move(statement));
+        case NodeType::IfStatement: {
+            generateIfStatement(std::move(statement), out);
+            out << "\n";
             break;
         }
-        case NodeType::UnaryOp:
-        {
-            if (statement->value == "--" or statement->value == "++")
-            {
-                std::string reg = emitExpression(std::move(statement));
+        case NodeType::UnaryOp: {
+            std::string op = statement->value;
+            auto scope = statement->scope;
+            std::string reg = emitExpression(std::move(statement), out);
+            restoreIfSpilled(reg, scope, out);
+            if (op == "--" or op == "++") {
                 alloc.free(reg);
             }
+            out << "\n";
             break;
         }
-        case NodeType::BinaryOp:
-        {
-            std::string reg = emitExpression(std::move(statement)); // I am doing this just so the increments/decrements work in x + y-- -> this itself must not have any result, but y-- should still be effective.
+        case NodeType::BinaryOp: {
+            auto scope = statement->scope;
+            std::string reg = emitExpression(std::move(statement), out);  // I am doing this just so the increments/decrements work in x + y-- -> this itself must not have any result, but y-- should still be effective.
+            restoreIfSpilled(reg, scope, out);
             alloc.free(reg);
+            out << "\n";
+            break;
+        }
+        case NodeType::FunctionCall: {
+            std::string reg = generateFunctionCall(std::move(statement), out);
+            alloc.free(reg);
+            out << "\n";
+            break;
+        }
+        case NodeType::Function: {
+            generateFunctionDeclaration(std::move(statement), out);
+            out << "\n";
+            break;
+        }
+        case NodeType::ExternFunction: {
+            generateExternFunctionDeclaration(std::move(statement), out);
+            out << "\n";
+            break;
+        }
+        case NodeType::ReturnStatement: {
+            generateReturnstatement(std::move(statement), out);
+            out << "\n";
             break;
         }
         default:
             throw std::runtime_error("Unknown statement encountered.");
         }
     }
-    void CodeGenLinux::generateVariableReassignment(std::unique_ptr<ASTNode> statement)
-    {
+    void CodeGenLinux::generateVariableReassignment(std::unique_ptr<ASTNode> statement, std::ostringstream &out) {
         auto &scp = *statement->scope;
         auto nm = statement->value;
         auto ti = scp.lookupType(scp.lookupVariable(nm).type);
         uint64_t sz = ti.bits / 8;
 
-        auto r = emitExpression(std::move(statement->children.back()));
-        // Ensure the result is cast to the target variable's type
-        r = castValue(r, regType.at(r), ti);
+        auto r = emitExpression(std::move(statement->children.back()), out);
+        restoreIfSpilled(r, statement->scope, out);
+
+        r = castValue(r, regType.at(r), ti, statement->scope, out);
+        restoreIfSpilled(r, statement->scope, out);
 
         std::string addr = scp.isGlobalVariable(nm)
                                ? nm + "(%rip)"
                                : std::to_string(scp.getVariableOffset(nm)) + "(%rbp)";
 
-        if (ti.isFloat)
-        {
+        if (ti.isFloat) {
             out << "    " << (sz == 4 ? "movss %" : "movsd %") << r << ", " << addr << "\n";
-        }
-        else
-        {
+        } else {
             std::string adj = adjustReg(r, ti.bits);
             out << "    " << getCorrectMove(sz, false) << " %" << adj << ", " << addr << "\n";
         }
 
         alloc.free(r);
     }
-    void CodeGenLinux::generateVariableDeclaration(std::unique_ptr<ASTNode> statement)
-    {
+    void CodeGenLinux::generateVariableDeclaration(std::unique_ptr<ASTNode> statement, std::ostringstream &out) {
         auto &scp = *statement->scope;
         auto nm = statement->value;
         auto ti = scp.lookupType(scp.lookupVariable(nm).type);
         uint64_t sz = ti.bits / 8;
 
-        if (!scp.isGlobalVariable(nm))
-        {
-            if (statement->children.size() >= 2)
-            {
-                auto r = emitExpression(std::move(statement->children.back()));
-                r = castValue(r, regType.at(r), ti); // <- Added casting
-
-                if (ti.isFloat)
-                {
-                    out << "    " << (sz == 4 ? "movss %" : "movsd %") << r << ", "
-                        << std::to_string(scp.getVariableOffset(nm)) + "(%rbp)"
-                        << "\n";
-                }
-                else
-                {
-                    std::string adj = adjustReg(r, ti.bits);
-                    out << "    " << getCorrectMove(sz, false) << " %" << adj << ", "
-                        << std::to_string(scp.getVariableOffset(nm)) + "(%rbp)"
-                        << "\n";
-                }
-
-                alloc.free(r);
-            }
-            else
-            {
-                if (ti.isFloat)
-                {
-                    std::string r_xmm = alloc.allocateXMM();
-                    out << "    pxor %" << r_xmm << ", %" << r_xmm << "\n";
-                    out << "    " << (sz == 4 ? "movss %" : "movsd %") << r_xmm << ", "
-                        << std::to_string(scp.getVariableOffset(nm)) + "(%rbp)"
-                        << "\n";
-                    alloc.free(r_xmm);
-                }
-                else
-                {
-                    out << "    xorq %rax, %rax\n";
-                    out << "    mov" << integer_suffixes[ti.bits] << " %rax, "
-                        << std::to_string(scp.getVariableOffset(nm)) + "(%rbp)"
-                        << "\n";
-                }
+        auto emitStore = [&](const std::string &r) {
+            if (ti.isFloat) {
+                out << "    " << (sz == 4 ? "movss %" : "movsd %") << r << ", "
+                    << (scp.isGlobalVariable(nm) ? nm + "(%rip)" : std::to_string(scp.getVariableOffset(nm)) + "(%rbp)")
+                    << "\n";
+            } else {
+                std::string adj = adjustReg(r, ti.bits);
+                out << "    " << getCorrectMove(sz, false) << " %" << adj << ", "
+                    << (scp.isGlobalVariable(nm) ? nm + "(%rip)" : std::to_string(scp.getVariableOffset(nm)) + "(%rbp)")
+                    << "\n";
             }
-        }
-        else // Global variable path
-        {
-            if (statement->children.size() >= 2)
-            {
-                auto r = emitExpression(std::move(statement->children.back()));
-                r = castValue(r, regType.at(r), ti); // <- Added casting
-
-                if (ti.isFloat)
-                {
-                    out << "    " << (sz == 4 ? "movss %" : "movsd %") << r << ", "
-                        << nm + "(%rip)"
-                        << "\n";
-                }
-                else
-                {
-                    std::string adj = adjustReg(r, ti.bits);
-                    out << "    " << getCorrectMove(sz, false) << " %" << adj << ", "
-                        << nm + "(%rip)"
-                        << "\n";
-                }
+        };
 
-                alloc.free(r);
-            }
-            else
-            {
-                if (ti.isFloat)
-                {
-                    std::string r_xmm = alloc.allocateXMM();
-                    out << "    pxor %" << r_xmm << ", %" << r_xmm << "\n";
-                    out << "    " << (sz == 4 ? "movss %" : "movsd %") << r_xmm << ", "
-                        << nm + "(%rip)"
-                        << "\n";
-                    alloc.free(r_xmm);
-                }
-                else
-                {
-                    out << "    xorq %rax, %rax\n";
-                    out << "    mov" << integer_suffixes[ti.bits] << " %rax, "
-                        << nm + "(%rip)"
-                        << "\n";
-                }
+        if (statement->children.size() >= 2) {
+            auto r = emitExpression(std::move(statement->children.back()), out);
+            restoreIfSpilled(r, statement->scope, out);
+            r = castValue(r, regType.at(r), ti, statement->scope, out);
+            restoreIfSpilled(r, statement->scope, out);
+            emitStore(r);
+            alloc.free(r);
+        } else {
+            if (ti.isFloat) {
+                auto r_xmm = allocateOrSpill(true, statement->scope, out);
+                out << "    pxor %" << r_xmm << ", %" << r_xmm << "\n";
+                emitStore(r_xmm);
+                alloc.free(r_xmm);
+            } else {
+                out << "    xorq %rax, %rax\n";
+                out << "    mov" << integer_suffixes.at(ti.bits) << " %rax, "
+                    << (scp.isGlobalVariable(nm) ? nm + "(%rip)" : std::to_string(scp.getVariableOffset(nm)) + "(%rbp)")
+                    << "\n";
             }
         }
     }
-    void CodeGenLinux::generateIfStatement(std::unique_ptr<ASTNode> statement)
-    {
+    void CodeGenLinux::generateIfStatement(std::unique_ptr<ASTNode> statement, std::ostringstream &out) {
         int id = blockLabelCount++;
         std::string endLbl = ".Lend" + std::to_string(id);
         std::vector<std::string> elseLabels;
 
         // Precompute labels for each else-if / else branch
         ASTNode *branch = statement->getElseBranch();
-        while (branch)
-        {
+        while (branch) {
             elseLabels.push_back(".Lelse" + std::to_string(blockLabelCount++));
             branch = branch->getElseBranch();
         }
 
         size_t elseIdx = 0;
 
-        auto condR = emitExpression(std::move(statement->children[0]));
+        // IF branch
+        auto condR = emitExpression(std::move(statement->children[0]), out);
+        restoreIfSpilled(condR, statement->scope, out);
         out << "    cmpq $0, %" << condR << "\n";
         out << "    je " << (elseLabels.empty() ? endLbl : elseLabels[elseIdx]) << "\n";
         alloc.free(condR);
 
         auto ifBlock = std::move(statement->children[1]);
-        auto children = std::move(ifBlock->children);
-        emitPrologue(std::move(ifBlock));
-        for (auto &stmt : children)
-            generateStatement(std::move(stmt));
-        emitEpilogue();
+        emitPrologue(ifBlock->scope, out);
+        for (auto &stmt : ifBlock->children) {
+            generateStatement(std::move(stmt), out);
+        }
+        emitEpilogue(ifBlock->scope, out);
         out << "    jmp " << endLbl << "\n";
 
+        // ELSE-IF / ELSE branches
         branch = statement->getElseBranch();
-        while (branch)
-        {
+        while (branch) {
             out << elseLabels[elseIdx++] << ":\n";
 
-            if (branch->type == NodeType::ElseIfStatement)
-            {
-                auto r2 = emitExpression(std::move(branch->children[0]));
+            if (branch->type == NodeType::ElseIfStatement) {
+                auto r2 = emitExpression(std::move(branch->children[0]), out);
+                restoreIfSpilled(r2, branch->scope, out);
                 out << "    cmpq $0, %" << r2 << "\n";
                 out << "    je " << (elseIdx < elseLabels.size() ? elseLabels[elseIdx] : endLbl) << "\n";
                 alloc.free(r2);
 
                 auto elifBlock = std::move(branch->children[1]);
-                auto children = std::move(elifBlock->children);
-                emitPrologue(std::move(elifBlock));
-                for (auto &stmt : children)
-                    generateStatement(std::move(stmt));
-                emitEpilogue();
+                emitPrologue(elifBlock->scope, out);
+                for (auto &stmt : elifBlock->children) {
+                    generateStatement(std::move(stmt), out);
+                }
+                emitEpilogue(elifBlock->scope, out);
                 out << "    jmp " << endLbl << "\n";
-            }
-            else if (branch->type == NodeType::ElseStatement)
-            {
+
+            } else if (branch->type == NodeType::ElseStatement) {
                 auto elseBlock = std::move(branch->children[0]);
-                auto children = std::move(elseBlock->children);
-                emitPrologue(std::move(elseBlock));
-                for (auto &stmt : children)
-                    generateStatement(std::move(stmt));
-                emitEpilogue();
+                emitPrologue(elseBlock->scope, out);
+                for (auto &stmt : elseBlock->children) {
+                    generateStatement(std::move(stmt), out);
+                }
+                emitEpilogue(elseBlock->scope, out);
             }
 
             branch = branch->getElseBranch();
@@ -660,44 +703,355 @@ namespace zlang
 
         out << endLbl << ":\n\n";
     }
-    void CodeGenLinux::generate(std::unique_ptr<ASTNode> program)
-    {
+    void CodeGenLinux::generate(std::unique_ptr<ASTNode> program) {
         std::vector<ASTNode *> globals;
-        for (auto &statement : program->children)
-            if (statement->type == NodeType::VariableDeclaration)
+
+        // Collect global variable declarations
+        for (auto &statement : program->children) {
+            if (statement->type == NodeType::VariableDeclaration) {
                 globals.push_back(statement.get());
-        outGlobal << ".data\n\n";
-        for (auto &g : globals)
-        {
+            }
+        }
+
+        // Emit .data section for globals
+        outGlobalStream << ".data\n\n";
+        for (auto *g : globals) {
             TypeInfo info = g->scope->lookupType(g->children[0]->value);
-            switch (info.bits / 8)
-            {
+            switch (info.bits / 8) {
             case 8:
-                outGlobal << g->value << ": .quad 0\n";
+                outGlobalStream << g->value << ": .quad 0\n";
                 break;
             case 4:
-                outGlobal << g->value << ": .long 0\n";
+                outGlobalStream << g->value << ": .long 0\n";
                 break;
             case 2:
-                outGlobal << g->value << ": .word 0\n";
+                outGlobalStream << g->value << ": .word 0\n";
                 break;
             case 1:
-                outGlobal << g->value << ": .byte 0\n";
+                outGlobalStream << g->value << ": .byte 0\n";
                 break;
             default:
-                throw std::runtime_error("Unsupported global size");
+                throw std::runtime_error("Unsupported global size: " + std::to_string(info.bits / 8));
             }
         }
-        outGlobal << "\n.section .rodata\n"; // Ensure rodata section exists
-        out << ".text\n.global _start\n_start:\n\n";
-        for (std::unique_ptr<ASTNode> &statement : program.get()->children)
-        {
-            generateStatement(std::move(statement));
+
+        // Emit rodata and stack protection code
+        outGlobalStream << "\n.section .rodata\n";
+
+        outStream << ".text\n";
+        outStream << ".globl __stack_smash_detected\n";
+        outStream << "__stack_smash_detected:\n";
+        outStream << "    mov $60, %rax # syscall: exit\n";
+        outStream << "    mov $69, %rdi # exit code\n";
+        outStream << "    syscall\n";
+
+        // Entry point
+        outStream << ".global main\n";
+
+        std::unique_ptr<ASTNode> mainFunction;
+        std::vector<std::unique_ptr<ASTNode>> declarationsAndReassignments;
+
+        // Generate code for all top-level statements
+        for (auto &statement : program->children) {
+            if (statement->type == NodeType::Function and statement->value == "main") {
+                mainFunction = std::move(statement);
+            } else if (statement->type == NodeType::VariableDeclaration || statement->type == NodeType::VariableReassignment || (statement->type == NodeType::UnaryOp and (statement->value == "++" || statement->value == "--"))) {
+                declarationsAndReassignments.push_back(std::move(statement));
+            } else {
+                generateStatement(std::move(statement), outStream);
+            }
         }
 
-        out << "    movq $60, %rax\n    movq $0, %rdi\n    syscall\n";
+        outStream << "main:\n";
+        for (auto &s : declarationsAndReassignments) {
+            generateStatement(std::move(s), outStream);
+        }
+        generateFunctionDeclaration(std::move(mainFunction), outStream, true);
 
-        outfinal << outGlobal.str() + "\n# ==============Globals End Here==============\n"
-                 << out.str() << "\n\n";
+        // Final output
+        outfinal << outGlobalStream.str()
+                 << "\n# ============== Globals End Here ==============\n"
+                 << outStream.str() << "\n";
     }
-} // namespace zlang
\ No newline at end of file
+
+    std::string CodeGenLinux::generateFunctionCall(std::unique_ptr<ASTNode> node, std::ostringstream &out) {
+        auto fnInfo = node->scope->lookupFunction(node->value);
+        const std::string &label = fnInfo.isExtern ? node->value : fnInfo.label;
+        auto &args = node->children[0]->children;
+        const auto &functionParams = fnInfo.paramTypes;
+
+        // --- Save caller-saved GPRs ---
+        std::vector<std::string> savedGPR;
+        for (const auto &reg : CALLER_GPR_LINUX) {
+            if (alloc.isInUse(reg)) {
+                out << "    push   %" << reg << "    # save caller-saved GPR\n";
+                savedGPR.push_back(reg);
+            }
+        }
+
+        // --- Save caller-saved XMMs ---
+        std::vector<std::pair<std::string, std::string>> savedXMM;
+        for (const auto &reg : CALLER_XMM_LINUX) {
+            if (alloc.isInUseXMM(reg)) {
+                auto funcScope = std::static_pointer_cast<FunctionScope>(node->scope->findEnclosingFunctionScope());
+                std::string slot = funcScope->allocateSpillSlot(16, CodegenOutputFormat::X86_64_LINUX);
+                alloc.markSpilledXMM(reg, slot);
+                out << "    movdqu %" << reg << ", " << slot << "    # save caller-saved XMM\n";
+                savedXMM.emplace_back(reg, slot);
+            }
+        }
+
+        // calculate stack space for overflow arguments
+        uint64_t gpCount = 0, xmmCount = 0, stackOffset = 0;
+        for (size_t i = 0; i < args.size(); ++i) {
+            bool isFloat;
+            if (i < functionParams.size()) {
+                isFloat = node->scope->lookupType(functionParams[i].type).isFloat;
+            } else if (fnInfo.isVariadic) {
+                // Promote variadic argument based on the actual passed type
+                // We cannot know actual float/int until expression emitted; assume float if expression type is float
+                // For stack-space calculation, we'll conservatively treat variadic floats as double
+                // so count toward xmmCount
+                // Here, default to integer (non-float) stack slot; actual float moved will go to xmm later
+                isFloat = false;
+            } else {
+                throw std::runtime_error("Too many arguments passed to non-variadic function '" + node->value + "'");
+            }
+
+            if (!isFloat) {
+                if (gpCount < ARG_GPR_LINUX.size())
+                    gpCount++;
+                else
+                    stackOffset += 8;
+            } else {
+                if (xmmCount < ARG_XMM_LINUX.size())
+                    xmmCount++;
+                else
+                    stackOffset += 8;
+            }
+        }
+        uint64_t stackReserve = (stackOffset + 15) & ~15ULL;
+        if (stackReserve)
+            out << "    sub    $" << stackReserve << ", %rsp    # reserve stack for args\n";
+
+        // emit argument moves
+        gpCount = xmmCount = 0;
+        stackOffset = 0;
+        std::vector<std::string> reservedArgumentRegs;
+        std::vector<std::string> spilledArgumentRegs;
+
+        for (size_t i = 0; i < args.size(); ++i) {
+            std::string src = emitExpression(std::move(args[i]), out);
+            restoreIfSpilled(src, node->scope, out);
+
+            TypeInfo passed = regType.at(src);
+            bool passedIsFloat = passed.isFloat;
+
+            TypeInfo expect;
+            if (i < functionParams.size()) {
+                expect = node->scope->lookupType(functionParams[i].type);
+            } else if (fnInfo.isVariadic) {
+                if (passedIsFloat) {
+                    expect = node->scope->lookupType("double");
+                } else {
+                    expect = node->scope->lookupType("int64_t");
+                }
+            } else {
+                throw std::runtime_error("Too many arguments passed to non-variadic function '" + node->value + "'");
+            }
+
+            std::string cvt = castValue(src, passed, expect, node->scope, out);
+            restoreIfSpilled(cvt, node->scope, out);
+
+            bool isFloatArg = expect.isFloat;
+            if (!isFloatArg && gpCount < ARG_GPR_LINUX.size()) {
+                std::string dst = ARG_GPR_LINUX[gpCount];
+                if (alloc.isInUseArgument(dst)) {
+                    auto funcScope = std::static_pointer_cast<FunctionScope>(node->scope->findEnclosingFunctionScope());
+                    std::string slot = funcScope->allocateSpillSlot(8, CodegenOutputFormat::X86_64_LINUX);
+                    alloc.markSpilled(dst, slot);
+                    spilledArgumentRegs.push_back(dst);
+                    out << "    movq   %" << dst << ", " << slot << "    # spill GPR\n";
+                } else {
+                    dst = alloc.allocateArgument(gpCount);
+                    reservedArgumentRegs.emplace_back(dst);
+                }
+                gpCount++;
+                out << "    movq   %" << cvt << ", %" << dst << "\n";
+            } else if (isFloatArg && xmmCount < ARG_XMM_LINUX.size()) {
+                std::string dst = ARG_XMM_LINUX[xmmCount];
+                if (alloc.isInUseArgumentXMM(dst)) {
+                    auto funcScope = std::static_pointer_cast<FunctionScope>(node->scope->findEnclosingFunctionScope());
+                    std::string slot = funcScope->allocateSpillSlot(16, CodegenOutputFormat::X86_64_LINUX);
+                    alloc.markSpilledXMM(dst, slot);
+                    spilledArgumentRegs.push_back(dst);
+                    out << "    movdqu %" << dst << ", " << slot << "    # spill XMM\n";
+                } else {
+                    dst = alloc.allocateArgumentXMM(xmmCount);
+                    reservedArgumentRegs.emplace_back(dst);
+                }
+                xmmCount++;
+                out << "    movsd  %" << cvt << ", %" << dst << "\n";
+            } else {
+                out << "    mov" << (isFloatArg ? "ss  %" : "q   %") << cvt << ", " << stackOffset << "(%rsp)\n";
+                stackOffset += 8;
+            }
+            alloc.free(cvt);
+        }
+
+        // tell ABI how many float args are in XMM regs
+        out << "    mov    $" << xmmCount << ", %rax    # variadic ABI float count\n";
+
+        // --- Call ---
+        out << "    call   " << label << "    # function call\n";
+
+        for (std::string &reg : spilledArgumentRegs) {
+            restoreIfSpilled(reg, node->scope, out);
+        }
+
+        for (std::string &reg : reservedArgumentRegs) {
+            alloc.freeArgument(reg);
+        }
+
+        // restore caller-saved XMMs
+        for (auto it = savedXMM.rbegin(); it != savedXMM.rend(); ++it) {
+            out << "    movdqu " << it->second << ", %" << it->first << "    # restore XMM\n";
+        }
+        // restore caller-saved GPRs
+        for (auto it = savedGPR.rbegin(); it != savedGPR.rend(); ++it) {
+            out << "    pop    %" << *it << "    # restore GPR\n";
+        }
+
+        // restore stack
+        if (stackReserve)
+            out << "    add    $" << stackReserve << ", %rsp    # free args stack\n";
+
+        // return value
+        bool isFloatRet = fnInfo.returnType == "float" || fnInfo.returnType == "double";
+        std::string holder = allocateOrSpill(isFloatRet, node->scope, out);
+        std::string abiReg = isFloatRet ? "xmm0" : "rax";
+        noteType(holder, node->scope->lookupType(fnInfo.returnType));
+        if (isFloatRet) {
+            const char *mov = fnInfo.returnType == "float" ? "movss" : "movsd";
+            out << "    " << mov << " %" << abiReg << ", %" << holder << "\n";
+        } else {
+            out << "    movq   %" << abiReg << ", %" << holder << "\n";
+        }
+        return holder;
+    }
+    void CodeGenLinux::generateFunctionDeclaration(std::unique_ptr<ASTNode> node, std::ostringstream &out, bool force) {
+        if (node->value == "main" && !force) {
+            return;
+        }
+        auto fnInfo = node->scope->lookupFunction(node->value);
+        auto bodyNode = node->getFunctionBody();
+        auto funcScope = std::dynamic_pointer_cast<FunctionScope>(
+            bodyNode->scope->findEnclosingFunctionScope());
+
+        // Function label and prologue with canary and stack frame setup
+        if (!force) {
+            out << fnInfo.label << ":\n";
+        }
+        std::ostringstream prologue;
+        std::ostringstream body;
+
+        // Canary setup
+        std::uint64_t canary = CanaryGenerator::generate();
+        funcScope->setCanary(canary);
+
+        std::vector<std::unique_ptr<ASTNode>> nestedFunctions;
+
+        auto &params = fnInfo.paramTypes;
+        size_t gpIdx = 0, xmmIdx = 0, stackArgOffset = 0;
+
+        // Move incoming args into their stack slots
+        for (size_t i = 0; i < params.size(); ++i) {
+            const auto &p = params[i];
+            TypeInfo ti = node->scope->lookupType(p.type);
+            bool isFloat = ti.isFloat;
+            int64_t slotOff = bodyNode->scope->getVariableOffset(p.name);
+
+            // Determine correct mov instruction
+            std::string movInst;
+            if (isFloat) {
+                movInst = (ti.bits == 64) ? "movsd" : "movss";
+            } else {
+                movInst = "mov" + std::string(1, integer_suffixes.at(64));  // "movq"
+            }
+
+            if (!isFloat && gpIdx < ARG_GPR_LINUX.size()) {
+                // integer in GPR
+                body << "    " << movInst
+                     << " %" << ARG_GPR_LINUX[gpIdx++]  // prefix register
+                     << ", " << std::to_string(slotOff) << "( %rbp)\n";
+
+            } else if (isFloat && xmmIdx < ARG_XMM_LINUX.size()) {
+                // float in XMM reg
+                body << "    " << movInst
+                     << " %" << ARG_XMM_LINUX[xmmIdx++]
+                     << ", " << std::to_string(slotOff) << "( %rbp)\n";
+
+            } else {
+                // spilled argument on caller's stack
+                uint64_t callerDisp = 16 + stackArgOffset;
+                body << "    " << movInst
+                     << " " << callerDisp << "(%rbp)"
+                     << ", " << std::to_string(slotOff) << "( %rbp)\n";
+                stackArgOffset += 8;
+            }
+        }
+
+        // Generate the function body
+        for (auto &stmt : bodyNode->children) {
+            if (stmt->type == NodeType::Function) {
+                nestedFunctions.push_back(std::move(stmt));  // defer
+            } else {
+                generateStatement(std::move(stmt), body);
+            }
+        }
+        emitPrologue(funcScope, prologue);
+        if (bodyNode->scope->returnType == "none") {
+            emitEpilogue(funcScope, body, force);
+        }
+        out << prologue.str() + body.str();
+        for (auto &nestedFn : nestedFunctions) {
+            generateFunctionDeclaration(std::move(nestedFn), out, false);
+        }
+    }
+    void CodeGenLinux::generateExternFunctionDeclaration(std::unique_ptr<ASTNode> node, std::ostringstream &out) {
+        auto fnInfo = node->scope->lookupFunction(node->value);
+        const std::string &label = node->value;
+        outGlobalStream << "    .global  " << label << "\n";
+        outGlobalStream << "    .type   " << label << ", @function\n";
+    }
+    void CodeGenLinux::generateReturnstatement(std::unique_ptr<ASTNode> node, std::ostringstream &out) {
+        // TODO: Ensure that we are not returning a local type, at this point I assume that typechecker handles this.
+        std::string result = emitExpression(std::move(node->children[0]), out);
+
+        std::shared_ptr<FunctionScope> funcScope = node->scope->findEnclosingFunctionScope();
+        restoreIfSpilled(result, funcScope, out);
+
+        TypeInfo actual = regType.at(result);
+        TypeInfo expected = funcScope->lookupType(funcScope->returnType);
+        std::string casted = castValue(result, actual, expected, funcScope, out);
+        restoreIfSpilled(casted, funcScope, out);
+
+        std::string retReg = expected.isFloat ? "xmm0" : "rax";
+
+        if (expected.name == "none") {
+            out << "    xor %rax, %rax\n";
+        } else if (!expected.isFloat) {
+            out << "    mov" << integer_suffixes.at(64)
+                << " %" << casted << ", %" << retReg << "\n";
+        } else {
+            const char *mov = (expected.bits == 32 ? "movss" : "movsd");
+            out << "    " << mov
+                << " %" << casted << ", %" << retReg << "\n";
+        }
+        alloc.free(casted);
+        emitEpilogue(funcScope, out);
+    }
+}  // namespace zlang
+
+// TODO: Dont nest the code generation of nested functions.
+// This leads to disasters.
\ No newline at end of file
diff --git a/src/codegen/CodeGenWindows.cpp b/src/codegen/CodeGenWindows.cpp
index 3b7713e..bede6d2 100644
--- a/src/codegen/CodeGenWindows.cpp
+++ b/src/codegen/CodeGenWindows.cpp
@@ -1,128 +1,102 @@
 #include "all.hpp"
 
-namespace zlang
-{
-    std::string CodeGenWindows::castValue(const std::string &srcReg, const TypeInfo &fromType, const TypeInfo &toType)
-    {
-        if (fromType.bits == toType.bits && fromType.isFloat == toType.isFloat)
-        {
+namespace zlang {
+    std::string CodeGenWindows::castValue(const std::string &val,
+                                          const TypeInfo &fromType,
+                                          const TypeInfo &toType, const std::shared_ptr<ScopeContext> currentScope, std::ostringstream &out) {
+        restoreIfSpilled(val, currentScope, out);
+
+        if (fromType.bits == toType.bits && fromType.isFloat == toType.isFloat) {
             if (!fromType.isFloat && fromType.bits == toType.bits &&
-                fromType.isSigned != toType.isSigned)
-            {
-                std::string dst = alloc.allocate();
+                fromType.isSigned != toType.isSigned) {
+                std::string dst = allocateOrSpill(false, currentScope, out);
                 out << "    mov " << adjustReg(dst, fromType.bits)
-                    << ", " << adjustReg(srcReg, fromType.bits) << "\n";
-                alloc.free(srcReg);
+                    << ", " << adjustReg(val, fromType.bits) << "\n";
+                alloc.free(val);
                 noteType(dst, toType);
                 return dst;
             }
-            return RegisterAllocator::getBaseReg(srcReg);
+            return RegisterAllocator::getBaseReg(val);
         }
 
-        if (fromType.isFloat && toType.isFloat)
-        {
-            std::string dst = alloc.allocateXMM();
+        if (fromType.isFloat && toType.isFloat) {
+            std::string dst = allocateOrSpill(true, currentScope, out);
             auto instr = (fromType.bits < toType.bits)
                              ? "cvtss2sd"
                              : "cvtsd2ss";
-            out << "    " << instr << " " << dst << ", " << srcReg << "\n";
-            alloc.free(srcReg);
+            out << "    " << instr << " " << dst << ", " << val << "\n";
+            alloc.free(val);
             noteType(dst, toType);
             return dst;
         }
 
-        if (!fromType.isFloat && toType.isFloat)
-        {
-            std::string dst = alloc.allocateXMM();
+        if (!fromType.isFloat && toType.isFloat) {
+            std::string dst = allocateOrSpill(true, currentScope, out);
             auto instr = (toType.bits == 32)
                              ? "cvtsi2ss"
                              : "cvtsi2sd";
             out << "    " << instr << " " << dst
-                << ", " << adjustReg(srcReg, fromType.bits) << "\n";
-            alloc.free(srcReg);
+                << ", " << adjustReg(val, fromType.bits) << "\n";
+            alloc.free(val);
             noteType(dst, toType);
             return dst;
         }
 
-        if (fromType.isFloat && !toType.isFloat)
-        {
-            std::string dst = alloc.allocate();
+        if (fromType.isFloat && !toType.isFloat) {
+            std::string dst = allocateOrSpill(false, currentScope, out);
             auto instr = (fromType.bits == 32)
                              ? "cvttss2si"
                              : "cvttsd2si";
-            out << "    " << instr << " " << dst << ", " << srcReg << "\n";
-            alloc.free(srcReg);
+            out << "    " << instr << " " << dst << ", " << val << "\n";
+            alloc.free(val);
             noteType(dst, toType);
             return dst;
         }
 
-        if (!fromType.isFloat && !toType.isFloat)
-        {
-            std::string dst = alloc.allocate();
-            std::string srcAdj = adjustReg(srcReg, fromType.bits);
-            std::string dstAdj = dst;
+        if (!fromType.isFloat && !toType.isFloat) {
+            std::string dst = allocateOrSpill(false, currentScope, out);
+            std::string srcAdj = adjustReg(val, fromType.bits);
+            std::string dstAdj = adjustReg(dst, toType.bits);
 
-            if (toType.bits > fromType.bits)
-            {
-                if (fromType.isSigned)
-                {
-                    if (fromType.bits == 32 && toType.bits == 64)
-                    {
+            if (toType.bits > fromType.bits) {
+                // widening
+                if (fromType.isSigned) {
+                    // signed → use movsxd for 32→64, movsx otherwise
+                    if (fromType.bits == 32 && toType.bits == 64) {
                         out << "    movsxd " << dstAdj << ", " << srcAdj << "\n";
+                    } else {
+                        out << "    movsx  " << dstAdj << ", " << srcAdj << "\n";
                     }
-                    else
-                    {
-                        out << "    movsx " << dstAdj << ", " << srcAdj << "\n";
-                    }
-                }
-                else
-                {
-                    if (fromType.bits == 8 || fromType.bits == 16)
-                    {
-                        out << "    movzx " << dstAdj << ", " << srcAdj << "\n";
-                    }
-                    else if (fromType.bits == 32 && toType.bits == 64)
-                    {
-                        out << "    mov " << dstAdj << "d, " << srcAdj << "\n";
-                    }
-                    else
-                    {
-                        throw std::runtime_error("Unsupported unsigned cast: " + std::to_string(fromType.bits) + " -> " + std::to_string(toType.bits));
-                    }
-                }
-            }
-            else if (toType.bits < fromType.bits)
-            {
-                if (toType.bits == 8 || toType.bits == 16)
-                {
-                    if (toType.isSigned)
-                    {
-                        out << "    movsx " << dstAdj << ", " << adjustReg(srcReg, toType.bits) << "\n";
-                    }
-                    else
-                    {
-                        out << "    movzx " << dstAdj << ", " << adjustReg(srcReg, toType.bits) << "\n";
+                } else {
+                    // unsigned → use movzx for width ≤ 16, plain mov for 32→64
+                    if (fromType.bits == 8 || fromType.bits == 16) {
+                        out << "    movzx  " << dstAdj << ", " << srcAdj << "\n";
+                    } else if (fromType.bits == 32 && toType.bits == 64) {
+                        out << "    mov    " << dstAdj << "d, " << srcAdj << "\n";
+                    } else {
+                        throw std::runtime_error(
+                            "Unsupported unsigned cast: " +
+                            std::to_string(fromType.bits) +
+                            " -> " +
+                            std::to_string(toType.bits)
+                        );
                     }
                 }
-                else if (toType.bits == 32)
-                {
-                    out << "    mov " << adjustReg(dstAdj, 32) << ", " << adjustReg(srcReg, 32) << "\n";
-                }
-                else
-                {
-                    throw std::runtime_error("Unsupported downcast to " + std::to_string(toType.bits));
-                }
-            }
-            else
-            {
-                out << "    mov " << adjustReg(dstAdj, toType.bits) << ", " << srcAdj << "\n";
+
+            } else if (toType.bits < fromType.bits) {
+                out << "    mov    " << dstAdj << ", " << adjustReg(val, toType.bits) << "\n";
+
+            } else {
+                // same size — plain mov
+                out << "    mov    " << dstAdj << ", " << srcAdj << "\n";
             }
 
-            alloc.free(srcReg);
+            alloc.free(val);
             noteType(dst, toType);
             return dst;
         }
 
+
         throw std::runtime_error(
             "Unsupported cast from " +
             fromType.to_string() +
@@ -130,601 +104,1257 @@ namespace zlang
             toType.to_string());
     }
 
-    std::string CodeGenWindows::getVariableAddress(const ScopeContext &scope, const std::string &name) const
-    {
-        if (scope.isGlobalVariable(name))
-        {
-            return "[" + name + "]";
+    std::string CodeGenWindows::allocateOrSpill(bool isXMM, std::shared_ptr<ScopeContext> scope, std::ostringstream &out) {
+        try {
+            std::string reg = isXMM ? alloc.allocateXMM() : alloc.allocate();
+            if (!reg.empty())
+                return reg;
+        } catch (...) {
         }
-        else
-        {
-            int offset = scope.getVariableOffset(name);
-            return (offset < 0)
-                       ? "[rbp - " + std::to_string(-offset) + "]"
-                       : "[rbp + " + std::to_string(offset) + "]";
+
+        std::shared_ptr<FunctionScope> result_scope = scope->findEnclosingFunctionScope();
+        if (!result_scope)
+            throw std::runtime_error("Cannot spill in global context");
+
+        std::shared_ptr<FunctionScope> funcScope = std::static_pointer_cast<FunctionScope>(result_scope);
+        std::string victim = isXMM ? alloc.pickVictimXMM() : alloc.pickVictim();
+        if (victim.empty())
+            throw std::runtime_error("No available registers and no victim found");
+
+        std::string spillSlot =
+            funcScope->allocateSpillSlot(isXMM ? 16 : 8,
+                                         CodegenOutputFormat::X86_64_MSWIN);
+
+        if (isXMM) {
+            alloc.markSpilledXMM(victim, spillSlot);
+            out << "    movdqu " << victim
+                << ", XMMWORD PTR " << spillSlot
+                << "    ; Spill XMM\n";
+        } else {
+            alloc.markSpilled(victim, spillSlot);
+            out << "    mov " << victim
+                << ", QWORD PTR " << spillSlot
+                << "    ; Spill GPR\n";
         }
+
+        return victim;
     }
-    std::string CodeGenWindows::generateIntegerLiteral(std::unique_ptr<ASTNode> node)
-    {
-        TypeInfo ti = node->scope->lookupType("int64_t");
-        auto r = alloc.allocate();
-        std::string adj = adjustReg(r, ti.bits);
+    void CodeGenWindows::restoreIfSpilled(const std::string &reg, std::shared_ptr<ScopeContext> scope, std::ostringstream &out) {
+        if (!alloc.isSpilled(reg))
+            return;
+
+        std::string slot = alloc.spillSlotFor(reg);
+
+        if (reg.rfind("xm", 0) == 0) {
+            alloc.unSpillXMM(reg,
+                             CodegenOutputFormat::X86_64_MSWIN,
+                             out);
+        } else {
+            alloc.unSpill(reg,
+                          CodegenOutputFormat::X86_64_MSWIN,
+                          out);
+        }
 
-        out << "    mov " << adj << ", " << node->value << "\n";
-        noteType(r, ti);
+        auto result_scope = scope->findEnclosingFunctionScope();
+        if (result_scope) {
+            auto funcScope =
+                std::static_pointer_cast<FunctionScope>(result_scope);
+            funcScope->freeSpillSlot(
+                slot,
+                reg.rfind("xm", 0) == 0 ? 16 : 8);
+        }
+    }
 
-        return r;
+    std::string CodeGenWindows::generateIntegerLiteral(std::unique_ptr<ASTNode> node, std::ostringstream &out) {
+        TypeInfo ti = node->scope->lookupType("int64_t");
+        std::string adj = allocateOrSpill(false, node->scope, out);
+        out << "    mov " << adj << ", " << node->value << "\n";
+        noteType(adj, ti);
+        return adj;
     }
-    std::string CodeGenWindows::generateFloatLiteral(std::unique_ptr<ASTNode> node)
-    {
+
+    std::string CodeGenWindows::generateFloatLiteral(std::unique_ptr<ASTNode> node, std::ostringstream &out) {
         std::string lbl = "Lfloat" + std::to_string(floatLabelCount++);
         std::string val = node->value;
         bool isF32 = (!val.empty() && (val.back() == 'f' || val.back() == 'F'));
-
         if (isF32)
             val.pop_back();
-
-        if (isF32)
-            outGlobal << lbl << " DWORD " << val << "\n";
-        else
-            outGlobal << lbl << " QWORD " << val << "\n";
-
-        auto r_xmm = alloc.allocateXMM();
-
-        out << "    " << (isF32 ? "movss" : "movsd")
-            << " " << r_xmm << ", "
+        outGlobalStream
+            << "    ALIGN " << (isF32 ? 4 : 8) << "\n"
+            << lbl << " "
+            << (isF32 ? "dd " : "dq ")
+            << val << "\n";
+        TypeInfo floatType = isF32
+                                 ? node->scope->lookupType("float")
+                                 : node->scope->lookupType("double");
+        std::string r_xmm = allocateOrSpill(true, node->scope, out);
+        out
+            << "    " << (isF32 ? "movss " : "movsd ")
+            << r_xmm << ", "
             << (isF32 ? "DWORD PTR " : "QWORD PTR ")
-            << "[" << lbl << "]\n";
-
-        noteType(r_xmm, node->scope->lookupType(isF32 ? "float" : "double"));
+            << lbl << "\n";
 
+        noteType(r_xmm, floatType);
         return r_xmm;
     }
-    std::string CodeGenWindows::generateStringLiteral(std::unique_ptr<ASTNode> node)
-    {
+    std::string CodeGenWindows::generateStringLiteral(
+        std::unique_ptr<ASTNode> node,
+        std::ostringstream &out
+    ) {
+        // 1) Create a unique label
         std::string lbl = "Lstr" + std::to_string(stringLabelCount++);
-        outGlobal << lbl << " BYTE "
-                  << '"' << ((node->value.length() == 0) ? "\\0" : node->value) << '"' << ", 0\n";
-        auto r = alloc.allocate();
-        out << "    lea " << r << ", [" << lbl << "]\n";
-        noteType(r, node->scope->lookupType("string"));
 
+        // 2) Raw value from the AST (e.g. contains "\n", "\"", etc.)
+        const std::string &raw = node->value;
+
+        // 3) Split into printable chars and numeric bytes
+        std::string printable;
+        std::vector<unsigned char> nums;
+
+        for (size_t i = 0; i < raw.size(); ++i) {
+            if (raw[i] == '\\' && i + 1 < raw.size()) {
+                char esc = raw[++i];
+                switch (esc) {
+                    case 'n':  nums.push_back(0x0A); break;
+                    case 't':  nums.push_back(0x09); break;
+                    case '\\': printable.push_back('\\'); break;
+                    case '"':  printable.push_back('"');  break;
+                    case '0':  nums.push_back(0x00); break;
+                    default:
+                        // Unknown escape: emit literally
+                        printable.push_back('\\');
+                        printable.push_back(esc);
+                }
+            } else {
+                printable.push_back(raw[i]);
+            }
+        }
+        // Always null-terminate
+        nums.push_back(0x00);
+
+        // 4) Emit the data declaration
+        outGlobalStream << "    ALIGN 1\n";
+        outGlobalStream << lbl << " db ";
+
+        // Emit the quoted printable portion if non-empty
+        if (!printable.empty()) {
+            outGlobalStream << "\"";
+            for (unsigned char c : printable) {
+                if (c == '"')       outGlobalStream << "\"\"";   // MASM doubles quotes
+                else if (c == '\\') outGlobalStream << "\\\\"; // literal backslash
+                else                outGlobalStream << c;
+            }
+            outGlobalStream << "\"";
+
+            if (!nums.empty()) {
+                outGlobalStream << ",";
+            }
+        }
+
+        // Emit numeric bytes (e.g. 0Ah for newline, 00h for terminator)
+        for (size_t i = 0; i < nums.size(); ++i) {
+            unsigned int b = nums[i];
+            outGlobalStream
+                << std::uppercase
+                << std::hex
+                << "0" << b << "h"
+                << std::dec;
+            if (i + 1 < nums.size()) {
+                outGlobalStream << ",";
+            }
+        }
+        outGlobalStream << "\n\n";
+
+        // 5) Generate the code to load its address
+        TypeInfo strType = node->scope->lookupType("string");
+        std::string r = allocateOrSpill(false, node->scope, out);
+        out << "    lea " << r << ", OFFSET " << lbl << "\n";
+        noteType(r, strType);
         return r;
     }
-    std::string CodeGenWindows::generateBooleanLiteral(std::unique_ptr<ASTNode> node)
-    {
-        auto r = alloc.allocate();
-        out << "    mov " << r << ", " << (node->value == "true" ? "1" : "0") << "\n";
-        noteType(r, node->scope->lookupType("boolean"));
+
+    std::string CodeGenWindows::generateBooleanLiteral(std::unique_ptr<ASTNode> node, std::ostringstream &out) {
+        TypeInfo boolType = node->scope->lookupType("boolean");
+        std::string r = allocateOrSpill(false, node->scope, out);
+        out
+            << "    mov " << r << ", "
+            << (node->value == "true" ? "1" : "0") << "\n";
+
+        noteType(r, boolType);
         return r;
     }
-    std::string CodeGenWindows::generateVariableAccess(std::unique_ptr<ASTNode> node)
-    {
+    std::string CodeGenWindows::generateVariableAccess(std::unique_ptr<ASTNode> node, std::ostringstream &out) {
         auto &scope = *node->scope;
-        const std::string name = node->value;
+        std::string name = node->value;
         TypeInfo ti = scope.lookupType(scope.lookupVariable(name).type);
         uint64_t sz = ti.bits / 8;
-        uint64_t bits = ti.bits;
+        bool isGlobal = scope.isGlobalVariable(name);
 
-        std::string address = getVariableAddress(scope, name); // Use helper
-
-        if (ti.isFloat)
-        {
-            auto r_xmm = alloc.allocateXMM();
-            if (sz == 4)
-            {
-                out << "    movss " << r_xmm << ", DWORD PTR " << address << "\n";
-            }
-            else if (sz == 8)
-            {
-                out << "    movsd " << r_xmm << ", QWORD PTR " << address << "\n";
-            }
-            else
-            {
-                throw std::runtime_error("Unsupported float size: " + std::to_string(sz));
-            }
-            noteType(r_xmm, ti);
-            return r_xmm;
-        }
-        else
-        {
-            auto r64 = alloc.allocate();
-            auto r_adj = adjustReg(r64, bits);
-
-            std::string ptrSize;
-            switch (sz)
-            {
+        auto ptrQualifier = [&](uint64_t bytes) {
+            switch (bytes) {
             case 8:
-                ptrSize = "QWORD PTR ";
-                break;
+                return "QWORD PTR ";
             case 4:
-                ptrSize = "DWORD PTR ";
-                break;
+                return "DWORD PTR ";
             case 2:
-                ptrSize = "WORD PTR ";
-                break;
+                return "WORD PTR ";
             case 1:
-                ptrSize = "BYTE PTR ";
-                break;
+                return "BYTE PTR ";
             default:
-                throw std::runtime_error("Unsupported integer size: " + std::to_string(sz));
+                return "";
+            }
+        };
+
+        if (ti.isFloat) {
+            std::string r_xmm = allocateOrSpill(true, node->scope, out);
+            std::string instr = (sz == 4 ? "movss" : "movsd");
+            std::string qualifier = ptrQualifier(sz);
+
+            if (isGlobal) {
+                out << "    "
+                    << instr << " "
+                    << r_xmm << ", "
+                    << qualifier << "[" << name << "]"
+                    << "\n";
+            } else {
+                int64_t off = std::abs(scope.getVariableOffset(name));
+                out << "    "
+                    << instr << " "
+                    << r_xmm << ", "
+                    << qualifier << "[rbp - " << off << "]"
+                    << "\n";
+            }
+
+            noteType(r_xmm, ti);
+            return r_xmm;
+        } else {
+            std::string r = allocateOrSpill(false, node->scope, out);
+            std::string adj = adjustReg(r, ti.bits);
+            std::string qualifier = ptrQualifier(sz);
+
+            if (isGlobal) {
+                out << "    "
+                    << "mov "
+                    << adj << ", "
+                    << qualifier << "[" << name << "]"
+                    << "\n";
+            } else {
+                int64_t off = std::abs(scope.getVariableOffset(name));
+                out << "    "
+                    << "mov "
+                    << adj << ", "
+                    << qualifier << "[rbp - " << off << "]"
+                    << "\n";
             }
 
-            out << "    mov " << r_adj << ", " << ptrSize << address << "\n";
-            noteType(r_adj, ti);
-            return r_adj;
+            noteType(r, ti);
+            return r;
         }
     }
-    std::string CodeGenWindows::generateBinaryOperation(std::unique_ptr<ASTNode> node)
-    {
-        std::string rl = emitExpression(std::move(node->children[0]));
-        std::string rr = emitExpression(std::move(node->children[1]));
+    std::string CodeGenWindows::generateBinaryOperation(std::unique_ptr<ASTNode> node, std::ostringstream &out) {
+        // 1. Evaluate left operand
+        std::string rl = emitExpression(std::move(node->children[0]), out);
+        restoreIfSpilled(rl, node->scope, out);
+
+        // 2. Evaluate right operand
+        std::string rr = emitExpression(std::move(node->children[1]), out);
+        restoreIfSpilled(rr, node->scope, out);
 
+        // 3. Figure out result type and operator
         TypeInfo t1 = regType.at(rl);
         TypeInfo t2 = regType.at(rr);
         TypeInfo tr = TypeChecker::promoteType(t1, t2);
-        uint64_t bits = tr.bits;
         const std::string &op = node->value;
 
-        // Cast operands to the promoted type
-        rl = castValue(rl, t1, tr);
-        rr = castValue(rr, t2, tr);
-
-        if (tr.isFloat)
-        {
-            const char *suf = (bits == 32 ? "ss" : "sd");
-
+        // 4. Cast both sides to the common type
+        rl = castValue(rl, t1, tr, node->scope, out);
+        restoreIfSpilled(rl, node->scope, out);
+        rr = castValue(rr, t2, tr, node->scope, out);
+        restoreIfSpilled(rr, node->scope, out);
+
+        // 5. Floating‑point operations?
+        if (tr.isFloat) {
+            bool isF32 = (tr.bits == 32);
+            std::string vsuf = isF32 ? "ss" : "sd";  // movss/movsd, addss/addsd...
+            std::string instr;
             if (op == "+")
-                out << "    add" << suf << " " << rl << ", " << rr << "\n";
+                instr = "add" + vsuf;
             else if (op == "-")
-                out << "    sub" << suf << " " << rl << ", " << rr << "\n";
+                instr = "sub" + vsuf;
             else if (op == "*")
-                out << "    mul" << suf << " " << rl << ", " << rr << "\n";
+                instr = "mul" + vsuf;
             else if (op == "/")
-                out << "    div" << suf << " " << rl << ", " << rr << "\n";
-            else if (assembly_comparison_operations.count(op))
-            {
-                out << "    ucomi" << suf << " " << rl << ", " << rr << "\n";
-                auto result = alloc.allocate();
-                auto result8 = adjustReg(result, 8);
-                out << "    " << assembly_comparison_operations.at(op) << " " << result8 << "\n";
-                out << "    movzx " << result << ", " << result8 << "\n";
-                alloc.free(rl);
+                instr = "div" + vsuf;
+            else if (assembly_comparison_operations.count(op)) {
+                // unordered compare + setcc
+                std::string ucom = "ucomi" + vsuf;  // ucomiss / ucomisd
+                out << "    " << ucom << " " << rl << ", " << rr << "\n"
+                    << "    " << assembly_comparison_operations.at(op) << " al\n";
+                // alloc bool
+                TypeInfo boolType = node->scope->lookupType("boolean");
+                std::string r_bool = allocateOrSpill(false, node->scope, out);
+                out << "    movzx " << r_bool << ", al\n";
+                noteType(r_bool, boolType);
                 alloc.free(rr);
-                noteType(result, node->scope->lookupType("boolean"));
-                return result;
-            }
-            else
-            {
-                throw std::runtime_error("Unsupported FP op: " + op);
+                alloc.free(rl);
+                return r_bool;
+            } else {
+                throw std::runtime_error("Unsupported FP op " + op);
             }
 
+            // binary fp op
+            out << "    " << instr << " " << rl << ", " << rr << "\n";
             alloc.free(rr);
             noteType(rl, tr);
             return rl;
         }
-        else
-        {
-            std::string dl = rl;
-            std::string dr = rr;
 
-            if (op == "+")
-                out << "    add " << dl << ", " << dr << "\n";
-            else if (op == "-")
-                out << "    sub " << dl << ", " << dr << "\n";
-            else if (op == "*")
-                out << "    imul " << dl << ", " << dr << "\n";
-            else if (op == "/")
-            {
-                auto temp = alloc.allocate();
-                out << "    mov " << temp << ", rax\n";
-                out << "    mov rax, " << dl << "\n";
-                out << "    cqo\n";
-                out << "    idiv " << dr << "\n";
-                out << "    mov " << dl << ", rax\n";
-                out << "    mov rax, " << temp << "\n";
-                alloc.free(temp);
-                alloc.free(rr);
-                noteType(dl, tr);
-                return dl;
-            }
-            else if (assembly_comparison_operations.count(op))
-            {
-                out << "    cmp " << dl << ", " << dr << "\n";
-                auto result = alloc.allocate();
-                auto result8 = adjustReg(result, 8);
-                out << "    " << assembly_comparison_operations.at(op) << " " << result8 << "\n";
-                out << "    movzx " << result << ", " << result8 << "\n";
+        // 6. Integer operations
+        char suf = integer_suffixes.at(tr.bits);  // e.g. 'q' for 64, 'l' for 32
+        std::string adj_l = adjustReg(rl, tr.bits);
+        std::string adj_r = adjustReg(rr, tr.bits);
+
+        if (op == "+" || op == "-" || op == "*" || op == "/") {
+            if (op == "+") {
+                out << "    add" << " " << adj_l << ", " << adj_r << "\n";
+            } else if (op == "-") {
+                out << "    sub" << " " << adj_l << ", " << adj_r << "\n";
+            } else if (op == "*") {
+                out << "    imul" << " " << adj_l << ", " << adj_r << "\n";
+            } else {
+                // division
+                if (tr.isSigned) {
+                    // signed: RDX:RAX ← RAX / src
+                    out << "    mov" << " rax, " << adj_l << "\n"
+                        << "    cqo\n"  // sign‑extend RAX→RDX:RAX
+                        << "    idiv" << " " << adj_r << "\n"
+                        << "    mov" << " " << adj_l << ", rax\n";
+                } else {
+                    // unsigned
+                    out << "    mov" << " rax, " << adj_l << "\n"
+                        << "    xor rdx, rdx\n"
+                        << "    div" << " " << adj_r << "\n"
+                        << "    mov" << " " << adj_l << ", rax\n";
+                }
                 alloc.free(rr);
-                noteType(result, node->scope->lookupType("boolean"));
-                return result;
-            }
-            else
-            {
-                throw std::runtime_error("Unsupported integer op: " + op);
+                noteType(rl, tr);
+                return rl;
             }
 
             alloc.free(rr);
             noteType(rl, tr);
             return rl;
         }
+
+        // 7. Integer comparison?
+        if (assembly_comparison_operations.count(op)) {
+            std::string cmpInstr = "cmp";
+            out << "    " << cmpInstr << " " << adj_l << ", " << adj_r << "\n"
+                << "    " << assembly_comparison_operations.at(op) << " al\n";
+            TypeInfo boolType = node->scope->lookupType("boolean");
+            std::string r_bool = allocateOrSpill(false, node->scope, out);
+            out << "    movzx " << r_bool << ", al\n";
+            alloc.free(rr);
+            alloc.free(rl);
+            return r_bool;
+        }
+
+        // 8. Bitwise/logical ops: &&, ||, &, |
+        if (op == "&&" || op == "||" || op == "&" || op == "|") {
+            std::string instr = (op == "&&" ? "and" : op == "||" ? "or"
+                                                                 : op);
+            out << "    " << instr << suf << " " << adj_l << ", " << adj_r << "\n";
+            alloc.free(rr);
+            noteType(rl, tr);
+            return rl;
+        }
+
+        throw std::runtime_error("Unsupported int op " + op);
     }
-    std::string CodeGenWindows::generateUnaryOperation(std::unique_ptr<ASTNode> node)
-    {
+    std::string CodeGenWindows::generateUnaryOperation(std::unique_ptr<ASTNode> node, std::ostringstream &out) {
         const std::string &op = node->value;
-        auto child = std::move(node->children[0]);
+        if (op != "!" && op != "++" && op != "--")
+            throw std::runtime_error("Unsupported unary operator: " + op);
 
-        if (op == "!")
-        {
-            std::string r = emitExpression(std::move(child));
-            TypeInfo t = regType.at(r);
+        if (op == "!") {
+            // logical not
+            std::string r = emitExpression(std::move(node->children[0]), out);
+            restoreIfSpilled(r, node->scope, out);
 
-            // Cast value to boolean-compatible type (e.g., integer of any size)
             TypeInfo boolType = node->scope->lookupType("boolean");
-            r = castValue(r, t, boolType);
-
-            out << "    cmp " << r << ", 0\n";
+            r = castValue(r, regType.at(r), boolType, node->scope, out);
+            restoreIfSpilled(r, node->scope, out);
 
-            std::string result = alloc.allocate();
-            std::string result8 = adjustReg(result, 8);
-
-            out << "    sete " << result8 << "\n";
-            out << "    movzx " << result << ", " << result8 << "\n";
+            std::string res = allocateOrSpill(false, node->scope, out);
+            out << "    cmp BYTE PTR " << adjustReg(r, 8) << ", 0\n"
+                << "    sete al\n"
+                << "    movzx " << res << ", al\n";
+            noteType(res, boolType);
 
             alloc.free(r);
-            noteType(result, boolType);
-            return result;
+            return res;
         }
-        else if (op == "++" || op == "--")
-        {
-            if (child->type != NodeType::VariableAccess)
-                throw std::runtime_error(op + " can only be applied to variables");
 
-            std::string var = child->value;
-            auto &scp = *child->scope;
-            TypeInfo ti = scp.lookupType(scp.lookupVariable(var).type);
-
-            if (ti.isFloat)
-                throw std::runtime_error("Increment/Decrement not supported on float");
-
-            std::string reg = generateVariableAccess(std::move(child));
-            reg = castValue(reg, regType.at(reg), ti); // Ensure reg is properly typed
-            std::string adj = adjustReg(reg, ti.bits);
-
-            out << "    " << (op == "++" ? "inc" : "dec") << " " << adj << "\n";
+        // ++ or -- must be applied to a variable
+        auto child = std::move(node->children[0]);
+        if (child->type != NodeType::VariableAccess)
+            throw std::runtime_error(op + " can only be applied to variables");
 
-            std::string ptrSize;
-            switch (ti.bits)
-            {
-            case 64:
-                ptrSize = "QWORD PTR ";
-                break;
-            case 32:
-                ptrSize = "DWORD PTR ";
-                break;
-            case 16:
-                ptrSize = "WORD PTR ";
-                break;
-            case 8:
-                ptrSize = "BYTE PTR ";
-                break;
-            default:
-                throw std::runtime_error("Unsupported variable size: " + std::to_string(ti.bits));
-            }
+        auto &scp = *child->scope;
+        std::string varName = child->value;
+        TypeInfo ti = scp.lookupType(scp.lookupVariable(varName).type);
+        if (ti.isFloat)
+            throw std::runtime_error(op + " not supported on float");
+
+        // Compute address
+        std::string ptr;
+        if (scp.isGlobalVariable(varName)) {
+            ptr = "[" + varName + "]";
+        } else {
+            int64_t off = std::abs(scp.getVariableOffset(varName));
+            ptr = "[rbp - " + std::to_string(off) + "]";
+        }
+        // Load variable
+        std::string r = allocateOrSpill(false, node->scope, out);
+        std::string adj = adjustReg(r, ti.bits);
+        out << "    mov" << " " << adj << ", " << ptr << "\n";
 
-            std::string addr = getVariableAddress(scp, var);
-            out << "    mov " << ptrSize << addr << ", " << adj << "\n";
+        // inc/dec
+        out << "    " << (op == "++" ? "inc" : "dec") << " " << adj << "\n";
 
-            noteType(reg, ti);
-            return reg;
-        }
+        // store back
+        out << "    mov" << " " << ptr << ", " << adj << "\n";
 
-        throw std::runtime_error("Unknown Unary Operator: " + op);
+        noteType(adj, ti);
+        return adj;
     }
-    std::string CodeGenWindows::emitExpression(std::unique_ptr<ASTNode> node)
-    {
-        switch (node->type)
-        {
+    std::string CodeGenWindows::emitExpression(std::unique_ptr<ASTNode> node, std::ostringstream &out) {
+        switch (node->type) {
         case NodeType::IntegerLiteral:
-            return generateIntegerLiteral(std::move(node));
+            return generateIntegerLiteral(std::move(node), out);
         case NodeType::FloatLiteral:
-            return generateFloatLiteral(std::move(node));
+            return generateFloatLiteral(std::move(node), out);
         case NodeType::StringLiteral:
-            return generateStringLiteral(std::move(node));
+            return generateStringLiteral(std::move(node), out);
         case NodeType::BooleanLiteral:
-            return generateBooleanLiteral(std::move(node));
+            return generateBooleanLiteral(std::move(node), out);
         case NodeType::VariableAccess:
-            return generateVariableAccess(std::move(node));
+            return generateVariableAccess(std::move(node), out);
         case NodeType::BinaryOp:
-            return generateBinaryOperation(std::move(node));
+            return generateBinaryOperation(std::move(node), out);
         case NodeType::UnaryOp:
-            return generateUnaryOperation(std::move(node));
+            return generateUnaryOperation(std::move(node), out);
+        case NodeType::FunctionCall:
+            return generateFunctionCall(std::move(node), out);
         default:
-            throw std::runtime_error("Unknown expression encountered.");
+            throw std::runtime_error("Unknown statement encountered.");
         }
     }
-    void CodeGenWindows::emitPrologue(std::unique_ptr<ASTNode> blockNode)
-    {
-        auto size = -blockNode->scope->stackOffset + 32; // +32 for shadow space
-        out << "    ; Block Starts (scope enter)\n";
-        out << "    push rbp\n";
-        out << "    mov rbp, rsp\n";
-        out << "    sub rsp, " << size << "\n";
+
+    std::string formatHex32(uint32_t value) {
+        std::ostringstream oss;
+        oss << std::hex << value;
+        std::string s = oss.str();
+        if (!s.empty()) {
+            char first = s[0];
+            if ((first >= 'a' && first <= 'f') || 
+                (first >= 'A' && first <= 'F')) {
+                s = "0" + s;
+            }
+        }
+        return s + "h";
     }
-    void CodeGenWindows::emitEpilogue()
-    {
-        out << "    ; Block Ends (scope exit)\n";
-        out << "    leave\n";
+
+    void CodeGenWindows::emitPrologue(std::shared_ptr<ScopeContext> scope, std::ostringstream &out) {
+        if (scope->kind() != "Function")
+            return;
+
+        out << "    ; Function Prologue\n";
+        out << "    push    rbp\n";
+        out << "    mov     rbp, rsp\n";
+
+        auto funcScope = std::dynamic_pointer_cast<FunctionScope>(scope);
+        if (!funcScope)
+            throw std::runtime_error("Expected FunctionScope for function prologue");
+
+        // Compute sizes
+        std::uint64_t spillSize = std::abs(funcScope->getSpillSize());
+        std::uint64_t localSize = std::abs(funcScope->getStackOffset());
+        std::uint64_t rawSize = 8 + localSize + spillSize;
+        std::uint64_t stackReserve = (rawSize + 15) & ~15ULL;
+
+        uint64_t canary = funcScope->getCanary();
+        uint32_t low = static_cast<uint32_t>(canary);
+        uint32_t high = static_cast<uint32_t>(canary >> 32);
+
+        out << "    ; store canary as two 32-bit values\n";
+        out << "    mov     DWORD PTR [rbp-8], " << formatHex32(low) << "\n";
+        out << "    mov     DWORD PTR [rbp-4], " << formatHex32(high) << "\n";
+
+        // Reserve stack for locals + spills
+        if (stackReserve > 0) {
+            out << "    sub     rsp, "
+                << stackReserve
+                << "    ; reserve locals + spills\n";
+        }
+
+        // Save callee-saved GPRs
+        for (auto &reg : CALLEE_GPR_MSVC) {
+            out << "    push    " << reg
+                << "    ; save callee-saved GPR\n";
+        }
+
+        // 🔑 Align stack after odd number of GPR pushes
+        if (CALLEE_GPR_MSVC.size() % 2 != 0) {
+            out << "    sub     rsp, 8    ; align stack\n";
+        }
+
+        // Save callee-saved XMMs
+        for (auto &reg : CALLEE_XMM_MSVC) {
+            out << "    sub     rsp, 16\n";
+            out << "    movdqu  [rsp], " << reg << "\n";
+        }
     }
-    void CodeGenWindows::generateStatement(std::unique_ptr<ASTNode> statement)
-    {
-        switch (statement->type)
-        {
-        case NodeType::VariableReassignment:
-        {
-            generateVariableReassignment(std::move(statement));
+    void CodeGenWindows::emitEpilogue(std::shared_ptr<ScopeContext> scope, std::ostringstream &out, bool clearRax) {
+        if (scope->kind() != "Function")
+            return;
+
+        out << "    ; Function Epilogue with Canary Check\n";
+
+        auto funcScope = std::dynamic_pointer_cast<FunctionScope>(scope);
+        if (!funcScope)
+            throw std::runtime_error("Expected FunctionScope for function epilogue");
+
+        // Compute sizes
+        std::uint64_t spillSize = std::abs(funcScope->getSpillSize());
+        std::uint64_t localSize = std::abs(funcScope->getStackOffset());
+        std::uint64_t rawSize = 8 + localSize + spillSize;
+        std::uint64_t stackReserve = (rawSize + 15) & ~15ULL;
+
+        // Canary check
+        uint64_t canary = funcScope->getCanary();
+        uint32_t low_expected = static_cast<uint32_t>(canary);
+        uint32_t high_expected = static_cast<uint32_t>(canary >> 32);
+
+        std::string reg = adjustReg(allocateOrSpill(false, scope, out), 32);
+
+        out << "    mov     " << reg << ", DWORD PTR [rbp-8]    ; load stored low\n";
+        out << "    cmp     " << reg << ", " << formatHex32(low_expected) << "\n";
+        out << "    jne     __stack_smash_detected\n";
+
+        out << "    mov     " << reg << ", DWORD PTR [rbp-4]    ; load stored high\n";
+        out << "    cmp     " << reg << ", " << formatHex32(high_expected) << "\n";
+        out << "    jne     __stack_smash_detected\n";
+
+        alloc.free(reg);
+
+        // Restore XMM registers
+        for (auto it = CALLEE_XMM_MSVC.rbegin(); it != CALLEE_XMM_MSVC.rend(); ++it) {
+            out << "    movdqu  " << *it << ", [rsp]\n";
+            out << "    add     rsp, 16\n";
+        }
+
+        // 🔑 Undo stack alignment after GPR pushes
+        if (CALLEE_GPR_MSVC.size() % 2 != 0) {
+            out << "    add     rsp, 8    ; undo alignment\n";
+        }
+
+        // Restore callee-saved GPRs in reverse
+        for (auto it = CALLEE_GPR_MSVC.rbegin(); it != CALLEE_GPR_MSVC.rend(); ++it) {
+            out << "    pop     " << *it
+                << "    ; restore callee-saved GPR\n";
+        }
+
+        // Unwind stack frame
+        if (stackReserve > 0) {
+            out << "    add     rsp, "
+                << stackReserve
+                << "    ; free locals + spills\n";
+        }
+
+        // Zero RAX if required
+        if (clearRax) {
+            out << "    xor     rax, rax\n";
+        }
+
+        // Leave + ret
+        out << "    leave    ; mov rsp, rbp & pop rbp\n";
+        out << "    ret\n";
+    }
+
+    void CodeGenWindows::generateStatement(std::unique_ptr<ASTNode> statement, std::ostringstream &out) {
+        switch (statement->type) {
+        case NodeType::VariableReassignment: {
+            generateVariableReassignment(std::move(statement), out);
+            out << "\n";
             break;
         }
-        case NodeType::VariableDeclaration:
-        {
-            generateVariableDeclaration(std::move(statement));
+        case NodeType::VariableDeclaration: {
+            generateVariableDeclaration(std::move(statement), out);
+            out << "\n";
             break;
         }
-        case NodeType::IfStatement:
-        {
-            generateIfStatement(std::move(statement));
+        case NodeType::IfStatement: {
+            generateIfStatement(std::move(statement), out);
+            out << "\n";
             break;
         }
-        case NodeType::UnaryOp:
-        {
-            if (statement->value == "--" or statement->value == "++")
-            {
-                std::string reg = emitExpression(std::move(statement));
+        case NodeType::UnaryOp: {
+            std::string op = statement->value;
+            auto scope = statement->scope;
+            std::string reg = emitExpression(std::move(statement), out);
+            restoreIfSpilled(reg, scope, out);
+            if (op == "--" or op == "++") {
                 alloc.free(reg);
             }
+            out << "\n";
             break;
         }
-        case NodeType::BinaryOp:
-        {
-            std::string reg = emitExpression(std::move(statement)); // I am doing this just so the increments/decrements work in x + y-- -> this itself must not have any result, but y-- should still be effective.
+        case NodeType::BinaryOp: {
+            auto scope = statement->scope;
+            std::string reg = emitExpression(std::move(statement), out);  // I am doing this just so the increments/decrements work in x + y-- -> this itself must not have any result, but y-- should still be effective.
+            restoreIfSpilled(reg, scope, out);
             alloc.free(reg);
+            out << "\n";
+            break;
+        }
+        case NodeType::FunctionCall: {
+            std::string reg = generateFunctionCall(std::move(statement), out);
+            alloc.free(reg);
+            out << "\n";
+            break;
+        }
+        case NodeType::Function: {
+            generateFunctionDeclaration(std::move(statement), out);
+            out << "\n";
+            break;
+        }
+        case NodeType::ExternFunction: {
+            generateExternFunctionDeclaration(std::move(statement), out);
+            out << "\n";
+            break;
+        }
+        case NodeType::ReturnStatement: {
+            generateReturnstatement(std::move(statement), out);
+            out << "\n";
             break;
         }
         default:
             throw std::runtime_error("Unknown statement encountered.");
         }
     }
-    void CodeGenWindows::generateVariableReassignment(std::unique_ptr<ASTNode> statement)
-    {
-        auto &scope = *statement->scope;
-        const std::string &name = statement->value;
-        TypeInfo ti = scope.lookupType(scope.lookupVariable(name).type);
-        uint64_t bits = ti.bits;
-        std::string dest = getVariableAddress(scope, name);
-
-        std::string r = emitExpression(std::move(statement->children.back()));
-        TypeInfo rt = regType.at(r);
-
-        r = castValue(r, rt, ti);
+    void CodeGenWindows::generateVariableReassignment(std::unique_ptr<ASTNode> statement, std::ostringstream &out) {
+        auto &scp = *statement->scope;
+        const std::string name = statement->value;
+        TypeInfo ti = scp.lookupType(scp.lookupVariable(name).type);
+        uint64_t sz = ti.bits / 8;
 
-        if (ti.isFloat)
-        {
-            std::string movInstr = (bits == 32 ? "movss" : "movsd");
-            std::string ptrPrefix = (bits == 32 ? "DWORD PTR " : "QWORD PTR ");
-            out << "    " << movInstr << " "
-                << ptrPrefix << dest << ", " << r << "\n";
-            alloc.free(r);
+        // Evaluate RHS expression
+        std::string r = emitExpression(std::move(statement->children.back()), out);
+        restoreIfSpilled(r, statement->scope, out);
+
+        // Cast to the variable's type
+        r = castValue(r, regType.at(r), ti, statement->scope, out);
+        restoreIfSpilled(r, statement->scope, out);
+
+        // Determine memory operand
+        std::string mem;
+        if (scp.isGlobalVariable(name)) {
+            mem = "[" + name + "]";
+        } else {
+            int64_t off = std::abs(scp.getVariableOffset(name));
+            mem = "[rbp - " + std::to_string(off) + "]";
         }
-        else
-        {
-            std::string adj = adjustReg(r, bits);
-            std::string ptrPrefix;
-            switch (bits)
-            {
-            case 64:
-                ptrPrefix = "QWORD PTR ";
-                break;
-            case 32:
-                ptrPrefix = "DWORD PTR ";
-                break;
-            case 16:
-                ptrPrefix = "WORD PTR ";
-                break;
-            case 8:
-                ptrPrefix = "BYTE PTR ";
-                break;
-            default:
-                throw std::runtime_error("Unsupported size in reassignment: " + std::to_string(bits));
+
+        // Emit store based on size and type
+        if (ti.isFloat) {
+            if (sz == 4) {
+                out << "    movss DWORD PTR " << mem << ", " << r << "\n";
+            } else {
+                out << "    movsd QWORD PTR " << mem << ", " << r << "\n";
+            }
+        } else {
+            switch (sz) {
+                case 1:
+                    out << "    mov     BYTE PTR " << mem << ", " << r << "\n";
+                    break;
+                case 2:
+                    out << "    mov     WORD PTR " << mem << ", " << r << "\n";
+                    break;
+                case 4:
+                    out << "    mov     DWORD PTR " << mem << ", " << r << "\n";
+                    break;
+                case 8:
+                default:
+                    out << "    mov     QWORD PTR " << mem << ", " << r << "\n";
+                    break;
             }
-            out << "    mov " << ptrPrefix << dest << ", " << adj << "\n";
-            alloc.free(r);
         }
+
+        alloc.free(r);
     }
-    void CodeGenWindows::generateVariableDeclaration(std::unique_ptr<ASTNode> statement)
-    {
-        auto &scope = *statement->scope;
-        const std::string &name = statement->value;
-        TypeInfo ti = scope.lookupType(scope.lookupVariable(name).type);
-        uint64_t bits = ti.bits;
 
-        auto ptrPrefix = [&]() -> std::string
-        {
-            switch (bits)
-            {
-            case 64:
-                return "QWORD PTR ";
-            case 32:
-                return "DWORD PTR ";
-            case 16:
-                return "WORD PTR ";
-            case 8:
-                return "BYTE PTR ";
-            default:
-                throw std::runtime_error("Unsupported size in declaration: " + std::to_string(bits));
+    void CodeGenWindows::generateVariableDeclaration(std::unique_ptr<ASTNode> statement, std::ostringstream &out) {
+        auto &scp = *statement->scope;
+        const std::string name = statement->value;
+        TypeInfo ti = scp.lookupType(scp.lookupVariable(name).type);
+        uint64_t sz = ti.bits / 8;  // bytes
+
+        // Compute memory operand
+        std::string mem = scp.isGlobalVariable(name)
+            ? ("[" + name + "]")
+            : ("[rbp - " + std::to_string(std::abs(scp.getVariableOffset(name))) + "]");
+
+        // Lambda to emit store
+        auto emitStore = [&](const std::string &r) {
+            if (ti.isFloat) {
+                if (sz == 4) {
+                    out << "    movss DWORD PTR " << mem << ", " << r << "\n";
+                } else {
+                    out << "    movsd QWORD PTR " << mem << ", " << r << "\n";
+                }
+            } else {
+                switch (sz) {
+                    case 1:
+                        out << "    mov     BYTE PTR " << mem << ", " << adjustReg(r, sz*8) << "\n";
+                        break;
+                    case 2:
+                        out << "    mov     WORD PTR " << mem << ", " << adjustReg(r, sz*8) << "\n";
+                        break;
+                    case 4:
+                        out << "    mov     DWORD PTR " << mem << ", " << adjustReg(r, sz*8) << "\n";
+                        break;
+                    case 8:
+                    default:
+                        out << "    mov     QWORD PTR " << mem << ", " << adjustReg(r, sz*8) << "\n";
+                        break;
+                }
             }
         };
 
-        if (statement->children.size() >= 2)
-        {
-            std::string r = emitExpression(std::move(statement->children.back()));
-            TypeInfo rt = regType.at(r);
-            r = castValue(r, rt, ti);
+        if (statement->children.size() >= 2) {
+            std::string r = emitExpression(std::move(statement->children.back()), out);
+            restoreIfSpilled(r, statement->scope, out);
 
-            std::string addr = getVariableAddress(scope, name);
-            if (ti.isFloat)
-            {
-                std::string movInstr = (bits == 32 ? "movss" : "movsd");
-                out << "    " << movInstr << " "
-                    << ptrPrefix() << addr << ", " << r << "\n";
-            }
-            else
-            {
-                std::string adj = adjustReg(r, bits);
-                out << "    mov " << ptrPrefix() << addr << ", " << adj << "\n";
-            }
+            r = castValue(r, regType.at(r), ti, statement->scope, out);
+            restoreIfSpilled(r, statement->scope, out);
+
+            emitStore(r);
             alloc.free(r);
-        }
-        else
-        {
-            std::string addr = getVariableAddress(scope, name);
-            if (ti.isFloat)
-            {
-                std::string r_xmm = alloc.allocateXMM();
-                std::string movInstr = (bits == 32 ? "movss" : "movsd");
-                out << "    pxor " << r_xmm << ", " << r_xmm << "\n"
-                    << "    " << movInstr << " "
-                    << ptrPrefix() << addr << ", " << r_xmm << "\n";
+        } else {
+            if (ti.isFloat) {
+                std::string r_xmm = allocateOrSpill(true, statement->scope, out);
+                out << "    pxor    " << r_xmm << ", " << r_xmm << "\n";
+                emitStore(r_xmm);
                 alloc.free(r_xmm);
-            }
-            else
-            {
-                out << "    xor rax, rax\n"
-                    << "    mov " << ptrPrefix() << addr << ", rax\n";
+            } else {
+                // Zero-initialize integer of size sz
+                switch (sz) {
+                    case 1:
+                        out << "    mov     BYTE PTR " << mem << ", 0\n";
+                        break;
+                    case 2:
+                        out << "    mov     WORD PTR " << mem << ", 0\n";
+                        break;
+                    case 4:
+                        out << "    mov     DWORD PTR " << mem << ", 0\n";
+                        break;
+                    case 8:
+                    default:
+                        out << "    xor     rax, rax\n";
+                        out << "    mov     QWORD PTR " << mem << ", rax\n";
+                        break;
+                }
             }
         }
     }
-    void CodeGenWindows::generateIfStatement(std::unique_ptr<ASTNode> statement)
-    {
+    void CodeGenWindows::generateIfStatement(std::unique_ptr<ASTNode> statement, std::ostringstream &out) {
         int id = blockLabelCount++;
         std::string endLbl = "Lend" + std::to_string(id);
+        std::vector<std::string> elseLbls;
 
-        std::vector<std::string> elseLabels;
+        // Precompute labels for all else‑if / else branches
         ASTNode *branch = statement->getElseBranch();
-        while (branch)
-        {
-            elseLabels.push_back("Lelse" + std::to_string(blockLabelCount++));
+        while (branch) {
+            elseLbls.push_back("Lelse" + std::to_string(blockLabelCount++));
             branch = branch->getElseBranch();
         }
 
         size_t elseIdx = 0;
 
-        auto condReg = emitExpression(std::move(statement->children[0]));
-        out << "    cmp " << condReg << ", 0\n";
-        if (!elseLabels.empty())
-            out << "    je " << elseLabels[elseIdx] << "\n";
-        else
-            out << "    je " << endLbl << "\n";
-        alloc.free(condReg);
-
-        auto ifBlock = std::move(statement->children[1]);
-        auto stmts = std::move(ifBlock->children);
-        emitPrologue(std::move(ifBlock));
-        for (auto &stmt : stmts)
-            generateStatement(std::move(stmt));
-        emitEpilogue();
-        out << "    jmp " << endLbl << "\n";
+        // --- IF branch ---
+        std::string condR = emitExpression(std::move(statement->children[0]), out);
+        restoreIfSpilled(condR, statement->scope, out);
+
+        // cmp condR, 0
+        out << "    cmp     " << condR << ", 0\n";
+        // je to first else (or end)
+        out << "    je      " << (elseLbls.empty() ? endLbl : elseLbls[elseIdx]) << "\n";
+        alloc.free(condR);
+
+        // then‑block
+        auto ifBlk = std::move(statement->children[1]);
+        emitPrologue(ifBlk->scope, out);
+        for (auto &stmt : ifBlk->children) {
+            generateStatement(std::move(stmt), out);
+        }
+        emitEpilogue(ifBlk->scope, out);
+        // jump past else‐chains
+        out << "    jmp     " << endLbl << "\n";
 
+        // --- ELSE‑IF / ELSE branches ---
         branch = statement->getElseBranch();
-        while (branch)
-        {
-            out << elseLabels[elseIdx++] << ":\n";
-
-            if (branch->type == NodeType::ElseIfStatement)
-            {
-                auto r = emitExpression(std::move(branch->children[0]));
-                out << "    cmp " << r << ", 0\n";
-                if (elseIdx < elseLabels.size())
-                    out << "    je " << elseLabels[elseIdx] << "\n";
-                else
-                    out << "    je " << endLbl << "\n";
-                alloc.free(r);
-
-                auto elifBlock = std::move(branch->children[1]);
-                auto stmts = std::move(elifBlock->children);
-                emitPrologue(std::move(elifBlock));
-                for (auto &stmt : stmts)
-                    generateStatement(std::move(stmt));
-                emitEpilogue();
-                out << "    jmp " << endLbl << "\n";
-            }
-            else if (branch->type == NodeType::ElseStatement)
-            {
-                auto elseBlock = std::move(branch->children[0]);
-                auto stmts = std::move(elseBlock->children);
-                emitPrologue(std::move(elseBlock));
-                for (auto &stmt : stmts)
-                    generateStatement(std::move(stmt));
-                emitEpilogue();
-                break;
-            }
-            else
-            {
-                throw std::runtime_error("Unexpected node type in else chain");
+        while (branch) {
+            out << elseLbls[elseIdx++] << ":\n";
+
+            if (branch->type == NodeType::ElseIfStatement) {
+                // test elseif condition
+                std::string r2 = emitExpression(std::move(branch->children[0]), out);
+                restoreIfSpilled(r2, branch->scope, out);
+                out << "    cmp     " << r2 << ", 0\n";
+                // je to next else / end
+                std::string nextLbl = (elseIdx < elseLbls.size()
+                                           ? elseLbls[elseIdx]
+                                           : endLbl);
+                out << "    je      " << nextLbl << "\n";
+                alloc.free(r2);
+
+                // elseif‑block
+                auto elifBlk = std::move(branch->children[1]);
+                emitPrologue(elifBlk->scope, out);
+                for (auto &stmt : elifBlk->children) {
+                    generateStatement(std::move(stmt), out);
+                }
+                emitEpilogue(elifBlk->scope, out);
+                out << "    jmp     " << endLbl << "\n";
+            } else if (branch->type == NodeType::ElseStatement) {
+                // else‑block
+                auto elseBlk = std::move(branch->children[0]);
+                emitPrologue(elseBlk->scope, out);
+                for (auto &stmt : elseBlk->children) {
+                    generateStatement(std::move(stmt), out);
+                }
+                emitEpilogue(elseBlk->scope, out);
             }
 
             branch = branch->getElseBranch();
         }
 
+        // end label
         out << endLbl << ":\n\n";
     }
-    void CodeGenWindows::generate(std::unique_ptr<ASTNode> program)
-    {
-        std::vector<ASTNode *> globals;
-        for (auto &statement : program->children)
-            if (statement->type == NodeType::VariableDeclaration)
-                globals.push_back(statement.get());
+    void CodeGenWindows::generate(std::unique_ptr<ASTNode> program) {
+        std::vector<ASTNode*> globals;
 
-        outGlobal << ".data\n\n";
+        // collect globals
+        for (auto &stmt : program->children) {
+            if (stmt->type == NodeType::VariableDeclaration) {
+                globals.push_back(stmt.get());
+            }
+        }
 
+        // --- .DATA segment (read-write globals) ---
+        outGlobalStream << ".data\n\n";
         for (auto &g : globals)
         {
             TypeInfo info = g->scope->lookupType(g->children[0]->value);
             switch (info.bits / 8)
             {
             case 8:
-                outGlobal << g->value << " QWORD 0\n";
+                outGlobalStream << g->value << " QWORD 0\n";
                 break;
             case 4:
-                outGlobal << g->value << " DWORD 0\n";
+                outGlobalStream << g->value << " DWORD 0\n";
                 break;
             case 2:
-                outGlobal << g->value << " WORD 0\n";
+                outGlobalStream << g->value << " WORD 0\n";
                 break;
             case 1:
-                outGlobal << g->value << " BYTE 0\n";
+                outGlobalStream << g->value << " BYTE 0\n";
                 break;
             default:
                 throw std::runtime_error("Unsupported global size");
             }
         }
 
-        outGlobal << "\n.const\n";
+        outGlobalStream << "\n.const\n";
+        
+        // --- .CODE segment ---
+        outStream << ".code\n";
+
+        // emit stack-smash handler (define only, no EXTERN)
+        outStream << "__stack_smash_detected PROC\n"
+                << "    mov     rax, 60       ; syscall: exit\n"
+                << "    mov     rdi, 69       ; exit code\n"
+                << "    syscall\n"
+                << "    ret\n"
+                << "__stack_smash_detected ENDP\n\n";
+
+        // collect main and top-level init statements
+        std::unique_ptr<ASTNode> mainFn;
+        std::vector<std::unique_ptr<ASTNode>> initStmts;
+        for (auto &stmt : program->children) {
+            if (stmt->type == NodeType::Function && stmt->value == "main") {
+                mainFn = std::move(stmt);
+            } else if (stmt->type == NodeType::VariableDeclaration || stmt->type == NodeType::VariableReassignment
+                    || (stmt->type == NodeType::UnaryOp && (stmt->value == "++" || stmt->value == "--"))) {
+                initStmts.push_back(std::move(stmt));
+            } else {
+                generateStatement(std::move(stmt), outStream);
+            }
+        }
 
-        out << ".code\n";
-        out << "main PROC\n";
+        // emit main
+        outStream << "main PROC\n";
+        for (auto &s : initStmts) {
+            generateStatement(std::move(s), outStream);
+        }
+        generateFunctionDeclaration(std::move(mainFn), outStream, /*force=*/true);
+        outStream << "    ret\n";
+        outStream << "main ENDP\n\n";
+
+        // finalize with END directive
+        outfinal << outGlobalStream.str()
+                << "; ============== Globals End Here ==============\n\n"
+                << outStream.str()
+                << "\nEND\n";
+    }
 
-        for (std::unique_ptr<ASTNode> &statement : program.get()->children)
-        {
-            generateStatement(std::move(statement));
+    std::string CodeGenWindows::generateFunctionCall(std::unique_ptr<ASTNode> node, std::ostringstream &out) {
+        // 1) Lookup target and args
+        auto fnInfo = node->scope->lookupFunction(node->value);
+        const std::string label = fnInfo.isExtern ? node->value : fnInfo.label;
+        auto &args = node->children[0]->children;
+        const auto &params = fnInfo.paramTypes;
+
+        // 2) Save caller‑saved GPRs
+        std::vector<std::string> savedGPR;
+        for (auto &reg : CALLER_GPR_MSVC) {
+            if (alloc.isInUse(reg)) {
+                out << "    push    " << reg << "    ; save caller GPR\n";
+                savedGPR.push_back(reg);
+            }
         }
 
-        out << "    xor eax, eax\n";
-        out << "    ret\n";
+        // 3) Save caller‑saved XMMs
+        std::vector<std::pair<std::string, std::string>> savedXMM;
+        for (auto &reg : CALLER_XMM_MSVC) {
+            if (alloc.isInUseXMM(reg)) {
+                auto funcScope = std::static_pointer_cast<FunctionScope>(
+                    node->scope->findEnclosingFunctionScope());
+                std::string slot = funcScope->allocateSpillSlot(16,
+                                                                CodegenOutputFormat::X86_64_MSWIN);
+                alloc.markSpilledXMM(reg, slot);
+                out << "    movdqu  " << reg
+                    << ", XMMWORD PTR " << slot
+                    << "    ; spill caller XMM\n";
+                savedXMM.emplace_back(reg, slot);
+            }
+        }
+
+        // 4) Compute stack‐space needed for overflow args
+        uint64_t gpCount = 0, xmmCount = 0, stackOff = 0;
+        for (size_t i = 0; i < args.size(); ++i) {
+            bool isFloat = (i < params.size())
+                            ? node->scope->lookupType(params[i].type).isFloat
+                            : (fnInfo.isVariadic ? false
+                                                    : throw std::runtime_error(
+                                                        "Too many args"));
+            if (!isFloat) {
+                if (gpCount < ARG_GPR_MSVC.size())
+                    gpCount++;
+                else
+                    stackOff += 8;
+            } else {
+                if (xmmCount < ARG_XMM_MSVC.size())
+                    xmmCount++;
+                else
+                    stackOff += 8;
+            }
+        }
+        uint64_t stackReserve = (stackOff + 15) & ~15ULL;
+        if (stackReserve) {
+            out << "    sub     rsp, " << stackReserve
+                << "    ; reserve arg stack\n";
+        }
+
+        std::vector<std::pair<int, std::string>> shadowDuplicates;
+
+        // 5) Materialize arguments
+        gpCount = xmmCount = stackOff = 0;
+        std::vector<std::string> reservedArgs;
+        std::vector<std::string> spilledArgs;
+
+        for (size_t i = 0; i < args.size(); ++i) {
+            // evaluate and cast
+            std::string src = emitExpression(std::move(args[i]), out);
+            restoreIfSpilled(src, node->scope, out);
+            TypeInfo passed = regType.at(src);
+            TypeInfo expect =
+                (i < params.size())
+                    ? node->scope->lookupType(params[i].type)
+                    : (fnInfo.isVariadic
+                        ? (passed.isFloat
+                                ? node->scope->lookupType("double")
+                                : node->scope->lookupType("int64_t"))
+                        : throw std::runtime_error("Too many args"));
+            std::string cvt = castValue(src, passed, expect, node->scope, out);
+            restoreIfSpilled(cvt, node->scope, out);
+
+            bool isF = expect.isFloat;
+            // GPR args
+            if (!isF && gpCount < ARG_GPR_MSVC.size()) {
+                std::string dst = ARG_GPR_MSVC[gpCount];
+                if (alloc.isInUseArgument(dst)) {
+                    auto funcScope = std::static_pointer_cast<FunctionScope>(
+                        node->scope->findEnclosingFunctionScope());
+                    std::string slot = funcScope->allocateSpillSlot(8,
+                                                                    CodegenOutputFormat::X86_64_MSWIN);
+                    alloc.markSpilled(dst, slot);
+                    spilledArgs.push_back(dst);
+                    out << "    mov     QWORD PTR " << slot
+                        << ", " << dst
+                        << "    ; spill arg GPR\n";
+                } else {
+                    dst = alloc.allocateArgument(gpCount);
+                    reservedArgs.push_back(dst);
+                }
+                out << "    mov     " << dst
+                    << ", " << cvt
+                    << "\n";
+                gpCount++;
+            }
+            // XMM args
+            else if (isF && xmmCount < ARG_XMM_MSVC.size()) {
+                std::string dst = ARG_XMM_MSVC[xmmCount];
+                if (alloc.isInUseArgumentXMM(dst)) {
+                    auto funcScope = std::static_pointer_cast<FunctionScope>(
+                        node->scope->findEnclosingFunctionScope());
+                    std::string slot = funcScope->allocateSpillSlot(16,
+                                                                    CodegenOutputFormat::X86_64_MSWIN);
+                    alloc.markSpilledXMM(dst, slot);
+                    spilledArgs.push_back(dst);
+                    out << "    movdqu  " << dst
+                        << ", XMMWORD PTR " << slot
+                        << "    ; spill arg XMM\n";
+                } else {
+                    dst = alloc.allocateArgumentXMM(xmmCount);
+                    reservedArgs.push_back(dst);
+                }
+
+                out << "    movsd   " << dst << ", " << cvt << "\n";
+
+                // CORRECTED: Use argument index (i) instead of xmmCount
+                if (fnInfo.isVariadic && i < 4) {
+                    static const std::vector<std::string> VARIADIC_FLOAT_GPRS = { "rcx", "rdx", "r8", "r9" };
+                    std::string gprDst = VARIADIC_FLOAT_GPRS[i];
+                    out << "    movq    " << gprDst << ", " << dst << "    ; duplicate variadic float to GPR\n";
+                    // Record for shadow space duplication
+                    shadowDuplicates.push_back({8 * static_cast<int>(i), dst});
+                }
+
+                xmmCount++;
+            }
+            // stack‐overflow args
+            else {
+                out << "    mov     QWORD PTR [rsp+" << stackOff << "], "
+                    << cvt << "\n";
+                stackOff += 8;
+            }
+
+            alloc.free(cvt);
+        }
+
+        // 6) Variadic‐ABI: number of float args in XMM
+        if (fnInfo.isVariadic) {
+            out << "    mov     rax, " << xmmCount
+                << "    ; variadic float count\n";
+        }
+
+        // CORRECTED: Calculate proper stack alignment (32+8=40)
+        uint64_t shadowAndAlign = 32;
+        out << "    sub     rsp, " << shadowAndAlign << "      ; 🔑 Allocate shadow space + alignment\n";
+        out << "    call    " << label << "\n";
+        out << "    add     rsp, " << shadowAndAlign << "      ; 🔑 Cleanup shadow space + alignment\n";
+
+        // 8) Restore spilled argument regs
+        for (auto &r : spilledArgs) {
+            restoreIfSpilled(r, node->scope, out);
+        }
+        for (auto &r : reservedArgs) {
+            alloc.freeArgument(r);
+        }
 
-        out << "main ENDP\n";
+        // 9) Restore caller‑saved XMMs & GPRs
+        for (auto it = savedXMM.rbegin(); it != savedXMM.rend(); ++it) {
+            out << "    movdqu  XMMWORD PTR " << it->second
+                << ", " << it->first
+                << "    ; restore XMM\n";
+        }
+        for (auto it = savedGPR.rbegin(); it != savedGPR.rend(); ++it) {
+            out << "    pop     " << *it
+                << "    ; restore GPR\n";
+        }
 
-        outfinal << outGlobal.str()
-                 << "\n; ============== Globals End Here ==============\n"
-                 << out.str() << "END\n\n";
+        // 10) Tear down arg stack
+        if (stackReserve) {
+            out << "    add     rsp, " << stackReserve
+                << "    ; pop arg stack\n";
+        }
+
+        // 11) Capture return
+        bool isFltRet = fnInfo.returnType == "float" || fnInfo.returnType == "double";
+        std::string holder = allocateOrSpill(isFltRet, node->scope, out);
+        noteType(holder, node->scope->lookupType(fnInfo.returnType));
+
+        if (isFltRet) {
+            const char *mov = (fnInfo.returnType == "float" ? "movss" : "movsd");
+            out << "    " << mov << " " << holder
+                << ", xmm0\n";
+        } else {
+            out << "    mov     " << holder
+                << ", rax\n";
+        }
+
+        return holder;
+    }
+    
+    void CodeGenWindows::generateFunctionDeclaration(std::unique_ptr<ASTNode> node, std::ostringstream &out, bool force) {        
+        if (node->value == "main" && !force)
+            return;
+
+        // Lookup signature & body
+        auto fnInfo = node->scope->lookupFunction(node->value);
+        auto bodyNode = node->getFunctionBody();
+        auto funcScope = std::dynamic_pointer_cast<FunctionScope>(
+            bodyNode->scope->findEnclosingFunctionScope());
+
+        if (!funcScope)
+            throw std::runtime_error("Expected FunctionScope for function declaration");
+
+        if(!force)
+            out << fnInfo.label << " PROC\n";
+
+        // Generate parameter moves into locals ([rbp - offset])
+        // Windows registers: RCX, RDX, R8, R9; XMM0–XMM3
+        static const std::vector<std::string> ARG_GPR_MS = {"rcx", "rdx", "r8", "r9"};
+        static const std::vector<std::string> ARG_XMM_MS = {"xmm0", "xmm1", "xmm2", "xmm3"};
+
+        // Build body before prologue so we can prefix it
+        std::ostringstream paramInit, body;
+
+        size_t gpIdx = 0, xmmIdx = 0, stackArgOffset = 0;
+        for (auto &p : fnInfo.paramTypes) {
+            TypeInfo ti = node->scope->lookupType(p.type);
+            bool isFlt = ti.isFloat;
+            int64_t slotOff = std::abs(bodyNode->scope->getVariableOffset(p.name));
+
+            // Select MOV instruction
+            std::string movInst;
+            if (isFlt)
+                movInst = (ti.bits == 64 ? "movsd" : "movss");
+            else
+                movInst = "mov     ";  // QWORD PTR implied by reg
+
+            if (!isFlt && gpIdx < ARG_GPR_MS.size()) {
+                // integer reg → local slot
+                paramInit
+                    << "    " << movInst
+                    << " QWORD PTR [rbp-" << slotOff << "], "
+                    << ARG_GPR_MS[gpIdx++] << "\n";
+            } else if (isFlt && xmmIdx < ARG_XMM_MS.size()) {
+                // xmm reg → local slot
+                paramInit
+                    << "    " << "movdqu"
+                    << " XMMWORD PTR [rbp-" << slotOff << "], "
+                    << ARG_XMM_MS[xmmIdx++] << "\n";
+            } else {
+                // spilled on caller’s stack at [rbp+16 + stackArgOffset]
+                int64_t callerDisp = 16 + stackArgOffset;
+                paramInit
+                    << "    " << movInst
+                    << (isFlt ? "XMMWORD PTR " : "QWORD PTR ")
+                    << "[rbp+" << callerDisp << "], "
+                    << (isFlt ? ARG_XMM_MS[xmmIdx++]
+                              : ARG_GPR_MS[gpIdx++])
+                    << "\n";
+                stackArgOffset += 8;
+            }
+        }
+
+        // Setup canary and stack frame
+        std::ostringstream prologue;
+        std::uint64_t canary = CanaryGenerator::generate();
+        funcScope->setCanary(canary);
+
+        // Generate the actual function body
+        std::vector<std::unique_ptr<ASTNode>> nestedFns;
+        for (auto &stmt : bodyNode->children) {
+            if (stmt->type == NodeType::Function) {
+                nestedFns.push_back(std::move(stmt));
+            } else {
+                generateStatement(std::move(stmt), body);
+            }
+        }
+
+
+        emitPrologue(funcScope, prologue);
+
+        // If void return, emit epilogue after body
+        std::ostringstream epilogue;
+        if (bodyNode->scope->returnType == "none") {
+            // Note: clearRax must be true for void
+            emitEpilogue(funcScope, epilogue, /*clearRax=*/true);
+        }
+
+        // Stitch it all together
+        out
+            << prologue.str()
+            << paramInit.str()
+            << body.str()
+            << epilogue.str();
+
+        // Nested functions follow
+        for (auto &nf : nestedFns) {
+            generateFunctionDeclaration(std::move(nf), out, /*force=*/false);
+        }
+
+        // End PROC
+        if(!force)
+        out << fnInfo.label << " ENDP\n\n";
+    }
+    void CodeGenWindows::generateExternFunctionDeclaration(std::unique_ptr<ASTNode> node, std::ostringstream &out) {
+        auto fnInfo = node->scope->lookupFunction(node->value);
+        const std::string &label = node->value;
+        outGlobalStream << "EXTERN  " << label << ":FAR\n";
+    }
+    void CodeGenWindows::generateReturnstatement(std::unique_ptr<ASTNode> node, std::ostringstream &out) {
+        std::string result = emitExpression(std::move(node->children[0]), out);
+
+        // Restore if spilled
+        auto funcScope = std::static_pointer_cast<FunctionScope>(
+            node->scope->findEnclosingFunctionScope());
+        restoreIfSpilled(result, funcScope, out);
+
+        // Perform any necessary casts
+        TypeInfo actual = regType.at(result);
+        TypeInfo expected = funcScope->lookupType(funcScope->returnType);
+        std::string casted = castValue(result, actual, expected, funcScope, out);
+        restoreIfSpilled(casted, funcScope, out);
+
+        // Move into the ABI return register
+        if (expected.name == "none") {
+            // void return: zero RAX
+            out << "    xor     rax, rax\n";
+        } else if (!expected.isFloat) {
+            // integer return
+            out << "    mov     rax, " << casted << "\n";
+        } else {
+            // floating‑point return
+            const char *mov = (expected.bits == 32 ? "movss" : "movsd");
+            out << "    " << mov << " xmm0, " << casted << "\n";
+        }
+        alloc.free(casted);
+        emitEpilogue(funcScope, out);
     }
-} // namespace zlang
\ No newline at end of file
+}  // namespace zlang
\ No newline at end of file
diff --git a/src/codegen/RegisterAllocator.cpp b/src/codegen/RegisterAllocator.cpp
index 5d1c627..de36943 100644
--- a/src/codegen/RegisterAllocator.cpp
+++ b/src/codegen/RegisterAllocator.cpp
@@ -1,41 +1,50 @@
 #include "all.hpp"
 
-namespace zlang
-{
-    RegisterAllocator::RegisterAllocator(std::vector<std::string> regs)
-        : available(std::move(regs))
-    {
+namespace zlang {
+    RegisterAllocator::RegisterAllocator(std::vector<std::string> regs, std::vector<std::string> XMMregs, std::vector<std::string> argumentRegs, std::vector<std::string> argumentXMMRegs)
+        : available(std::move(regs)), availableXMM(std::move(XMMregs)), availableArgumentRegs(std::move(argumentRegs)), availableArgumentRegsXMM(std::move(argumentXMMRegs)) {
     }
 
-    RegisterAllocator RegisterAllocator::forSysV()
-    {
-        // Exclude %rsp, %rbp; use caller-saved first
-        return RegisterAllocator({"rax", "rcx", "rdx", "rsi", "rdi", "r8", "r9", "r10", "r11"});
+    RegisterAllocator RegisterAllocator::forSysV() {
+        return RegisterAllocator(
+            SCRATCH_GPR_LINUX,
+            SCRATCH_XMM_LINUX,
+            ARG_GPR_LINUX,
+            ARG_XMM_LINUX);
     }
 
-    RegisterAllocator RegisterAllocator::forMSVC()
-    {
-        // Windows: volatile registers
-        return RegisterAllocator({"rax", "rcx", "rdx", "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"});
+    RegisterAllocator RegisterAllocator::forMSVC() {
+        return RegisterAllocator(
+            SCRATCH_GPR_MSVC,
+            SCRATCH_XMM_MSVC,
+            ARG_GPR_MSVC,
+            ARG_XMM_MSVC);
     }
 
-    std::string RegisterAllocator::allocate()
-    {
-        if (available.empty())
-            throw std::runtime_error("RegisterAllocator: no registers available");
+    std::string RegisterAllocator::allocate() {
+        if (available.empty()) {
+            throw std::runtime_error("No free general-purpose registers available");
+        }
         std::string reg = available.back();
         available.pop_back();
         inUse.insert(reg);
+        lruRegs.push_back(reg);
         return reg;
     }
 
-    std::string RegisterAllocator::getBaseReg(const std::string &reg)
-    {
+    bool RegisterAllocator::isInUse(std::string reg) {
+        return inUse.find(reg) != inUse.end();
+    }
+
+    bool RegisterAllocator::isInUseXMM(std::string reg) {
+        return inUseXMM.find(reg) != inUseXMM.end();
+    }
+
+    std::string RegisterAllocator::getBaseReg(const std::string &reg) {
         static const std::unordered_map<std::string, std::string> reg_to_base = {
             {"rax", "rax"}, {"eax", "rax"}, {"ax", "rax"}, {"al", "rax"}, {"rbx", "rbx"}, {"ebx", "rbx"}, {"bx", "rbx"}, {"bl", "rbx"}, {"rcx", "rcx"}, {"ecx", "rcx"}, {"cx", "rcx"}, {"cl", "rcx"}, {"rdx", "rdx"}, {"edx", "rdx"}, {"dx", "rdx"}, {"dl", "rdx"}, {"rsi", "rsi"}, {"esi", "rsi"}, {"si", "rsi"}, {"sil", "rsi"}, {"rdi", "rdi"}, {"edi", "rdi"}, {"di", "rdi"}, {"dil", "rdi"}, {"rbp", "rbp"}, {"ebp", "rbp"}, {"bp", "rbp"}, {"bpl", "rbp"}, {"rsp", "rsp"}, {"esp", "rsp"}, {"sp", "rsp"}, {"spl", "rsp"}, {"r8", "r8"}, {"r8d", "r8"}, {"r8w", "r8"}, {"r8b", "r8"}, {"r9", "r9"}, {"r9d", "r9"}, {"r9w", "r9"}, {"r9b", "r9"}, {"r10", "r10"}, {"r10d", "r10"}, {"r10w", "r10"}, {"r10b", "r10"}, {"r11", "r11"}, {"r11d", "r11"}, {"r11w", "r11"}, {"r11b", "r11"}, {"r12", "r12"}, {"r12d", "r12"}, {"r12w", "r12"}, {"r12b", "r12"}, {"r13", "r13"}, {"r13d", "r13"}, {"r13w", "r13"}, {"r13b", "r13"}, {"r14", "r14"}, {"r14d", "r14"}, {"r14w", "r14"}, {"r14b", "r14"}, {"r15", "r15"}, {"r15d", "r15"}, {"r15w", "r15"}, {"r15b", "r15"}};
 
-        if (reg.starts_with("xmm"))
-        {
+        if (reg.starts_with("xmm")) {
             return reg;
         }
 
@@ -45,51 +54,157 @@ namespace zlang
         return it->second;
     }
 
-    void RegisterAllocator::free(const std::string &reg)
-    {
+    void RegisterAllocator::free(const std::string &reg) {
         auto it = inUse.find(getBaseReg(reg));
-        if (it == inUse.end())
-        {
-            if (freeXMM(reg))
-            {
+        if (it == inUse.end()) {
+            if (freeXMM(getBaseReg(reg))) {
                 return;
             }
-            std::cout << "Free Normal" << std::endl;
             throw std::runtime_error("RegisterAllocator: attempted to free unallocated register '" + reg + "'");
         }
         inUse.erase(it);
+        lruRegs.remove(reg);
         available.push_back(getBaseReg(reg));
     }
 
-    void RegisterAllocator::reset()
-    {
+    void RegisterAllocator::reset() {
         // Move all inUse back to available
         for (auto &reg : inUse)
             available.push_back(reg);
         inUse.clear();
     }
 
-    std::string RegisterAllocator::allocateXMM()
-    {
-        if (availableXMM.empty())
-        {
-            std::cout << "Free XMM" << std::endl;
-            throw std::runtime_error("RegisterAllocator: no XMM registers available");
+    std::string RegisterAllocator::allocateXMM() {
+        if (availableXMM.empty()) {
+            throw std::runtime_error("No free XMM registers available");
         }
         std::string reg = availableXMM.back();
         availableXMM.pop_back();
         inUseXMM.insert(reg);
+        lruXMMRegs.push_back(reg);
         return reg;
     }
 
-    bool RegisterAllocator::freeXMM(const std::string &reg)
-    {
+    bool RegisterAllocator::freeXMM(const std::string &reg) {
         auto it = inUseXMM.find(reg);
         if (it == inUseXMM.end())
             return false;
         inUseXMM.erase(it);
         availableXMM.push_back(reg);
+        lruXMMRegs.remove(reg);
+        return true;
+    }
+
+    std::string RegisterAllocator::allocateArgument(uint8_t position) {
+        std::string reg = availableArgumentRegs[position];
+        inUseArgument.insert(reg);
+        return reg;
+    }
+    std::string RegisterAllocator::allocateArgumentXMM(uint8_t position) {
+        std::string reg = availableArgumentRegsXMM[position];
+        inUseArgumentXMM.insert(reg);
+        return reg;
+    }
+    void RegisterAllocator::freeArgument(const std::string &reg) {
+        auto it = inUseArgument.find(getBaseReg(reg));
+        if (it == inUseArgument.end()) {
+            if (freeArgumentXMM(getBaseReg(reg))) {
+                return;
+            }
+            throw std::runtime_error("RegisterAllocator: attempted to free unallocated register '" + reg + "'");
+        }
+        inUseArgument.erase(it);
+    }
+    bool RegisterAllocator::freeArgumentXMM(const std::string &reg) {
+        auto it = inUseArgumentXMM.find(getBaseReg(reg));
+        if (it == inUseArgumentXMM.end()) {
+            return false;
+        }
+        inUseArgumentXMM.erase(it);
         return true;
     }
+    bool RegisterAllocator::isInUseArgument(const std::string &reg) const {
+        return inUseArgument.find(reg) != inUseArgument.end();
+    }
+    bool RegisterAllocator::isInUseArgumentXMM(const std::string &reg) const {
+        return inUseArgumentXMM.find(reg) != inUseArgumentXMM.end();
+    }
+    std::string RegisterAllocator::pickVictimXMM() {
+        if (lruXMMRegs.empty()) {
+            throw std::runtime_error("No victim available for XMM registers");
+        }
+        return lruXMMRegs.front();
+    }
+    std::string RegisterAllocator::pickVictim() {
+        if (lruRegs.empty()) {
+            throw std::runtime_error("No victim available for general-purpose registers");
+        }
+        return lruRegs.front();
+    }
+
+    void RegisterAllocator::markSpilledXMM(const std::string &reg, const std::string &spillSlot) {
+        spilledRegs[reg] = {spillSlot, true};
+    }
+
+    void RegisterAllocator::markSpilled(const std::string &reg, const std::string &spillSlot) {
+        spilledRegs[reg] = {spillSlot, false};
+    }
+
+    bool RegisterAllocator::isSpilled(const std::string &reg) const {
+        return spilledRegs.find(reg) != spilledRegs.end();
+    }
+
+    std::string RegisterAllocator::spillSlotFor(const std::string &reg) const {
+        auto it = spilledRegs.find(reg);
+        if (it == spilledRegs.end())
+            throw std::runtime_error("Register not spilled: " + reg);
+        return it->second.spillSlot;
+    }
+
+    void RegisterAllocator::unSpillXMM(const std::string &reg, zlang::CodegenOutputFormat format, std::ostream &out) {
+        auto it = spilledRegs.find(reg);
+        if (it == spilledRegs.end())
+            throw std::runtime_error("XMM reg not spilled: " + reg);
+
+        emitSpillRestore(reg, it->second.spillSlot, true, format, out);
+        spilledRegs.erase(it);
+    }
 
-} // namespace zlang
\ No newline at end of file
+    void RegisterAllocator::unSpill(const std::string &reg, zlang::CodegenOutputFormat format, std::ostream &out) {
+        auto it = spilledRegs.find(reg);
+        if (it == spilledRegs.end())
+            throw std::runtime_error("GPR reg not spilled: " + reg);
+
+        emitSpillRestore(reg, it->second.spillSlot, false, format, out);
+        spilledRegs.erase(it);
+    }
+
+    void RegisterAllocator::emitSpillRestore(const std::string &reg, const std::string &slot, bool isXMM, zlang::CodegenOutputFormat format, std::ostream &out) {
+        if (format == CodegenOutputFormat::X86_64_LINUX) {
+            if (isXMM)
+                out << "    movdqu " << slot << ", %" << reg << "\n";
+            else
+                out << "    mov " << slot << ", %" << reg << "\n";
+        } else if (format == CodegenOutputFormat::X86_64_MSWIN) {
+            if (isXMM) {
+                out << "    movdqu " << reg << ", XMMWORD PTR " << slot << "\n";
+            } else {
+                out << "    mov " << reg << ", QWORD PTR " << slot << "\n";
+            }
+        }
+    }
+
+    void RegisterAllocator::touch(const std::string &reg) {
+        if (inUse.count(reg)) {
+            lruRegs.remove(reg);
+            lruRegs.push_back(reg);
+        }
+    }
+
+    void RegisterAllocator::touchXMM(const std::string &reg) {
+        if (inUseXMM.count(reg)) {
+            lruXMMRegs.remove(reg);
+            lruXMMRegs.push_back(reg);
+        }
+    }
+}  // namespace zlang
\ No newline at end of file
diff --git a/src/lexer/Lexer.cpp b/src/lexer/Lexer.cpp
index c33ba91..ba4cc71 100644
--- a/src/lexer/Lexer.cpp
+++ b/src/lexer/Lexer.cpp
@@ -1,56 +1,44 @@
 #include "all.hpp"
 
-namespace zlang
-{
+namespace zlang {
 
     Lexer::Lexer(const std::string &source)
-        : source_(source), pos_(0), line_(1), column_(1)
-    {
+        : source_(source), pos_(0), line_(1), column_(1) {
     }
 
-    void Lexer::reset()
-    {
+    void Lexer::reset() {
         pos_ = 0;
         line_ = 1;
         column_ = 1;
     }
 
-    char Lexer::advance()
-    {
+    char Lexer::advance() {
         if (pos_ >= source_.size())
             return '\0';
         char c = source_[pos_++];
-        if (c == '\n')
-        {
+        if (c == '\n') {
             ++line_;
             column_ = 1;
-        }
-        else
-        {
+        } else {
             ++column_;
         }
         return c;
     }
 
-    char Lexer::peekChar(size_t offset) const
-    {
+    char Lexer::peekChar(size_t offset) const {
         if (pos_ + offset >= source_.size())
             return '\0';
         return source_[pos_ + offset];
     }
 
-    void Lexer::skipWhitespaceAndComments()
-    {
-        while (true)
-        {
+    void Lexer::skipWhitespaceAndComments() {
+        while (true) {
             char c = peekChar();
-            if (std::isspace(static_cast<unsigned char>(c)))
-            {
+            if (std::isspace(static_cast<unsigned char>(c))) {
                 advance();
                 continue;
             }
-            if (c == '/' && peekChar(1) == '/')
-            {
+            if (c == '/' && peekChar(1) == '/') {
                 // line comment
                 advance();
                 advance();
@@ -62,15 +50,13 @@ namespace zlang
         }
     }
 
-    Token Lexer::nextToken()
-    {
+    Token Lexer::nextToken() {
         skipWhitespaceAndComments();
         size_t tokLine = line_;
         size_t tokCol = column_;
 
         char c = peekChar();
-        if (c == '\0')
-        {
+        if (c == '\0') {
             return Token{Token::Kind::EndOfFile, "", tokLine, tokCol};
         }
 
@@ -86,8 +72,7 @@ namespace zlang
         return scanSymbol();
     }
 
-    Token Lexer::peek(size_t offset) const
-    {
+    Token Lexer::peek(size_t offset) const {
         Lexer copy = *this;
         Token tok;
         for (size_t i = 0; i <= offset; ++i)
@@ -95,8 +80,7 @@ namespace zlang
         return tok;
     }
 
-    Token Lexer::scanIdentifierOrKeywordOrConditional()
-    {
+    Token Lexer::scanIdentifierOrKeywordOrConditional() {
         size_t startLine = line_;
         size_t startCol = column_;
         std::string text;
@@ -118,27 +102,32 @@ namespace zlang
         if (text == "else")
             return {Token::Kind::Else, text, startLine, startCol};
 
+        if (text == "fn")
+            return {Token::Kind::Function, text, startLine, startCol};
+
+        if (text == "extern")
+            return {Token::Kind::Symbol, text, startLine, startCol};
+
+        if (text == "return")
+            return {Token::Kind::Return, text, startLine, startCol};
+
         return Token{Token::Kind::Identifier, text, startLine, startCol};
     }
 
-    Token Lexer::scanNumber()
-    {
+    Token Lexer::scanNumber() {
         size_t startLine = line_;
         size_t startCol = column_;
         std::string text;
         bool seenDot = false;
-        if (peekChar() == '-' and isdigit(peekChar(1)))
-        {
+        if (peekChar() == '-' and isdigit(peekChar(1))) {
             text.push_back(advance());
         }
-        while (std::isdigit(static_cast<unsigned char>(peekChar())) || (!seenDot && peekChar() == '.'))
-        {
+        while (std::isdigit(static_cast<unsigned char>(peekChar())) || (!seenDot && peekChar() == '.')) {
             if (peekChar() == '.')
                 seenDot = true;
             text.push_back(advance());
         }
-        if ((peekChar() == 'f' || peekChar() == 'F') && seenDot)
-        {
+        if ((peekChar() == 'f' || peekChar() == 'F') && seenDot) {
             text.push_back(advance());
         }
         return Token{
@@ -146,28 +135,42 @@ namespace zlang
             text, startLine, startCol};
     }
 
-    Token Lexer::scanString()
-    {
+    Token Lexer::scanString() {
         size_t startLine = line_;
         size_t startCol = column_;
-        advance(); // consume '"'
+        advance();  // consume '"'
         std::string text;
         while (peekChar() != '"' && peekChar() != '\0')
             text.push_back(advance());
         if (peekChar() == '"')
-            advance(); // consume closing '"'
+            advance();  // consume closing '"'
         else
             logError(Error(ErrorType::Syntax, "Unterminated string literal."));
         return Token{Token::Kind::StringLiteral, text, startLine, startCol};
     }
 
-    Token Lexer::scanSymbol()
-    {
+    Token Lexer::scanSymbol() {
         size_t startLine = line_;
         size_t startCol = column_;
         char c = advance();
         std::string text(1, c);
         char next = peekChar();
+
+        if (c == '.' && next == '.') {
+            if (peekChar(1) == '.') {
+                advance();
+                advance();
+                return Token{Token::Kind::Ellipsis, "...", startLine, startCol};
+            } else {
+                throw std::runtime_error("'..' is not a operator");
+            }
+        }
+
+        if (c == '-' && next == '>') {
+            text.push_back(advance());
+            return Token{Token::Kind::Arrow, text, startLine, startCol};
+        }
+
         // Multi-char operators
         if ((c == '&' && next == '&') ||
             (c == '|' && next == '|') ||
@@ -178,15 +181,15 @@ namespace zlang
             (c == '!' && next == '=') ||
             (c == '=' && next == '=') ||
             (c == '+' && next == '+') ||
-            (c == '-' && next == '-'))
-        {
+            (c == '-' && next == '-')) {
             text.push_back(advance());
         }
 
-        switch (c)
-        {
+        switch (c) {
         case ':':
             return Token{Token::Kind::Colon, text, startLine, startCol};
+        case '.':
+            return Token{Token::Kind::Dot, text, startLine, startCol};
         case '=':
             return Token{Token::Kind::Equal, text, startLine, startCol};
         case ';':
@@ -199,6 +202,8 @@ namespace zlang
             return Token{Token::Kind::LeftParen, text, startLine, startCol};
         case ')':
             return Token{Token::Kind::RightParen, text, startLine, startCol};
+        case ',':
+            return Token{Token::Kind::Comma, text, startLine, startCol};
         case '+':
         case '-':
         case '*':
@@ -213,5 +218,4 @@ namespace zlang
             return Token{Token::Kind::Symbol, text, startLine, startCol};
         }
     }
-
-} // namespace zlang
\ No newline at end of file
+}  // namespace zlang
\ No newline at end of file
diff --git a/src/parser/Parser.cpp b/src/parser/Parser.cpp
index 4a33a73..0b093f0 100644
--- a/src/parser/Parser.cpp
+++ b/src/parser/Parser.cpp
@@ -1,68 +1,207 @@
 #include "all.hpp"
 
-namespace zlang
-{
-    Parser::Parser(Lexer &lex) : lexer(lex)
-    {
-        currentScope = std::make_shared<ScopeContext>(nullptr, "GLOBAL SCOPE");
-        // TODO: This is controversial, lets make something in the near future that gets these (size_t, integer, float, double, etc) sizes dynamically
-        currentScope->defineType("boolean", TypeInfo{8, 1, false, false});
-        currentScope->defineType("string", TypeInfo{64, 8, false, false}); // Assuming pointer to heap
-        currentScope->defineType("size_t", TypeInfo{64, 8, false, false});
-        currentScope->defineType("integer", TypeInfo{64, 8, false, true}); // Default int type
+// TODO: 4 Things then I'm done
+// Loops
+// Pointers
+// Structures
+// Stdlib
+
+namespace zlang {
+    Parser::Parser(Lexer& lex) : lexer(lex) {
+        currentScope = std::make_shared<NamespaceScope>("GLOBAL__SCOPE", nullptr);
+        // TODO: This is controversial, lets make something in the near future that
+        // gets these (size_t, integer, float, double, etc) sizes dynamically
+        currentScope->defineType("boolean", TypeInfo{.bits = 8,
+                                                     .align = 1,
+                                                     .isFloat = false,
+                                                     .isSigned = false,
+                                                     .isString = false,
+                                                     .isBoolean = true,
+                                                     .isPointer = false,
+                                                     .isUserDefined = false,
+                                                     .isFunction = false,
+                                                     .name = "boolean"});
+        currentScope->defineType("none", TypeInfo{.bits = 0,
+                                                  .align = 0,
+                                                  .isFloat = false,
+                                                  .isSigned = false,
+                                                  .isString = false,
+                                                  .isBoolean = false,
+                                                  .isPointer = false,
+                                                  .isUserDefined = false,
+                                                  .isFunction = false,
+                                                  .name = "none"});
+        currentScope->defineType("string", TypeInfo{.bits = 64,
+                                                    .align = 8,
+                                                    .isFloat = false,
+                                                    .isSigned = false,
+                                                    .isString = true,
+                                                    .isBoolean = false,
+                                                    .isPointer = true,
+                                                    .isUserDefined = false,
+                                                    .isFunction = false,
+                                                    .name = "string"});
+        currentScope->defineType("size_t", TypeInfo{.bits = 64,
+                                                    .align = 8,
+                                                    .isFloat = false,
+                                                    .isSigned = false,
+                                                    .isString = false,
+                                                    .isBoolean = false,
+                                                    .isPointer = false,
+                                                    .isUserDefined = false,
+                                                    .isFunction = false,
+                                                    .name = "size_t"});
+        currentScope->defineType("integer", TypeInfo{.bits = 64,
+                                                     .align = 8,
+                                                     .isFloat = false,
+                                                     .isSigned = true,
+                                                     .isString = false,
+                                                     .isBoolean = false,
+                                                     .isPointer = false,
+                                                     .isUserDefined = false,
+                                                     .isFunction = false,
+                                                     .name = "integer"});
 
         // Unsigned integers
-        currentScope->defineType("uint8_t", TypeInfo{8, 1, false, false});
-        currentScope->defineType("uint16_t", TypeInfo{16, 2, false, false});
-        currentScope->defineType("uint32_t", TypeInfo{32, 4, false, false});
-        currentScope->defineType("uint64_t", TypeInfo{64, 8, false, false});
+        currentScope->defineType("uint8_t", TypeInfo{.bits = 8,
+                                                     .align = 1,
+                                                     .isFloat = false,
+                                                     .isSigned = false,
+                                                     .isString = false,
+                                                     .isBoolean = false,
+                                                     .isPointer = false,
+                                                     .isUserDefined = false,
+                                                     .isFunction = false,
+                                                     .name = "uint8_t"});
+
+        currentScope->defineType("uint16_t", TypeInfo{.bits = 16,
+                                                      .align = 2,
+                                                      .isFloat = false,
+                                                      .isSigned = false,
+                                                      .isString = false,
+                                                      .isBoolean = false,
+                                                      .isPointer = false,
+                                                      .isUserDefined = false,
+                                                      .isFunction = false,
+                                                      .name = "uint16_t"});
+
+        currentScope->defineType("uint32_t", TypeInfo{.bits = 32,
+                                                      .align = 4,
+                                                      .isFloat = false,
+                                                      .isSigned = false,
+                                                      .isString = false,
+                                                      .isBoolean = false,
+                                                      .isPointer = false,
+                                                      .isUserDefined = false,
+                                                      .isFunction = false,
+                                                      .name = "uint32_t"});
+
+        currentScope->defineType("uint64_t", TypeInfo{.bits = 64,
+                                                      .align = 8,
+                                                      .isFloat = false,
+                                                      .isSigned = false,
+                                                      .isString = false,
+                                                      .isBoolean = false,
+                                                      .isPointer = false,
+                                                      .isUserDefined = false,
+                                                      .isFunction = false,
+                                                      .name = "uint64_t"});
 
         // Signed integers
-        currentScope->defineType("int8_t", TypeInfo{8, 1, false, true});
-        currentScope->defineType("int16_t", TypeInfo{16, 2, false, true});
-        currentScope->defineType("int32_t", TypeInfo{32, 4, false, true});
-        currentScope->defineType("int64_t", TypeInfo{64, 8, false, true});
+        currentScope->defineType("int8_t", TypeInfo{.bits = 8,
+                                                    .align = 1,
+                                                    .isFloat = false,
+                                                    .isSigned = true,
+                                                    .isString = false,
+                                                    .isBoolean = false,
+                                                    .isPointer = false,
+                                                    .isUserDefined = false,
+                                                    .isFunction = false,
+                                                    .name = "int8_t"});
+
+        currentScope->defineType("int16_t", TypeInfo{.bits = 16,
+                                                     .align = 2,
+                                                     .isFloat = false,
+                                                     .isSigned = true,
+                                                     .isString = false,
+                                                     .isBoolean = false,
+                                                     .isPointer = false,
+                                                     .isUserDefined = false,
+                                                     .isFunction = false,
+                                                     .name = "int16_t"});
+
+        currentScope->defineType("int32_t", TypeInfo{.bits = 32,
+                                                     .align = 4,
+                                                     .isFloat = false,
+                                                     .isSigned = true,
+                                                     .isString = false,
+                                                     .isBoolean = false,
+                                                     .isPointer = false,
+                                                     .isUserDefined = false,
+                                                     .isFunction = false,
+                                                     .name = "int32_t"});
+
+        currentScope->defineType("int64_t", TypeInfo{.bits = 64,
+                                                     .align = 8,
+                                                     .isFloat = false,
+                                                     .isSigned = true,
+                                                     .isString = false,
+                                                     .isBoolean = false,
+                                                     .isPointer = false,
+                                                     .isUserDefined = false,
+                                                     .isFunction = false,
+                                                     .name = "int64_t"});
 
         // Floating-point types
-        currentScope->defineType("float", TypeInfo{32, 4, true, true});
-        currentScope->defineType("double", TypeInfo{64, 8, true, true});
+        currentScope->defineType("float", TypeInfo{.bits = 32,
+                                                   .align = 8,
+                                                   .isFloat = true,
+                                                   .isSigned = true,
+                                                   .isString = false,
+                                                   .isBoolean = false,
+                                                   .isPointer = false,
+                                                   .isUserDefined = false,
+                                                   .isFunction = false,
+                                                   .name = "float"});
+
+        currentScope->defineType("double", TypeInfo{.bits = 64,
+                                                    .align = 16,
+                                                    .isFloat = true,
+                                                    .isSigned = true,
+                                                    .isString = false,
+                                                    .isBoolean = false,
+                                                    .isPointer = false,
+                                                    .isUserDefined = false,
+                                                    .isFunction = false,
+                                                    .name = "double"});
         shouldTypecheck = true;
         advance();
     }
 
-    void Parser::advance()
-    {
-        currentToken = lexer.nextToken();
-    }
+    void Parser::advance() { currentToken = lexer.nextToken(); }
 
-    bool Parser::match(Token::Token::Kind kind)
-    {
-        if (currentToken.kind == kind)
-        {
+    bool Parser::match(Token::Token::Kind kind) {
+        if (currentToken.kind == kind) {
             advance();
             return true;
         }
         return false;
     }
 
-    void Parser::expect(Token::Token::Kind kind, const std::string &errMsg)
-    {
-        if (!match(kind))
-        {
+    void Parser::expect(Token::Token::Kind kind, const std::string& errMsg) {
+        if (!match(kind)) {
             logError({ErrorType::Syntax,
-                      errMsg +
-                          " at line " + std::to_string(currentToken.line) +
+                      errMsg + " at line " + std::to_string(currentToken.line) +
                           ", column " + std::to_string(currentToken.column)});
             shouldTypecheck = false;
+            exit(0);
             return;
         }
     }
 
-    std::unique_ptr<ASTNode> Parser::parse()
-    {
+    std::unique_ptr<ASTNode> Parser::parse() {
         auto program = ASTNode::makeProgramNode(currentScope);
-        while (currentToken.kind != Token::Token::Kind::EndOfFile)
-        {
+        while (currentToken.kind != Token::Token::Kind::EndOfFile) {
             auto stmt = parseStatement();
             if (stmt)
                 program->addChild(std::move(stmt));
@@ -70,119 +209,292 @@ namespace zlang
         return program;
     }
 
-    std::unique_ptr<ASTNode> Parser::parseStatement()
-    {
+    std::unique_ptr<ASTNode> Parser::parseStatement() {
+        if (currentToken.kind == Token::Kind::Return) {
+            if (currentScope->isGlobalScope()) {
+                logError({ErrorType::Syntax,
+                          "Unexpected keyword '" + currentToken.text +
+                              "' outside any function at line " +
+                              std::to_string(currentToken.line) + ", column " +
+                              std::to_string(currentToken.column) + "."});
+                shouldTypecheck = false;
+                advance();
+                return nullptr;
+            } else {
+                advance();
+                auto node = std::make_unique<ASTNode>(NodeType::ReturnStatement, "",
+                                                      currentScope);
+                if (currentToken.kind == Token::Kind::SemiColon) {
+                    auto ret = std::make_unique<ASTNode>(NodeType::Symbol, "none",
+                                                         currentScope);
+                    node->addChild(std::move(ret));
+                } else {
+                    node->addChild(parseExpression(true));
+                }
+                return node;
+            }
+        }
+        if ((currentToken.kind == Token::Kind::Symbol and
+             currentToken.text == "extern") ||
+            currentToken.kind == Token::Kind::Function)
+            return parseFunctionDeclaration();
         if (match(Token::Token::Kind::Let))
             return parseVariableDeclaration();
-        if (currentToken.kind == Token::Token::Kind::Identifier)
+        if (currentToken.kind == Token::Token::Kind::Identifier and lexer.peek().kind == Token::Kind::Equal)
             return parseVariableReassignment();
-        if (currentToken.kind == Token::Kind::If || currentToken.kind == Token::Kind::ElseIf || currentToken.kind == Token::Kind::Else)
+        if (currentToken.kind == Token::Kind::If ||
+            currentToken.kind == Token::Kind::ElseIf ||
+            currentToken.kind == Token::Kind::Else)
             return parseConditionals();
-        if (currentToken.kind == Token::Kind::Symbol || currentToken.kind == Token::Kind::Identifier)
+        if (currentToken.kind == Token::Kind::Symbol ||
+            currentToken.kind == Token::Kind::Identifier)
             return parseExpression(true);
         logError({ErrorType::Syntax,
-                  "Unexpected token '" + currentToken.text +
-                      "' at line " + std::to_string(currentToken.line) +
-                      ", column " + std::to_string(currentToken.column) + "."});
+                  "Unexpected token '" + currentToken.text + "' at line " +
+                      std::to_string(currentToken.line) + ", column " +
+                      std::to_string(currentToken.column) + "."});
         shouldTypecheck = false;
         return nullptr;
     }
 
-    std::unique_ptr<ASTNode> Parser::parseBlock()
-    {
-        expect(Token::Kind::LeftBrace, "Expected a '{' to open a scope, at line " + std::to_string(currentToken.line) + ", column " + std::to_string(currentToken.column) + ".");
-        enterScope("blockNumber" + std::to_string(blockNumber++));
-        auto blockNode = std::make_unique<ASTNode>(NodeType::Program, "", currentScope);
-        while (!match(Token::Kind::RightBrace) && currentToken.kind != Token::Kind::EndOfFile)
-        {
-            if (currentToken.kind == Token::Kind::EndOfFile)
-            {
+    std::unique_ptr<ASTNode> Parser::parseFunctionDeclaration() {
+        bool isExtern = false;
+        bool isVariadic = false;
+        if (currentToken.kind == Token::Kind::Symbol &&
+            currentToken.text == "extern") {
+            isExtern = true;
+            advance();
+        }
+
+        // Expect 'fn' keyword
+        expect(Token::Kind::Function,
+               "Expected 'fn' to start function declaration");
+
+        // Function name
+        std::string name = currentToken.text;
+        expect(Token::Kind::Identifier, "Expected function name after 'fn'");
+
+        // Parameter list
+        expect(Token::Kind::LeftParen, "Expected '(' after function name");
+
+        std::vector<ParamInfo> params;
+        if (currentToken.kind != Token::Kind::RightParen) {
+            // Parse first parameter
+            std::string paramName = currentToken.text;
+            expect(Token::Kind::Identifier, "Expected parameter name");
+
+            expect(Token::Kind::Colon, "Expected ':' after parameter name");
+
+            if (currentToken.kind != Token::Kind::Identifier) {
+                logError(Error{ErrorType::Syntax,
+                               "Expected data type after ':' at line " +
+                                   std::to_string(currentToken.line) + ", column " +
+                                   std::to_string(currentToken.column)});
+                shouldTypecheck = false;
+                return nullptr;
+            }
+            std::string typeName = currentToken.text;
+            advance();
+
+            params.push_back(ParamInfo{.name = paramName, .type = typeName});
+
+            while (match(Token::Kind::Comma)) {
+                if (currentToken.kind == Token::Kind::Ellipsis) {
+                    if (!isExtern) {
+                        logError(Error{ErrorType::Generic, "We only support variadic arguments with extern functions"});
+                        shouldTypecheck = false;
+                        return nullptr;
+                    }
+                    isVariadic = true;
+                    advance();
+
+                    // Ellipsis must be the last thing before ')'
+                    if (currentToken.kind != Token::Kind::RightParen) {
+                        logError(Error{ErrorType::Syntax,
+                                       "Variadic parameter '...' must be the last in the parameter list at line " +
+                                           std::to_string(currentToken.line) + ", column " +
+                                           std::to_string(currentToken.column)});
+                        shouldTypecheck = false;
+                        return nullptr;
+                    }
+                    break;
+                }
+
+                std::string nextName = currentToken.text;
+                expect(Token::Kind::Identifier,
+                       "Expected parameter name after ','");
+
+                expect(Token::Kind::Colon, "Expected ':' after parameter name");
+
+                if (currentToken.kind != Token::Kind::Identifier) {
+                    logError(Error{ErrorType::Syntax,
+                                   "Expected data type after ':' at line " +
+                                       std::to_string(currentToken.line) +
+                                       ", column " +
+                                       std::to_string(currentToken.column)});
+                    shouldTypecheck = false;
+                    return nullptr;
+                }
+                std::string nextType = currentToken.text;
+                advance();
+
+                params.push_back(ParamInfo{.name = nextName, .type = nextType});
+            }
+        }
+        expect(Token::Kind::RightParen, "Expected ')' after parameters");
+
+        // Return type (optional)
+        std::string returnTypeName = "none";
+        if (match(Token::Kind::Arrow)) {
+            if (currentToken.kind != Token::Kind::Identifier) {
+                logError(
+                    Error{ErrorType::Syntax,
+                          "Expected return type identifier after '->' at line " +
+                              std::to_string(currentToken.line) + ", column " +
+                              std::to_string(currentToken.column)});
+                shouldTypecheck = false;
+                return nullptr;
+            }
+            returnTypeName = currentToken.text;
+            advance();
+        }
+
+        if (isExtern) {
+            expect(Token::Kind::SemiColon,
+                   "Expected ';' after extern function declaration");
+            return ASTNode::makeExternFunctionDeclaration(name, currentScope,
+                                                          params, returnTypeName, isVariadic);
+        }
+        enterScope(currentScope->name() + "___" + name, true);
+        auto body = parseBlock();
+        exitScope();
+        if (name == "main") {
+            if (currentScope->parent() == nullptr) {
+                // Ok go ahead
+            } else {
+                throw std::runtime_error("Main should be in global scope");
+            }
+        }
+        return ASTNode::makeFunctionDeclaration(name, currentScope, params,
+                                                returnTypeName, std::move(body), isVariadic);
+    }
+
+    std::unique_ptr<ASTNode> Parser::parseBlock() {
+        expect(Token::Kind::LeftBrace,
+               "Expected a '{' to open a scope, at line " +
+                   std::to_string(currentToken.line) + ", column " +
+                   std::to_string(currentToken.column) + ".");
+        auto blockNode =
+            std::make_unique<ASTNode>(NodeType::Program, "", currentScope);
+        while (!match(Token::Kind::RightBrace) &&
+               currentToken.kind != Token::Kind::EndOfFile) {
+            if (currentToken.kind == Token::Kind::EndOfFile) {
                 logError({ErrorType::Syntax,
-                          "Expected token '}' found 'End Of File' at line " + std::to_string(currentToken.line) +
-                              ", column " + std::to_string(currentToken.column) + "."});
+                          "Expected token '}' found 'End Of File' at line " +
+                              std::to_string(currentToken.line) + ", column " +
+                              std::to_string(currentToken.column) + "."});
                 shouldTypecheck = false;
                 return nullptr;
             }
             blockNode->addChild(parseStatement());
         }
-        exitScope();
         return blockNode;
     }
 
-    std::unique_ptr<ASTNode> Parser::parseConditionals()
-    {
-        if (!match(Token::Kind::If))
-        {
+    std::unique_ptr<ASTNode> Parser::parseConditionals() {
+        if (!match(Token::Kind::If)) {
             logError({ErrorType::Syntax, "Expected 'if'"});
             shouldTypecheck = false;
             exit(1);
         }
 
-        expect(Token::Kind::LeftParen, "Expected a '(' after if block at line " + std::to_string(currentToken.line) + ", column " + std::to_string(currentToken.column) + ".");
+        expect(Token::Kind::LeftParen,
+               "Expected a '(' after if block at line " +
+                   std::to_string(currentToken.line) + ", column " +
+                   std::to_string(currentToken.column) + ".");
         auto condition = parseExpression();
-        expect(Token::Kind::RightParen, "Expected a ')' after condition at line " + std::to_string(currentToken.line) + ", column " + std::to_string(currentToken.column) + ".");
+        expect(Token::Kind::RightParen,
+               "Expected a ')' after condition at line " +
+                   std::to_string(currentToken.line) + ", column " +
+                   std::to_string(currentToken.column) + ".");
 
+        enterScope("Block__" + std::to_string(++blockNumber), false);
         auto ifBlock = parseBlock();
-        auto root = ASTNode::makeIfStatement(std::move(condition), std::move(ifBlock), currentScope);
-        ASTNode *current = root.get();
-
-        while (match(Token::Kind::ElseIf))
-        {
-            expect(Token::Kind::LeftParen, "Expected a '(' after if block at line " + std::to_string(currentToken.line) + ", column " + std::to_string(currentToken.column) + ".");
+        exitScope();
+        auto root = ASTNode::makeIfStatement(std::move(condition),
+                                             std::move(ifBlock), currentScope);
+        ASTNode* current = root.get();
+
+        while (match(Token::Kind::ElseIf)) {
+            expect(Token::Kind::LeftParen,
+                   "Expected a '(' after if block at line " +
+                       std::to_string(currentToken.line) + ", column " +
+                       std::to_string(currentToken.column) + ".");
             auto condition = parseExpression();
-            expect(Token::Kind::RightParen, "Expected a ')' after condition at line " + std::to_string(currentToken.line) + ", column " + std::to_string(currentToken.column) + ".");
+            expect(Token::Kind::RightParen,
+                   "Expected a ')' after condition at line " +
+                       std::to_string(currentToken.line) + ", column " +
+                       std::to_string(currentToken.column) + ".");
+            enterScope("Block__" + std::to_string(++blockNumber), false);
             auto elifBlock = parseBlock();
-            auto elifNode = ASTNode::makeElseIfStatement(std::move(condition), std::move(elifBlock), currentScope);
+            exitScope();
+            auto elifNode = ASTNode::makeElseIfStatement(
+                std::move(condition), std::move(elifBlock), currentScope);
             current->setElseBranch(std::move(elifNode));
             current = current->getElseBranch();
         }
 
         // optional 'else'
-        if (match(Token::Kind::Else))
-        {
+        if (match(Token::Kind::Else)) {
+            enterScope("Block__" + std::to_string(++blockNumber), false);
             auto elseBlock = parseBlock();
-            auto elseNode = ASTNode::makeElseStatement(std::move(elseBlock), currentScope);
+            exitScope();
+            auto elseNode =
+                ASTNode::makeElseStatement(std::move(elseBlock), currentScope);
             current->setElseBranch(std::move(elseNode));
         }
 
         return root;
     }
 
-    std::unique_ptr<ASTNode> Parser::parseVariableDeclaration()
-    {
+    std::unique_ptr<ASTNode> Parser::parseVariableDeclaration() {
         if (currentToken.kind != Token::Token::Kind::Identifier)
-            expect(Token::Token::Kind::Identifier, "Expected variable name after 'let'");
+            expect(Token::Token::Kind::Identifier,
+                   "Expected variable name after 'let'");
 
         std::string name = currentToken.text;
         advance();
         std::unique_ptr<ASTNode> typeNode, initNode;
 
-        if (match(Token::Kind::Colon))
-        {
+        if (match(Token::Kind::Colon)) {
             typeNode = ASTNode::makeSymbolNode(currentToken.text, currentScope);
             advance();
+        } else {
+            // TODO: Handle type deduction but its a far far task.
+            logError(
+                Error(
+                    ErrorType::Generic, "Expected ':' followed by a type name for declaring variables at line " + std::to_string(currentToken.line) + ", column: " + std::to_string(currentToken.column)));
+            shouldTypecheck = false;
+            advance();
+            return nullptr;
         }
-        if (match(Token::Kind::Equal))
-        {
+        if (match(Token::Kind::Equal)) {
             initNode = parseExpression();
         }
-        if (initNode == nullptr)
-        {
+        if (initNode == nullptr) {
             TypeInfo ty = currentScope->lookupType(typeNode->value);
-            if (zlang::numeric_types.find(typeNode->value) != zlang::numeric_types.end())
-            {
-                if (ty.isFloat)
-                {
+            if (zlang::numeric_types.find(typeNode->value) !=
+                zlang::numeric_types.end()) {
+                if (ty.isFloat) {
                     if (ty.bits == 32)
-                        initNode = ASTNode::makeFloatLiteralNode("0.0F", currentScope);
+                        initNode =
+                            ASTNode::makeFloatLiteralNode("0.0F", currentScope);
                     else
-                        initNode = ASTNode::makeFloatLiteralNode("0.0", currentScope);
-                }
-                else
+                        initNode =
+                            ASTNode::makeFloatLiteralNode("0.0", currentScope);
+                } else
                     initNode = ASTNode::makeIntegerLiteralNode("0", currentScope);
-            }
-            else
-            {
+            } else {
                 if (typeNode->value == "boolean")
                     initNode = ASTNode::makeBooleanLiteralNode(true, currentScope);
 
@@ -191,99 +503,105 @@ namespace zlang
             }
         }
         expect(Token::Kind::SemiColon, "Expected ';' after declaration");
-        std::optional<std::unique_ptr<ASTNode>> result = ASTNode::makeVariableDeclarationNode(name, std::move(typeNode), std::move(initNode), currentScope);
-        if (!result.has_value())
-        {
-            logError(Error(ErrorType::Generic, "Variable '" + name + "' already defined in current scope."));
+        std::optional<std::unique_ptr<ASTNode>> result =
+            ASTNode::makeVariableDeclarationNode(name, std::move(typeNode),
+                                                 std::move(initNode), currentScope);
+        if (!result.has_value()) {
+            logError(
+                Error(ErrorType::Generic,
+                      "Variable '" + name + "' already defined in current scope."));
             shouldTypecheck = false;
             return nullptr;
-        }
-        else
-        {
+        } else {
             return std::move(result.value());
         }
     }
 
-    std::unique_ptr<ASTNode> Parser::parseVariableReassignment()
-    {
+    std::unique_ptr<ASTNode> Parser::parseVariableReassignment() {
         std::string name = currentToken.text;
         advance();
 
         expect(Token::Token::Kind::Equal, "Expected '=' for variable reassignment");
         auto expr = parseExpression();
         expect(Token::Token::Kind::SemiColon, "Expected ';' after reassignment");
-        return ASTNode::makeVariableReassignmentNode(name, std::move(expr), currentScope);
+        return ASTNode::makeVariableReassignmentNode(name, std::move(expr),
+                                                     currentScope);
     }
 
-    std::unique_ptr<ASTNode> Parser::parseExpression(bool expect_exclaim)
-    {
+    std::unique_ptr<ASTNode> Parser::parseExpression(bool expect_exclaim) {
         auto lhs = parseUnary();
         auto ans = parseBinaryRHS(0, std::move(lhs));
-        if (expect_exclaim)
-        {
-            expect(Token::Kind::SemiColon, "';' Expected at the end of statement at line " + std::to_string(currentToken.line) + ", column " + std::to_string(currentToken.column) + ".");
+        if (expect_exclaim) {
+            expect(Token::Kind::SemiColon, "';' Expected at the end of statement.");
         }
         return ans;
     }
 
-    std::unique_ptr<ASTNode> Parser::parsePrimary()
-    {
-        if (currentToken.kind == Token::Kind::BoolLiteral)
-        {
+    std::unique_ptr<ASTNode> Parser::parsePrimary() {
+        if (currentToken.kind == Token::Kind::BoolLiteral) {
             bool val = (currentToken.text == "true");
             advance();
             return ASTNode::makeBooleanLiteralNode(val, currentScope);
         }
-        if (currentToken.kind == Token::Token::Kind::StringLiteral)
-        {
+        if (currentToken.kind == Token::Token::Kind::StringLiteral) {
             std::string s = currentToken.text;
             advance();
             return ASTNode::makeStringLiteralNode(s, currentScope);
         }
-        if (currentToken.kind == Token::Token::Kind::FloatLiteral)
-        {
+        if (currentToken.kind == Token::Token::Kind::FloatLiteral) {
             std::string f = currentToken.text;
             advance();
             return ASTNode::makeFloatLiteralNode(f, currentScope);
         }
-        if (currentToken.kind == Token::Token::Kind::IntegerLiteral)
-        {
+        if (currentToken.kind == Token::Token::Kind::IntegerLiteral) {
             std::string val = currentToken.text;
             advance();
             return ASTNode::makeIntegerLiteralNode(val, currentScope);
         }
-        if (currentToken.kind == Token::Token::Kind::Identifier)
-        {
+        if (currentToken.kind == Token::Token::Kind::Identifier) {
             std::string name = currentToken.text;
             advance();
 
-            // 2) make the VariableAccess node
-            auto node = ASTNode::makeVariableAccessNode(name, currentScope);
+            if (currentToken.kind == Token::Kind::LeftParen) {
+                advance();
+                std::vector<std::unique_ptr<ASTNode>> arguments;
+
+                if (currentToken.kind != Token::Kind::RightParen) {
+                    while (true) {
+                        arguments.push_back(parseExpression(false));
+                        if (currentToken.kind == Token::Kind::Comma) {
+                            advance();
+                        } else {
+                            break;
+                        }
+                    }
+                }
+                expect(Token::Kind::RightParen, "Expected ')' after function arguments");
+                return ASTNode::makeFunctionCall(name, std::move(arguments), currentScope);
+            }
 
-            // 3) check if the *current* token is ++ or -- (postfix)
+            auto node = ASTNode::makeVariableAccessNode(name, currentScope);
             if (currentToken.kind == Token::Kind::Symbol &&
-                (currentToken.text == "++" || currentToken.text == "--"))
-            {
-                std::string op = currentToken.text; // "++" or "--"
-                advance();                          // consume the ++/--
+                (currentToken.text == "++" || currentToken.text == "--")) {
+                std::string op = currentToken.text;
+                advance();
                 node = ASTNode::makeUnaryOp(op, std::move(node), currentScope);
             }
 
             return node;
         }
         logError({ErrorType::Syntax,
-                  "Expected expression, got '" + currentToken.text +
-                      "' at line " + std::to_string(currentToken.line) +
-                      ", column " + std::to_string(currentToken.column)});
+                  "Expected expression, got '" + currentToken.text + "' at line " +
+                      std::to_string(currentToken.line) + ", column " +
+                      std::to_string(currentToken.column)});
         shouldTypecheck = false;
         return nullptr;
     }
 
-    std::unique_ptr<ASTNode> Parser::parseUnary()
-    {
+    std::unique_ptr<ASTNode> Parser::parseUnary() {
         if (currentToken.kind == Token::Kind::Symbol &&
-            (currentToken.text == "++" || currentToken.text == "--" || currentToken.text == "!"))
-        {
+            (currentToken.text == "++" || currentToken.text == "--" ||
+             currentToken.text == "!")) {
             std::string op = currentToken.text;
             advance();
             auto operand = parseUnary();
@@ -293,12 +611,12 @@ namespace zlang
     }
 
     std::unique_ptr<ASTNode> Parser::parseBinaryRHS(int exprPrec,
-                                                    std::unique_ptr<ASTNode> lhs)
-    {
-        while (true)
-        {
+                                                    std::unique_ptr<ASTNode> lhs) {
+        while (true) {
             // Only consider tokens that can represent binary operators
-            if (!(currentToken.kind == Token::Kind::Symbol || (currentToken.kind == Token::Kind::Equal and currentToken.text == "==")))
+            if (!(currentToken.kind == Token::Kind::Symbol ||
+                  (currentToken.kind == Token::Kind::Equal and
+                   currentToken.text == "==")))
                 break;
 
             std::string op = currentToken.text;
@@ -316,13 +634,13 @@ namespace zlang
             if (tokPrec < nextPrec)
                 rhs = parseBinaryRHS(tokPrec + 1, std::move(rhs));
 
-            lhs = ASTNode::makeBinaryOp(op, std::move(lhs), std::move(rhs), currentScope);
+            lhs = ASTNode::makeBinaryOp(op, std::move(lhs), std::move(rhs),
+                                        currentScope);
         }
         return lhs;
     }
 
-    int Parser::getPrecedence(const std::string &op) const
-    {
+    int Parser::getPrecedence(const std::string& op) const {
         static std::map<std::string, int> prec = {
             {"||", 1}, {"&&", 2}, {"==", 3}, {"!=", 3}, {"<", 4}, {">", 4}, {"<=", 4}, {">=", 4}, {"+", 5}, {"-", 5}, {"*", 6}, {"/", 6}};
 
@@ -330,14 +648,20 @@ namespace zlang
         return it == prec.end() ? -1 : it->second;
     }
 
-    void Parser::enterScope(std::string name)
-    {
-        currentScope = std::make_shared<ScopeContext>(currentScope, name);
+    void Parser::enterScope(const std::string& name, bool isFunction) {
+        if (isFunction) {
+            currentScope = std::make_shared<FunctionScope>(name, currentScope);
+        } else {
+            auto funcScope = currentScope->findEnclosingFunctionScope();
+            if (!funcScope) {
+                throw std::runtime_error("Block scope must be inside a function scope");
+            }
+            currentScope = std::make_shared<BlockScope>(name, funcScope, currentScope);
+        }
     }
-    void Parser::exitScope()
-    {
-        if (!currentScope->parent_)
+    void Parser::exitScope() {
+        if (!currentScope->parent())
             throw std::runtime_error("Scope underflow");
-        currentScope = currentScope->parent_;
+        currentScope = currentScope->parent();
     }
-} // namespace zlang
+}  // namespace zlang
diff --git a/src/parser/ScopeContext.cpp b/src/parser/ScopeContext.cpp
index 4a9de70..06760c9 100644
--- a/src/parser/ScopeContext.cpp
+++ b/src/parser/ScopeContext.cpp
@@ -1,130 +1,267 @@
 #include <all.hpp>
 
-namespace zlang
-{
-    bool ScopeContext::defineVariable(const std::string &varName, const VariableInfo &info)
-    {
-        if (lookupVariableInCurrentContext(varName).has_value())
-        {
-            return false;
-        }
-        else
-        {
+namespace zlang {
+    bool ScopeContext::defineVariable(const std::string &name,
+                                      const VariableInfo &info) {
+        if (!parent_ || (parent_->kind() == "Namespace" && kind() != "Function")) {
+            if (lookupVariableInCurrentContext(name).has_value()) {
+                return false;
+            }
             TypeInfo ti = lookupType(info.type);
-            int size = ti.bits / 8;
-            name_mappings[varName] = varName + "___" + this->name + "___" + std::to_string(variableNumber++);
-            int padding = (ti.align - (stackOffset % ti.align)) % ti.align;
-            stackOffset += padding;
-            stackOffset += size;
-            offsetTable[varName] = -stackOffset;
-            vars_[varName] = info;
+            vars_[name] = info;
+            variable_name_mappings[name] = GLOBAL_NAME_MAPPER.mapVariable(name, name_);
+            return true;
+        } else {
+            if (lookupVariableInCurrentContext(name).has_value()) {
+                return false;
+            }
+            TypeInfo ti = lookupType(info.type);
+            std::int64_t offset = allocateStack(name, ti);
+            vars_[name] = info;
+            offsetTable_[name] = offset;
+            variable_name_mappings[name] = GLOBAL_NAME_MAPPER.mapVariable(name, name_);
             return true;
         }
     }
-
-    void ScopeContext::defineFunction(const std::string &functionName, const FunctionInfo &info)
-    {
-        funcs_[functionName] = info;
+    void ScopeContext::defineFunction(const std::string &name, FunctionInfo info) {
+        if (!info.isExtern) {
+            info.label = GLOBAL_NAME_MAPPER.mapFunction(name, name_);
+        }
+        funcs_[name] = info;
     }
-
-    void ScopeContext::defineType(const std::string &typeName, const TypeInfo &info)
-    {
-        types_[typeName] = info;
+    void ScopeContext::defineType(const std::string &name, const TypeInfo &info) {
+        types_[name] = info;
     }
-
-    VariableInfo ScopeContext::lookupVariable(const std::string &varName) const
-    {
-        auto it = vars_.find(varName);
-        if (it != vars_.end())
+    VariableInfo ScopeContext::lookupVariable(const std::string &name) const {
+        auto it = vars_.find(name);
+        if (it != vars_.end()) {
             return it->second;
-        if (parent_)
-            return parent_->lookupVariable(varName);
-        throw std::runtime_error("Undefined variable '" + varName + "'");
-    }
-
-    std::string ScopeContext::getMapping(std::string varName)
-    {
-        try
-        {
-            lookupVariable(varName);
-            auto it = vars_.find(varName);
-            if (it != vars_.end())
-            {
-                if (name_mappings.find(varName) != name_mappings.end())
-                {
-                    return name_mappings[varName];
-                }
-                else
-                {
-                    throw std::runtime_error("Mapping not found for variable '" + varName + "', in scope named '" + name + "'.");
-                }
+        }
+        if (parent_) {
+            // Skip outer function locals if crossing function boundary
+            if (this->kind() == "Function" && parent_->kind() == "Function" &&
+                parent_->parent_) {
+                return parent_->parent_->lookupVariable(name);
             }
-            if (parent_)
-                return parent_->getMapping(varName);
+            return parent_->lookupVariable(name);
         }
-        catch (...)
-        {
-            throw std::runtime_error("Undefined variable '" + varName + "'");
+        throw std::runtime_error("Undefined variable: " + name);
+    }
+    FunctionInfo ScopeContext::lookupFunction(const std::string &name) const {
+        auto it = funcs_.find(name);
+        if (it != funcs_.end()) {
+            return it->second;
+        }
+        if (parent_) {
+            return parent_->lookupFunction(name);
         }
-        return "";
+        throw std::runtime_error("Undefined function: " + name);
     }
-
-    std::optional<VariableInfo> ScopeContext::lookupVariableInCurrentContext(const std::string &varName) const
-    {
-        auto it = vars_.find(varName);
-        if (it != vars_.end())
+    TypeInfo ScopeContext::lookupType(const std::string &name) const {
+        auto it = types_.find(name);
+        if (it != types_.end()) {
             return it->second;
-        return std::nullopt;
+        }
+        if (parent_) {
+            return parent_->lookupType(name);
+        }
+        throw std::runtime_error("Undefined type: " + name);
     }
-
-    FunctionInfo ScopeContext::lookupFunction(const std::string &functionName) const
-    {
-        auto it = funcs_.find(functionName);
-        if (it != funcs_.end())
+    std::optional<VariableInfo>
+    ScopeContext::lookupVariableInCurrentContext(const std::string &name) const {
+        auto it = vars_.find(name);
+        if (it != vars_.end()) {
             return it->second;
-        if (parent_)
-            return parent_->lookupFunction(functionName);
-        throw std::runtime_error("Undefined function '" + functionName + "'");
+        }
+        return std::nullopt;
     }
-
-    TypeInfo ScopeContext::lookupType(const std::string &typeName) const
-    {
-        auto it = types_.find(typeName);
-        if (it != types_.end())
+    std::int64_t ScopeContext::allocateStack(const std::string & /*varName*/,
+                                             const TypeInfo & /*type*/) {
+        throw std::runtime_error("allocateStack not implemented for scope: " +
+                                 kind());
+    }
+    std::int64_t ScopeContext::getVariableOffset(const std::string &name) const {
+        auto it = offsetTable_.find(name);
+        if (it != offsetTable_.end()) {
             return it->second;
-        if (parent_)
-            return parent_->lookupType(typeName);
-        throw std::runtime_error("Undefined type '" + typeName + "'");
+        }
+        if (parent_) {
+            if (this->kind() == "Function" && parent_->kind() == "Function" &&
+                parent_->parent_) {
+                return parent_->parent_->getVariableOffset(name);
+            }
+            return parent_->getVariableOffset(name);
+        }
+        throw std::runtime_error("Unknown variable: " + name);
     }
-
-    std::int64_t ScopeContext::getVariableOffset(const std::string &varName) const
-    {
-        auto it = offsetTable.find(varName);
-        if (it != offsetTable.end())
+    bool ScopeContext::isGlobalVariable(const std::string &name) const {
+        const ScopeContext *ctx = this;
+        while (ctx) {
+            auto it = ctx->vars_.find(name);
+            if (it != ctx->vars_.end()) {
+                return ctx->isGlobalScope();
+            }
+            ctx = ctx->parent_.get();
+        }
+        throw std::runtime_error("Unknown variable: " + name);
+    }
+    bool ScopeContext::isGlobalScope() const { return parent_ == nullptr; }
+    std::string ScopeContext::getMapping(std::string name) {
+        auto it = variable_name_mappings.find(name);
+        if (it != variable_name_mappings.end()) {
             return it->second;
-        if (parent_)
-            return parent_->getVariableOffset(varName);
-        throw std::runtime_error("Unknown variable " + varName);
+        }
+        if (parent_) {
+            if (this->kind() == "Function" && parent_->kind() == "Function" &&
+                parent_->parent_) {
+                return parent_->parent_->getMapping(name);
+            }
+            return parent_->getMapping(name);
+        }
+        throw std::runtime_error("Mapping not found for variable: " + name);
+    }
+    void ScopeContext::setMapping(const std::string &name,
+                                  const std::string &llvmName) {
+        variable_name_mappings[name] = llvmName;
     }
+    void ScopeContext::printScope(std::ostream &out, int indent) const {
+        std::string pad(indent, ' ');
+        out << pad << kind() << " Scope: " << name_ << "\n";
 
-    bool ScopeContext::isGlobalVariable(const std::string &varName) const
-    {
+        if (!vars_.empty()) {
+            out << pad << "  Variables:\n";
+            for (const auto &kv : vars_) {
+                out << pad << "    " << kv.first << ": " << kv.second.type << "\n";
+            }
+        }
 
-        const ScopeContext *ctx = this;
-        while (ctx)
-        {
-            auto it = ctx->vars_.find(varName);
-            if (it != ctx->vars_.end())
-            {
-                return (ctx->parent_ == nullptr);
+        if (!funcs_.empty()) {
+            out << pad << "  Functions:\n";
+            for (const auto &kv : funcs_) {
+                out << pad << "    " << kv.first << " -> " << kv.second.returnType
+                    << "\n";
             }
-            ctx = ctx->parent_.get();
         }
-        throw std::runtime_error("Unknown variable " + varName);
+
+        if (!types_.empty()) {
+            out << pad << "  Types:\n";
+            for (const auto &kv : types_) {
+                out << pad << "    " << kv.first << "\n";
+            }
+        }
+    }
+    std::shared_ptr<FunctionScope> ScopeContext::findEnclosingFunctionScope() {
+        std::shared_ptr<ScopeContext> current = shared_from_this();
+        while (current) {
+            if (current->kind() == "Function") {
+                return std::static_pointer_cast<FunctionScope>(current);
+            }
+            current = current->parent_;
+        }
+        return nullptr;
+    }
+    std::shared_ptr<ScopeContext> ScopeContext::getGlobal() {
+        if (!parent_) {
+            return shared_from_this();
+        } else {
+            return parent_->getGlobal();
+        }
+    }
+
+    FunctionScope::FunctionScope(std::string name,
+                                 std::shared_ptr<ScopeContext> parent)
+        : ScopeContext(std::move(name), std::move(parent)), stackOffset_(-16) {}
+    FunctionScope::~FunctionScope() = default;
+    std::int64_t FunctionScope::allocateStack(const std::string &varName,
+                                              const TypeInfo &type) {
+        std::int64_t size = alignSize(type);
+        stackOffset_ -= size;
+        offsetTable_[varName] = stackOffset_;
+        return stackOffset_;
+    }
+    void FunctionScope::printScope(std::ostream &out, int indent) const {
+        // Use base implementation for printing variables, functions, and types
+        ScopeContext::printScope(out, indent);
+    }
+    std::int64_t FunctionScope::getStackOffset() const {
+        return stackOffset_;
+    }
+    std::string FunctionScope::allocateSpillSlot(std::int64_t size, CodegenOutputFormat format) {
+        for (auto it = freeSpillSlots_.begin(); it != freeSpillSlots_.end(); ++it) {
+            if (it->second == size) {
+                std::int64_t offset = it->first;
+                freeSpillSlots_.erase(it);
+                switch (format) {
+                case CodegenOutputFormat::X86_64_LINUX:
+                    return "-" + std::to_string(offset) + "(%rbp)";
+                case CodegenOutputFormat::X86_64_MSWIN:
+                    return "[rbp - " + std::to_string(stackOffset_ + offset) + "]";
+                default:
+                    return "";
+                }
+            }
+        }
+        nextSpillOffset_ -= size;
+        std::int64_t offset = nextSpillOffset_;
+        switch (format) {
+        case CodegenOutputFormat::X86_64_LINUX:
+            return std::to_string(offset) + "(%rbp)";
+        case CodegenOutputFormat::X86_64_MSWIN:
+            return "[rbp - " + std::to_string(std::abs(stackOffset_ + offset)) + "]";
+        default:
+            return "";
+        }
     }
+    std::int64_t FunctionScope::getSpillSize() const {
+        return nextSpillOffset_;
+    }
+    void FunctionScope::freeSpillSlot(const std::string &slot, std::int64_t size) {
+        std::int64_t offset = 0;
+        if (!slot.empty() && slot.front() == '[') {
+            auto close = slot.find(']');
+            if (close == std::string::npos)
+                throw std::runtime_error("Invalid MASM spill slot format: " + slot);
+
+            std::string inside = slot.substr(1, close - 1);
+            auto opPos = inside.find_first_of("+-", 3);
+            if (opPos == std::string::npos)
+                throw std::runtime_error("No offset operator in MASM spill slot: " + slot);
 
-    bool ScopeContext::isGlobalScope() const
-    {
-        return !this->parent_.get();
+            char op = inside[opPos];
+            std::string numStr = inside.substr(opPos + 1);
+            numStr.erase(0, numStr.find_first_not_of(" \t"));
+            numStr.erase(numStr.find_last_not_of(" \t") + 1);
+
+            offset = std::stoll(numStr);
+            if (op == '-') offset = -offset;
+        }
+        else {
+            // existing style: "(<offset>)", e.g. "-8(rbp)"
+            auto paren = slot.find('(');
+            if (paren == std::string::npos)
+                throw std::runtime_error("Invalid spill slot format: " + slot);
+
+            // e.g. slot = "-8(rbp)" → offsetStr = "-8"
+            std::string offsetStr = slot.substr(0, paren);
+            offset = std::stoll(offsetStr);
+        }
+
+        freeSpillSlots_.emplace_back(offset, size);
+    }
+
+    BlockScope::BlockScope(std::string name,
+                           std::shared_ptr<FunctionScope> funcScope,
+                           std::shared_ptr<ScopeContext> parent)
+        : ScopeContext(std::move(name), std::move(parent)),
+          funcScope_(std::move(funcScope)) {}
+    BlockScope::~BlockScope() = default;
+    std::int64_t BlockScope::allocateStack(const std::string &varName,
+                                           const TypeInfo &type) {
+        return funcScope_->allocateStack(varName, type);
+    }
+    void BlockScope::printScope(std::ostream &out, int indent) const {
+        std::string pad(indent, ' ');
+        out << pad << kind() << " Scope: " << name_ << "\n";
+        ScopeContext::printScope(out, indent + 2);
     }
-}
+}  // namespace zlang
diff --git a/src/support/CommandLine.cpp b/src/support/CommandLine.cpp
index e5a1d5a..d4b370e 100644
--- a/src/support/CommandLine.cpp
+++ b/src/support/CommandLine.cpp
@@ -1,154 +1,118 @@
 #include "support/CommandLine.hpp"
 
-#include <iostream>
 #include <cstring>
+#include <iostream>
 
-namespace zlang
-{
+namespace zlang {
 
-    CommandLine::CommandLine(int argc, char *argv[])
-    {
+    CommandLine::CommandLine(int argc, char *argv[]) {
         parseArgs(argc, argv);
     }
 
-    bool CommandLine::printAST() const noexcept
-    {
+    bool CommandLine::printAST() const noexcept {
         return printAST_;
     }
 
-    void CommandLine::parseArgs(int argc, char *argv[])
-    {
-        for (int i = 1; i < argc; ++i)
-        {
+    void CommandLine::parseArgs(int argc, char *argv[]) {
+        for (int i = 1; i < argc; ++i) {
             const char *arg = argv[i];
 
-            if (std::strcmp(arg, "-h") == 0 || std::strcmp(arg, "--help") == 0)
-            {
+            if (std::strcmp(arg, "-h") == 0 || std::strcmp(arg, "--help") == 0) {
                 helpFlag = true;
-                return; // no need to parse further
+                return;  // no need to parse further
             }
-            if (std::strcmp(arg, "-p") == 0 || std::strcmp(arg, "--printAST") == 0)
-            {
+            if (std::strcmp(arg, "-p") == 0 || std::strcmp(arg, "--printAST") == 0) {
                 printAST_ = true;
-                return; // no need to parse further
-            }
-            else if (std::strcmp(arg, "--formats") == 0)
-            {
+            } else if (std::strcmp(arg, "--formats") == 0) {
                 formatsFlag = true;
                 return;
-            }
-            else if (std::strcmp(arg, "-v") == 0 || std::strcmp(arg, "--verbose") == 0)
-            {
+            } else if (std::strcmp(arg, "-v") == 0 || std::strcmp(arg, "--verbose") == 0) {
                 verbosity = 1;
-            }
-            else if (std::strcmp(arg, "-o") == 0 || std::strcmp(arg, "--output") == 0)
-            {
-                if (++i >= argc)
-                {
+            } else if (std::strcmp(arg, "-o") == 0 || std::strcmp(arg, "--output") == 0) {
+                if (++i >= argc) {
                     errorFlag = true;
-                    error.message = "Expected filepath after output command line argument";
-                    return;
-                }
-                if (argv[i][0] == '-')
-                {
-                    errorFlag = true;
-                    error.message = std::string("Expected filepath after output argument, got: ") + argv[i];
+                    error.message = "Expected filepath after " + std::string(arg);
                     return;
                 }
                 outputFile = argv[i];
-            }
-            else if (std::strcmp(arg, "-f") == 0 || std::strcmp(arg, "--format") == 0)
-            {
-                if (++i >= argc)
-                {
+            } else if (std::strcmp(arg, "-f") == 0 || std::strcmp(arg, "--format") == 0) {
+                if (++i >= argc) {
                     errorFlag = true;
                     error.message = "Expected format after format command line argument";
                     return;
                 }
-                if (argv[i][0] == '-')
-                {
+                if (argv[i][0] == '-') {
                     errorFlag = true;
                     error.message = std::string("Expected format after format argument, got: ") + argv[i];
                     return;
                 }
                 std::string fmt = argv[i];
-                if (fmt == "default")
-                {
+                if (fmt == "default") {
                     format = CodegenOutputFormat::Default;
-                }
-                else if (fmt == "x86_64-mswin")
-                {
+                } else if (fmt == "x86_64-mswin") {
                     format = CodegenOutputFormat::X86_64_MSWIN;
-                }
-                else if (fmt == "x86_64-linux")
-                {
+                } else if (fmt == "x86_64-linux") {
                     format = CodegenOutputFormat::X86_64_LINUX;
-                }
-                else if (fmt == "llvm-ir")
-                {
+                } else if (fmt == "llvm-ir") {
                     format = CodegenOutputFormat::LLVM_IR;
-                }
-                else
-                {
+                } else {
                     errorFlag = true;
                     error.message = "Unrecognized format: " + fmt;
                     return;
                 }
-            }
-            else
-            {
+            } else {
                 // treat as input file
-                if (!inputFile.empty())
-                {
+                if (!inputFile.empty()) {
                     std::cerr << "Warning: Multiple input files detected; using the last one: " << arg << "\n";
                 }
                 inputFile = arg;
             }
         }
+        if (helpFlag && !formatsFlag) {
+            return;
+        }
+        if (formatsFlag) {
+            return;
+        }
+        if (inputFile.empty() && !helpFlag && !formatsFlag) {
+            errorFlag = true;
+            error.message = "No input file specified";
+        }
     }
 
-    bool CommandLine::hasError() const noexcept
-    {
+    bool CommandLine::hasError() const noexcept {
         return errorFlag;
     }
 
-    const CliError &CommandLine::getError() const noexcept
-    {
+    const CliError &CommandLine::getError() const noexcept {
         return error;
     }
 
-    bool CommandLine::showHelp() const noexcept
-    {
+    bool CommandLine::showHelp() const noexcept {
         return helpFlag;
     }
 
-    bool CommandLine::showFormats() const noexcept
-    {
+    bool CommandLine::showFormats() const noexcept {
         return formatsFlag;
     }
 
-    std::string CommandLine::getInputFile() const noexcept
-    {
+    std::string CommandLine::getInputFile() const noexcept {
         return inputFile;
     }
 
-    std::string CommandLine::getOutputFile() const noexcept
-    {
+    std::string CommandLine::getOutputFile() const noexcept {
         return outputFile;
     }
 
-    CodegenOutputFormat CommandLine::getFormat() const noexcept
-    {
+    CodegenOutputFormat CommandLine::getFormat() const noexcept {
         return format;
     }
 
-    int CommandLine::getVerbosity() const noexcept
-    {
+    int CommandLine::getVerbosity() const noexcept {
         return verbosity;
     }
 
-    void CommandLine::printUsage(const std::string &programName)
-    {
+    void CommandLine::printUsage(const std::string &programName) {
         std::cout << "\nUSAGE: " << programName << " [FLAGS] [OPTIONS] <path to file to compile>\n"
                   << "Flags:\n"
                   << "   `-h`, `--help`    :: Show this help and usage information.\n"
@@ -160,12 +124,11 @@ namespace zlang
                   << "Anything else is treated as the input file path.\n";
     }
 
-    void CommandLine::printFormats()
-    {
+    void CommandLine::printFormats() {
         std::cout << "Acceptable formats include:\n"
                   << " -> default\n"
                   << " -> x86_64-mswin\n"
                   << " -> x86_64-linux\n";
     }
 
-} // namespace zlang
\ No newline at end of file
+}  // namespace zlang
\ No newline at end of file
diff --git a/src/typechecker/TypeChecker.cpp b/src/typechecker/TypeChecker.cpp
index fa2b2bf..8113871 100644
--- a/src/typechecker/TypeChecker.cpp
+++ b/src/typechecker/TypeChecker.cpp
@@ -1,11 +1,8 @@
 #include "all.hpp"
 
-namespace zlang
-{
-    void TypeChecker::check(const std::unique_ptr<ASTNode> &program)
-    {
-        if (!program || program->type != NodeType::Program)
-        {
+namespace zlang {
+    void TypeChecker::check(const std::unique_ptr<ASTNode> &program) {
+        if (!program || program->type != NodeType::Program) {
             logError({ErrorType::Type,
                       "TypeChecker error: root is not a Program node"});
             shouldCodegen_ = false;
@@ -14,36 +11,138 @@ namespace zlang
         checkNode(program.get());
     }
 
-    std::string TypeChecker::checkNode(const ASTNode *node)
-    {
+    std::string TypeChecker::checkNode(const ASTNode *node) {
         if (!node)
             return "";
         auto scope = node->scope;
-        switch (node->type)
-        {
-
+        switch (node->type) {
         case NodeType::Program:
-            for (auto &child : node->children)
-            {
+            for (auto &child : node->children) {
                 checkNode(child.get());
             }
             return "";
 
-        case NodeType::VariableDeclaration:
-        {
+        case NodeType::ExternFunction: {
+            if (node->value == "main") {
+                logError({ErrorType::Generic, "Function named 'main' cannot be extern"});
+                shouldCodegen_ = false;
+                return "";
+            }
+            ASTNode *params = node->getFunctionParamList();
+            for (const auto &childPtr : params->children) {
+                ASTNode *param = childPtr.get();
+                try {
+                    node->scope->lookupType(param->children[1]->value);
+                } catch (...) {
+                    logError(Error{ErrorType::Type, "Undefined type '" + (param->children[1]->value) + "' for parameter named '" + param->children[0]->value + "' in declaration of function named '" + node->value + "'."});
+                    shouldCodegen_ = false;
+                    return "";
+                }
+            }
+            try {
+                node->scope->lookupType(node->getFunctionParamReturnType()->value);
+            } catch (...) {
+                logError(Error{ErrorType::Type, "Undefined type '" + (node->getFunctionParamReturnType()->value) + "' for return type in declaration of function named '" + node->value + "'."});
+                shouldCodegen_ = false;
+            }
+            return "";
+        }
+
+        case NodeType::FunctionCall: {
+            if (node->value == "main") {
+                logError({ErrorType::Generic, "Cannot call 'main' function explicitly."});
+                shouldCodegen_ = false;
+                return "";
+            }
+            FunctionInfo functionInfo;
+            try {
+                functionInfo = node->scope->lookupFunction(node->value);
+            } catch (...) {
+                logError(Error{ErrorType::Type, "Undefined functions '" + (node->value) + "'."});
+                shouldCodegen_ = false;
+                return "";
+            }
+            const std::vector<zlang::ParamInfo> &functionParams = functionInfo.paramTypes;
+            const std::vector<std::unique_ptr<ASTNode>> &functionArguments = node->children[0]->children;
+
+            if (functionArguments.size() != functionParams.size()) {
+                logError(Error{
+                    ErrorType::Type,
+                    "Function '" + node->value + "' expects " +
+                        std::to_string(functionParams.size()) + " arguments, got " +
+                        std::to_string(functionArguments.size()) + "."});
+                shouldCodegen_ = false;
+                return "";
+            }
+
+            for (size_t i = 0; i < functionArguments.size(); ++i) {
+                std::string argType = checkNode(functionArguments[i].get());
+                std::string paramType = functionParams[i].type;
+
+                if (argType != paramType) {
+                    if (!(isNumeric(argType) && isNumeric(paramType))) {
+                        logError(Error{
+                            ErrorType::Type,
+                            "Function '" + node->value + "' argument " +
+                                std::to_string(i + 1) + " expects '" + paramType +
+                                "', got '" + argType + "'."});
+                        shouldCodegen_ = false;
+                        return "";
+                    }
+                }
+            }
+            return functionInfo.returnType;
+        }
+
+        case NodeType::Function: {
+            ASTNode *params = node->getFunctionParamList();
+            for (const auto &childPtr : params->children) {
+                ASTNode *param = childPtr.get();
+                try {
+                    node->scope->lookupType(param->children[1]->value);
+                } catch (...) {
+                    logError(Error{ErrorType::Type, "Undefined type '" + (param->children[1]->value) + "' for parameter named '" + param->children[0]->value + "' in declaration of function named '" + node->value + "'."});
+                    shouldCodegen_ = false;
+                    return "";
+                }
+            }
+            try {
+                node->scope->lookupType(node->getFunctionParamReturnType()->value);
+            } catch (...) {
+                logError(Error{ErrorType::Type, "Undefined type '" + (node->getFunctionParamReturnType()->value) + "' for return type in declaration of function named '" + node->value + "'."});
+                shouldCodegen_ = false;
+            }
+            return "";
+        }
+
+        case NodeType::ReturnStatement: {
+            std::string expectedRet = scope->returnType;
+            std::string actualRet = "none";
+            if (!node->children.empty()) {
+                actualRet = checkNode(node->children[0].get());
+            }
+
+            if (actualRet != expectedRet &&
+                !(isNumeric(actualRet) && isNumeric(expectedRet))) {
+                logError({ErrorType::Type,
+                          "Return type mismatch: expected '" + expectedRet +
+                              "', got '" + actualRet + "'"});
+                shouldCodegen_ = false;
+            }
+            return actualRet;
+        }
+
+        case NodeType::VariableDeclaration: {
             std::string annotatedType, initType;
             if (node->children.size() >= 1 &&
-                node->children[0]->type == NodeType::Symbol)
-            {
+                node->children[0]->type == NodeType::Symbol) {
                 annotatedType = node->children[0]->value;
             }
-            if (node->children.size() == 2)
-            {
+            if (node->children.size() == 2) {
                 initType = checkNode(node->children[1].get());
             }
 
-            if (annotatedType.empty() && initType.empty())
-            {
+            if (annotatedType.empty() && initType.empty()) {
                 logError({ErrorType::Type,
                           "Declaration of '" + node->value +
                               "' needs a type annotation or initializer"});
@@ -53,10 +152,8 @@ namespace zlang
 
             // If both present but mismatch, only error if *non‑numeric*
             if (!annotatedType.empty() && !initType.empty() &&
-                annotatedType != initType)
-            {
-                if (!(isNumeric(annotatedType) && isNumeric(initType)))
-                {
+                annotatedType != initType) {
+                if (!(isNumeric(annotatedType) && isNumeric(initType))) {
                     logError({ErrorType::Type,
                               "Initializer type '" + initType +
                                   "' does not match annotation '" + annotatedType +
@@ -72,13 +169,11 @@ namespace zlang
             return finalType;
         }
 
-        case NodeType::VariableReassignment:
-        {
+        case NodeType::VariableReassignment: {
             VariableInfo info = scope->lookupVariable(node->value);
             std::string expected = info.type;
             std::string actual = checkNode(node->children[0].get());
-            if (!(expected == actual or isNumeric(expected) == isNumeric(actual)))
-            {
+            if (!(expected == actual or isNumeric(expected) == isNumeric(actual))) {
                 logError({ErrorType::Type,
                           "Reassignment of '" + node->value +
                               "' expects '" + expected +
@@ -88,14 +183,10 @@ namespace zlang
             return expected;
         }
 
-        case NodeType::VariableAccess:
-        {
-            try
-            {
+        case NodeType::VariableAccess: {
+            try {
                 return scope->lookupVariable(node->value).type;
-            }
-            catch (...)
-            {
+            } catch (...) {
                 logError({ErrorType::Type, "Unknown variable " + node->value});
                 shouldCodegen_ = false;
                 return "";
@@ -104,28 +195,27 @@ namespace zlang
 
         case NodeType::IntegerLiteral:
             return "integer";
+
         case NodeType::FloatLiteral:
             if (!node->value.empty() &&
                 (node->value.back() == 'f' || node->value.back() == 'F'))
                 return "float";
             else
                 return "double";
+
         case NodeType::StringLiteral:
             return "string";
         case NodeType::BooleanLiteral:
             return "boolean";
 
-        case NodeType::BinaryOp:
-        {
+        case NodeType::BinaryOp: {
             std::string lhs = checkNode(node->children[0].get());
             std::string rhs = checkNode(node->children[1].get());
             const auto &op = node->value;
 
             // Arithmetic + - * /
-            if (op == "+" || op == "-" || op == "*" || op == "/")
-            {
-                if (isNumeric(lhs) && isNumeric(rhs))
-                {
+            if (op == "+" || op == "-" || op == "*" || op == "/") {
+                if (isNumeric(lhs) && isNumeric(rhs)) {
                     const TypeInfo &tL = node->scope->lookupType(lhs);
                     const TypeInfo &tR = node->scope->lookupType(rhs);
 
@@ -142,8 +232,7 @@ namespace zlang
             }
 
             // Logical || &&
-            if (op == "||" || op == "&&")
-            {
+            if (op == "||" || op == "&&") {
                 if (lhs == "boolean" && rhs == "boolean")
                     return "boolean";
                 logError({ErrorType::Type,
@@ -155,8 +244,7 @@ namespace zlang
             }
 
             // Comparisons
-            if (op == "==" || op == "!=" || op == ">=" || op == ">" || op == "<=" || op == "<")
-            {
+            if (op == "==" || op == "!=" || op == ">=" || op == ">" || op == "<=" || op == "<") {
                 // numeric vs numeric → OK
                 if (isNumeric(lhs) && isNumeric(rhs))
                     return "boolean";
@@ -184,25 +272,19 @@ namespace zlang
             shouldCodegen_ = false;
             return "";
         }
-
-        case NodeType::UnaryOp:
-        {
+        case NodeType::UnaryOp: {
             std::string ty = checkNode(node->children[0].get());
             const auto &op = node->value;
-            if (op == "!")
-            {
-                if (ty != "boolean")
-                {
+            if (op == "!") {
+                if (ty != "boolean") {
                     logError({ErrorType::Type,
                               "Logical '!' needs boolean, got '" + ty + "'"});
                     shouldCodegen_ = false;
                 }
                 return "boolean";
             }
-            if (op == "++" || op == "--")
-            {
-                if (!isInteger(ty))
-                {
+            if (op == "++" || op == "--") {
+                if (!isInteger(ty)) {
                     logError({ErrorType::Type,
                               "Unary '" + op + "' needs Integral type, got '" + ty + "'"});
                     shouldCodegen_ = false;
@@ -214,10 +296,8 @@ namespace zlang
             shouldCodegen_ = false;
             return "";
         }
-
         case NodeType::IfStatement:
-        case NodeType::ElseIfStatement:
-        {
+        case NodeType::ElseIfStatement: {
             if (node->children.size() > 0)
                 checkNode(node->children[0].get());
 
@@ -229,8 +309,7 @@ namespace zlang
 
             return "";
         }
-        case NodeType::ElseStatement:
-        {
+        case NodeType::ElseStatement: {
             if (!node->children.empty())
                 checkNode(node->children[0].get());
             return "";
@@ -241,19 +320,16 @@ namespace zlang
         }
     }
 
-    bool TypeChecker::isInteger(const std::string &ty)
-    {
+    bool TypeChecker::isInteger(const std::string &ty) {
         return integral_types.find(ty) != integral_types.end();
     }
 
-    bool TypeChecker::isNumeric(const std::string &ty)
-    {
+    bool TypeChecker::isNumeric(const std::string &ty) {
         return numeric_types.find(ty) != numeric_types.end();
     }
 
-    bool TypeChecker::isComparable(const std::string &ty)
-    {
+    bool TypeChecker::isComparable(const std::string &ty) {
         return isNumeric(ty);
     }
 
-} // namespace zlang
\ No newline at end of file
+}  // namespace zlang
\ No newline at end of file
diff --git a/test_runner.py b/test_runner.py
index 00c86ce..d505d7a 100644
--- a/test_runner.py
+++ b/test_runner.py
@@ -22,27 +22,19 @@
         "zpiler_flag": "--format x86_64-linux",
         "asm_ext": ".s",
         "assemble": lambda asm, obj: ["as", asm, "-o", obj],
-        "link": lambda obj, exe: ["ld", obj, "-o", exe],
+        "link": lambda obj, exe: ["gcc", obj, "-o", exe],
     },
     "windows": {
         "zpiler_flag": "--format x86_64-mswin",
         "asm_ext": ".asm",
-        # Produce obj in cwd, move manually
         "assemble": lambda asm, obj: ["ml64", "/nologo", "/c", asm],
-        "link": lambda obj, exe: [
-            "link",
-            "/nologo",
-            "/SUBSYSTEM:CONSOLE",
-            "/ENTRY:main",
-            "/OUT:" + exe,
-            obj,
-        ],
+        "link": lambda obj, exe: ["gcc", obj, "-o", exe],
     },
     "llvm": {
         "zpiler_flag": "--format llvm-ir",
         "asm_ext": ".ll",
         "assemble": lambda ir, obj: ["llc", "-filetype=obj", ir, "-o", obj],
-        "link": lambda obj, exe: ["clang", obj, "-o", exe, "-no-pie"],
+        "link": lambda obj, exe: ["gcc", obj, "-o", exe, "-no-pie"],
     },
 }
 
diff --git a/tests/zz/conditionals/if-elif-else.zz b/tests/zz/conditionals/if-elif-else.zz
index 9031254..a26ef23 100644
--- a/tests/zz/conditionals/if-elif-else.zz
+++ b/tests/zz/conditionals/if-elif-else.zz
@@ -2,15 +2,31 @@ let a: int64_t = 10;
 let f: float = 20.5;
 let u: uint8_t = 10;
 
-if (a > 100) {
-    let res: int64_t = a * 2;
-}
-elif (f < 10.0) {
-    let res: float = f + 1.0;
+extern fn printf(fmt: string, ...) -> int32_t;
+
+fn print_int(x: int64_t) -> none {
+    printf("%d\n", x);
 }
-elif (u == a) {
-    let res: uint8_t = u + 1;
+
+fn print_float(x: float) -> none {
+    printf("%f\n", x);
 }
-else {
-    let res: int64_t = -1;
+
+fn main() {
+    if (a > 100) {
+        let res: int64_t = a * 2;
+        print_int(res);
+    }
+    elif (f < 10.0) {
+        let res: float = f + 1.0;
+        print_float(res);
+    }
+    elif (u == a) {
+        let res: uint8_t = u + 1;
+        print_int(res);
+    }
+    else {
+        let res: int64_t = -1;
+        print_int(res);
+    }
 }
diff --git a/tests/zz/conditionals/if-elif.zz b/tests/zz/conditionals/if-elif.zz
index 648bfa4..ace4f83 100644
--- a/tests/zz/conditionals/if-elif.zz
+++ b/tests/zz/conditionals/if-elif.zz
@@ -2,12 +2,14 @@ let a: int64_t = 50;
 let f: double = 25.25;
 let u: uint32_t = 50;
 
-if (a < 0) {
-    let res: int64_t = a - 1;
-}
-elif (f >= 25.0) {
-    let res: double = f * 1.1;
-}
-elif (u != a) {
-    let res: uint32_t = u + 10;
-}
+fn main() {
+    if (a < 0) {
+        let res: int64_t = a - 1;
+    }
+    elif (f >= 25.0) {
+        let res: double = f * 1.1;
+    }
+    elif (u != a) {
+        let res: uint32_t = u + 10;
+    }
+}
\ No newline at end of file
diff --git a/tests/zz/conditionals/if-else.zz b/tests/zz/conditionals/if-else.zz
index ebc377a..fc53f79 100644
--- a/tests/zz/conditionals/if-else.zz
+++ b/tests/zz/conditionals/if-else.zz
@@ -2,23 +2,25 @@ let a: int64_t = 15;
 let f: double = 12.34;
 let u: uint16_t = 15;
 
-if (a >= 20) {
-    let res: int64_t = a - 5;
-}
-else {
-    let res: int64_t = a + 5;
-}
+fn main() {
+    if (a >= 20) {
+        let res: int64_t = a - 5;
+    }
+    else {
+        let res: int64_t = a + 5;
+    }
 
-if (f != 0.0) {
-    let val: double = f / 2.0;
-}
-else {
-    let val: double = 0.0;
-}
+    if (f != 0.0) {
+        let val: double = f / 2.0;
+    }
+    else {
+        let val: double = 0.0;
+    }
 
-if (u < a) {
-    let x: uint16_t = u * 2;
+    if (u < a) {
+        let x: uint16_t = u * 2;
+    }
+    else {
+        let x: uint16_t = u / 2;
+    }
 }
-else {
-    let x: uint16_t = u / 2;
-}
\ No newline at end of file
diff --git a/tests/zz/conditionals/if.zz b/tests/zz/conditionals/if.zz
index e11c62e..a1a9706 100644
--- a/tests/zz/conditionals/if.zz
+++ b/tests/zz/conditionals/if.zz
@@ -3,14 +3,16 @@ let b: int64_t = 20;
 let f: float = 10.5f;
 let u: uint8_t = 10;
 
-if (a < b) {
-    let x: int64_t = 1;
-}
+fn main() {
+    if (a < b) {
+        let x: int64_t = 1;
+    }
 
-if (f > 5.5) {
-    let y: float = f * 2.0;
-}
+    if (f > 5.5) {
+        let y: float = f * 2.0;
+    }
 
-if (u == a) {
-    let z: uint8_t = u + 1;
-}
\ No newline at end of file
+    if (u == a) {
+        let z: uint8_t = u + 1;
+    }
+}
diff --git a/tests/zz/functions/basics.zz b/tests/zz/functions/basics.zz
new file mode 100644
index 0000000..d839171
--- /dev/null
+++ b/tests/zz/functions/basics.zz
@@ -0,0 +1,39 @@
+extern fn printf(fmt: string, ...) -> int32_t;
+
+fn print_int(x: int64_t) -> none {
+    printf("%d\n", x);
+}
+
+fn print_float(x: float) -> none {
+    printf("%f\n", x);
+}
+
+fn print_bool(x: boolean) -> none {
+    if(x == 1){
+        printf("true\n");
+    }else{
+        printf("false\n");
+    }
+}
+
+fn add(x: int64_t, y: int64_t) -> int64_t {
+    return x + y;
+}
+
+fn square(f: float) -> float {
+    return f * f;
+}
+
+fn negate(b: boolean) -> boolean {
+    return !b;
+}
+
+fn main() {
+    let a: int64_t = add(10, 32);         // 42
+    let s: float = square(3.0);           // 9.0
+    let b: boolean = negate(false);       // true
+
+    print_int(a);
+    print_float(s);
+    print_bool(b);
+}
diff --git a/tests/zz/functions/recursive.zz b/tests/zz/functions/recursive.zz
new file mode 100644
index 0000000..dd47fcf
--- /dev/null
+++ b/tests/zz/functions/recursive.zz
@@ -0,0 +1,40 @@
+extern fn printf(fmt: string, ...) -> int32_t;
+
+fn print_int(x: int64_t) -> none {
+    printf("%d\n", x);
+}
+
+fn print_float(x: float) -> none {
+    printf("%f\n", x);
+}
+
+fn print_bool(x: boolean) -> none {
+    if(x == 1){
+        printf("true\n");
+    }else{
+        printf("false\n");
+    }
+}
+
+fn factorial(n: int64_t) -> int64_t {
+    if (n <= 1) {
+        return 1;
+    }
+    return n * factorial(n - 1);
+}
+
+fn is_even(n: int64_t) -> boolean {
+    if (n == 0) {return true;}
+    if (n == 1) {return false;}
+    return is_even(n - 2);
+}
+
+fn main() {
+    let f: int64_t = factorial(5);      // 120
+    let e: boolean = is_even(42);       // true
+    let o: boolean = is_even(17);       // false
+
+    print_int(f);
+    print_bool(e);
+    print_bool(o);
+}
diff --git a/tests/zz/functions/scopes.zz b/tests/zz/functions/scopes.zz
new file mode 100644
index 0000000..072b53d
--- /dev/null
+++ b/tests/zz/functions/scopes.zz
@@ -0,0 +1,39 @@
+extern fn printf(fmt: string, ...) -> int32_t;
+
+fn print_int(x: int64_t) -> none {
+    printf("%d\n", x);
+}
+
+fn print_float(x: float) -> none {
+    printf("%f\n", x);
+}
+
+fn print_bool(x: boolean) -> none {
+    if(x == 1){
+        printf("true\n");
+    }else{
+        printf("false\n");
+    }
+}
+
+fn increment(n: int64_t) -> int64_t {
+    let res: int64_t = n + 1;
+    return res;
+}
+
+fn double(n: int64_t) -> int64_t {
+    return n * 2;
+}
+
+fn process(n: int64_t) -> int64_t {
+    let step1: int64_t = increment(n);   // n + 1
+    let step2: int64_t = double(step1);  // (n + 1) * 2
+    return step2;
+}
+
+fn main() {
+    let input: int64_t = 10;
+    let result: int64_t = process(input);  // (10 + 1) * 2 = 22
+
+    print_int(result);
+}
diff --git a/tests/zz/operations/binary.zz b/tests/zz/operations/binary.zz
index 061847e..4f9086a 100644
--- a/tests/zz/operations/binary.zz
+++ b/tests/zz/operations/binary.zz
@@ -1,4 +1,22 @@
-// Integer + Integer
+// Arithmetic and Comparison test
+extern fn printf(fmt: string, ...) -> int32_t;
+
+fn print_int(x: int64_t) -> none {
+    printf("%d\n", x);
+}
+
+fn print_float(x: float) -> none {
+    printf("%f\n", x);
+}
+
+fn print_bool(x: boolean) -> none {
+    if(x == 1){
+        printf("true\n");
+    }else{
+        printf("false\n");
+    }
+}
+
 let a: int64_t = 10;
 let b: int64_t = 20;
 let sum_i: int64_t = a + b;
@@ -6,14 +24,12 @@ let diff_i: int64_t = a - b;
 let prod_i: int64_t = a * b;
 let div_i: int64_t = b / a;
 
-// Integer + Float (promote to float)
 let c: float = 2.5;
 let sum_if: float = a + c;
 let diff_if: float = c - a;
 let prod_if: float = a * c;
 let div_if: float = a / c;
 
-// Float + Float
 let d: double = 3.1415;
 let e: double = 2.718;
 let sum_f: double = d + e;
@@ -21,12 +37,10 @@ let diff_f: double = d - e;
 let prod_f: double = d * e;
 let div_f: double = d / e;
 
-// Unsigned + Signed
 let ua: uint8_t = 5;
 let sb: int8_t = -2;
 let sum_us: int16_t = ua + sb;
 
-// Comparisons int
 let cmp_lt: boolean = a < b;
 let cmp_le: boolean = a <= b;
 let cmp_gt: boolean = a > b;
@@ -34,15 +48,46 @@ let cmp_ge: boolean = a >= b;
 let cmp_eq: boolean = a == b;
 let cmp_ne: boolean = a != b;
 
-// Comparisons float
 let cmpf_lt: boolean = d < e;
 let cmpf_eq: boolean = d == e;
 
-// Mixed Comparison
 let cmpmix: boolean = a < d;
 
-// Comparison boolean (only ==, != valid)
 let ba: boolean = true;
 let bb: boolean = false;
 let cmpb_eq: boolean = ba == bb;
-let cmpb_ne: boolean = ba != bb;
\ No newline at end of file
+let cmpb_ne: boolean = ba != bb;
+
+fn main() {
+    print_int(sum_i);     // 30
+    print_int(diff_i);    // -10
+    print_int(prod_i);    // 200
+    print_int(div_i);     // 2
+
+    print_float(sum_if);   // 12.5
+    print_float(diff_if);  // -7.5
+    print_float(prod_if);  // 25.0
+    print_float(div_if);   // 4.0
+
+    print_float(sum_f);   // 5.8595
+    print_float(diff_f);  // 0.4235
+    print_float(prod_f);  // 8.5392257
+    print_float(div_f);   // 1.1557276
+
+    print_int(sum_us);    // 3
+
+    print_bool(cmp_lt);   // true
+    print_bool(cmp_le);   // true
+    print_bool(cmp_gt);   // false
+    print_bool(cmp_ge);   // false
+    print_bool(cmp_eq);   // false
+    print_bool(cmp_ne);   // true
+
+    print_bool(cmpf_lt);  // false
+    print_bool(cmpf_eq);  // false
+
+    print_bool(cmpmix);   // true
+
+    print_bool(cmpb_eq);  // false
+    print_bool(cmpb_ne);  // true
+}
diff --git a/tests/zz/operations/unary.zz b/tests/zz/operations/unary.zz
index 108c02d..b761a49 100644
--- a/tests/zz/operations/unary.zz
+++ b/tests/zz/operations/unary.zz
@@ -1,18 +1,42 @@
+extern fn printf(fmt: string, ...) -> int32_t;
+
+fn print_int(x: int64_t) -> none {
+    printf("%d\n", x);
+}
+
+fn print_bool(x: boolean) -> none {
+    if(x == 1){
+        printf("%d\n", 1);
+    }else{
+        printf("%d\n", 0);
+    }
+}
+
 let x: int64_t = 5;
-++x;
---x;
+++x;        // x = 6
+--x;        // x = 5
 
 let y: uint8_t = 255;
-++y;
---y;
+++y;        // y = 0 (wrap-around)
+--y;        // y = 255
 
 let z: size_t = 100;
-++z;
---z;
+++z;        // z = 101
+--z;        // z = 100
 
-// Logical NOT on boolean
 let b1: boolean = true;
 let nb1: boolean = !b1;
 
 let b2: boolean = false;
 let nb2: boolean = !b2;
+
+fn main() {
+    print_int(x);    // 5
+    print_int(y);    // 255
+    print_int(z);    // 100
+
+    print_bool(nb1); // false
+    print_bool(nb2); // true
+}
+
+
diff --git a/tests/zz/types.zz b/tests/zz/types.zz
new file mode 100644
index 0000000..201534b
--- /dev/null
+++ b/tests/zz/types.zz
@@ -0,0 +1,24 @@
+// Arithmetic and Comparison test
+extern fn printf(fmt: string, ...) -> int32_t;
+
+fn print_int(x: int64_t) -> none {
+    printf("%d\n", x);
+}
+
+fn print_float(x: float) -> none {
+    printf("%f\n", x);
+}
+
+fn print_bool(x: boolean) -> none {
+    if(x == 1){
+        printf("true\n");
+    }else{
+        printf("false\n");
+    }
+}
+
+fn main() {
+    let x: uint8_t = 255;
+    x++;
+    print_int(x);
+}
\ No newline at end of file
diff --git a/tests/zz/variables.zz b/tests/zz/variables.zz
index 6ddd9e2..0504a38 100644
--- a/tests/zz/variables.zz
+++ b/tests/zz/variables.zz
@@ -7,8 +7,13 @@ let other: boolean = false;
 let s: string = "hello";
 let a: string;
 
-let x1: int64_t = 10;
-x = 20;
+extern fn printf(fmt: string, ...) -> int32_t;
 
-let f1: float = 1.5f;
-f = 2.5f;
\ No newline at end of file
+fn main(){
+    s = "It is what it is";
+    printf(s);
+    let x1: int64_t = 10;
+    x = 20;
+    let f1: float = 1.5f;
+    f = 2.5f;
+}