HTLL.htvm

include "HT-Lib.htvm"

str str0 := ""
str str1 := ""
str str2 := ""
str str3 := ""
str str4 := ""
str str5 := ""
str str6 := ""
str str7 := ""
str str8 := ""
str str9 := ""
str str10 := ""
str str11 := ""
str str12 := ""
str str13 := ""
str str14 := ""
str str15 := ""
str str16 := ""
str str17 := ""
str str18 := ""
str str19 := ""
str str20 := ""
int is_arm := 0
int is_oryx := 0
int ring0 := 0
arr str nintArr

func str SubStrLastChars(str text, int numOfChars) {
    str LastOut := ""
    int NumOfChars := 0
    Loop, Parse, text {
        NumOfChars++
    }
    Loop, % numOfChars {
        NumOfChars--
    }
    Loop, Parse, text {
        if (A_Index >= NumOfChars) {
            LastOut .= A_LoopField
        }
    }
    return LastOut
}
func str transformBracesToHTLL(str code) {
    str out := ""
    arr str blockStack
    int ifNestLevel := 0
    int loopNestLevel := 0

    Loop, Parse, code, `n, `r {
        str currentLine := A_LoopField
        str trimmedLine := StrLower(Trim(currentLine))

        if (SubStr(trimmedLine, 1, 5) = "func ") {
            blockStack.add("func:0")
            out .= currentLine . Chr(10)
            continue
        }
        
        ; ===================================================================
        ; IF BLOCKS
        ; ===================================================================
        if (SubStr(trimmedLine, 1, 4) = "if (") {
            ifNestLevel++
            blockStack.add("if:" . STR(ifNestLevel))

            str newIfKeyword := "if"
            if (ifNestLevel > 1) {
                newIfKeyword .= STR(ifNestLevel)
            }

            str conditionPart := SubStr(Trim(currentLine), 4)
            str modifiedIfLine := newIfKeyword . " " . conditionPart
            
            int indentLen := InStr(StrLower(currentLine), "if") - 1
            str indentation := SubStr(currentLine, 1, indentLen)

            out .= indentation . modifiedIfLine . Chr(10)
            continue 
        }

        ; ===================================================================
        ; LOOP BLOCKS
        ; ===================================================================
        if (SubStr(trimmedLine, 1, 5) = "loop,") {
            loopNestLevel++
            blockStack.add("loop:" . STR(loopNestLevel))
            str newLoopKeyword := "loop"
            if (loopNestLevel > 1) {
                newLoopKeyword .= STR(loopNestLevel)
            }
            str loopParams := SubStr(Trim(currentLine), 6)
            str modifiedLoopLine := newLoopKeyword . "," . loopParams
            int indentLen := InStr(StrLower(currentLine), "loop,") - 1
            str indentation := SubStr(currentLine, 1, indentLen)
            out .= indentation . modifiedLoopLine . Chr(10)
            continue
        }

        ; ===================================================================
        ; AUTO-NUMBERING BREAK & CONTINUE
        ; ===================================================================
        if (trimmedLine = "break") {
            str breakCmd := "break"
            if (loopNestLevel > 1) {
                breakCmd .= STR(loopNestLevel)
            }
            int indentLen := InStr(StrLower(currentLine), "break") - 1
            str indentation := SubStr(currentLine, 1, indentLen)
            out .= indentation . breakCmd . Chr(10)
            continue
        }

        if (trimmedLine = "continue") {
            str contCmd := "continue"
            if (loopNestLevel > 1) {
                contCmd .= STR(loopNestLevel)
            }
            int indentLen := InStr(StrLower(currentLine), "continue") - 1
            str indentation := SubStr(currentLine, 1, indentLen)
            out .= indentation . contCmd . Chr(10)
            continue
        }

        ; ===================================================================
        ; BRACES HANDLING
        ; ===================================================================
        if (trimmedLine = "{") {
            continue
        }
        
        if (trimmedLine = "}") {
            if (blockStack.size() = 0) {
                out .= "; SYNTAX ERROR: Unmatched closing brace found." . Chr(10)
                continue
            }
            str blockInfo := blockStack[blockStack.size() - 1]
            blockStack.pop()
            str blockType := StrSplit(blockInfo, ":", 1)
            int level := INT(StrSplit(blockInfo, ":", 2))
            int indentLen := InStr(currentLine, "}") - 1
            str indentation := SubStr(currentLine, 1, indentLen)
            if (blockType = "func") {
                out .= indentation . "funcend" . Chr(10)
            } else if (blockType = "if") {
                str ender := "ifend"
                if (level > 1) { ender .= STR(level) }
                out .= indentation . ender . Chr(10)
                ifNestLevel--
            } else if (blockType = "loop") {
                str ender := "endloop"
                if (level > 1) { ender .= STR(level) }
                out .= indentation . ender . Chr(10)
                loopNestLevel--
            }
            continue
        }
        
        out .= currentLine . Chr(10)
    }

    if (blockStack.size() > 0) {
        out .= "; SYNTAX ERROR: " . STR(blockStack.size()) . " unclosed blocks at end of file." . Chr(10)
    }

    return Trim(out)
}
func str HTLL_Lang(str code) {
str out := ""

code := cleanUpFirst(code)
code := preserveStrings(code)
code := handleComments(code)
code := formatCurlyBracesForParsing(code)
;print(code)

if (InStr(code, "{")) {
    code := transformBracesToHTLL(code)
}

; VYIGUOYIYVIUCFCYIUCFCYIGCYGICFHYFHCTCFTFDFGYGFCAA
;print(code)
;Loop, % HT_Lib_theIdNumOfThe34theVar.size() {
;if (Trim(HT_Lib_theIdNumOfThe34theVar[A_Index]) != "") {
;print(A_Index)
;print(HT_Lib_theIdNumOfThe34theVar[A_Index])
;}
;if (A_Index = 50) {
;break
;}
;}

Loop, Parse, code, `n, `r {

if (SubStr(A_LoopField, 1, 4) = "str ") {
str1 := Trim(StringTrimLeft(A_LoopField, 4))
}
else {
out .= A_LoopField . Chr(10)
}
}

out := Trim(out)
out := restoreStrings(out)

return out
}

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

func bool isNint(str name) {
    Loop, % nintArr.size() {
        if (Trim(name) = Trim(nintArr[A_Index])) {
            return true
        }
    }
    return false
}
func str compiler(str code) {
    code := HTLL_Lang(code)
    str out := ""
    arr str oryx_param_map
    str main_syntax := ""
    if (is_arm = 1) {
        if (RegExMatch(code, "\bargs_array\b")) {
            main_syntax := "_start:" . Chr(10)
            ; FIXED: Removed parens and comments that confuse the parser
            main_syntax .= "    ldr x19, [sp]" . Chr(10)
            main_syntax .= "    stp x29, x30, [sp, #-32]!" . Chr(10)
            main_syntax .= "    mov x29, sp" . Chr(10)
            main_syntax .= "    ldr x0, =args_array" . Chr(10)
            main_syntax .= "    bl array_clear" . Chr(10)
            main_syntax .= "    add x20, sp, #40" . Chr(10)
            main_syntax .= "    mov x21, #1" . Chr(10)
            main_syntax .= ".arg_loop:" . Chr(10)
            main_syntax .= "    cmp x21, x19" . Chr(10)
            main_syntax .= "    b.ge .args_done" . Chr(10)
            ; Load argv[x21]
            main_syntax .= "    ldr x22, [x20, x21, lsl #3]" . Chr(10)
            main_syntax .= ".unpack_byte_loop:" . Chr(10)
            main_syntax .= "    ldrb w1, [x22], #1" . Chr(10)
            main_syntax .= "    cmp w1, #0" . Chr(10)
            main_syntax .= "    b.eq .unpack_byte_done" . Chr(10)
            main_syntax .= "    ldr x0, =args_array" . Chr(10)
            main_syntax .= "    bl array_append" . Chr(10)
            main_syntax .= "    b .unpack_byte_loop" . Chr(10)
            main_syntax .= ".unpack_byte_done:" . Chr(10)
            main_syntax .= "    mov x1, #10" . Chr(10)
            main_syntax .= "    ldr x0, =args_array" . Chr(10)
            main_syntax .= "    bl array_append" . Chr(10)
            main_syntax .= "    add x21, x21, #1" . Chr(10)
            main_syntax .= "    b .arg_loop" . Chr(10)
            main_syntax .= ".args_done:" . Chr(10) . Chr(10)
        }
        else {
            ; --- THE FIX IS HERE ---
            main_syntax := "_start:" . Chr(10)
            main_syntax .= "    stp x29, x30, [sp, #-16]!" . Chr(10)
            main_syntax .= "    mov x29, sp" . Chr(10) . Chr(10)
        }
    }
    else if (is_oryx = 1) {
        ; --- ORYX IR ENTRY ---
        ; Oryx is a VM, so it handles stack alignment automatically.
        ; We just need the entry label to tell the VM where to begin.
        main_syntax := "_start:" . Chr(10)
        
        if (RegExMatch(code, "\bargs_array\b")) {
            ; In Oryx IR, we assume the VM environment populates 'args_array' 
            ; automatically if it exists, or we add a specific sys-call later.
            ; We don't need manual stack walking code here.
            main_syntax .= "    ; args_array handling" . Chr(10)
        }
    }
    else {
        ; --- YOUR EXISTING X86 CODE - UNCHANGED AND CORRECT ---
        if (RegExMatch(code, "\bargs_array\b")) {
            main_syntax := Chr(10) . "_start:" . Chr(10) . "push rbp" . Chr(10) . "mov rbp, rsp" . Chr(10) . "and rsp, -16" . Chr(10) . "mov rdi, args_array" . Chr(10) . "call array_clear" . Chr(10) . "mov r12, [rbp+8]" . Chr(10) . "lea r13, [rbp+16]" . Chr(10) . "mov r14, 1" . Chr(10) . ".arg_loop:" . Chr(10) . "cmp r14, r12" . Chr(10) . "jge .args_done" . Chr(10) . "mov r15, [r13 + r14*8]" . Chr(10) . ".unpack_byte_loop:" . Chr(10) . "movzx rbx, byte [r15]" . Chr(10) . "cmp rbx, 0" . Chr(10) . "je .unpack_byte_done" . Chr(10) . "mov rdi, args_array" . Chr(10) . "mov rsi, rbx" . Chr(10) . "call array_append" . Chr(10) . "inc r15" . Chr(10) . "jmp .unpack_byte_loop" . Chr(10) . ".unpack_byte_done:" . Chr(10) . "mov rdi, args_array" . Chr(10) . "mov rsi, 10" . Chr(10) . "call array_append" . Chr(10) . "inc r14" . Chr(10) . "jmp .arg_loop" . Chr(10) . ".args_done:" . Chr(10) . Chr(10)
        }
        else {
            main_syntax := Chr(10) . "_start:" . Chr(10) . "push rbp" . Chr(10) . "mov rbp, rsp" . Chr(10) . "and rsp, -16 " . Chr(10) . Chr(10)
        }
    }
    str HTLL_Libs_x86 := ""
    if (ring0 = 0) {
        HTLL_Libs_x86 := FileRead("HTLL_Libs_x86.txt")
    }
    else {
        HTLL_Libs_x86 := FileRead("HTLL_Libs_ring0.txt")
    }
    if (is_arm = 1) {
        HTLL_Libs_x86 := FileRead("HTLL_Libs_AArch64.txt")
    }
    if (is_oryx = 1) {
        HTLL_Libs_x86 := ""
    }
    int isDotCompile := 0
    str dot_data := Chr(10)
    str dot_data_print_temp_strings := Chr(10)
    int dot_data_print_temp_strings_count := 0
    str dot_data_ints := Chr(10)
    str path_label := ""
    str dot_bss := Chr(10)
    str dot_bss_str := Chr(10)
    str arrBss := ""
    arr str theIdNumOfThe34theVar
    arr str getAllCharForTheFurtureSoIcanAddEscapeChar
    str ReplaceFixWhitOutFixDoubleQuotesInsideDoubleQuotes := ""
    str str21 := ""
    str htCodeOUT754754 := ""
    str OutFixDoubleQuotesInsideDoubleQuotes := ""
    str keyWordEscpaeChar := "\"
    int fixOutFixDoubleQuotesInsideDoubleQuotesFIXok := 0
    int removeNexFixkeyWordEscpaeChar := 0
    int theIdNumOfThe34 := 0
    int areWEinSome34sNum := 0
    int loopCount := 0
    int loopCount1 := 0
    int loopCount2 := 0
    int loopCount3 := 0
    int loopCount4 := 0
    int loopCount5 := 0
    int loopCount6 := 0
    int loopCount7 := 0
    int loopCount8 := 0
    int loopCount9 := 0
    int ifCount := 0
    int ifCount1 := 0
    int ifCount2 := 0
    int ifCount3 := 0
    int ifCount4 := 0
    int ifCount5 := 0
    int ifCount6 := 0
    int ifCount7 := 0
    int ifCount8 := 0
    int ifCount9 := 0
    int funcCount := 0
    int isNum := 0
    int localVarNum := 1
    int inFunc := 0
    int funcArgsCount := 0
    arr str funcArgsArr
    str funcName := ""
    str str_index := ""
    str str_value := ""
    int int1 := 0
    int int2 := 0
    int int3 := 0
    int int4 := 0
    int int5 := 0
    int int6 := 0
    int isOryxFuncFirst := 0
    int HTLL_fix_int := 0
    
str strSrc := ""
str strLhs := ""
str strRhs := ""
str strVal := ""
str strIndex := ""
str idxSrc := ""
str valSrc := ""
str strArg := ""
    
    Loop, Parse, code {
        theIdNumOfThe34theVar.add("")
        theIdNumOfThe34theVar.add("")
    }
    Loop, Parse, code {
        theIdNumOfThe34theVar[A_Index] := theIdNumOfThe34theVar[A_Index] . Chr(34)
        getAllCharForTheFurtureSoIcanAddEscapeChar.add(A_LoopField)
    }
    getAllCharForTheFurtureSoIcanAddEscapeChar.add(" ")
    ReplaceFixWhitOutFixDoubleQuotesInsideDoubleQuotes := Chr(34) . "ihuiuuhuuhtheidFor" . str21 . "--" . str21 . "asds" . str21 . "as--" . str21 . "theuhtuwaesphoutr" . Chr(34)
    Loop, Parse, code {
        if (A_LoopField = keyWordEscpaeChar) and (getAllCharForTheFurtureSoIcanAddEscapeChar[A_Index + 1] = Chr(34)) {
            fixOutFixDoubleQuotesInsideDoubleQuotesFIXok := 1
            OutFixDoubleQuotesInsideDoubleQuotes .= ReplaceFixWhitOutFixDoubleQuotesInsideDoubleQuotes
        }
        else {
            if (fixOutFixDoubleQuotesInsideDoubleQuotesFIXok != 1) {
                OutFixDoubleQuotesInsideDoubleQuotes .= A_LoopField
            }
            else {
                fixOutFixDoubleQuotesInsideDoubleQuotesFIXok := 0
            }
        }
    }
    code := OutFixDoubleQuotesInsideDoubleQuotes
    if (keyWordEscpaeChar != Chr(92)) {
        code := StrReplace(code, Chr(92), Chr(92) . Chr(92))
    }
    if (keyWordEscpaeChar = Chr(92)) {
        Loop, Parse, code {
            if (A_LoopField = Chr(34)) {
                areWEinSome34sNum++
            }
            if (areWEinSome34sNum = 1) {
                if (A_LoopField != Chr(34)) {
                    if (A_LoopField = keyWordEscpaeChar) {
                        theIdNumOfThe34theVar[theIdNumOfThe34] := theIdNumOfThe34theVar[theIdNumOfThe34] . Chr(92)
                    }
                    else {
                        theIdNumOfThe34theVar[theIdNumOfThe34] := theIdNumOfThe34theVar[theIdNumOfThe34] . A_LoopField
                    }
                }
                else {
                    theIdNumOfThe34++
                    htCodeOUT754754 .= "VYIGUOYIYVIUCFCYIUCFCYIGCYGICFHYFHCTCFTFDFGYGFC" . Chr(65) . Chr(65) . STR(theIdNumOfThe34) . Chr(65) . Chr(65)
                }
            }
            if (areWEinSome34sNum = 2) or (areWEinSome34sNum = 0) {
                if (A_LoopField != Chr(34)) {
                    htCodeOUT754754 .= A_LoopField
                }
                areWEinSome34sNum := 0
            }
        }
    }
    else {
        Loop, Parse, code {
            if (A_LoopField = Chr(34)) {
                areWEinSome34sNum++
            }
            if (areWEinSome34sNum = 1) {
                if (A_LoopField != Chr(34)) {
                    if (A_LoopField = keyWordEscpaeChar) and (keyWordEscpaeChar = getAllCharForTheFurtureSoIcanAddEscapeChar[A_Index + 1]) {
                        theIdNumOfThe34theVar[theIdNumOfThe34] := theIdNumOfThe34theVar[theIdNumOfThe34] . keyWordEscpaeChar
                        removeNexFixkeyWordEscpaeChar := 1
                    }
                    else if (A_LoopField = keyWordEscpaeChar) {
                        if (removeNexFixkeyWordEscpaeChar != 1) {
                            theIdNumOfThe34theVar[theIdNumOfThe34] := theIdNumOfThe34theVar[theIdNumOfThe34] . Chr(92)
                        }
                        else {
                            removeNexFixkeyWordEscpaeChar := 0
                        }
                    }
                    else {
                        theIdNumOfThe34theVar[theIdNumOfThe34] := theIdNumOfThe34theVar[theIdNumOfThe34] . A_LoopField
                    }
                }
                else {
                    theIdNumOfThe34++
                    htCodeOUT754754 .= "VYIGUOYIYVIUCFCYIUCFCYIGCYGICFHYFHCTCFTFDFGYGFC" . Chr(65) . Chr(65) . STR(theIdNumOfThe34) . Chr(65) . Chr(65)
                }
            }
            if (areWEinSome34sNum = 2) or (areWEinSome34sNum = 0) {
                if (A_LoopField != Chr(34)) {
                    htCodeOUT754754 .= A_LoopField
                }
                areWEinSome34sNum := 0
            }
        }
    }
    code := htCodeOUT754754
    Loop, % theIdNumOfThe34 {
        theIdNumOfThe34theVar[A_Index] := theIdNumOfThe34theVar[A_Index] . Chr(34)
    }
    theIdNumOfThe34theVar.add(Chr(34))
    code := StrReplace(code, "{", Chr(10) . "{" . Chr(10))
    code := StrReplace(code, "}", Chr(10) . "}" . Chr(10))
    Loop, Parse, code, `n, `r {
        out .= Trim(A_LoopField) . Chr(10)
    }
    StringTrimRight, code, out, 1
    str1 := ""
    out := ""
    Loop, Parse, code, `n, `r {
        Loop, Parse, A_LoopField {
            if (A_LoopField != ";") {
                str1 .= A_LoopField
            }
            else {
                break
            }
        }
        out .= Trim(str1) . Chr(10)
        str1 := ""
    }
    StringTrimRight, code, out, 1
    int seenMain := 0
    out := ""
    Loop, Parse, code, `n, `r {
        if (Trim(A_LoopField) = "main") {
            seenMain := 1
            out .= main_syntax . Chr(10)
        }
        else {
            out .= A_LoopField . Chr(10)
        }
    }
    StringTrimRight, code, out, 1
    int fix_func_temp_int := 0
    arr str fix_func_temp_arr
    out := ""
    Loop, Parse, code, `n, `r {
        if (SubStr(A_LoopField, 1, 5) = "func ") {
            ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
            ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
            str1 := Trim(StringTrimLeft(A_LoopField, 5))
            str2 := Trim(StrSplit(str1, "(", 1))
            str3 := StrSplit(str1, "(", 2)
            str3 := Trim(StrReplace(str3, ")", ""))
            str4 := ""
            if (Trim(str3) != "") {
                fix_func_temp_arr := []
                fix_func_temp_int := 1
                Loop, Parse, str3, "," {
                    str4 .= "_jhkjli_HTLL_HTLL_HTLL_" . Trim(A_LoopField) . ", "
                    fix_func_temp_arr.add(Trim(A_LoopField))
                }
                StringTrimRight, str4, str4, 2
                out .= "func " . str2 . "(" . str4 . ")" . Chr(10)
            }
            else {
                out .= A_LoopField . Chr(10)
            }
            ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
            ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
        }
        else if (Trim(A_LoopField) = "funcend") or (Trim(A_LoopField) = "endfunc") {
            fix_func_temp_int := 0
            fix_func_temp_arr := []
            out .= A_LoopField . Chr(10)
        }
        else {
            if (fix_func_temp_int = 1) {
                str1 := A_LoopField
                Loop, % fix_func_temp_arr.size() {
                    str1 := RegExReplace(str1, "\b" . Trim(fix_func_temp_arr[A_Index]) . "\b", "_jhkjli_HTLL_HTLL_HTLL_" . Trim(fix_func_temp_arr[A_Index]))
                }
                out .= str1 . Chr(10)
            }
            else {
                out .= A_LoopField . Chr(10)
            }
        }
    }
    StringTrimRight, code, out, 1
    out := ""
    Loop, Parse, code, `n, `r {
        if (SubStr(A_LoopField, 1, 7) = "arradd ") {
            str1 := Trim(StringTrimLeft(A_LoopField, 7))
            str2 := StrSplit(str1, " ", 1)
            str3 := StringTrimLeft(str1, StrLen(str2) + 1)
            str4 := ""
            if (is_arm = 1) {
                ; --- AArch64 CODE GENERATION ---
                Loop, Parse, str3 {
                    ; For each character, we call array_append(array_ptr, char_value)
                    ; Arg 1 (array_ptr) goes in x0
                    ; Arg 2 (char_value) goes in x1
                    str4 .= "    ldr x0, =" . str2 . Chr(10)
                    str4 .= "    mov x1, #" . Chr(39) . A_LoopField . Chr(39) . Chr(10)
                    str4 .= "    bl array_append" . Chr(10)
                }
            }
            else if (is_oryx = 1) {
                        out .= "meta " . A_LoopField . Chr(10)
                ; --- ORYX IR GENERATION ---
                Loop, Parse, str3 {
                    ; arr.add arrayName, charValue
                    str4 .= "    arr.add " . str2 . ", " . STR(Asc(A_LoopField)) . Chr(10)
                }
            }
            else {
                ; --- YOUR EXISTING X86 CODE - UNCHANGED ---
                Loop, Parse, str3 {
                    str4 .= "mov rsi, " . Chr(39) . A_LoopField . Chr(39) . Chr(10) . "mov rdi, " . str2 . Chr(10) . "call array_append" . Chr(10)
                }
            }
            out .= str4 . Chr(10)
        }
        else if (SubStr(A_LoopField, 1, 4) = "int ") {
            str1 := Trim(StringTrimLeft(A_LoopField, 4))
            if (is_arm = 1) {
                ; --- AArch64 CODE GENERATION ---
                if (InStr(str1, ":=")) {
                    str2 := Trim(StrSplit(str1, ":=", 1))
                    str3 := Trim(StrSplit(str1, ":=", 2))
                    if (RegExMatch(str3, "^\d+$")) {
                        dot_data_ints .= str2 . ": .quad " . str3 . Chr(10)
                    }
                    else {
                        dot_data_ints .= str2 . ": .quad 0" . Chr(10)
                        ; ############## FIX START ##############
                        if (str3 = "rax") {
                            out .= "    mov x9, x0" . Chr(10)
                        }
                        else if (str3 = "A_Index") {
                            out .= "    mov x9, x20" . Chr(10)
                        }
                        else {
                            out .= "    ldr x10, =" . str3 . Chr(10)
                            out .= "    ldr x9, [x10]" . Chr(10)
                        }
                        ; ############## FIX END ##############
                        out .= "    ldr x10, =" . str2 . Chr(10)
                        out .= "    str x9, [x10]" . Chr(10)
                    }
                }
                else {
                    if (InStr(str1, ":=") = false) and (InStr(str1, "+=") = false) and (InStr(str1, "-=") = false) and (InStr(str1, "*=") = false) {
                        dot_data_ints .= Trim(str1) . ": .quad 0" . Chr(10)
                    }
                }
                if (InStr(str1, "*=")) {
                    str2 := Trim(StrSplit(str1, "*=", 1))
                    dot_data_ints .= str2 . ": .quad 0" . Chr(10)
                }
                else if (InStr(str1, "+=")) {
                    str2 := Trim(StrSplit(str1, "+=", 1))
                    dot_data_ints .= str2 . ": .quad 0" . Chr(10)
                }
                else if (InStr(str1, "-=")) {
                    str2 := Trim(StrSplit(str1, "-=", 1))
                    dot_data_ints .= str2 . ": .quad 0" . Chr(10)
                }
                if (InStr(A_LoopField, " += ")) {
                    str2 := Trim(StrSplit(str1, "+=", 1))
                    str3 := Trim(StrSplit(str1, "+=", 2))
                    out .= "    ldr x10, =" . str2 . Chr(10)
                    out .= "    ldr x9, [x10]" . Chr(10)
                    ; ############## FIX START ##############
                    if (str3 = "rax") {
                        out .= "    add x9, x9, x0" . Chr(10)
                    }
                    else if (str3 = "A_Index") {
                        out .= "    add x9, x9, x20" . Chr(10)
                    }
                    else if (RegExMatch(str3, "^\d+$")) {
                        out .= "    add x9, x9, #" . str3 . Chr(10)
                    }
                    else {
                        out .= "    ldr x11, =" . str3 . Chr(10) . "    ldr x11, [x11]" . Chr(10)
                        out .= "    add x9, x9, x11" . Chr(10)
                    }
                    ; ############## FIX END ##############
                    out .= "    str x9, [x10]" . Chr(10)
                }
                else if (InStr(A_LoopField, " *= ")) {
                    str2 := Trim(StrSplit(str1, "*=", 1))
                    str3 := Trim(StrSplit(str1, "*=", 2))
                    out .= "    ldr x10, =" . str2 . Chr(10)
                    out .= "    ldr x9, [x10]" . Chr(10)
                    ; ############## FIX START ##############
                    if (str3 = "rax") {
                        out .= "    mul x9, x9, x0" . Chr(10)
                    }
                    else if (str3 = "A_Index") {
                        out .= "    mul x9, x9, x20" . Chr(10)
                    }
                    else if (RegExMatch(str3, "^\d+$")) {
                        out .= "    mov x11, #" . str3 . Chr(10)
                        out .= "    mul x9, x9, x11" . Chr(10)
                    }
                    else {
                        out .= "    ldr x11, =" . str3 . Chr(10) . "    ldr x11, [x11]" . Chr(10)
                        out .= "    mul x9, x9, x11" . Chr(10)
                    }
                    ; ############## FIX END ##############
                    out .= "    str x9, [x10]" . Chr(10)
                }
                else if (InStr(A_LoopField, " -= ")) {
                    str2 := Trim(StrSplit(str1, "-=", 1))
                    str3 := Trim(StrSplit(str1, "-=", 2))
                    out .= "    ldr x10, =" . str2 . Chr(10)
                    out .= "    ldr x9, [x10]" . Chr(10)
                    ; ############## FIX START ##############
                    if (str3 = "rax") {
                        out .= "    sub x9, x9, x0" . Chr(10)
                    }
                    else if (str3 = "A_Index") {
                        out .= "    sub x9, x9, x20" . Chr(10)
                    }
                    else if (RegExMatch(str3, "^\d+$")) {
                        out .= "    sub x9, x9, #" . str3 . Chr(10)
                    }
                    else {
                        out .= "    ldr x11, =" . str3 . Chr(10) . "    ldr x11, [x11]" . Chr(10)
                        out .= "    sub x9, x9, x11" . Chr(10)
                    }
                    ; ############## FIX END ##############
                    out .= "    str x9, [x10]" . Chr(10)
                }
            }
            else if (is_oryx = 1) {
                        out .= "meta " . A_LoopField . Chr(10)
                ; --- ORYX IR GENERATION ---
                if (InStr(str1, ":=")) {
                    str2 := Trim(StrSplit(str1, ":=", 1))
                    str3 := Trim(StrSplit(str1, ":=", 2))
                    
                    if (RegExMatch(str3, "^\d+$")) {
                        out .= "int " . str2 . ": " . str3 . Chr(10)
                    }
                    else {
                        out .= "int " . str2 . ": 0" . Chr(10)
                        strSrc := str3
                        if (str3 = "rax") {
                            strSrc := "r0"
                        }
                        else if (str3 = "A_Index") {
                            strSrc := "r20"
                        }
                        out .= "mov " . str2 . ", " . strSrc . Chr(10)
                    }
                }
                else {
                    ; Handle pure declaration or declaration with math
                    str2 := str1
                    if (InStr(str1, "+=")) {
                        str2 := Trim(StrSplit(str1, "+=", 1))
                    }
                    else if (InStr(str1, "-=")) {
                        str2 := Trim(StrSplit(str1, "-=", 1))
                    }
                    else if (InStr(str1, "*=")) {
                        str2 := Trim(StrSplit(str1, "*=", 1))
                    }
                    out .= "int " . Trim(str2) . ": 0" . Chr(10)
                }

                if (InStr(A_LoopField, " += ")) {
                    str2 := Trim(StrSplit(str1, "+=", 1))
                    str3 := Trim(StrSplit(str1, "+=", 2))
                    strSrc := str3
                    if (str3 = "rax") { strSrc := "r0" }
                    else if (str3 = "A_Index") { strSrc := "r20" }
                    out .= "add " . str2 . ", " . strSrc . Chr(10)
                }
                else if (InStr(A_LoopField, " *= ")) {
                    str2 := Trim(StrSplit(str1, "*=", 1))
                    str3 := Trim(StrSplit(str1, "*=", 2))
                    strSrc := str3
                    if (str3 = "rax") { strSrc := "r0" }
                    else if (str3 = "A_Index") { strSrc := "r20" }
                    out .= "mul " . str2 . ", " . strSrc . Chr(10)
                }
                else if (InStr(A_LoopField, " -= ")) {
                    str2 := Trim(StrSplit(str1, "-=", 1))
                    str3 := Trim(StrSplit(str1, "-=", 2))
                    strSrc := str3
                    if (str3 = "rax") { strSrc := "r0" }
                    else if (str3 = "A_Index") { strSrc := "r20" }
                    out .= "sub " . str2 . ", " . strSrc . Chr(10)
                }
            }
            else {
                ; --- YOUR EXISTING X86 CODE - UNCHANGED ---
                str1 := Trim(StringTrimLeft(A_LoopField, 4))
                if (InStr(str1, ":=")) {
                    str2 := Trim(StrSplit(str1, ":=", 1))
                    str3 := Trim(StrSplit(str1, ":=", 2))
                    if (RegExMatch(str3, "^\d+$")) {
                        dot_data_ints .= str2 . " dq " . str3 . Chr(10)
                    }
                    else {
                        dot_data_ints .= str2 . " dq 0" . Chr(10)
                        out .= "mov rdi, [" . str3 . "]" . Chr(10)
                        out .= "mov [" . str2 . "], rdi" . Chr(10)
                    }
                }
                else {
                    if (InStr(str1, ":=") = false) and (InStr(str1, "+=") = false) and (InStr(str1, "-=") = false) and (InStr(str1, "*=") = false) {
                        dot_data_ints .= Trim(str1) . " dq 0" . Chr(10)
                    }
                }
                if (InStr(str1, "*=")) {
                    str2 := Trim(StrSplit(str1, "*=", 1))
                    str3 := Trim(StrSplit(str1, "*=", 2))
                    dot_data_ints .= str2 . " dq 0" . Chr(10)
                }
                else if (InStr(str1, "+=")) {
                    str2 := Trim(StrSplit(str1, "+=", 1))
                    str3 := Trim(StrSplit(str1, "+=", 2))
                    dot_data_ints .= str2 . " dq 0" . Chr(10)
                }
                else if (InStr(str1, "-=")) {
                    str2 := Trim(StrSplit(str1, "-=", 1))
                    str3 := Trim(StrSplit(str1, "-=", 2))
                    dot_data_ints .= str2 . " dq 0" . Chr(10)
                }
                if (InStr(A_LoopField, " += ")) {
                    str2 := Trim(StrSplit(str1, "+=", 1))
                    str3 := Trim(StrSplit(str1, "+=", 2))
                    if (RegExMatch(str3, "^\d+$")) {
                        out .= "add qword [" . str2 . "], " . str3 . Chr(10)
                    }
                    else {
                        out .= "mov rdi, [" . str3 . "]" . Chr(10)
                        out .= "add qword [" . str2 . "], rdi" . Chr(10)
                    }
                }
                else if (InStr(A_LoopField, " *= ")) {
                    str2 := Trim(StrSplit(str1, "*=", 1))
                    str3 := Trim(StrSplit(str1, "*=", 2))
                    if (RegExMatch(str3, "^\d+$")) {
                        out .= "mov rax, [" . str2 . "]" . Chr(10)
                        out .= "imul rax, " . str3 . Chr(10)
                        out .= "mov [" . str2 . "], rax" . Chr(10)
                    }
                    else {
                        out .= "mov rax, [" . str2 . "]" . Chr(10)
                        out .= "imul rax, [" . str3 . "]" . Chr(10)
                        out .= "mov [" . str2 . "], rax" . Chr(10)
                    }
                }
                else if (InStr(A_LoopField, " -= ")) {
                    str2 := Trim(StrSplit(str1, "-=", 1))
                    str3 := Trim(StrSplit(str1, "-=", 2))
                    if (RegExMatch(str3, "^\d+$")) {
                        out .= "sub qword [" . str2 . "], " . str3 . Chr(10)
                    }
                    else {
                        out .= "mov rdi, [" . str3 . "]" . Chr(10)
                        out .= "sub qword [" . str2 . "], rdi" . Chr(10)
                    }
                }
            }
        }
        else if (SubStr(A_LoopField, 1, 5) = "nint ") {
            str1 := Trim(StringTrimLeft(A_LoopField, 5))
            if (InStr(str1, " ")) {
                nintArr.add(StrSplit(str1, " ", 1))
            }
            else {
                nintArr.add(Trim(str1))
            }
            if (is_arm = 1) {
                ; --- AArch64 CODE GENERATION ---
                if (InStr(str1, ":=")) {
                    str2 := Trim(StrSplit(str1, ":=", 1))
                    str3 := Trim(StrSplit(str1, ":=", 2))
                    if (RegExMatch(str3, "^\d+$")) {
                        dot_data_ints .= str2 . ": .quad " . str3 . Chr(10)
                        dot_data_ints .= str2 . "_is_negative: .quad 0" . Chr(10)
                    }
                    else {
                        dot_data_ints .= str2 . ": .quad 0" . Chr(10)
                        dot_data_ints .= str2 . "_is_negative: .quad 0" . Chr(10)
                        ; ############## FIX START ##############
                        if (str3 = "rax") {
                            out .= "    mov x9, x0" . Chr(10)
                        }
                        else if (str3 = "A_Index") {
                            out .= "    mov x9, x20" . Chr(10)
                        }
                        else {
                            out .= "    ldr x10, =" . str3 . Chr(10) . "    ldr x9, [x10]" . Chr(10)
                        }
                        ; ############## FIX END ##############
                        out .= "    ldr x10, =" . str2 . Chr(10) . "    str x9, [x10]" . Chr(10)
                    }
                }
                else {
                    if (InStr(str1, ":=") = false) and (InStr(str1, "+=") = false) and (InStr(str1, "-=") = false) and (InStr(str1, "*=") = false) {
                        dot_data_ints .= Trim(str1) . ": .quad 0" . Chr(10)
                        dot_data_ints .= Trim(str1) . "_is_negative: .quad 0" . Chr(10)
                    }
                }
                if (InStr(str1, "*=")) {
                    str2 := Trim(StrSplit(str1, "*=", 1))
                    dot_data_ints .= str2 . ": .quad 0" . Chr(10)
                    dot_data_ints .= str2 . "_is_negative: .quad 0" . Chr(10)
                }
                else if (InStr(str1, "+=")) {
                    str2 := Trim(StrSplit(str1, "+=", 1))
                    dot_data_ints .= str2 . ": .quad 0" . Chr(10)
                    dot_data_ints .= str2 . "_is_negative: .quad 0" . Chr(10)
                }
                else if (InStr(str1, "-=")) {
                    str2 := Trim(StrSplit(str1, "-=", 1))
                    dot_data_ints .= str2 . ": .quad 0" . Chr(10)
                    dot_data_ints .= str2 . "_is_negative: .quad 0" . Chr(10)
                }
                if (InStr(A_LoopField, " += ")) {
                    str2 := Trim(StrSplit(str1, "+=", 1))
                    str3 := Trim(StrSplit(str1, "+=", 2))
                    out .= "    ldr x10, =" . str2 . Chr(10) . "    ldr x9, [x10]" . Chr(10)
                    ; ############## FIX START ##############
                    if (str3 = "rax") {
                        out .= "    add x9, x9, x0" . Chr(10)
                    }
                    else if (str3 = "A_Index") {
                        out .= "    add x9, x9, x20" . Chr(10)
                    }
                    else if (RegExMatch(str3, "^\d+$")) {
                        out .= "    add x9, x9, #" . str3 . Chr(10)
                    }
                    else {
                        out .= "    ldr x11, =" . str3 . Chr(10) . "    ldr x11, [x11]" . Chr(10)
                        out .= "    add x9, x9, x11" . Chr(10)
                    }
                    ; ############## FIX END ##############
                    out .= "    str x9, [x10]" . Chr(10)
                    out .= "    ldr x0, =" . str2 . Chr(10)
                    out .= "    ldr x1, =" . str2 . "_is_negative" . Chr(10)
                    out .= "    bl is_nint_negative" . Chr(10)
                }
                else if (InStr(A_LoopField, " *= ")) {
                    str2 := Trim(StrSplit(str1, "*=", 1))
                    str3 := Trim(StrSplit(str1, "*=", 2))
                    out .= "    ldr x10, =" . str2 . Chr(10) . "    ldr x9, [x10]" . Chr(10)
                    ; ############## FIX START ##############
                    if (str3 = "rax") {
                        out .= "    mul x9, x9, x0" . Chr(10)
                    }
                    else if (str3 = "A_Index") {
                        out .= "    mul x9, x9, x20" . Chr(10)
                    }
                    else if (RegExMatch(str3, "^\d+$")) {
                        out .= "    mov x11, #" . str3 . Chr(10)
                        out .= "    mul x9, x9, x11" . Chr(10)
                    }
                    else {
                        out .= "    ldr x11, =" . str3 . Chr(10) . "    ldr x11, [x11]" . Chr(10)
                        out .= "    mul x9, x9, x11" . Chr(10)
                    }
                    ; ############## FIX END ##############
                    out .= "    str x9, [x10]" . Chr(10)
                    out .= "    ldr x0, =" . str2 . Chr(10)
                    out .= "    ldr x1, =" . str2 . "_is_negative" . Chr(10)
                    out .= "    bl is_nint_negative" . Chr(10)
                }
                else if (InStr(A_LoopField, " -= ")) {
                    str2 := Trim(StrSplit(str1, "-=", 1))
                    str3 := Trim(StrSplit(str1, "-=", 2))
                    out .= "    ldr x10, =" . str2 . Chr(10) . "    ldr x9, [x10]" . Chr(10)
                    ; ############## FIX START ##############
                    if (str3 = "rax") {
                        out .= "    sub x9, x9, x0" . Chr(10)
                    }
                    else if (str3 = "A_Index") {
                        out .= "    sub x9, x9, x20" . Chr(10)
                    }
                    else if (RegExMatch(str3, "^\d+$")) {
                        out .= "    sub x9, x9, #" . str3 . Chr(10)
                    }
                    else {
                        out .= "    ldr x11, =" . str3 . Chr(10) . "    ldr x11, [x11]" . Chr(10)
                        out .= "    sub x9, x9, x11" . Chr(10)
                    }
                    ; ############## FIX END ##############
                    out .= "    str x9, [x10]" . Chr(10)
                    out .= "    ldr x0, =" . str2 . Chr(10)
                    out .= "    ldr x1, =" . str2 . "_is_negative" . Chr(10)
                    out .= "    bl is_nint_negative" . Chr(10)
                }
            }
            else if (is_oryx = 1) {
                        out .= "meta " . A_LoopField . Chr(10)
                ; --- ORYX IR GENERATION (nint) ---
                if (InStr(str1, ":=")) {
                    str2 := Trim(StrSplit(str1, ":=", 1))
                    str3 := Trim(StrSplit(str1, ":=", 2))
                    
                    if (RegExMatch(str3, "^\d+$")) {
                        out .= "int " . str2 . ": " . str3 . Chr(10)
                    }
                    else {
                        out .= "int " . str2 . ": 0" . Chr(10)
                        strSrc := str3
                        if (str3 = "rax") { strSrc := "r0" }
                        else if (str3 = "A_Index") { strSrc := "r20" }
                        out .= "mov " . str2 . ", " . strSrc . Chr(10)
                    }
                    ; Initialize _is_negative just for compatibility
                    out .= "int " . str2 . "_is_negative: 0" . Chr(10)
                }
                else {
                    str2 := str1
                    if (InStr(str1, "+=")) { str2 := Trim(StrSplit(str1, "+=", 1)) }
                    else if (InStr(str1, "-=")) { str2 := Trim(StrSplit(str1, "-=", 1)) }
                    else if (InStr(str1, "*=")) { str2 := Trim(StrSplit(str1, "*=", 1)) }
                    
                    out .= "int " . Trim(str2) . ": 0" . Chr(10)
                    out .= "int " . Trim(str2) . "_is_negative: 0" . Chr(10)
                }

                if (InStr(A_LoopField, " += ")) {
                    str2 := Trim(StrSplit(str1, "+=", 1))
                    str3 := Trim(StrSplit(str1, "+=", 2))
                    strSrc := str3
                    if (str3 = "rax") { strSrc := "r0" }
                    else if (str3 = "A_Index") { strSrc := "r20" }
                    out .= "add " . str2 . ", " . strSrc . Chr(10)
                }
                else if (InStr(A_LoopField, " *= ")) {
                    str2 := Trim(StrSplit(str1, "*=", 1))
                    str3 := Trim(StrSplit(str1, "*=", 2))
                    strSrc := str3
                    if (str3 = "rax") { strSrc := "r0" }
                    else if (str3 = "A_Index") { strSrc := "r20" }
                    out .= "mul " . str2 . ", " . strSrc . Chr(10)
                }
                else if (InStr(A_LoopField, " -= ")) {
                    str2 := Trim(StrSplit(str1, "-=", 1))
                    str3 := Trim(StrSplit(str1, "-=", 2))
                    strSrc := str3
                    if (str3 = "rax") { strSrc := "r0" }
                    else if (str3 = "A_Index") { strSrc := "r20" }
                    out .= "sub " . str2 . ", " . strSrc . Chr(10)
                }
            }
            else {
                ; --- YOUR EXISTING X86 CODE - UNCHANGED ---
                if (InStr(str1, ":=")) {
                    str2 := Trim(StrSplit(str1, ":=", 1))
                    str3 := Trim(StrSplit(str1, ":=", 2))
                    if (RegExMatch(str3, "^\d+$")) {
                        dot_data_ints .= str2 . " dq " . str3 . Chr(10)
                        dot_data_ints .= str2 . "_is_negative: dq 0" . Chr(10)
                    }
                    else {
                        dot_data_ints .= str2 . " dq 0" . Chr(10)
                        dot_data_ints .= str2 . "_is_negative: dq 0" . Chr(10)
                        out .= "mov rdi, [" . str3 . "]" . Chr(10)
                        out .= "mov [" . str2 . "], rdi" . Chr(10)
                    }
                }
                else {
                    if (InStr(str1, ":=") = false) and (InStr(str1, "+=") = false) and (InStr(str1, "-=") = false) and (InStr(str1, "*=") = false) {
                        dot_data_ints .= Trim(str1) . " dq 0" . Chr(10)
                        dot_data_ints .= Trim(str1) . "_is_negative: dq 0" . Chr(10)
                    }
                }
                if (InStr(str1, "*=")) {
                    str2 := Trim(StrSplit(str1, "*=", 1))
                    str3 := Trim(StrSplit(str1, "*=", 2))
                    dot_data_ints .= str2 . " dq 0" . Chr(10)
                    dot_data_ints .= str2 . "_is_negative: dq 0" . Chr(10)
                }
                else if (InStr(str1, "+=")) {
                    str2 := Trim(StrSplit(str1, "+=", 1))
                    str3 := Trim(StrSplit(str1, "+=", 2))
                    dot_data_ints .= str2 . " dq 0" . Chr(10)
                    dot_data_ints .= str2 . "_is_negative: dq 0" . Chr(10)
                }
                else if (InStr(str1, "-=")) {
                    str2 := Trim(StrSplit(str1, "-=", 1))
                    str3 := Trim(StrSplit(str1, "-=", 2))
                    dot_data_ints .= str2 . " dq 0" . Chr(10)
                    dot_data_ints .= str2 . "_is_negative: dq 0" . Chr(10)
                }
                if (InStr(A_LoopField, " += ")) {
                    str2 := Trim(StrSplit(str1, "+=", 1))
                    str3 := Trim(StrSplit(str1, "+=", 2))
                    if (RegExMatch(str3, "^\d+$")) {
                        out .= "add qword [" . str2 . "], " . str3 . Chr(10)
                        out .= "lea rdi, [" . str2 . "]" . Chr(10) . "lea rsi, [" . str2 . "_is_negative]" . Chr(10) . "call is_nint_negative" . Chr(10)
                    }
                    else {
                        out .= "mov rdi, [" . str3 . "]" . Chr(10)
                        out .= "add qword [" . str2 . "], rdi" . Chr(10)
                        out .= "lea rdi, [" . str2 . "]" . Chr(10) . "lea rsi, [" . str2 . "_is_negative]" . Chr(10) . "call is_nint_negative" . Chr(10)
                    }
                }
                else if (InStr(A_LoopField, " *= ")) {
                    str2 := Trim(StrSplit(str1, "*=", 1))
                    str3 := Trim(StrSplit(str1, "*=", 2))
                    if (RegExMatch(str3, "^\d+$")) {
                        out .= "mov rax, [" . str2 . "]" . Chr(10)
                        out .= "imul rax, " . str3 . Chr(10)
                        out .= "mov [" . str2 . "], rax" . Chr(10)
                        out .= "lea rdi, [" . str2 . "]" . Chr(10) . "lea rsi, [" . str2 . "_is_negative]" . Chr(10) . "call is_nint_negative" . Chr(10)
                    }
                    else {
                        out .= "mov rax, [" . str2 . "]" . Chr(10)
                        out .= "imul rax, [" . str3 . "]" . Chr(10)
                        out .= "mov [" . str2 . "], rax" . Chr(10)
                        out .= "lea rdi, [" . str2 . "]" . Chr(10) . "lea rsi, [" . str2 . "_is_negative]" . Chr(10) . "call is_nint_negative" . Chr(10)
                    }
                }
                else if (InStr(A_LoopField, " -= ")) {
                    str2 := Trim(StrSplit(str1, "-=", 1))
                    str3 := Trim(StrSplit(str1, "-=", 2))
                    if (RegExMatch(str3, "^\d+$")) {
                        out .= "sub qword [" . str2 . "], " . str3 . Chr(10)
                        out .= "lea rdi, [" . str2 . "]" . Chr(10) . "lea rsi, [" . str2 . "_is_negative]" . Chr(10) . "call is_nint_negative" . Chr(10)
                    }
                    else {
                        out .= "mov rdi, [" . str3 . "]" . Chr(10)
                        out .= "sub qword [" . str2 . "], rdi" . Chr(10)
                        out .= "lea rdi, [" . str2 . "]" . Chr(10) . "lea rsi, [" . str2 . "_is_negative]" . Chr(10) . "call is_nint_negative" . Chr(10)
                    }
                }
            }
        }
        else if (InStr(A_LoopField, " := ")) or (InStr(A_LoopField, " += ")) or (InStr(A_LoopField, " -= ")) or (InStr(A_LoopField, " *= ")) {
            if (is_arm = 1) {
                if (InStr(A_LoopField, " := ")) {
                    str1 := Trim(A_LoopField)
                    str2 := Trim(StrSplit(str1, ":=", 1))
                    str3 := Trim(StrSplit(str1, ":=", 2))
                    int isLhsStackVar := 0
                    if (inFunc = 1) {
                        Loop, % funcArgsArr.size() {
                            if (Trim(funcArgsArr[A_Index]) = str2) {
                                isLhsStackVar := 1
                                break
                            }
                        }
                    }
                    if (str3 = "rax") {
                        out .= "    mov x9, x0" . Chr(10)
                    }
                    else if (str3 = "A_Index") {
                        out .= "    mov x9, x20" . Chr(10)
                    }
                    else if (RegExMatch(str3, "^\d+$")) {
                        out .= "    mov x9, #" . str3 . Chr(10)
                    }
                    else {
                        int isRhsStackVar := 0
                        if (inFunc = 1) {
                            Loop, % funcArgsArr.size() {
                                if (Trim(funcArgsArr[A_Index]) = str3) {
                                    isRhsStackVar := 1
                                    break
                                }
                            }
                        }
                        if (isRhsStackVar = 1) {
                            out .= "    ldr x9, =" . str3 . Chr(10)
                        }
                        else {
                            out .= "    ldr x10, =" . str3 . Chr(10) . Chr(10)
                            out .= "    ldr x9, [x10]" . Chr(10)
                        }
                    }
                    if (isLhsStackVar = 1) {
                        out .= "    str x9, =" . str2 . Chr(10)
                    }
                    else {
                        out .= "    ldr x10, =" . str2 . Chr(10) . Chr(10)
                        out .= "    str x9, [x10]" . Chr(10)
                    }
                    if (isNint(str2)) {
                        out .= "    ldr x0, =" . str2 . Chr(10) . "    ldr x1, =" . str2 . "_is_negative" . Chr(10) . "    bl is_nint_negative" . Chr(10)
                    }
                }
                else {
                    ; Handles +=, -=, *= []
                    str op := ""
                    str op_asm := ""
                    if (InStr(A_LoopField, " += ")) {
                        op := "+="
                        op_asm := "add"
                    }
                    else if (InStr(A_LoopField, " -= ")) {
                        op := "-="
                        op_asm := "sub"
                    }
                    else if (InStr(A_LoopField, " *= ")) {
                        op := "*="
                        op_asm := "mul"
                    }
                    str1 := Trim(A_LoopField)
                    str2 := Trim(StrSplit(str1, op, 1))
                    str3 := Trim(StrSplit(str1, op, 2))
                    ; --- Load Destination Value into x9 ---
                    int isLhsStackVar := 0
                    if (inFunc = 1) {
                        Loop, % funcArgsArr.size() {
                            if (Trim(funcArgsArr[A_Index]) = str2) {
                                isLhsStackVar := 1
                                break
                            }
                        }
                    }
                    if (isLhsStackVar = 1) {
                        out .= "    ldr x9, =" . str2 . Chr(10)
                    }
                    else {
                        out .= "    ldr x10, =" . str2 . Chr(10) . Chr(10)
                        out .= "    ldr x9, [x10]" . Chr(10)
                    }
                    ; --- Load Source Value into x11 and perform operation ---
                    if (str3 = "rax") {
                        out .= "    " . op_asm . " x9, x9, x0" . Chr(10)
                    }
                    else if (str3 = "A_Index") {
                        out .= "    " . op_asm . " x9, x9, x20" . Chr(10)
                    }
                    else if (RegExMatch(str3, "^\d+$")) {
                        if (op_asm = "mul") {
                            out .= "    mov x11, #" . str3 . Chr(10) . Chr(10)
                            out .= "    " . op_asm . " x9, x9, x11" . Chr(10)
                        }
                        else {
                            out .= "    " . op_asm . " x9, x9, #" . str3 . Chr(10)
                        }
                    }
                    else {
                        int isRhsStackVar := 0
                        if (inFunc = 1) {
                            Loop, % funcArgsArr.size() {
                                if (Trim(funcArgsArr[A_Index]) = str3) {
                                    isRhsStackVar := 1
                                    break
                                }
                            }
                        }
                        if (isRhsStackVar = 1) {
                            out .= "    ldr x11, =" . str3 . Chr(10) . Chr(10)
                            out .= "    " . op_asm . " x9, x9, x11" . Chr(10)
                        }
                        else {
                            out .= "    ldr x11, =" . str3 . Chr(10) . Chr(10)
                            out .= "    ldr x11, [x11]" . Chr(10) . Chr(10)
                            out .= "    " . op_asm . " x9, x9, x11" . Chr(10)
                        }
                    }
                    ; --- Store Result back into Destination ---
                    if (isLhsStackVar = 1) {
                        out .= "    str x9, =" . str2 . Chr(10)
                    }
                    else {
                        out .= "    str x9, [x10]" . Chr(10)
                    }
                    if (isNint(str2)) {
                        out .= "    ldr x0, =" . str2 . Chr(10) . "    ldr x1, =" . str2 . "_is_negative" . Chr(10) . "    bl is_nint_negative" . Chr(10)
                    }
                }
            }
            else if (is_oryx = 1) {
                        out .= "meta " . A_LoopField . Chr(10)
                ; --- ORYX IR GENERATION (assignments) ---
                if (InStr(A_LoopField, " := ")) {
                    str1 := Trim(A_LoopField)
                    str2 := Trim(StrSplit(str1, ":=", 1))
                    str3 := Trim(StrSplit(str1, ":=", 2))
                    strSrc := str3
                    if (str3 = "rax") { strSrc := "r0" }
                    else if (str3 = "A_Index") { strSrc := "r20" }
                    
                    ; mov dest, src
                    out .= "mov " . str2 . ", " . strSrc . Chr(10)
                    
                    ; Optional negative check for nint compatibility
                    if (isNint(str2)) {
                        ; out .= "cmp " . str2 . ", 0" ... (VM handles signs, skipping)
                    }
                }
                else {
                    ; Handles +=, -=, *=
                    str op := ""
                    str op_asm := ""
                    if (InStr(A_LoopField, " += ")) { op := "+="; op_asm := "add" }
                    else if (InStr(A_LoopField, " -= ")) { op := "-="; op_asm := "sub" }
                    else if (InStr(A_LoopField, " *= ")) { op := "*="; op_asm := "mul" }
                    
                    str1 := Trim(A_LoopField)
                    str2 := Trim(StrSplit(str1, op, 1))
                    str3 := Trim(StrSplit(str1, op, 2))
                    strSrc := str3
                    if (str3 = "rax") { strSrc := "r0" }
                    else if (str3 = "A_Index") { strSrc := "r20" }
                    
                    out .= op_asm . " " . str2 . ", " . strSrc . Chr(10)
                }
            }
            else {
                ; --- YOUR EXISTING X86 CODE - UNCHANGED ---
                if (InStr(A_LoopField, " := ")) {
                    str1 := Trim(A_LoopField)
                    str2 := Trim(StrSplit(str1, ":=", 1))
                    str3 := Trim(StrSplit(str1, ":=", 2))
                    if (RegExMatch(str3, "^\d+$")) {
                        out .= "mov qword [" . str2 . "], " . str3 . Chr(10)
                        if (isNint(str2)) {
                            out .= "lea rdi, [" . str2 . "]" . Chr(10) . "lea rsi, [" . str2 . "_is_negative]" . Chr(10) . "call is_nint_negative" . Chr(10)
                        }
                    }
                    else {
                        out .= "mov rdi, [" . str3 . "]" . Chr(10)
                        out .= "mov [" . str2 . "], rdi" . Chr(10)
                        if (isNint(str2)) {
                            out .= "lea rdi, [" . str2 . "]" . Chr(10) . "lea rsi, [" . str2 . "_is_negative]" . Chr(10) . "call is_nint_negative" . Chr(10)
                        }
                    }
                }
                else if (InStr(A_LoopField, " += ")) {
                    str1 := Trim(A_LoopField)
                    str2 := Trim(StrSplit(str1, "+=", 1))
                    str3 := Trim(StrSplit(str1, "+=", 2))
                    if (RegExMatch(str3, "^\d+$")) {
                        out .= "add qword [" . str2 . "], " . str3 . Chr(10)
                        if (isNint(str2)) {
                            out .= "lea rdi, [" . str2 . "]" . Chr(10) . "lea rsi, [" . str2 . "_is_negative]" . Chr(10) . "call is_nint_negative" . Chr(10)
                        }
                    }
                    else {
                        out .= "mov rdi, [" . str3 . "]" . Chr(10)
                        out .= "add qword [" . str2 . "], rdi" . Chr(10)
                        if (isNint(str2)) {
                            out .= "lea rdi, [" . str2 . "]" . Chr(10) . "lea rsi, [" . str2 . "_is_negative]" . Chr(10) . "call is_nint_negative" . Chr(10)
                        }
                    }
                }
                else if (InStr(A_LoopField, " *= ")) {
                    str1 := Trim(A_LoopField)
                    str2 := Trim(StrSplit(str1, "*=", 1))
                    str3 := Trim(StrSplit(str1, "*=", 2))
                    if (RegExMatch(str3, "^\d+$")) {
                        out .= "mov rax, [" . str2 . "]" . Chr(10)
                        out .= "imul rax, " . str3 . Chr(10)
                        out .= "mov [" . str2 . "], rax" . Chr(10)
                        if (isNint(str2)) {
                            out .= "lea rdi, [" . str2 . "]" . Chr(10) . "lea rsi, [" . str2 . "_is_negative]" . Chr(10) . "call is_nint_negative" . Chr(10)
                        }
                    }
                    else {
                        out .= "mov rax, [" . str2 . "]" . Chr(10)
                        out .= "imul rax, [" . str3 . "]" . Chr(10)
                        out .= "mov [" . str2 . "], rax" . Chr(10)
                        if (isNint(str2)) {
                            out .= "lea rdi, [" . str2 . "]" . Chr(10) . "lea rsi, [" . str2 . "_is_negative]" . Chr(10) . "call is_nint_negative" . Chr(10)
                        }
                    }
                }
                else if (InStr(A_LoopField, " -= ")) {
                    str1 := Trim(A_LoopField)
                    str2 := Trim(StrSplit(str1, "-=", 1))
                    str3 := Trim(StrSplit(str1, "-=", 2))
                    if (RegExMatch(str3, "^\d+$")) {
                        out .= "sub qword [" . str2 . "], " . str3 . Chr(10)
                        if (isNint(str2)) {
                            out .= "lea rdi, [" . str2 . "]" . Chr(10) . "lea rsi, [" . str2 . "_is_negative]" . Chr(10) . "call is_nint_negative" . Chr(10)
                        }
                    }
                    else {
                        out .= "mov rdi, [" . str3 . "]" . Chr(10)
                        out .= "sub qword [" . str2 . "], rdi" . Chr(10)
                        if (isNint(str2)) {
                            out .= "lea rdi, [" . str2 . "]" . Chr(10) . "lea rsi, [" . str2 . "_is_negative]" . Chr(10) . "call is_nint_negative" . Chr(10)
                        }
                    }
                }
            }
        }
        else if (InStr(A_LoopField, "++")) {
            str1 := Trim(A_LoopField)
            StringTrimRight, str1, str1, 2
            str1 := Trim(str1)
            if (is_arm = 1) {
                if (str1 = "rax") {
                    out .= "    add x0, x0, #1" . Chr(10)
                }
                else if (str1 = "A_Index") {
                    out .= "    add x20, x20, #1" . Chr(10)
                }
                else {
                    int isStackVar := 0
                    if (inFunc = 1) {
                        Loop, % funcArgsArr.size() {
                            if (Trim(funcArgsArr[A_Index]) = str1) {
                                isStackVar := 1
                                break
                            }
                        }
                    }
                    if (isStackVar = 1) {
                        out .= "    ldr x9, =" . str1 . Chr(10)
                        out .= "    add x9, x9, #1" . Chr(10)
                        out .= "    str x9, =" . str1 . Chr(10)
                    }
                    else {
                        out .= "    ldr x10, =" . str1 . Chr(10)
                        out .= "    ldr x9, [x10]" . Chr(10)
                        out .= "    add x9, x9, #1" . Chr(10)
                        out .= "    str x9, [x10]" . Chr(10)
                    }
                    if (isNint(str1)) {
                        out .= "    ldr x0, =" . str1 . Chr(10) . "    ldr x1, =" . str1 . "_is_negative" . Chr(10) . "    bl is_nint_negative" . Chr(10)
                    }
                }
            }
            else if (is_oryx = 1) {
                        out .= "meta " . A_LoopField . Chr(10)
                ; --- ORYX IR (++) ---
                if (str1 = "rax") {
                    out .= "inc r0" . Chr(10)
                }
                else if (str1 = "A_Index") {
                    out .= "inc r20" . Chr(10)
                }
                else {
                    out .= "inc " . str1 . Chr(10)
                }
            }
            else {
                out .= "inc qword [" . str1 . "]" . Chr(10)
                if (isNint(str1)) {
                    out .= "lea rdi, [" . str1 . "]" . Chr(10) . "lea rsi, [" . str1 . "_is_negative]" . Chr(10) . "call is_nint_negative" . Chr(10)
                }
            }
        }
        else if (InStr(A_LoopField, "--")) {
            str1 := Trim(A_LoopField)
            StringTrimRight, str1, str1, 2
            str1 := Trim(str1)
            if (is_arm = 1) {
                if (str1 = "rax") {
                    out .= "    sub x0, x0, #1" . Chr(10)
                }
                else if (str1 = "A_Index") {
                    out .= "    sub x20, x20, #1" . Chr(10)
                }
                else {
                    int isStackVar := 0
                    if (inFunc = 1) {
                        Loop, % funcArgsArr.size() {
                            if (Trim(funcArgsArr[A_Index]) = str1) {
                                isStackVar := 1
                                break
                            }
                        }
                    }
                    if (isStackVar = 1) {
                        out .= "    ldr x9, =" . str1 . Chr(10)
                        out .= "    sub x9, x9, #1" . Chr(10)
                        out .= "    str x9, =" . str1 . Chr(10)
                    }
                    else {
                        out .= "    ldr x10, =" . str1 . Chr(10)
                        out .= "    ldr x9, [x10]" . Chr(10)
                        out .= "    sub x9, x9, #1" . Chr(10)
                        out .= "    str x9, [x10]" . Chr(10)
                    }
                    if (isNint(str1)) {
                        out .= "    ldr x0, =" . str1 . Chr(10) . "    ldr x1, =" . str1 . "_is_negative" . Chr(10) . "    bl is_nint_negative" . Chr(10)
                    }
                }
            }
            else if (is_oryx = 1) {
                        out .= "meta " . A_LoopField . Chr(10)
                ; --- ORYX IR (--) ---
                if (str1 = "rax") {
                    out .= "dec r0" . Chr(10)
                }
                else if (str1 = "A_Index") {
                    out .= "dec r20" . Chr(10)
                }
                else {
                    out .= "dec " . str1 . Chr(10)
                }
            }
            else {
                out .= "dec qword [" . str1 . "]" . Chr(10)
                if (isNint(str1)) {
                    out .= "lea rdi, [" . str1 . "]" . Chr(10) . "lea rsi, [" . str1 . "_is_negative]" . Chr(10) . "call is_nint_negative" . Chr(10)
                }
            }
        }
        else if (SubStr(A_LoopField, 1, 6) = "print(") {
            str1 := StringTrimLeft(A_LoopField, 6)
            StringTrimRight, str1, str1, 1
            if (is_arm = 1) {
                if (str1 = "rax") {
                    ; The value to print is ALREADY in x0.
                    ; We just need to set the 2nd arg (is_negative) and call.
                    out .= "    mov x1, xzr" . Chr(10)
                    out .= "    bl print_number" . Chr(10)
                }
                else if (str1 = "A_Index") {
                    out .= "    mov x0, x20" . Chr(10)
                    out .= "    mov x1, xzr" . Chr(10)
                    out .= "    bl print_number" . Chr(10)
                }
                else if (RegExMatch(str1, "^\d+$")) {
                    out .= "    mov x0, #" . Trim(str1) . Chr(10)
                    out .= "    mov x1, xzr" . Chr(10)
                    out .= "    bl print_number" . Chr(10)
                }
                else if (InStr(str1, "VYIGUOYIYVIUCFCYIUCFCYIGCYGICFHYFHCTCFTFDFGYGFC")) {
                    dot_data_print_temp_strings_count++
                    str temp_label := "ASM_STR_TEMP_PRINT_" . STR(dot_data_print_temp_strings_count)
                    ; GNU AS needs the string and newline handled separately for length calculation
                    str parsed_string := str1
                    dot_data_print_temp_strings .= temp_label . ": .string " . parsed_string . Chr(10)
                    dot_data_print_temp_strings .= temp_label . "_len = . - " . temp_label . Chr(10)
                    out .= "    ldr x1, =" . temp_label . Chr(10)
                    out .= "    mov x2, " . temp_label . "_len" . Chr(10)
                    out .= "    bl print_str" . Chr(10)
                    out .= "    ldr x1, =HTLL_nl" . Chr(10)
                    out .= "    mov x2, 1" . Chr(10)
                    out .= "    bl print_str" . Chr(10)
                }
                else {
                    ; --- START FIX ---
                    int isStackVar := 0
                    if (inFunc = 1) {
                        Loop, % funcArgsArr.size() {
                            if (Trim(str1) = funcArgsArr[A_Index]) {
                                isStackVar := 1
                                break
                            }
                        }
                    }
                    if (isStackVar = 1) {
                        ; Stack Var: Regex will convert '=str1' to '[sp, #offset]'
                        ; This generates: ldr x0, [sp, #offset]
                        out .= "    ldr x0, =" . Trim(str1) . Chr(10)
                        out .= "    mov x1, xzr" . Chr(10)
                        out .= "    bl print_number" . Chr(10)
                    }
                    else {
                        ; Global Var (your existing logic)
                        if (isNint(str1)) {
                            out .= "    ldr x9, =" . Trim(str1) . Chr(10) . "    ldr x0, [x9]" . Chr(10)
                            out .= "    ldr x9, =" . Trim(str1) . "_is_negative" . Chr(10) . "    ldr x1, [x9]" . Chr(10)
                            out .= "    bl print_number" . Chr(10)
                        }
                        else {
                            out .= "    ldr x9, =" . Trim(str1) . Chr(10) . "    ldr x0, [x9]" . Chr(10)
                            out .= "    mov x1, xzr" . Chr(10)
                            out .= "    bl print_number" . Chr(10)
                        }
                    }
                    ; --- END FIX ---
                }
            }
            else if (is_oryx = 1) {
                        out .= "meta " . A_LoopField . Chr(10)
                ; --- ORYX IR (print) ---
                if (str1 = "rax") {
                    out .= "mov r1, r0" . Chr(10)
                }
                else if (str1 = "A_Index") {
                    out .= "mov r1, r20" . Chr(10)
                }
                else if (RegExMatch(str1, "^\d+$")) {
                    out .= "mov r1, " . Trim(str1) . Chr(10)
                }
                else if (InStr(str1, "VYIGUOYIYVIUCFCYIUCFCYIGCYGICFHYFHCTCFTFDFGYGFC")) {
                    ; The post-processing loop will replace this token with "Actual String"
                    out .= "mov r1, " . str1 . Chr(10)
                }
                else {
                    ; Variable
                    out .= "mov r1, " . Trim(str1) . Chr(10)
                }
                out .= "call print" . Chr(10)
            }
            else {
                ; --- YOUR EXISTING X86 CODE - UNCHANGED ---
                if (RegExMatch(str1, "^\d+$")) {
                    out .= "mov rdi, " . Trim(str1) . Chr(10) . "mov rsi, 0" . Chr(10) . "call print_number" . Chr(10)
                }
                else if (InStr(str1, "VYIGUOYIYVIUCFCYIUCFCYIGCYGICFHYFHCTCFTFDFGYGFC")) {
                    dot_data_print_temp_strings_count++
                    dot_data_print_temp_strings .= "ASM_STR_TEMP_PRINT_" . STR(dot_data_print_temp_strings_count) . " db " . Trim(str1) . ", 10" . Chr(10) . "ASM_STR_TEMP_PRINT_" . STR(dot_data_print_temp_strings_count) . "_len = $-" . "ASM_STR_TEMP_PRINT_" . STR(dot_data_print_temp_strings_count) . Chr(10)
                    out .= "mov rsi, ASM_STR_TEMP_PRINT_" . STR(dot_data_print_temp_strings_count) . Chr(10) . "mov rdx, " . "ASM_STR_TEMP_PRINT_" . STR(dot_data_print_temp_strings_count) . "_len" . Chr(10) . "call print_str" . Chr(10)
                }
                else {
                    if (isNint(str1)) {
                        out .= "mov rdi, [" . Trim(str1) . "]" . Chr(10) . "mov rsi, [" . str1 . "_is_negative]" . Chr(10) . "call print_number" . Chr(10)
                    }
                    else {
                        out .= "mov rdi, [" . Trim(str1) . "]" . Chr(10) . "mov rsi, 0" . Chr(10) . "call print_number" . Chr(10)
                    }
                }
            }
        }
        else if (Trim(A_LoopField) = "print_rax_as_char") {
            if (is_arm = 1) {
                ; rax maps to x0, which is already the first argument for print_char
                out .= "    bl print_char" . Chr(10)
            }
            else if (is_oryx = 1) {
                        out .= "meta " . A_LoopField . Chr(10)
            ; rax maps to r0. print_char likely expects argument in r1 (standard convention)
            ; or if your VM has a specific 'print_char' that takes r0, adjust accordingly.
            ; Assuming r1 is the argument register for syscalls:
            out .= "mov r1, r0" . Chr(10)
            out .= "call print_char" . Chr(10)
        }
            else {
                out .= "mov rdi, rax" . Chr(10) . "push rcx" . Chr(10) . "call print_char" . Chr(10) . "pop rcx" . Chr(10)
            }
        }
        else if (StrLower(Trim(A_LoopField)) = "continue") or (StrLower(Trim(A_LoopField)) = "continue1") {
            if (is_arm = 1) {
                out .= "    b .cloop1_end" . STR(loopCount1) . Chr(10)
            }
            else if (is_oryx = 1) {
                        out .= "meta " . A_LoopField . Chr(10)
            ; Oryx uses 'jmp' just like x86
            out .= "jmp cloop1_end" . STR(loopCount1) . Chr(10)
        }
            else {
                out .= "jmp .cloop1_end" . STR(loopCount1) . Chr(10)
            }
        }
        else if (StrLower(Trim(A_LoopField)) = "continue2") {
            if (is_arm = 1) {
                out .= "    b .cloop2_end" . STR(loopCount2) . Chr(10)
            }
            else if (is_oryx = 1) {
                        out .= "meta " . A_LoopField . Chr(10)
            out .= "jmp cloop2_end" . STR(loopCount2) . Chr(10)
        }
            else {
                out .= "jmp .cloop2_end" . STR(loopCount2) . Chr(10)
            }
        }
        else if (StrLower(Trim(A_LoopField)) = "continue3") {
            if (is_arm = 1) {
                out .= "    b .cloop3_end" . STR(loopCount3) . Chr(10)
            }
            else if (is_oryx = 1) {
                        out .= "meta " . A_LoopField . Chr(10)
            out .= "jmp cloop3_end" . STR(loopCount3) . Chr(10)
        }
            else {
                out .= "jmp .cloop3_end" . STR(loopCount3) . Chr(10)
            }
        }
        else if (StrLower(Trim(A_LoopField)) = "continue4") {
            if (is_arm = 1) {
                out .= "    b .cloop4_end" . STR(loopCount4) . Chr(10)
            }
            else if (is_oryx = 1) {
                        out .= "meta " . A_LoopField . Chr(10)
            out .= "jmp cloop4_end" . STR(loopCount4) . Chr(10)
        }
            else {
                out .= "jmp .cloop4_end" . STR(loopCount4) . Chr(10)
            }
        }
        else if (StrLower(Trim(A_LoopField)) = "continue5") {
            if (is_arm = 1) {
                out .= "    b .cloop5_end" . STR(loopCount5) . Chr(10)
            }
            else if (is_oryx = 1) {
                        out .= "meta " . A_LoopField . Chr(10)
            out .= "jmp cloop5_end" . STR(loopCount5) . Chr(10)
        }
            else {
                out .= "jmp .cloop5_end" . STR(loopCount5) . Chr(10)
            }
        }
        else if (StrLower(Trim(A_LoopField)) = "continue6") {
            if (is_arm = 1) {
                out .= "    b .cloop6_end" . STR(loopCount6) . Chr(10)
            }
            else if (is_oryx = 1) {
                        out .= "meta " . A_LoopField . Chr(10)
            out .= "jmp cloop6_end" . STR(loopCount6) . Chr(10)
        }
            else {
                out .= "jmp .cloop6_end" . STR(loopCount6) . Chr(10)
            }
        }
        else if (StrLower(Trim(A_LoopField)) = "continue7") {
            if (is_arm = 1) {
                out .= "    b .cloop7_end" . STR(loopCount7) . Chr(10)
            }
            else if (is_oryx = 1) {
                        out .= "meta " . A_LoopField . Chr(10)
            out .= "jmp cloop7_end" . STR(loopCount7) . Chr(10)
        }
            else {
                out .= "jmp .cloop7_end" . STR(loopCount7) . Chr(10)
            }
        }
        else if (StrLower(Trim(A_LoopField)) = "continue8") {
            if (is_arm = 1) {
                out .= "    b .cloop8_end" . STR(loopCount8) . Chr(10)
            }
            else if (is_oryx = 1) {
                        out .= "meta " . A_LoopField . Chr(10)
            out .= "jmp cloop8_end" . STR(loopCount8) . Chr(10)
        }
            else {
                out .= "jmp .cloop8_end" . STR(loopCount8) . Chr(10)
            }
        }
        else if (StrLower(Trim(A_LoopField)) = "continue9") {
            if (is_arm = 1) {
                out .= "    b .cloop9_end" . STR(loopCount9) . Chr(10)
            }
            else if (is_oryx = 1) {
                        out .= "meta " . A_LoopField . Chr(10)
            out .= "jmp cloop9_end" . STR(loopCount9) . Chr(10)
        }
            else {
                out .= "jmp .cloop9_end" . STR(loopCount9) . Chr(10)
            }
        }
        else if (StrLower(Trim(A_LoopField)) = "break") or (StrLower(Trim(A_LoopField)) = "break1") {
            if (is_arm = 1) {
                out .= "    b .loop1_end" . STR(loopCount1) . Chr(10)
            }
            else if (is_oryx = 1) {
                        out .= "meta " . A_LoopField . Chr(10)
                out .= "jmp loop1_end" . STR(loopCount1) . Chr(10)
            }
            else {
                out .= "jmp .loop1_end" . STR(loopCount1) . Chr(10)
            }
        }
        else if (StrLower(Trim(A_LoopField)) = "break2") {
            if (is_arm = 1) {
                out .= "    b .loop2_end" . STR(loopCount2) . Chr(10)
            }
            else if (is_oryx = 1) {
                        out .= "meta " . A_LoopField . Chr(10)
                out .= "jmp loop2_end" . STR(loopCount2) . Chr(10)
            }
            else {
                out .= "jmp .loop2_end" . STR(loopCount2) . Chr(10)
            }
        }
        else if (StrLower(Trim(A_LoopField)) = "break3") {
            if (is_arm = 1) {
                out .= "    b .loop3_end" . STR(loopCount3) . Chr(10)
            }
            else if (is_oryx = 1) {
                        out .= "meta " . A_LoopField . Chr(10)
                out .= "jmp loop3_end" . STR(loopCount3) . Chr(10)
            }
            else {
                out .= "jmp .loop3_end" . STR(loopCount3) . Chr(10)
            }
        }
        else if (StrLower(Trim(A_LoopField)) = "break4") {
            if (is_arm = 1) {
                out .= "    b .loop4_end" . STR(loopCount4) . Chr(10)
            }
            else if (is_oryx = 1) {
                        out .= "meta " . A_LoopField . Chr(10)
                out .= "jmp loop4_end" . STR(loopCount4) . Chr(10)
            }
            else {
                out .= "jmp .loop4_end" . STR(loopCount4) . Chr(10)
            }
        }
        else if (StrLower(Trim(A_LoopField)) = "break5") {
            if (is_arm = 1) {
                out .= "    b .loop5_end" . STR(loopCount5) . Chr(10)
            }
            else if (is_oryx = 1) {
                        out .= "meta " . A_LoopField . Chr(10)
                out .= "jmp loop5_end" . STR(loopCount5) . Chr(10)
            }
            else {
                out .= "jmp .loop5_end" . STR(loopCount5) . Chr(10)
            }
        }
        else if (StrLower(Trim(A_LoopField)) = "break6") {
            if (is_arm = 1) {
                out .= "    b .loop6_end" . STR(loopCount6) . Chr(10)
            }
            else if (is_oryx = 1) {
                        out .= "meta " . A_LoopField . Chr(10)
                out .= "jmp loop6_end" . STR(loopCount6) . Chr(10)
            }
            else {
                out .= "jmp .loop6_end" . STR(loopCount6) . Chr(10)
            }
        }
        else if (StrLower(Trim(A_LoopField)) = "break7") {
            if (is_arm = 1) {
                out .= "    b .loop7_end" . STR(loopCount7) . Chr(10)
            }
            else if (is_oryx = 1) {
                        out .= "meta " . A_LoopField . Chr(10)
                out .= "jmp loop7_end" . STR(loopCount7) . Chr(10)
            }
            else {
                out .= "jmp .loop7_end" . STR(loopCount7) . Chr(10)
            }
        }
        else if (StrLower(Trim(A_LoopField)) = "break8") {
            if (is_arm = 1) {
                out .= "    b .loop8_end" . STR(loopCount8) . Chr(10)
            }
            else if (is_oryx = 1) {
                        out .= "meta " . A_LoopField . Chr(10)
                out .= "jmp loop8_end" . STR(loopCount8) . Chr(10)
            }
            else {
                out .= "jmp .loop8_end" . STR(loopCount8) . Chr(10)
            }
        }
        else if (StrLower(Trim(A_LoopField)) = "break9") {
            if (is_arm = 1) {
                out .= "    b .loop9_end" . STR(loopCount9) . Chr(10)
            }
            else if (is_oryx = 1) {
                        out .= "meta " . A_LoopField . Chr(10)
                out .= "jmp loop9_end" . STR(loopCount9) . Chr(10)
            }
            else {
                out .= "jmp .loop9_end" . STR(loopCount9) . Chr(10)
            }
        }
        else if (SubStr(StrLower(A_LoopField), 1, 6) = "loop, ") or (SubStr(StrLower(A_LoopField), 1, 7) = "loop1, ") {
            str1 := Trim(StringTrimLeft(Trim(A_LoopField), 6))
            if (is_arm = 1) {
                out .= "    stp x19, x20, [sp, #-16]!" . Chr(10)
                out .= "    mov x20, xzr" . Chr(10)
                if (Trim(str1) = "rax") {
                    out .= "    mov x19, x0" . Chr(10)
                }
                else if (RegExMatch(str1, "^\d+$")) {
                    out .= "    mov x19, #" . str1 . Chr(10)
                }
                else if (Trim(str1) = "A_Index") {
                    out .= "    mov x19, x20" . Chr(10)
                }
                else {
                    int isStackVar := 0
                    if (inFunc = 1) {
                        Loop, % funcArgsArr.size() {
                            if (Trim(funcArgsArr[A_Index]) = str1) {
                                isStackVar := 1
                                break
                            }
                        }
                    }
                    if (isStackVar = 1) {
                        out .= "    ldr x19, =" . str1 . Chr(10)
                    }
                    else {
                        out .= "    ldr x9, =" . str1 . Chr(10) . "    ldr x19, [x9]" . Chr(10)
                    }
                }
                out .= ".loop1_" . STR(loopCount1) . ":" . Chr(10) . "    cmp x19, #0" . Chr(10) . "    b.eq .loop1_end" . STR(loopCount1) . Chr(10)
            }
            else if (is_oryx = 1) {
                        out .= "meta " . A_LoopField . Chr(10)
                ; --- ORYX IR (Loop 1) ---
                out .= "push r90" . Chr(10)
                out .= "push r91" . Chr(10)
                
                strSrc := str1
                if (str1 = "rax") { strSrc := "r0" }
                else if (str1 = "A_Index") { strSrc := "r20" } ; Should ideally be the current loop's iterator register
                
                out .= "mov r90, " . strSrc . Chr(10) ; Limit
                out .= "mov r91, 0" . Chr(10) ; Iterator
                
                out .= "loop1_" . STR(loopCount1) . ":" . Chr(10)
                out .= "cmp r91, r90" . Chr(10)
                out .= "jge loop1_end" . STR(loopCount1) . Chr(10)
                
                ; Update A_Index alias (r20) to current loop iterator (r91)
                out .= "mov r20, r91" . Chr(10)
            }
            else {
                if (RegExMatch(str1, "^\d+$")) {
                    out .= "push r12" . Chr(10) . "push r13" . Chr(10) . "xor r13, r13" . Chr(10) . "mov r12, " . str1 . Chr(10) . ".loop1_" . STR(loopCount1) . ":" . Chr(10) . "cmp r12, 0" . Chr(10) . "je .loop1_end" . STR(loopCount1) . Chr(10)
                }
                else {
                    out .= "push r12" . Chr(10) . "push r13" . Chr(10) . "xor r13, r13" . Chr(10) . "mov r12, [" . str1 . "]" . Chr(10) . ".loop1_" . STR(loopCount1) . ":" . Chr(10) . "cmp r12, 0" . Chr(10) . "je .loop1_end" . STR(loopCount1) . Chr(10)
                }
            }
        }
        else if (Trim(A_LoopField) = "loopend") or (Trim(A_LoopField) = "endloop") or (Trim(A_LoopField) = "loopend1") or (Trim(A_LoopField) = "endloop1") {
            if (is_arm = 1) {
                out .= ".cloop1_end" . STR(loopCount1) . ":" . Chr(10) . "    add x20, x20, #1" . Chr(10) . "    sub x19, x19, #1" . Chr(10) . "    b .loop1_" . STR(loopCount1) . Chr(10) . ".loop1_end" . STR(loopCount1) . ":" . Chr(10) . "    ldp x19, x20, [sp], #16" . Chr(10)
            }
            else if (is_oryx = 1) {
                        out .= "meta " . A_LoopField . Chr(10)
                ; --- ORYX IR (Loop 1 End) ---
                out .= "cloop1_end" . STR(loopCount1) . ":" . Chr(10)
                out .= "inc r91" . Chr(10)
                out .= "jmp loop1_" . STR(loopCount1) . Chr(10)
                out .= "loop1_end" . STR(loopCount1) . ":" . Chr(10)
                out .= "pop r91" . Chr(10)
                out .= "pop r90" . Chr(10)
            }
            else {
                out .= ".cloop1_end" . STR(loopCount1) . ":" . Chr(10) . "inc r13" . Chr(10) . "dec r12" . Chr(10) . "jmp .loop1_" . STR(loopCount1) . Chr(10) . ".loop1_end" . STR(loopCount1) . ":" . Chr(10) . "pop r13" . Chr(10) . "pop r12" . Chr(10)
            }
            loopCount1++
        }
        else if (SubStr(StrLower(A_LoopField), 1, 7) = "loop2, ") {
            str1 := Trim(StringTrimLeft(Trim(A_LoopField), 7))
            if (is_arm = 1) {
                out .= "    stp x19, x20, [sp, #-16]!" . Chr(10)
                out .= "    mov x20, xzr" . Chr(10)
                if (Trim(str1) = "rax") {
                    out .= "    mov x19, x0" . Chr(10)
                }
                else if (RegExMatch(str1, "^\d+$")) {
                    out .= "    mov x19, #" . str1 . Chr(10)
                }
                else if (Trim(str1) = "A_Index") {
                    out .= "    mov x19, x20" . Chr(10)
                }
                else {
                    int isStackVar := 0
                    if (inFunc = 1) {
                        Loop, % funcArgsArr.size() {
                            if (Trim(funcArgsArr[A_Index]) = str1) {
                                isStackVar := 1
                                break
                            }
                        }
                    }
                    if (isStackVar = 1) {
                        out .= "    ldr x19, =" . str1 . Chr(10)
                    }
                    else {
                        out .= "    ldr x9, =" . str1 . Chr(10) . "    ldr x19, [x9]" . Chr(10)
                    }
                }
                out .= ".loop2_" . STR(loopCount2) . ":" . Chr(10) . "    cmp x19, #0" . Chr(10) . "    b.eq .loop2_end" . STR(loopCount2) . Chr(10)
            }
                        else if (is_oryx = 1) {
                                    out .= "meta " . A_LoopField . Chr(10)
                ; --- ORYX IR (Loop 2) ---
                ; Reuse r90 (Limit) and r91 (Iterator), save previous values to stack
                out .= "push r90" . Chr(10)
                out .= "push r91" . Chr(10)
                
                strSrc := str1
                if (str1 = "rax") { strSrc := "r0" }
                else if (str1 = "A_Index") { strSrc := "r20" }
                
                out .= "mov r90, " . strSrc . Chr(10) ; Limit
                out .= "mov r91, 0" . Chr(10) ; Iterator
                
                out .= "loop2_" . STR(loopCount2) . ":" . Chr(10)
                out .= "cmp r91, r90" . Chr(10)
                out .= "jge loop2_end" . STR(loopCount2) . Chr(10)
                
                ; Update A_Index alias (r20) to current loop iterator
                out .= "mov r20, r91" . Chr(10)
            }
            else {
                if (RegExMatch(str1, "^\d+$")) {
                    out .= "push r12" . Chr(10) . "push r13" . Chr(10) . "xor r13, r13" . Chr(10) . "mov r12, " . str1 . Chr(10) . ".loop2_" . STR(loopCount2) . ":" . Chr(10) . "cmp r12, 0" . Chr(10) . "je .loop2_end" . STR(loopCount2) . Chr(10)
                }
                else {
                    out .= "push r12" . Chr(10) . "push r13" . Chr(10) . "xor r13, r13" . Chr(10) . "mov r12, [" . str1 . "]" . Chr(10) . ".loop2_" . STR(loopCount2) . ":" . Chr(10) . "cmp r12, 0" . Chr(10) . "je .loop2_end" . STR(loopCount2) . Chr(10)
                }
            }
        }
        else if (Trim(A_LoopField) = "loopend2") or (Trim(A_LoopField) = "endloop2") {
            if (is_arm = 1) {
                out .= ".cloop2_end" . STR(loopCount2) . ":" . Chr(10) . "    add x20, x20, #1" . Chr(10) . "    sub x19, x19, #1" . Chr(10) . "    b .loop2_" . STR(loopCount2) . Chr(10) . ".loop2_end" . STR(loopCount2) . ":" . Chr(10) . "    ldp x19, x20, [sp], #16" . Chr(10)
            }
                     else if (is_oryx = 1) {
                                 out .= "meta " . A_LoopField . Chr(10)
                ; --- ORYX IR (Loop 2 End) ---
                out .= "cloop2_end" . STR(loopCount2) . ":" . Chr(10)
                out .= "inc r91" . Chr(10)
                out .= "jmp loop2_" . STR(loopCount2) . Chr(10)
                out .= "loop2_end" . STR(loopCount2) . ":" . Chr(10)
                out .= "pop r91" . Chr(10)
                out .= "pop r90" . Chr(10)
                ; Restore A_Index alias (r20) to the outer loop's iterator (r91)
                out .= "mov r20, r91" . Chr(10)
            }
            else {
                out .= ".cloop2_end" . STR(loopCount2) . ":" . Chr(10) . "inc r13" . Chr(10) . "dec r12" . Chr(10) . "jmp .loop2_" . STR(loopCount2) . Chr(10) . ".loop2_end" . STR(loopCount2) . ":" . Chr(10) . "pop r13" . Chr(10) . "pop r12" . Chr(10)
            }
            loopCount2++
        }
        else if (SubStr(StrLower(A_LoopField), 1, 7) = "loop3, ") {
            str1 := Trim(StringTrimLeft(Trim(A_LoopField), 7))
            if (is_arm = 1) {
                out .= "    stp x19, x20, [sp, #-16]!" . Chr(10)
                out .= "    mov x20, xzr" . Chr(10)
                if (Trim(str1) = "rax") {
                    out .= "    mov x19, x0" . Chr(10)
                }
                else if (RegExMatch(str1, "^\d+$")) {
                    out .= "    mov x19, #" . str1 . Chr(10)
                }
                else if (Trim(str1) = "A_Index") {
                    out .= "    mov x19, x20" . Chr(10)
                }
                else {
                    int isStackVar := 0
                    if (inFunc = 1) {
                        Loop, % funcArgsArr.size() {
                            if (Trim(funcArgsArr[A_Index]) = str1) {
                                isStackVar := 1
                                break
                            }
                        }
                    }
                    if (isStackVar = 1) {
                        out .= "    ldr x19, =" . str1 . Chr(10)
                    }
                    else {
                        out .= "    ldr x9, =" . str1 . Chr(10) . "    ldr x19, [x9]" . Chr(10)
                    }
                }
                out .= ".loop3_" . STR(loopCount3) . ":" . Chr(10) . "    cmp x19, #0" . Chr(10) . "    b.eq .loop3_end" . STR(loopCount3) . Chr(10)
            }
            else if (is_oryx = 1) {
                        out .= "meta " . A_LoopField . Chr(10)
                ; --- ORYX IR (Loop 3) ---
                out .= "push r90" . Chr(10)
                out .= "push r91" . Chr(10)
                
                strSrc := str1
                if (str1 = "rax") { strSrc := "r0" }
                else if (str1 = "A_Index") { strSrc := "r20" }
                
                out .= "mov r90, " . strSrc . Chr(10)
                out .= "mov r91, 0" . Chr(10)
                
                out .= "loop3_" . STR(loopCount3) . ":" . Chr(10)
                out .= "cmp r91, r90" . Chr(10)
                out .= "jge loop3_end" . STR(loopCount3) . Chr(10)
                
                out .= "mov r20, r91" . Chr(10)
            }
            else {
                if (RegExMatch(str1, "^\d+$")) {
                    out .= "push r12" . Chr(10) . "push r13" . Chr(10) . "xor r13, r13" . Chr(10) . "mov r12, " . str1 . Chr(10) . ".loop3_" . STR(loopCount3) . ":" . Chr(10) . "cmp r12, 0" . Chr(10) . "je .loop3_end" . STR(loopCount3) . Chr(10)
                }
                else {
                    out .= "push r12" . Chr(10) . "push r13" . Chr(10) . "xor r13, r13" . Chr(10) . "mov r12, [" . str1 . "]" . Chr(10) . ".loop3_" . STR(loopCount3) . ":" . Chr(10) . "cmp r12, 0" . Chr(10) . "je .loop3_end" . STR(loopCount3) . Chr(10)
                }
            }
        }
        else if (Trim(A_LoopField) = "loopend3") or (Trim(A_LoopField) = "endloop3") {
            if (is_arm = 1) {
                out .= ".cloop3_end" . STR(loopCount3) . ":" . Chr(10) . "    add x20, x20, #1" . Chr(10) . "    sub x19, x19, #1" . Chr(10) . "    b .loop3_" . STR(loopCount3) . Chr(10) . ".loop3_end" . STR(loopCount3) . ":" . Chr(10) . "    ldp x19, x20, [sp], #16" . Chr(10)
            }
            else if (is_oryx = 1) {
                        out .= "meta " . A_LoopField . Chr(10)
                ; --- ORYX IR (Loop 3 End) ---
                out .= "cloop3_end" . STR(loopCount3) . ":" . Chr(10)
                out .= "inc r91" . Chr(10)
                out .= "jmp loop3_" . STR(loopCount3) . Chr(10)
                out .= "loop3_end" . STR(loopCount3) . ":" . Chr(10)
                out .= "pop r91" . Chr(10)
                out .= "pop r90" . Chr(10)
                out .= "mov r20, r91" . Chr(10)
            }
            else {
                out .= ".cloop3_end" . STR(loopCount3) . ":" . Chr(10) . "inc r13" . Chr(10) . "dec r12" . Chr(10) . "jmp .loop3_" . STR(loopCount3) . Chr(10) . ".loop3_end" . STR(loopCount3) . ":" . Chr(10) . "pop r13" . Chr(10) . "pop r12" . Chr(10)
            }
            loopCount3++
        }
        else if (SubStr(StrLower(A_LoopField), 1, 7) = "loop4, ") {
            str1 := Trim(StringTrimLeft(Trim(A_LoopField), 7))
            if (is_arm = 1) {
                out .= "    stp x19, x20, [sp, #-16]!" . Chr(10)
                out .= "    mov x20, xzr" . Chr(10)
                if (Trim(str1) = "rax") {
                    out .= "    mov x19, x0" . Chr(10)
                }
                else if (RegExMatch(str1, "^\d+$")) {
                    out .= "    mov x19, #" . str1 . Chr(10)
                }
                else if (Trim(str1) = "A_Index") {
                    out .= "    mov x19, x20" . Chr(10)
                }
                else {
                    int isStackVar := 0
                    if (inFunc = 1) {
                        Loop, % funcArgsArr.size() {
                            if (Trim(funcArgsArr[A_Index]) = str1) {
                                isStackVar := 1
                                break
                            }
                        }
                    }
                    if (isStackVar = 1) {
                        out .= "    ldr x19, =" . str1 . Chr(10)
                    }
                    else {
                        out .= "    ldr x9, =" . str1 . Chr(10) . "    ldr x19, [x9]" . Chr(10)
                    }
                }
                out .= ".loop4_" . STR(loopCount4) . ":" . Chr(10) . "    cmp x19, #0" . Chr(10) . "    b.eq .loop4_end" . STR(loopCount4) . Chr(10)
            }
            else if (is_oryx = 1) {
                        out .= "meta " . A_LoopField . Chr(10)
                ; --- ORYX IR (Loop 4) ---
                out .= "push r90" . Chr(10)
                out .= "push r91" . Chr(10)
                
                strSrc := str1
                if (str1 = "rax") { strSrc := "r0" }
                else if (str1 = "A_Index") { strSrc := "r20" }
                
                out .= "mov r90, " . strSrc . Chr(10)
                out .= "mov r91, 0" . Chr(10)
                
                out .= "loop4_" . STR(loopCount4) . ":" . Chr(10)
                out .= "cmp r91, r90" . Chr(10)
                out .= "jge loop4_end" . STR(loopCount4) . Chr(10)
                
                out .= "mov r20, r91" . Chr(10)
            }
            else {
                if (RegExMatch(str1, "^\d+$")) {
                    out .= "push r12" . Chr(10) . "push r13" . Chr(10) . "xor r13, r13" . Chr(10) . "mov r12, " . str1 . Chr(10) . ".loop4_" . STR(loopCount4) . ":" . Chr(10) . "cmp r12, 0" . Chr(10) . "je .loop4_end" . STR(loopCount4) . Chr(10)
                }
                else {
                    out .= "push r12" . Chr(10) . "push r13" . Chr(10) . "xor r13, r13" . Chr(10) . "mov r12, [" . str1 . "]" . Chr(10) . ".loop4_" . STR(loopCount4) . ":" . Chr(10) . "cmp r12, 0" . Chr(10) . "je .loop4_end" . STR(loopCount4) . Chr(10)
                }
            }
        }
        else if (Trim(A_LoopField) = "loopend4") or (Trim(A_LoopField) = "endloop4") {
            if (is_arm = 1) {
                out .= ".cloop4_end" . STR(loopCount4) . ":" . Chr(10) . "    add x20, x20, #1" . Chr(10) . "    sub x19, x19, #1" . Chr(10) . "    b .loop4_" . STR(loopCount4) . Chr(10) . ".loop4_end" . STR(loopCount4) . ":" . Chr(10) . "    ldp x19, x20, [sp], #16" . Chr(10)
            }
            else if (is_oryx = 1) {
                        out .= "meta " . A_LoopField . Chr(10)
                ; --- ORYX IR (Loop 4 End) ---
                out .= "cloop4_end" . STR(loopCount4) . ":" . Chr(10)
                out .= "inc r91" . Chr(10)
                out .= "jmp loop4_" . STR(loopCount4) . Chr(10)
                out .= "loop4_end" . STR(loopCount4) . ":" . Chr(10)
                out .= "pop r91" . Chr(10)
                out .= "pop r90" . Chr(10)
                out .= "mov r20, r91" . Chr(10)
            }
            else {
                out .= ".cloop4_end" . STR(loopCount4) . ":" . Chr(10) . "inc r13" . Chr(10) . "dec r12" . Chr(10) . "jmp .loop4_" . STR(loopCount4) . Chr(10) . ".loop4_end" . STR(loopCount4) . ":" . Chr(10) . "pop r13" . Chr(10) . "pop r12" . Chr(10)
            }
            loopCount4++
        }
        else if (SubStr(StrLower(A_LoopField), 1, 7) = "loop5, ") {
            str1 := Trim(StringTrimLeft(Trim(A_LoopField), 7))
            if (is_arm = 1) {
                out .= "    stp x19, x20, [sp, #-16]!" . Chr(10)
                out .= "    mov x20, xzr" . Chr(10)
                if (Trim(str1) = "rax") {
                    out .= "    mov x19, x0" . Chr(10)
                }
                else if (RegExMatch(str1, "^\d+$")) {
                    out .= "    mov x19, #" . str1 . Chr(10)
                }
                else if (Trim(str1) = "A_Index") {
                    out .= "    mov x19, x20" . Chr(10)
                }
                else {
                    int isStackVar := 0
                    if (inFunc = 1) {
                        Loop, % funcArgsArr.size() {
                            if (Trim(funcArgsArr[A_Index]) = str1) {
                                isStackVar := 1
                                break
                            }
                        }
                    }
                    if (isStackVar = 1) {
                        out .= "    ldr x19, =" . str1 . Chr(10)
                    }
                    else {
                        out .= "    ldr x9, =" . str1 . Chr(10) . "    ldr x19, [x9]" . Chr(10)
                    }
                }
                out .= ".loop5_" . STR(loopCount5) . ":" . Chr(10) . "    cmp x19, #0" . Chr(10) . "    b.eq .loop5_end" . STR(loopCount5) . Chr(10)
            }
            else if (is_oryx = 1) {
                        out .= "meta " . A_LoopField . Chr(10)
                ; --- ORYX IR (Loop 5) ---
                out .= "push r90" . Chr(10)
                out .= "push r91" . Chr(10)
                
                strSrc := str1
                if (str1 = "rax") { strSrc := "r0" }
                else if (str1 = "A_Index") { strSrc := "r20" }
                
                out .= "mov r90, " . strSrc . Chr(10)
                out .= "mov r91, 0" . Chr(10)
                
                out .= "loop5_" . STR(loopCount5) . ":" . Chr(10)
                out .= "cmp r91, r90" . Chr(10)
                out .= "jge loop5_end" . STR(loopCount5) . Chr(10)
                
                out .= "mov r20, r91" . Chr(10)
            }
            else {
                if (RegExMatch(str1, "^\d+$")) {
                    out .= "push r12" . Chr(10) . "push r13" . Chr(10) . "xor r13, r13" . Chr(10) . "mov r12, " . str1 . Chr(10) . ".loop5_" . STR(loopCount5) . ":" . Chr(10) . "cmp r12, 0" . Chr(10) . "je .loop5_end" . STR(loopCount5) . Chr(10)
                }
                else {
                    out .= "push r12" . Chr(10) . "push r13" . Chr(10) . "xor r13, r13" . Chr(10) . "mov r12, [" . str1 . "]" . Chr(10) . ".loop5_" . STR(loopCount5) . ":" . Chr(10) . "cmp r12, 0" . Chr(10) . "je .loop5_end" . STR(loopCount5) . Chr(10)
                }
            }
        }
        else if (Trim(A_LoopField) = "loopend5") or (Trim(A_LoopField) = "endloop5") {
            if (is_arm = 1) {
                out .= ".cloop5_end" . STR(loopCount5) . ":" . Chr(10) . "    add x20, x20, #1" . Chr(10) . "    sub x19, x19, #1" . Chr(10) . "    b .loop5_" . STR(loopCount5) . Chr(10) . ".loop5_end" . STR(loopCount5) . ":" . Chr(10) . "    ldp x19, x20, [sp], #16" . Chr(10)
            }
            else if (is_oryx = 1) {
                        out .= "meta " . A_LoopField . Chr(10)
                ; --- ORYX IR (Loop 5 End) ---
                out .= "cloop5_end" . STR(loopCount5) . ":" . Chr(10)
                out .= "inc r91" . Chr(10)
                out .= "jmp loop5_" . STR(loopCount5) . Chr(10)
                out .= "loop5_end" . STR(loopCount5) . ":" . Chr(10)
                out .= "pop r91" . Chr(10)
                out .= "pop r90" . Chr(10)
                out .= "mov r20, r91" . Chr(10)
            }
            else {
                out .= ".cloop5_end" . STR(loopCount5) . ":" . Chr(10) . "inc r13" . Chr(10) . "dec r12" . Chr(10) . "jmp .loop5_" . STR(loopCount5) . Chr(10) . ".loop5_end" . STR(loopCount5) . ":" . Chr(10) . "pop r13" . Chr(10) . "pop r12" . Chr(10)
            }
            loopCount5++
        }
        else if (SubStr(StrLower(A_LoopField), 1, 7) = "loop6, ") {
            str1 := Trim(StringTrimLeft(Trim(A_LoopField), 7))
            if (is_arm = 1) {
                out .= "    stp x19, x20, [sp, #-16]!" . Chr(10)
                out .= "    mov x20, xzr" . Chr(10)
                if (Trim(str1) = "rax") {
                    out .= "    mov x19, x0" . Chr(10)
                }
                else if (RegExMatch(str1, "^\d+$")) {
                    out .= "    mov x19, #" . str1 . Chr(10)
                }
                else if (Trim(str1) = "A_Index") {
                    out .= "    mov x19, x20" . Chr(10)
                }
                else {
                    int isStackVar := 0
                    if (inFunc = 1) {
                        Loop, % funcArgsArr.size() {
                            if (Trim(funcArgsArr[A_Index]) = str1) {
                                isStackVar := 1
                                break
                            }
                        }
                    }
                    if (isStackVar = 1) {
                        out .= "    ldr x19, =" . str1 . Chr(10)
                    }
                    else {
                        out .= "    ldr x9, =" . str1 . Chr(10) . "    ldr x19, [x9]" . Chr(10)
                    }
                }
                out .= ".loop6_" . STR(loopCount6) . ":" . Chr(10) . "    cmp x19, #0" . Chr(10) . "    b.eq .loop6_end" . STR(loopCount6) . Chr(10)
            }
            else if (is_oryx = 1) {
                        out .= "meta " . A_LoopField . Chr(10)
                ; --- ORYX IR (Loop 6) ---
                out .= "push r90" . Chr(10)
                out .= "push r91" . Chr(10)
                
                strSrc := str1
                if (str1 = "rax") { strSrc := "r0" }
                else if (str1 = "A_Index") { strSrc := "r20" }
                
                out .= "mov r90, " . strSrc . Chr(10)
                out .= "mov r91, 0" . Chr(10)
                
                out .= "loop6_" . STR(loopCount6) . ":" . Chr(10)
                out .= "cmp r91, r90" . Chr(10)
                out .= "jge loop6_end" . STR(loopCount6) . Chr(10)
                
                out .= "mov r20, r91" . Chr(10)
            }
            else {
                if (RegExMatch(str1, "^\d+$")) {
                    out .= "push r12" . Chr(10) . "push r13" . Chr(10) . "xor r13, r13" . Chr(10) . "mov r12, " . str1 . Chr(10) . ".loop6_" . STR(loopCount6) . ":" . Chr(10) . "cmp r12, 0" . Chr(10) . "je .loop6_end" . STR(loopCount6) . Chr(10)
                }
                else {
                    out .= "push r12" . Chr(10) . "push r13" . Chr(10) . "xor r13, r13" . Chr(10) . "mov r12, [" . str1 . "]" . Chr(10) . ".loop6_" . STR(loopCount6) . ":" . Chr(10) . "cmp r12, 0" . Chr(10) . "je .loop6_end" . STR(loopCount6) . Chr(10)
                }
            }
        }
        else if (Trim(A_LoopField) = "loopend6") or (Trim(A_LoopField) = "endloop6") {
            if (is_arm = 1) {
                out .= ".cloop6_end" . STR(loopCount6) . ":" . Chr(10) . "    add x20, x20, #1" . Chr(10) . "    sub x19, x19, #1" . Chr(10) . "    b .loop6_" . STR(loopCount6) . Chr(10) . ".loop6_end" . STR(loopCount6) . ":" . Chr(10) . "    ldp x19, x20, [sp], #16" . Chr(10)
            }
            else if (is_oryx = 1) {
                        out .= "meta " . A_LoopField . Chr(10)
                ; --- ORYX IR (Loop 6 End) ---
                out .= "cloop6_end" . STR(loopCount6) . ":" . Chr(10)
                out .= "inc r91" . Chr(10)
                out .= "jmp loop6_" . STR(loopCount6) . Chr(10)
                out .= "loop6_end" . STR(loopCount6) . ":" . Chr(10)
                out .= "pop r91" . Chr(10)
                out .= "pop r90" . Chr(10)
                out .= "mov r20, r91" . Chr(10)
            }
            else {
                out .= ".cloop6_end" . STR(loopCount6) . ":" . Chr(10) . "inc r13" . Chr(10) . "dec r12" . Chr(10) . "jmp .loop6_" . STR(loopCount6) . Chr(10) . ".loop6_end" . STR(loopCount6) . ":" . Chr(10) . "pop r13" . Chr(10) . "pop r12" . Chr(10)
            }
            loopCount6++
        }
        else if (SubStr(StrLower(A_LoopField), 1, 7) = "loop7, ") {
            str1 := Trim(StringTrimLeft(Trim(A_LoopField), 7))
            if (is_arm = 1) {
                out .= "    stp x19, x20, [sp, #-16]!" . Chr(10)
                out .= "    mov x20, xzr" . Chr(10)
                if (Trim(str1) = "rax") {
                    out .= "    mov x19, x0" . Chr(10)
                }
                else if (RegExMatch(str1, "^\d+$")) {
                    out .= "    mov x19, #" . str1 . Chr(10)
                }
                else if (Trim(str1) = "A_Index") {
                    out .= "    mov x19, x20" . Chr(10)
                }
                else {
                    int isStackVar := 0
                    if (inFunc = 1) {
                        Loop, % funcArgsArr.size() {
                            if (Trim(funcArgsArr[A_Index]) = str1) {
                                isStackVar := 1
                                break
                            }
                        }
                    }
                    if (isStackVar = 1) {
                        out .= "    ldr x19, =" . str1 . Chr(10)
                    }
                    else {
                        out .= "    ldr x9, =" . str1 . Chr(10) . "    ldr x19, [x9]" . Chr(10)
                    }
                }
                out .= ".loop7_" . STR(loopCount7) . ":" . Chr(10) . "    cmp x19, #0" . Chr(10) . "    b.eq .loop7_end" . STR(loopCount7) . Chr(10)
            }
            else if (is_oryx = 1) {
                        out .= "meta " . A_LoopField . Chr(10)
                ; --- ORYX IR (Loop 7) ---
                out .= "push r90" . Chr(10)
                out .= "push r91" . Chr(10)
                
                strSrc := str1
                if (str1 = "rax") { strSrc := "r0" }
                else if (str1 = "A_Index") { strSrc := "r20" }
                
                out .= "mov r90, " . strSrc . Chr(10)
                out .= "mov r91, 0" . Chr(10)
                
                out .= "loop7_" . STR(loopCount7) . ":" . Chr(10)
                out .= "cmp r91, r90" . Chr(10)
                out .= "jge loop7_end" . STR(loopCount7) . Chr(10)
                
                out .= "mov r20, r91" . Chr(10)
            }
            else {
                if (RegExMatch(str1, "^\d+$")) {
                    out .= "push r12" . Chr(10) . "push r13" . Chr(10) . "xor r13, r13" . Chr(10) . "mov r12, " . str1 . Chr(10) . ".loop7_" . STR(loopCount7) . ":" . Chr(10) . "cmp r12, 0" . Chr(10) . "je .loop7_end" . STR(loopCount7) . Chr(10)
                }
                else {
                    out .= "push r12" . Chr(10) . "push r13" . Chr(10) . "xor r13, r13" . Chr(10) . "mov r12, [" . str1 . "]" . Chr(10) . ".loop7_" . STR(loopCount7) . ":" . Chr(10) . "cmp r12, 0" . Chr(10) . "je .loop7_end" . STR(loopCount7) . Chr(10)
                }
            }
        }
        else if (Trim(A_LoopField) = "loopend7") or (Trim(A_LoopField) = "endloop7") {
            if (is_arm = 1) {
                out .= ".cloop7_end" . STR(loopCount7) . ":" . Chr(10) . "    add x20, x20, #1" . Chr(10) . "    sub x19, x19, #1" . Chr(10) . "    b .loop7_" . STR(loopCount7) . Chr(10) . ".loop7_end" . STR(loopCount7) . ":" . Chr(10) . "    ldp x19, x20, [sp], #16" . Chr(10)
            }
            else if (is_oryx = 1) {
                        out .= "meta " . A_LoopField . Chr(10)
                ; --- ORYX IR (Loop 7 End) ---
                out .= "cloop7_end" . STR(loopCount7) . ":" . Chr(10)
                out .= "inc r91" . Chr(10)
                out .= "jmp loop7_" . STR(loopCount7) . Chr(10)
                out .= "loop7_end" . STR(loopCount7) . ":" . Chr(10)
                out .= "pop r91" . Chr(10)
                out .= "pop r90" . Chr(10)
                out .= "mov r20, r91" . Chr(10)
            }
            else {
                out .= ".cloop7_end" . STR(loopCount7) . ":" . Chr(10) . "inc r13" . Chr(10) . "dec r12" . Chr(10) . "jmp .loop7_" . STR(loopCount7) . Chr(10) . ".loop7_end" . STR(loopCount7) . ":" . Chr(10) . "pop r13" . Chr(10) . "pop r12" . Chr(10)
            }
            loopCount7++
        }
        else if (SubStr(StrLower(A_LoopField), 1, 7) = "loop8, ") {
            str1 := Trim(StringTrimLeft(Trim(A_LoopField), 7))
            if (is_arm = 1) {
                out .= "    stp x19, x20, [sp, #-16]!" . Chr(10)
                out .= "    mov x20, xzr" . Chr(10)
                if (Trim(str1) = "rax") {
                    out .= "    mov x19, x0" . Chr(10)
                }
                else if (RegExMatch(str1, "^\d+$")) {
                    out .= "    mov x19, #" . str1 . Chr(10)
                }
                else if (Trim(str1) = "A_Index") {
                    out .= "    mov x19, x20" . Chr(10)
                }
                else {
                    int isStackVar := 0
                    if (inFunc = 1) {
                        Loop, % funcArgsArr.size() {
                            if (Trim(funcArgsArr[A_Index]) = str1) {
                                isStackVar := 1
                                break
                            }
                        }
                    }
                    if (isStackVar = 1) {
                        out .= "    ldr x19, =" . str1 . Chr(10)
                    }
                    else {
                        out .= "    ldr x9, =" . str1 . Chr(10) . "    ldr x19, [x9]" . Chr(10)
                    }
                }
                out .= ".loop8_" . STR(loopCount8) . ":" . Chr(10) . "    cmp x19, #0" . Chr(10) . "    b.eq .loop8_end" . STR(loopCount8) . Chr(10)
            }
            else if (is_oryx = 1) {
                        out .= "meta " . A_LoopField . Chr(10)
                ; --- ORYX IR (Loop 8) ---
                out .= "push r90" . Chr(10)
                out .= "push r91" . Chr(10)
                
                strSrc := str1
                if (str1 = "rax") { strSrc := "r0" }
                else if (str1 = "A_Index") { strSrc := "r20" }
                
                out .= "mov r90, " . strSrc . Chr(10)
                out .= "mov r91, 0" . Chr(10)
                
                out .= "loop8_" . STR(loopCount8) . ":" . Chr(10)
                out .= "cmp r91, r90" . Chr(10)
                out .= "jge loop8_end" . STR(loopCount8) . Chr(10)
                
                out .= "mov r20, r91" . Chr(10)
            }
            else {
                if (RegExMatch(str1, "^\d+$")) {
                    out .= "push r12" . Chr(10) . "push r13" . Chr(10) . "xor r13, r13" . Chr(10) . "mov r12, " . str1 . Chr(10) . ".loop8_" . STR(loopCount8) . ":" . Chr(10) . "cmp r12, 0" . Chr(10) . "je .loop8_end" . STR(loopCount8) . Chr(10)
                }
                else {
                    out .= "push r12" . Chr(10) . "push r13" . Chr(10) . "xor r13, r13" . Chr(10) . "mov r12, [" . str1 . "]" . Chr(10) . ".loop8_" . STR(loopCount8) . ":" . Chr(10) . "cmp r12, 0" . Chr(10) . "je .loop8_end" . STR(loopCount8) . Chr(10)
                }
            }
        }
        else if (Trim(A_LoopField) = "loopend8") or (Trim(A_LoopField) = "endloop8") {
            if (is_arm = 1) {
                out .= ".cloop8_end" . STR(loopCount8) . ":" . Chr(10) . "    add x20, x20, #1" . Chr(10) . "    sub x19, x19, #1" . Chr(10) . "    b .loop8_" . STR(loopCount8) . Chr(10) . ".loop8_end" . STR(loopCount8) . ":" . Chr(10) . "    ldp x19, x20, [sp], #16" . Chr(10)
            }
            else if (is_oryx = 1) {
                        out .= "meta " . A_LoopField . Chr(10)
                ; --- ORYX IR (Loop 8 End) ---
                out .= "cloop8_end" . STR(loopCount8) . ":" . Chr(10)
                out .= "inc r91" . Chr(10)
                out .= "jmp loop8_" . STR(loopCount8) . Chr(10)
                out .= "loop8_end" . STR(loopCount8) . ":" . Chr(10)
                out .= "pop r91" . Chr(10)
                out .= "pop r90" . Chr(10)
                out .= "mov r20, r91" . Chr(10)
            }
            else {
                out .= ".cloop8_end" . STR(loopCount8) . ":" . Chr(10) . "inc r13" . Chr(10) . "dec r12" . Chr(10) . "jmp .loop8_" . STR(loopCount8) . Chr(10) . ".loop8_end" . STR(loopCount8) . ":" . Chr(10) . "pop r13" . Chr(10) . "pop r12" . Chr(10)
            }
            loopCount8++
        }
        else if (SubStr(StrLower(A_LoopField), 1, 7) = "loop9, ") {
            str1 := Trim(StringTrimLeft(Trim(A_LoopField), 7))
            if (is_arm = 1) {
                out .= "    stp x19, x20, [sp, #-16]!" . Chr(10)
                out .= "    mov x20, xzr" . Chr(10)
                if (Trim(str1) = "rax") {
                    out .= "    mov x19, x0" . Chr(10)
                }
                else if (RegExMatch(str1, "^\d+$")) {
                    out .= "    mov x19, #" . str1 . Chr(10)
                }
                else if (Trim(str1) = "A_Index") {
                    out .= "    mov x19, x20" . Chr(10)
                }
                else {
                    int isStackVar := 0
                    if (inFunc = 1) {
                        Loop, % funcArgsArr.size() {
                            if (Trim(funcArgsArr[A_Index]) = str1) {
                                isStackVar := 1
                                break
                            }
                        }
                    }
                    if (isStackVar = 1) {
                        out .= "    ldr x19, =" . str1 . Chr(10)
                    }
                    else {
                        out .= "    ldr x9, =" . str1 . Chr(10) . "    ldr x19, [x9]" . Chr(10)
                    }
                }
                out .= ".loop9_" . STR(loopCount9) . ":" . Chr(10) . "    cmp x19, #0" . Chr(10) . "    b.eq .loop9_end" . STR(loopCount9) . Chr(10)
            }
            else if (is_oryx = 1) {
                        out .= "meta " . A_LoopField . Chr(10)
                ; --- ORYX IR (Loop 9) ---
                out .= "push r90" . Chr(10)
                out .= "push r91" . Chr(10)
                
                strSrc := str1
                if (str1 = "rax") { strSrc := "r0" }
                else if (str1 = "A_Index") { strSrc := "r20" }
                
                out .= "mov r90, " . strSrc . Chr(10)
                out .= "mov r91, 0" . Chr(10)
                
                out .= "loop9_" . STR(loopCount9) . ":" . Chr(10)
                out .= "cmp r91, r90" . Chr(10)
                out .= "jge loop9_end" . STR(loopCount9) . Chr(10)
                
                out .= "mov r20, r91" . Chr(10)
            }
            else {
                if (RegExMatch(str1, "^\d+$")) {
                    out .= "push r12" . Chr(10) . "push r13" . Chr(10) . "xor r13, r13" . Chr(10) . "mov r12, " . str1 . Chr(10) . ".loop9_" . STR(loopCount9) . ":" . Chr(10) . "cmp r12, 0" . Chr(10) . "je .loop9_end" . STR(loopCount9) . Chr(10)
                }
                else {
                    out .= "push r12" . Chr(10) . "push r13" . Chr(10) . "xor r13, r13" . Chr(10) . "mov r12, [" . str1 . "]" . Chr(10) . ".loop9_" . STR(loopCount9) . ":" . Chr(10) . "cmp r12, 0" . Chr(10) . "je .loop9_end" . STR(loopCount9) . Chr(10)
                }
            }
        }
        else if (Trim(A_LoopField) = "loopend9") or (Trim(A_LoopField) = "endloop9") {
            if (is_arm = 1) {
                out .= ".cloop9_end" . STR(loopCount9) . ":" . Chr(10) . "    add x20, x20, #1" . Chr(10) . "    sub x19, x19, #1" . Chr(10) . "    b .loop9_" . STR(loopCount9) . Chr(10) . ".loop9_end" . STR(loopCount9) . ":" . Chr(10) . "    ldp x19, x20, [sp], #16" . Chr(10)
            }
            else if (is_oryx = 1) {
                        out .= "meta " . A_LoopField . Chr(10)
                ; --- ORYX IR (Loop 9 End) ---
                out .= "cloop9_end" . STR(loopCount9) . ":" . Chr(10)
                out .= "inc r91" . Chr(10)
                out .= "jmp loop9_" . STR(loopCount9) . Chr(10)
                out .= "loop9_end" . STR(loopCount9) . ":" . Chr(10)
                out .= "pop r91" . Chr(10)
                out .= "pop r90" . Chr(10)
                out .= "mov r20, r91" . Chr(10)
            }
            else {
                out .= ".cloop9_end" . STR(loopCount9) . ":" . Chr(10) . "inc r13" . Chr(10) . "dec r12" . Chr(10) . "jmp .loop9_" . STR(loopCount9) . Chr(10) . ".loop9_end" . STR(loopCount9) . ":" . Chr(10) . "pop r13" . Chr(10) . "pop r12" . Chr(10)
            }
            loopCount9++
        }
        else if (SubStr(StrLower(A_LoopField), 1, 3) = "if ") or (SubStr(StrLower(A_LoopField), 1, 4) = "if1 ") {
            isNum := 0
            str1 := Trim(StringTrimLeft(A_LoopField, 3))
            str1 := StringTrimLeft(str1, 1)
            str1 := StringTrimRight(str1, 1)
            if (InStr(str1, " = ")) {
                str2 := Trim(StrSplit(str1, " = ", 1))
                str3 := Trim(StrSplit(str1, " = ", 2))
                isNum := RegExMatch(str3, "^\d+$")
                if (is_arm = 1) {
                    ; --- LHS (str2) ---
                    int isLhsStackVar := 0
                    if (inFunc = 1) {
                        Loop, % funcArgsArr.size() {
                            if (Trim(funcArgsArr[A_Index]) = str2) {
                                isLhsStackVar := 1
                                break
                            }
                        }
                    }
                    if (str2 = "rax") {
                        out .= "    mov x9, x0" . Chr(10)
                    }
                    else if (str2 = "A_Index") {
                        out .= "    mov x9, x20" . Chr(10)
                    }
                    else if (isLhsStackVar = 1) {
                        out .= "    ldr x9, =" . str2 . Chr(10)
                    }
                    else {
                        out .= "    ldr x9, =" . str2 . Chr(10) . "    ldr x9, [x9]" . Chr(10)
                    }
                    ; --- RHS (str3) ---
                    int isRhsStackVar := 0
                    if (inFunc = 1) {
                        Loop, % funcArgsArr.size() {
                            if (Trim(funcArgsArr[A_Index]) = str3) {
                                isRhsStackVar := 1
                                break
                            }
                        }
                    }
                    if (str3 = "rax") {
                        out .= "    mov x10, x0" . Chr(10)
                    }
                    else if (str3 = "A_Index") {
                        out .= "    mov x10, x20" . Chr(10)
                    }
                    else if (isNum = 1) {
                        out .= "    mov x10, #" . str3 . Chr(10)
                    }
                    else if (isRhsStackVar = 1) {
                        out .= "    ldr x10, =" . str3 . Chr(10)
                    }
                    else {
                        out .= "    ldr x10, =" . str3 . Chr(10) . "    ldr x10, [x10]" . Chr(10)
                    }
                    out .= "    cmp x9, x10" . Chr(10) . "    b.ne .end_if1_" . STR(ifCount1) . Chr(10)
                }
                else if (is_oryx = 1) {
                            out .= "meta " . A_LoopField . Chr(10)
                    ; --- ORYX IR (if = -> jne) ---
                    strLhs := str2
                    if (str2 = "rax") { strLhs := "r0" }
                    else if (str2 = "A_Index") { strLhs := "r20" }
                    
                    strRhs := str3
                    if (str3 = "rax") { strRhs := "r0" }
                    else if (str3 = "A_Index") { strRhs := "r20" }
                    
                    out .= "cmp " . strLhs . ", " . strRhs . Chr(10)
                    out .= "jne end_if1_" . STR(ifCount1) . Chr(10)
                }
                else {
                    if (isNum = 1) {
                        out .= "mov rax, [" . str2 . "]" . Chr(10) . "cmp rax, " . str3 . Chr(10) . "jne .end_if1_" . STR(ifCount1) . Chr(10)
                    }
                    else {
                        out .= "mov rax, [" . str2 . "]" . Chr(10) . "cmp rax, [" . str3 . "]" . Chr(10) . "jne .end_if1_" . STR(ifCount1) . Chr(10)
                    }
                }
            }
            else if (InStr(str1, " != ")) {
                str2 := Trim(StrSplit(str1, " != ", 1))
                str3 := Trim(StrSplit(str1, " != ", 2))
                isNum := RegExMatch(str3, "^\d+$")
                if (is_arm = 1) {
                    int isLhsStackVar := 0
                    if (inFunc = 1) {
                        Loop, % funcArgsArr.size() {
                            if (Trim(funcArgsArr[A_Index]) = str2) {
                                isLhsStackVar := 1
                                break
                            }
                        }
                    }
                    if (str2 = "rax") {
                        out .= "    mov x9, x0" . Chr(10)
                    }
                    else if (str2 = "A_Index") {
                        out .= "    mov x9, x20" . Chr(10)
                    }
                    else if (isLhsStackVar = 1) {
                        out .= "    ldr x9, =" . str2 . Chr(10)
                    }
                    else {
                        out .= "    ldr x9, =" . str2 . Chr(10) . "    ldr x9, [x9]" . Chr(10)
                    }
                    if (isNum = 1) {
                        out .= "    mov x10, #" . str3 . Chr(10)
                    }
                    else {
                        int isRhsStackVar := 0
                        if (inFunc = 1) {
                            Loop, % funcArgsArr.size() {
                                if (Trim(funcArgsArr[A_Index]) = str3) {
                                    isRhsStackVar := 1
                                    break
                                }
                            }
                        }
                        if (str3 = "rax") {
                            out .= "    mov x10, x0" . Chr(10)
                        }
                        else if (str3 = "A_Index") {
                            out .= "    mov x10, x20" . Chr(10)
                        }
                        else if (isRhsStackVar = 1) {
                            out .= "    ldr x10, =" . str3 . Chr(10)
                        }
                        else {
                            out .= "    ldr x10, =" . str3 . Chr(10) . "    ldr x10, [x10]" . Chr(10)
                        }
                    }
                    out .= "    cmp x9, x10" . Chr(10) . "    b.eq .end_if1_" . STR(ifCount1) . Chr(10)
                }
                else if (is_oryx = 1) {
                            out .= "meta " . A_LoopField . Chr(10)
                    ; --- ORYX IR (if != -> je) ---
                    strLhs := str2
                    if (str2 = "rax") { strLhs := "r0" }
                    else if (str2 = "A_Index") { strLhs := "r20" }
                    
                    strRhs := str3
                    if (str3 = "rax") { strRhs := "r0" }
                    else if (str3 = "A_Index") { strRhs := "r20" }
                    
                    out .= "cmp " . strLhs . ", " . strRhs . Chr(10)
                    out .= "je end_if1_" . STR(ifCount1) . Chr(10)
                }
                else {
                    if (isNum = 1) {
                        out .= "mov rax, [" . str2 . "]" . Chr(10) . "cmp rax, " . str3 . Chr(10) . "je .end_if1_" . STR(ifCount1) . Chr(10)
                    }
                    else {
                        out .= "mov rax, [" . str2 . "]" . Chr(10) . "cmp rax, [" . str3 . "]" . Chr(10) . "je .end_if1_" . STR(ifCount1) . Chr(10)
                    }
                }
            }
            else if (InStr(str1, " > ")) {
                str2 := Trim(StrSplit(str1, " > ", 1))
                str3 := Trim(StrSplit(str1, " > ", 2))
                isNum := RegExMatch(str3, "^\d+$")
                if (is_arm = 1) {
                    int isLhsStackVar := 0
                    if (inFunc = 1) {
                        Loop, % funcArgsArr.size() {
                            if (Trim(funcArgsArr[A_Index]) = str2) {
                                isLhsStackVar := 1
                                break
                            }
                        }
                    }
                    if (str2 = "rax") {
                        out .= "    mov x9, x0" . Chr(10)
                    }
                    else if (str2 = "A_Index") {
                        out .= "    mov x9, x20" . Chr(10)
                    }
                    else if (isLhsStackVar = 1) {
                        out .= "    ldr x9, =" . str2 . Chr(10)
                    }
                    else {
                        out .= "    ldr x9, =" . str2 . Chr(10) . "    ldr x9, [x9]" . Chr(10)
                    }
                    if (isNum = 1) {
                        out .= "    mov x10, #" . str3 . Chr(10)
                    }
                    else {
                        int isRhsStackVar := 0
                        if (inFunc = 1) {
                            Loop, % funcArgsArr.size() {
                                if (Trim(funcArgsArr[A_Index]) = str3) {
                                    isRhsStackVar := 1
                                    break
                                }
                            }
                        }
                        if (str3 = "rax") {
                            out .= "    mov x10, x0" . Chr(10)
                        }
                        else if (str3 = "A_Index") {
                            out .= "    mov x10, x20" . Chr(10)
                        }
                        else if (isRhsStackVar = 1) {
                            out .= "    ldr x10, =" . str3 . Chr(10)
                        }
                        else {
                            out .= "    ldr x10, =" . str3 . Chr(10) . "    ldr x10, [x10]" . Chr(10)
                        }
                    }
                    out .= "    cmp x9, x10" . Chr(10) . "    b.le .end_if1_" . STR(ifCount1) . Chr(10)
                }
                else if (is_oryx = 1) {
                            out .= "meta " . A_LoopField . Chr(10)
                    ; --- ORYX IR (if > -> jle) ---
                    strLhs := str2
                    if (str2 = "rax") { strLhs := "r0" }
                    else if (str2 = "A_Index") { strLhs := "r20" }
                    
                    strRhs := str3
                    if (str3 = "rax") { strRhs := "r0" }
                    else if (str3 = "A_Index") { strRhs := "r20" }
                    
                    out .= "cmp " . strLhs . ", " . strRhs . Chr(10)
                    out .= "jle end_if1_" . STR(ifCount1) . Chr(10)
                }
                else {
                    if (isNum = 1) {
                        out .= "mov rax, [" . str2 . "]" . Chr(10) . "cmp rax, " . str3 . Chr(10) . "jle .end_if1_" . STR(ifCount1) . Chr(10)
                    }
                    else {
                        out .= "mov rax, [" . str2 . "]" . Chr(10) . "cmp rax, [" . str3 . "]" . Chr(10) . "jle .end_if1_" . STR(ifCount1) . Chr(10)
                    }
                }
            }
            else if (InStr(str1, " < ")) {
                str2 := Trim(StrSplit(str1, " < ", 1))
                str3 := Trim(StrSplit(str1, " < ", 2))
                isNum := RegExMatch(str3, "^\d+$")
                if (is_arm = 1) {
                    int isLhsStackVar := 0
                    if (inFunc = 1) {
                        Loop, % funcArgsArr.size() {
                            if (Trim(funcArgsArr[A_Index]) = str2) {
                                isLhsStackVar := 1
                                break
                            }
                        }
                    }
                    if (str2 = "rax") {
                        out .= "    mov x9, x0" . Chr(10)
                    }
                    else if (str2 = "A_Index") {
                        out .= "    mov x9, x20" . Chr(10)
                    }
                    else if (isLhsStackVar = 1) {
                        out .= "    ldr x9, =" . str2 . Chr(10)
                    }
                    else {
                        out .= "    ldr x9, =" . str2 . Chr(10) . "    ldr x9, [x9]" . Chr(10)
                    }
                    if (isNum = 1) {
                        out .= "    mov x10, #" . str3 . Chr(10)
                    }
                    else {
                        int isRhsStackVar := 0
                        if (inFunc = 1) {
                            Loop, % funcArgsArr.size() {
                                if (Trim(funcArgsArr[A_Index]) = str3) {
                                    isRhsStackVar := 1
                                    break
                                }
                            }
                        }
                        if (str3 = "rax") {
                            out .= "    mov x10, x0" . Chr(10)
                        }
                        else if (str3 = "A_Index") {
                            out .= "    mov x10, x20" . Chr(10)
                        }
                        else if (isRhsStackVar = 1) {
                            out .= "    ldr x10, =" . str3 . Chr(10)
                        }
                        else {
                            out .= "    ldr x10, =" . str3 . Chr(10) . "    ldr x10, [x10]" . Chr(10)
                        }
                    }
                    out .= "    cmp x9, x10" . Chr(10) . "    b.ge .end_if1_" . STR(ifCount1) . Chr(10)
                }
                else if (is_oryx = 1) { 
                            out .= "meta " . A_LoopField . Chr(10)
                    ; --- ORYX IR (if < -> jge) ---
                    strLhs := str2
                    if (str2 = "rax") { strLhs := "r0" }
                    else if (str2 = "A_Index") { strLhs := "r20" }
                    
                    strRhs := str3
                    if (str3 = "rax") { strRhs := "r0" }
                    else if (str3 = "A_Index") { strRhs := "r20" }
                    
                    out .= "cmp " . strLhs . ", " . strRhs . Chr(10)
                    out .= "jge end_if1_" . STR(ifCount1) . Chr(10)
                }
                else {
                    if (isNum = 1) {
                        out .= "mov rax, [" . str2 . "]" . Chr(10) . "cmp rax, " . str3 . Chr(10) . "jge .end_if1_" . STR(ifCount1) . Chr(10)
                    }
                    else {
                        out .= "mov rax, [" . str2 . "]" . Chr(10) . "cmp rax, [" . str3 . "]" . Chr(10) . "jge .end_if1_" . STR(ifCount1) . Chr(10)
                    }
                }
            }
            else if (InStr(str1, " >= ")) {
                str2 := Trim(StrSplit(str1, " >= ", 1))
                str3 := Trim(StrSplit(str1, " >= ", 2))
                isNum := RegExMatch(str3, "^\d+$")
                if (is_arm = 1) {
                    int isLhsStackVar := 0
                    if (inFunc = 1) {
                        Loop, % funcArgsArr.size() {
                            if (Trim(funcArgsArr[A_Index]) = str2) {
                                isLhsStackVar := 1
                                break
                            }
                        }
                    }
                    if (str2 = "rax") {
                        out .= "    mov x9, x0" . Chr(10)
                    }
                    else if (str2 = "A_Index") {
                        out .= "    mov x9, x20" . Chr(10)
                    }
                    else if (isLhsStackVar = 1) {
                        out .= "    ldr x9, =" . str2 . Chr(10)
                    }
                    else {
                        out .= "    ldr x9, =" . str2 . Chr(10) . "    ldr x9, [x9]" . Chr(10)
                    }
                    if (isNum = 1) {
                        out .= "    mov x10, #" . str3 . Chr(10)
                    }
                    else {
                        int isRhsStackVar := 0
                        if (inFunc = 1) {
                            Loop, % funcArgsArr.size() {
                                if (Trim(funcArgsArr[A_Index]) = str3) {
                                    isRhsStackVar := 1
                                    break
                                }
                            }
                        }
                        if (str3 = "rax") {
                            out .= "    mov x10, x0" . Chr(10)
                        }
                        else if (str3 = "A_Index") {
                            out .= "    mov x10, x20" . Chr(10)
                        }
                        else if (isRhsStackVar = 1) {
                            out .= "    ldr x10, =" . str3 . Chr(10)
                        }
                        else {
                            out .= "    ldr x10, =" . str3 . Chr(10) . "    ldr x10, [x10]" . Chr(10)
                        }
                    }
                    out .= "    cmp x9, x10" . Chr(10) . "    b.lt .end_if1_" . STR(ifCount1) . Chr(10)
                }
                else if (is_oryx = 1) {
                            out .= "meta " . A_LoopField . Chr(10)
                    ; --- ORYX IR (if >= -> jl) ---
                    strLhs := str2
                    if (str2 = "rax") { strLhs := "r0" }
                    else if (str2 = "A_Index") { strLhs := "r20" }
                    
                    strRhs := str3
                    if (str3 = "rax") { strRhs := "r0" }
                    else if (str3 = "A_Index") { strRhs := "r20" }
                    
                    out .= "cmp " . strLhs . ", " . strRhs . Chr(10)
                    out .= "jl end_if1_" . STR(ifCount1) . Chr(10)
                }
                else {
                    if (isNum = 1) {
                        out .= "mov rax, [" . str2 . "]" . Chr(10) . "cmp rax, " . str3 . Chr(10) . "jl .end_if1_" . STR(ifCount1) . Chr(10)
                    }
                    else {
                        out .= "mov rax, [" . str2 . "]" . Chr(10) . "cmp rax, [" . str3 . "]" . Chr(10) . "jl .end_if1_" . STR(ifCount1) . Chr(10)
                    }
                }
            }
            else if (InStr(str1, " <= ")) {
                str2 := Trim(StrSplit(str1, " <= ", 1))
                str3 := Trim(StrSplit(str1, " <= ", 2))
                isNum := RegExMatch(str3, "^\d+$")
                if (is_arm = 1) {
                    int isLhsStackVar := 0
                    if (inFunc = 1) {
                        Loop, % funcArgsArr.size() {
                            if (Trim(funcArgsArr[A_Index]) = str2) {
                                isLhsStackVar := 1
                                break
                            }
                        }
                    }
                    if (str2 = "rax") {
                        out .= "    mov x9, x0" . Chr(10)
                    }
                    else if (str2 = "A_Index") {
                        out .= "    mov x9, x20" . Chr(10)
                    }
                    else if (isLhsStackVar = 1) {
                        out .= "    ldr x9, =" . str2 . Chr(10)
                    }
                    else {
                        out .= "    ldr x9, =" . str2 . Chr(10) . "    ldr x9, [x9]" . Chr(10)
                    }
                    if (isNum = 1) {
                        out .= "    mov x10, #" . str3 . Chr(10)
                    }
                    else {
                        int isRhsStackVar := 0
                        if (inFunc = 1) {
                            Loop, % funcArgsArr.size() {
                                if (Trim(funcArgsArr[A_Index]) = str3) {
                                    isRhsStackVar := 1
                                    break
                                }
                            }
                        }
                        if (str3 = "rax") {
                            out .= "    mov x10, x0" . Chr(10)
                        }
                        else if (str3 = "A_Index") {
                            out .= "    mov x10, x20" . Chr(10)
                        }
                        else if (isRhsStackVar = 1) {
                            out .= "    ldr x10, =" . str3 . Chr(10)
                        }
                        else {
                            out .= "    ldr x10, =" . str3 . Chr(10) . "    ldr x10, [x10]" . Chr(10)
                        }
                    }
                    out .= "    cmp x9, x10" . Chr(10) . "    b.gt .end_if1_" . STR(ifCount1) . Chr(10)
                }
                else if (is_oryx = 1) {
                            out .= "meta " . A_LoopField . Chr(10)
                    ; --- ORYX IR (if <= -> jg) ---
                    strLhs := str2
                    if (str2 = "rax") { strLhs := "r0" }
                    else if (str2 = "A_Index") { strLhs := "r20" }
                    
                    strRhs := str3
                    if (str3 = "rax") { strRhs := "r0" }
                    else if (str3 = "A_Index") { strRhs := "r20" }
                    
                    out .= "cmp " . strLhs . ", " . strRhs . Chr(10)
                    out .= "jg end_if1_" . STR(ifCount1) . Chr(10)
                }
                else {
                    if (isNum = 1) {
                        out .= "mov rax, [" . str2 . "]" . Chr(10) . "cmp rax, " . str3 . Chr(10) . "jg .end_if1_" . STR(ifCount1) . Chr(10)
                    }
                    else {
                        out .= "mov rax, [" . str2 . "]" . Chr(10) . "cmp rax, [" . str3 . "]" . Chr(10) . "jg .end_if1_" . STR(ifCount1) . Chr(10)
                    }
                }
            }
        }
        else if (Trim(A_LoopField) = "ifend") or (Trim(A_LoopField) = "endif") or (Trim(A_LoopField) = "ifend1") or (Trim(A_LoopField) = "endif1") {
            if (is_oryx = 1) {
                        out .= "meta " . A_LoopField . Chr(10)
                out .= "end_if1_" . STR(ifCount1) . ":" . Chr(10)
            }
            else {
                out .= ".end_if1_" . STR(ifCount1) . ":" . Chr(10)
            }
            ifCount1++
        }
        else if (SubStr(StrLower(A_LoopField), 1, 4) = "if2 ") {
            isNum := 0
            str1 := Trim(StringTrimLeft(A_LoopField, 4))
            str1 := StringTrimLeft(str1, 1)
            str1 := StringTrimRight(str1, 1)
            if (InStr(str1, " = ")) {
                str2 := Trim(StrSplit(str1, " = ", 1))
                str3 := Trim(StrSplit(str1, " = ", 2))
                isNum := RegExMatch(str3, "^\d+$")
                if (is_arm = 1) {
                    ; --- LHS (str2) ---
                    int isLhsStackVar := 0
                    if (inFunc = 1) {
                        Loop, % funcArgsArr.size() {
                            if (Trim(funcArgsArr[A_Index]) = str2) {
                                isLhsStackVar := 1
                                break
                            }
                        }
                    }
                    if (str2 = "rax") {
                        out .= "    mov x9, x0" . Chr(10)
                    }
                    else if (str2 = "A_Index") {
                        out .= "    mov x9, x20" . Chr(10)
                    }
                    else if (isLhsStackVar = 1) {
                        out .= "    ldr x9, =" . str2 . Chr(10)
                    }
                    else {
                        out .= "    ldr x9, =" . str2 . Chr(10) . "    ldr x9, [x9]" . Chr(10)
                    }
                    ; --- RHS (str3) ---
                    int isRhsStackVar := 0
                    if (inFunc = 1) {
                        Loop, % funcArgsArr.size() {
                            if (Trim(funcArgsArr[A_Index]) = str3) {
                                isRhsStackVar := 1
                                break
                            }
                        }
                    }
                    if (str3 = "rax") {
                        out .= "    mov x10, x0" . Chr(10)
                    }
                    else if (str3 = "A_Index") {
                        out .= "    mov x10, x20" . Chr(10)
                    }
                    else if (isNum = 1) {
                        out .= "    mov x10, #" . str3 . Chr(10)
                    }
                    else if (isRhsStackVar = 1) {
                        out .= "    ldr x10, =" . str3 . Chr(10)
                    }
                    else {
                        out .= "    ldr x10, =" . str3 . Chr(10) . "    ldr x10, [x10]" . Chr(10)
                    }
                    out .= "    cmp x9, x10" . Chr(10) . "    b.ne .end_if2_" . STR(ifCount2) . Chr(10)
                }
                else if (is_oryx = 1) {
                            out .= "meta " . A_LoopField . Chr(10)
                    ; --- ORYX IR (if2 = -> jne) ---
                    strLhs := str2
                    if (str2 = "rax") { strLhs := "r0" }
                    else if (str2 = "A_Index") { strLhs := "r20" }
                    
                    strRhs := str3
                    if (str3 = "rax") { strRhs := "r0" }
                    else if (str3 = "A_Index") { strRhs := "r20" }
                    
                    out .= "cmp " . strLhs . ", " . strRhs . Chr(10)
                    out .= "jne end_if2_" . STR(ifCount2) . Chr(10)
                }
                else {
                    if (isNum = 1) {
                        out .= "mov rax, [" . str2 . "]" . Chr(10) . "cmp rax, " . str3 . Chr(10) . "jne .end_if2_" . STR(ifCount2) . Chr(10)
                    }
                    else {
                        out .= "mov rax, [" . str2 . "]" . Chr(10) . "cmp rax, [" . str3 . "]" . Chr(10) . "jne .end_if2_" . STR(ifCount2) . Chr(10)
                    }
                }
            }
            else if (InStr(str1, " != ")) {
                str2 := Trim(StrSplit(str1, " != ", 1))
                str3 := Trim(StrSplit(str1, " != ", 2))
                isNum := RegExMatch(str3, "^\d+$")
                if (is_arm = 1) {
                    int isLhsStackVar := 0
                    if (inFunc = 1) {
                        Loop, % funcArgsArr.size() {
                            if (Trim(funcArgsArr[A_Index]) = str2) {
                                isLhsStackVar := 1
                                break
                            }
                        }
                    }
                    if (str2 = "rax") {
                        out .= "    mov x9, x0" . Chr(10)
                    }
                    else if (str2 = "A_Index") {
                        out .= "    mov x9, x20" . Chr(10)
                    }
                    else if (isLhsStackVar = 1) {
                        out .= "    ldr x9, =" . str2 . Chr(10)
                    }
                    else {
                        out .= "    ldr x9, =" . str2 . Chr(10) . "    ldr x9, [x9]" . Chr(10)
                    }
                    if (isNum = 1) {
                        out .= "    mov x10, #" . str3 . Chr(10)
                    }
                    else {
                        int isRhsStackVar := 0
                        if (inFunc = 1) {
                            Loop, % funcArgsArr.size() {
                                if (Trim(funcArgsArr[A_Index]) = str3) {
                                    isRhsStackVar := 1
                                    break
                                }
                            }
                        }
                        if (str3 = "rax") {
                            out .= "    mov x10, x0" . Chr(10)
                        }
                        else if (str3 = "A_Index") {
                            out .= "    mov x10, x20" . Chr(10)
                        }
                        else if (isRhsStackVar = 1) {
                            out .= "    ldr x10, =" . str3 . Chr(10)
                        }
                        else {
                            out .= "    ldr x10, =" . str3 . Chr(10) . "    ldr x10, [x10]" . Chr(10)
                        }
                    }
                    out .= "    cmp x9, x10" . Chr(10) . "    b.eq .end_if2_" . STR(ifCount2) . Chr(10)
                }
                else if (is_oryx = 1) {
                            out .= "meta " . A_LoopField . Chr(10)
                    ; --- ORYX IR (if2 != -> je) ---
                    strLhs := str2
                    if (str2 = "rax") { strLhs := "r0" }
                    else if (str2 = "A_Index") { strLhs := "r20" }
                    
                    strRhs := str3
                    if (str3 = "rax") { strRhs := "r0" }
                    else if (str3 = "A_Index") { strRhs := "r20" }
                    
                    out .= "cmp " . strLhs . ", " . strRhs . Chr(10)
                    out .= "je end_if2_" . STR(ifCount2) . Chr(10)
                }
                else {
                    if (isNum = 1) {
                        out .= "mov rax, [" . str2 . "]" . Chr(10) . "cmp rax, " . str3 . Chr(10) . "je .end_if2_" . STR(ifCount2) . Chr(10)
                    }
                    else {
                        out .= "mov rax, [" . str2 . "]" . Chr(10) . "cmp rax, [" . str3 . "]" . Chr(10) . "je .end_if2_" . STR(ifCount2) . Chr(10)
                    }
                }
            }
            else if (InStr(str1, " > ")) {
                str2 := Trim(StrSplit(str1, " > ", 1))
                str3 := Trim(StrSplit(str1, " > ", 2))
                isNum := RegExMatch(str3, "^\d+$")
                if (is_arm = 1) {
                    int isLhsStackVar := 0
                    if (inFunc = 1) {
                        Loop, % funcArgsArr.size() {
                            if (Trim(funcArgsArr[A_Index]) = str2) {
                                isLhsStackVar := 1
                                break
                            }
                        }
                    }
                    if (str2 = "rax") {
                        out .= "    mov x9, x0" . Chr(10)
                    }
                    else if (str2 = "A_Index") {
                        out .= "    mov x9, x20" . Chr(10)
                    }
                    else if (isLhsStackVar = 1) {
                        out .= "    ldr x9, =" . str2 . Chr(10)
                    }
                    else {
                        out .= "    ldr x9, =" . str2 . Chr(10) . "    ldr x9, [x9]" . Chr(10)
                    }
                    if (isNum = 1) {
                        out .= "    mov x10, #" . str3 . Chr(10)
                    }
                    else {
                        int isRhsStackVar := 0
                        if (inFunc = 1) {
                            Loop, % funcArgsArr.size() {
                                if (Trim(funcArgsArr[A_Index]) = str3) {
                                    isRhsStackVar := 1
                                    break
                                }
                            }
                        }
                        if (str3 = "rax") {
                            out .= "    mov x10, x0" . Chr(10)
                        }
                        else if (str3 = "A_Index") {
                            out .= "    mov x10, x20" . Chr(10)
                        }
                        else if (isRhsStackVar = 1) {
                            out .= "    ldr x10, =" . str3 . Chr(10)
                        }
                        else {
                            out .= "    ldr x10, =" . str3 . Chr(10) . "    ldr x10, [x10]" . Chr(10)
                        }
                    }
                    out .= "    cmp x9, x10" . Chr(10) . "    b.le .end_if2_" . STR(ifCount2) . Chr(10)
                }
                else if (is_oryx = 1) {
                            out .= "meta " . A_LoopField . Chr(10)
                    ; --- ORYX IR (if2 > -> jle) ---
                    strLhs := str2
                    if (str2 = "rax") { strLhs := "r0" }
                    else if (str2 = "A_Index") { strLhs := "r20" }
                    
                    strRhs := str3
                    if (str3 = "rax") { strRhs := "r0" }
                    else if (str3 = "A_Index") { strRhs := "r20" }
                    
                    out .= "cmp " . strLhs . ", " . strRhs . Chr(10)
                    out .= "jle end_if2_" . STR(ifCount2) . Chr(10)
                }
                else {
                    if (isNum = 1) {
                        out .= "mov rax, [" . str2 . "]" . Chr(10) . "cmp rax, " . str3 . Chr(10) . "jle .end_if2_" . STR(ifCount2) . Chr(10)
                    }
                    else {
                        out .= "mov rax, [" . str2 . "]" . Chr(10) . "cmp rax, [" . str3 . "]" . Chr(10) . "jle .end_if2_" . STR(ifCount2) . Chr(10)
                    }
                }
            }
            else if (InStr(str1, " < ")) {
                str2 := Trim(StrSplit(str1, " < ", 1))
                str3 := Trim(StrSplit(str1, " < ", 2))
                isNum := RegExMatch(str3, "^\d+$")
                if (is_arm = 1) {
                    int isLhsStackVar := 0
                    if (inFunc = 1) {
                        Loop, % funcArgsArr.size() {
                            if (Trim(funcArgsArr[A_Index]) = str2) {
                                isLhsStackVar := 1
                                break
                            }
                        }
                    }
                    if (str2 = "rax") {
                        out .= "    mov x9, x0" . Chr(10)
                    }
                    else if (str2 = "A_Index") {
                        out .= "    mov x9, x20" . Chr(10)
                    }
                    else if (isLhsStackVar = 1) {
                        out .= "    ldr x9, =" . str2 . Chr(10)
                    }
                    else {
                        out .= "    ldr x9, =" . str2 . Chr(10) . "    ldr x9, [x9]" . Chr(10)
                    }
                    if (isNum = 1) {
                        out .= "    mov x10, #" . str3 . Chr(10)
                    }
                    else {
                        int isRhsStackVar := 0
                        if (inFunc = 1) {
                            Loop, % funcArgsArr.size() {
                                if (Trim(funcArgsArr[A_Index]) = str3) {
                                    isRhsStackVar := 1
                                    break
                                }
                            }
                        }
                        if (str3 = "rax") {
                            out .= "    mov x10, x0" . Chr(10)
                        }
                        else if (str3 = "A_Index") {
                            out .= "    mov x10, x20" . Chr(10)
                        }
                        else if (isRhsStackVar = 1) {
                            out .= "    ldr x10, =" . str3 . Chr(10)
                        }
                        else {
                            out .= "    ldr x10, =" . str3 . Chr(10) . "    ldr x10, [x10]" . Chr(10)
                        }
                    }
                    out .= "    cmp x9, x10" . Chr(10) . "    b.ge .end_if2_" . STR(ifCount2) . Chr(10)
                }
                else if (is_oryx = 1) {
                            out .= "meta " . A_LoopField . Chr(10)
                    ; --- ORYX IR (if2 < -> jge) ---
                    strLhs := str2
                    if (str2 = "rax") { strLhs := "r0" }
                    else if (str2 = "A_Index") { strLhs := "r20" }
                    
                    strRhs := str3
                    if (str3 = "rax") { strRhs := "r0" }
                    else if (str3 = "A_Index") { strRhs := "r20" }
                    
                    out .= "cmp " . strLhs . ", " . strRhs . Chr(10)
                    out .= "jge end_if2_" . STR(ifCount2) . Chr(10)
                }
                else {
                    if (isNum = 1) {
                        out .= "mov rax, [" . str2 . "]" . Chr(10) . "cmp rax, " . str3 . Chr(10) . "jge .end_if2_" . STR(ifCount2) . Chr(10)
                    }
                    else {
                        out .= "mov rax, [" . str2 . "]" . Chr(10) . "cmp rax, [" . str3 . "]" . Chr(10) . "jge .end_if2_" . STR(ifCount2) . Chr(10)
                    }
                }
            }
            else if (InStr(str1, " >= ")) {
                str2 := Trim(StrSplit(str1, " >= ", 1))
                str3 := Trim(StrSplit(str1, " >= ", 2))
                isNum := RegExMatch(str3, "^\d+$")
                if (is_arm = 1) {
                    int isLhsStackVar := 0
                    if (inFunc = 1) {
                        Loop, % funcArgsArr.size() {
                            if (Trim(funcArgsArr[A_Index]) = str2) {
                                isLhsStackVar := 1
                                break
                            }
                        }
                    }
                    if (str2 = "rax") {
                        out .= "    mov x9, x0" . Chr(10)
                    }
                    else if (str2 = "A_Index") {
                        out .= "    mov x9, x20" . Chr(10)
                    }
                    else if (isLhsStackVar = 1) {
                        out .= "    ldr x9, =" . str2 . Chr(10)
                    }
                    else {
                        out .= "    ldr x9, =" . str2 . Chr(10) . "    ldr x9, [x9]" . Chr(10)
                    }
                    if (isNum = 1) {
                        out .= "    mov x10, #" . str3 . Chr(10)
                    }
                    else {
                        int isRhsStackVar := 0
                        if (inFunc = 1) {
                            Loop, % funcArgsArr.size() {
                                if (Trim(funcArgsArr[A_Index]) = str3) {
                                    isRhsStackVar := 1
                                    break
                                }
                            }
                        }
                        if (str3 = "rax") {
                            out .= "    mov x10, x0" . Chr(10)
                        }
                        else if (str3 = "A_Index") {
                            out .= "    mov x10, x20" . Chr(10)
                        }
                        else if (isRhsStackVar = 1) {
                            out .= "    ldr x10, =" . str3 . Chr(10)
                        }
                        else {
                            out .= "    ldr x10, =" . str3 . Chr(10) . "    ldr x10, [x10]" . Chr(10)
                        }
                    }
                    out .= "    cmp x9, x10" . Chr(10) . "    b.lt .end_if2_" . STR(ifCount2) . Chr(10)
                }
                else if (is_oryx = 1) {
                            out .= "meta " . A_LoopField . Chr(10)
                    ; --- ORYX IR (if2 >= -> jl) ---
                    strLhs := str2
                    if (str2 = "rax") { strLhs := "r0" }
                    else if (str2 = "A_Index") { strLhs := "r20" }
                    
                    strRhs := str3
                    if (str3 = "rax") { strRhs := "r0" }
                    else if (str3 = "A_Index") { strRhs := "r20" }
                    
                    out .= "cmp " . strLhs . ", " . strRhs . Chr(10)
                    out .= "jl end_if2_" . STR(ifCount2) . Chr(10)
                }
                else {
                    if (isNum = 1) {
                        out .= "mov rax, [" . str2 . "]" . Chr(10) . "cmp rax, " . str3 . Chr(10) . "jl .end_if2_" . STR(ifCount2) . Chr(10)
                    }
                    else {
                        out .= "mov rax, [" . str2 . "]" . Chr(10) . "cmp rax, [" . str3 . "]" . Chr(10) . "jl .end_if2_" . STR(ifCount2) . Chr(10)
                    }
                }
            }
            else if (InStr(str1, " <= ")) {
                str2 := Trim(StrSplit(str1, " <= ", 1))
                str3 := Trim(StrSplit(str1, " <= ", 2))
                isNum := RegExMatch(str3, "^\d+$")
                if (is_arm = 1) {
                    int isLhsStackVar := 0
                    if (inFunc = 1) {
                        Loop, % funcArgsArr.size() {
                            if (Trim(funcArgsArr[A_Index]) = str2) {
                                isLhsStackVar := 1
                                break
                            }
                        }
                    }
                    if (str2 = "rax") {
                        out .= "    mov x9, x0" . Chr(10)
                    }
                    else if (str2 = "A_Index") {
                        out .= "    mov x9, x20" . Chr(10)
                    }
                    else if (isLhsStackVar = 1) {
                        out .= "    ldr x9, =" . str2 . Chr(10)
                    }
                    else {
                        out .= "    ldr x9, =" . str2 . Chr(10) . "    ldr x9, [x9]" . Chr(10)
                    }
                    if (isNum = 1) {
                        out .= "    mov x10, #" . str3 . Chr(10)
                    }
                    else {
                        int isRhsStackVar := 0
                        if (inFunc = 1) {
                            Loop, % funcArgsArr.size() {
                                if (Trim(funcArgsArr[A_Index]) = str3) {
                                    isRhsStackVar := 1
                                    break
                                }
                            }
                        }
                        if (str3 = "rax") {
                            out .= "    mov x10, x0" . Chr(10)
                        }
                        else if (str3 = "A_Index") {
                            out .= "    mov x10, x20" . Chr(10)
                        }
                        else if (isRhsStackVar = 1) {
                            out .= "    ldr x10, =" . str3 . Chr(10)
                        }
                        else {
                            out .= "    ldr x10, =" . str3 . Chr(10) . "    ldr x10, [x10]" . Chr(10)
                        }
                    }
                    out .= "    cmp x9, x10" . Chr(10) . "    b.gt .end_if2_" . STR(ifCount2) . Chr(10)
                }
                else if (is_oryx = 1) {
                            out .= "meta " . A_LoopField . Chr(10)
                    ; --- ORYX IR (if2 <= -> jg) ---
                    strLhs := str2
                    if (str2 = "rax") { strLhs := "r0" }
                    else if (str2 = "A_Index") { strLhs := "r20" }
                    
                    strRhs := str3
                    if (str3 = "rax") { strRhs := "r0" }
                    else if (str3 = "A_Index") { strRhs := "r20" }
                    
                    out .= "cmp " . strLhs . ", " . strRhs . Chr(10)
                    out .= "jg end_if2_" . STR(ifCount2) . Chr(10)
                }
                else {
                    if (isNum = 1) {
                        out .= "mov rax, [" . str2 . "]" . Chr(10) . "cmp rax, " . str3 . Chr(10) . "jg .end_if2_" . STR(ifCount2) . Chr(10)
                    }
                    else {
                        out .= "mov rax, [" . str2 . "]" . Chr(10) . "cmp rax, [" . str3 . "]" . Chr(10) . "jg .end_if2_" . STR(ifCount2) . Chr(10)
                    }
                }
            }
        }
        else if (Trim(A_LoopField) = "ifend2") or (Trim(A_LoopField) = "endif2") {
        if (is_oryx = 1) {
                    out .= "meta " . A_LoopField . Chr(10)
            out .= "end_if2_" . STR(ifCount2) . ":" . Chr(10)
        }
        else {
            out .= ".end_if2_" . STR(ifCount2) . ":" . Chr(10)
        }
            ifCount2++
        }
        else if (SubStr(StrLower(A_LoopField), 1, 4) = "if3 ") {
            isNum := 0
            str1 := Trim(StringTrimLeft(A_LoopField, 4))
            str1 := StringTrimLeft(str1, 1)
            str1 := StringTrimRight(str1, 1)
            if (InStr(str1, " = ")) {
                str2 := Trim(StrSplit(str1, " = ", 1))
                str3 := Trim(StrSplit(str1, " = ", 2))
                isNum := RegExMatch(str3, "^\d+$")
                if (is_arm = 1) {
                    int isLhsStackVar := 0
                    if (inFunc = 1) {
                        Loop, % funcArgsArr.size() {
                            if (Trim(funcArgsArr[A_Index]) = str2) {
                                isLhsStackVar := 1
                                break
                            }
                        }
                    }
                    if (str2 = "rax") {
                        out .= "    mov x9, x0" . Chr(10)
                    }
                    else if (str2 = "A_Index") {
                        out .= "    mov x9, x20" . Chr(10)
                    }
                    else if (isLhsStackVar = 1) {
                        out .= "    ldr x9, =" . str2 . Chr(10)
                    }
                    else {
                        out .= "    ldr x9, =" . str2 . Chr(10) . "    ldr x9, [x9]" . Chr(10)
                    }
                    int isRhsStackVar := 0
                    if (inFunc = 1) {
                        Loop, % funcArgsArr.size() {
                            if (Trim(funcArgsArr[A_Index]) = str3) {
                                isRhsStackVar := 1
                                break
                            }
                        }
                    }
                    if (str3 = "rax") {
                        out .= "    mov x10, x0" . Chr(10)
                    }
                    else if (str3 = "A_Index") {
                        out .= "    mov x10, x20" . Chr(10)
                    }
                    else if (isNum = 1) {
                        out .= "    mov x10, #" . str3 . Chr(10)
                    }
                    else if (isRhsStackVar = 1) {
                        out .= "    ldr x10, =" . str3 . Chr(10)
                    }
                    else {
                        out .= "    ldr x10, =" . str3 . Chr(10) . "    ldr x10, [x10]" . Chr(10)
                    }
                    out .= "    cmp x9, x10" . Chr(10) . "    b.ne .end_if3_" . STR(ifCount3) . Chr(10)
                }
                else if (is_oryx = 1) {
                            out .= "meta " . A_LoopField . Chr(10)
                    ; --- ORYX IR (if3 = -> jne) ---
                    strLhs := str2
                    if (str2 = "rax") { strLhs := "r0" }
                    else if (str2 = "A_Index") { strLhs := "r20" }
                    
                    strRhs := str3
                    if (str3 = "rax") { strRhs := "r0" }
                    else if (str3 = "A_Index") { strRhs := "r20" }
                    
                    out .= "cmp " . strLhs . ", " . strRhs . Chr(10)
                    out .= "jne end_if3_" . STR(ifCount3) . Chr(10)
                }
                else {
                    if (isNum = 1) {
                        out .= "mov rax, [" . str2 . "]" . Chr(10) . "cmp rax, " . str3 . Chr(10) . "jne .end_if3_" . STR(ifCount3) . Chr(10)
                    }
                    else {
                        out .= "mov rax, [" . str2 . "]" . Chr(10) . "cmp rax, [" . str3 . "]" . Chr(10) . "jne .end_if3_" . STR(ifCount3) . Chr(10)
                    }
                }
            }
            else if (InStr(str1, " != ")) {
                str2 := Trim(StrSplit(str1, " != ", 1))
                str3 := Trim(StrSplit(str1, " != ", 2))
                isNum := RegExMatch(str3, "^\d+$")
                if (is_arm = 1) {
                    int isLhsStackVar := 0
                    if (inFunc = 1) {
                        Loop, % funcArgsArr.size() {
                            if (Trim(funcArgsArr[A_Index]) = str2) {
                                isLhsStackVar := 1
                                break
                            }
                        }
                    }
                    if (str2 = "rax") {
                        out .= "    mov x9, x0" . Chr(10)
                    }
                    else if (str2 = "A_Index") {
                        out .= "    mov x9, x20" . Chr(10)
                    }
                    else if (isLhsStackVar = 1) {
                        out .= "    ldr x9, =" . str2 . Chr(10)
                    }
                    else {
                        out .= "    ldr x9, =" . str2 . Chr(10) . "    ldr x9, [x9]" . Chr(10)
                    }
                    if (isNum = 1) {
                        out .= "    mov x10, #" . str3 . Chr(10)
                    }
                    else {
                        int isRhsStackVar := 0
                        if (inFunc = 1) {
                            Loop, % funcArgsArr.size() {
                                if (Trim(funcArgsArr[A_Index]) = str3) {
                                    isRhsStackVar := 1
                                    break
                                }
                            }
                        }
                        if (str3 = "rax") {
                            out .= "    mov x10, x0" . Chr(10)
                        }
                        else if (str3 = "A_Index") {
                            out .= "    mov x10, x20" . Chr(10)
                        }
                        else if (isRhsStackVar = 1) {
                            out .= "    ldr x10, =" . str3 . Chr(10)
                        }
                        else {
                            out .= "    ldr x10, =" . str3 . Chr(10) . "    ldr x10, [x10]" . Chr(10)
                        }
                    }
                    out .= "    cmp x9, x10" . Chr(10) . "    b.eq .end_if3_" . STR(ifCount3) . Chr(10)
                }
                else if (is_oryx = 1) {
                            out .= "meta " . A_LoopField . Chr(10)
                    ; --- ORYX IR (if3 != -> je) ---
                    strLhs := str2
                    if (str2 = "rax") { strLhs := "r0" }
                    else if (str2 = "A_Index") { strLhs := "r20" }
                    
                    strRhs := str3
                    if (str3 = "rax") { strRhs := "r0" }
                    else if (str3 = "A_Index") { strRhs := "r20" }
                    
                    out .= "cmp " . strLhs . ", " . strRhs . Chr(10)
                    out .= "je end_if3_" . STR(ifCount3) . Chr(10)
                }
                else {
                    if (isNum = 1) {
                        out .= "mov rax, [" . str2 . "]" . Chr(10) . "cmp rax, " . str3 . Chr(10) . "je .end_if3_" . STR(ifCount3) . Chr(10)
                    }
                    else {
                        out .= "mov rax, [" . str2 . "]" . Chr(10) . "cmp rax, [" . str3 . "]" . Chr(10) . "je .end_if3_" . STR(ifCount3) . Chr(10)
                    }
                }
            }
            else if (InStr(str1, " > ")) {
                str2 := Trim(StrSplit(str1, " > ", 1))
                str3 := Trim(StrSplit(str1, " > ", 2))
                isNum := RegExMatch(str3, "^\d+$")
                if (is_arm = 1) {
                    int isLhsStackVar := 0
                    if (inFunc = 1) {
                        Loop, % funcArgsArr.size() {
                            if (Trim(funcArgsArr[A_Index]) = str2) {
                                isLhsStackVar := 1
                                break
                            }
                        }
                    }
                    if (str2 = "rax") {
                        out .= "    mov x9, x0" . Chr(10)
                    }
                    else if (str2 = "A_Index") {
                        out .= "    mov x9, x20" . Chr(10)
                    }
                    else if (isLhsStackVar = 1) {
                        out .= "    ldr x9, =" . str2 . Chr(10)
                    }
                    else {
                        out .= "    ldr x9, =" . str2 . Chr(10) . "    ldr x9, [x9]" . Chr(10)
                    }
                    if (isNum = 1) {
                        out .= "    mov x10, #" . str3 . Chr(10)
                    }
                    else {
                        int isRhsStackVar := 0
                        if (inFunc = 1) {
                            Loop, % funcArgsArr.size() {
                                if (Trim(funcArgsArr[A_Index]) = str3) {
                                    isRhsStackVar := 1
                                    break
                                }
                            }
                        }
                        if (str3 = "rax") {
                            out .= "    mov x10, x0" . Chr(10)
                        }
                        else if (str3 = "A_Index") {
                            out .= "    mov x10, x20" . Chr(10)
                        }
                        else if (isRhsStackVar = 1) {
                            out .= "    ldr x10, =" . str3 . Chr(10)
                        }
                        else {
                            out .= "    ldr x10, =" . str3 . Chr(10) . "    ldr x10, [x10]" . Chr(10)
                        }
                    }
                    out .= "    cmp x9, x10" . Chr(10) . "    b.le .end_if3_" . STR(ifCount3) . Chr(10)
                }
                else if (is_oryx = 1) {
                            out .= "meta " . A_LoopField . Chr(10)
                    ; --- ORYX IR (if3 > -> jle) ---
                    strLhs := str2
                    if (str2 = "rax") { strLhs := "r0" }
                    else if (str2 = "A_Index") { strLhs := "r20" }
                    
                    strRhs := str3
                    if (str3 = "rax") { strRhs := "r0" }
                    else if (str3 = "A_Index") { strRhs := "r20" }
                    
                    out .= "cmp " . strLhs . ", " . strRhs . Chr(10)
                    out .= "jle end_if3_" . STR(ifCount3) . Chr(10)
                }
                else {
                    if (isNum = 1) {
                        out .= "mov rax, [" . str2 . "]" . Chr(10) . "cmp rax, " . str3 . Chr(10) . "jle .end_if3_" . STR(ifCount3) . Chr(10)
                    }
                    else {
                        out .= "mov rax, [" . str2 . "]" . Chr(10) . "cmp rax, [" . str3 . "]" . Chr(10) . "jle .end_if3_" . STR(ifCount3) . Chr(10)
                    }
                }
            }
            else if (InStr(str1, " < ")) {
                str2 := Trim(StrSplit(str1, " < ", 1))
                str3 := Trim(StrSplit(str1, " < ", 2))
                isNum := RegExMatch(str3, "^\d+$")
                if (is_arm = 1) {
                    int isLhsStackVar := 0
                    if (inFunc = 1) {
                        Loop, % funcArgsArr.size() {
                            if (Trim(funcArgsArr[A_Index]) = str2) {
                                isLhsStackVar := 1
                                break
                            }
                        }
                    }
                    if (str2 = "rax") {
                        out .= "    mov x9, x0" . Chr(10)
                    }
                    else if (str2 = "A_Index") {
                        out .= "    mov x9, x20" . Chr(10)
                    }
                    else if (isLhsStackVar = 1) {
                        out .= "    ldr x9, =" . str2 . Chr(10)
                    }
                    else {
                        out .= "    ldr x9, =" . str2 . Chr(10) . "    ldr x9, [x9]" . Chr(10)
                    }
                    if (isNum = 1) {
                        out .= "    mov x10, #" . str3 . Chr(10)
                    }
                    else {
                        int isRhsStackVar := 0
                        if (inFunc = 1) {
                            Loop, % funcArgsArr.size() {
                                if (Trim(funcArgsArr[A_Index]) = str3) {
                                    isRhsStackVar := 1
                                    break
                                }
                            }
                        }
                        if (str3 = "rax") {
                            out .= "    mov x10, x0" . Chr(10)
                        }
                        else if (str3 = "A_Index") {
                            out .= "    mov x10, x20" . Chr(10)
                        }
                        else if (isRhsStackVar = 1) {
                            out .= "    ldr x10, =" . str3 . Chr(10)
                        }
                        else {
                            out .= "    ldr x10, =" . str3 . Chr(10) . "    ldr x10, [x10]" . Chr(10)
                        }
                    }
                    out .= "    cmp x9, x10" . Chr(10) . "    b.ge .end_if3_" . STR(ifCount3) . Chr(10)
                }
                else if (is_oryx = 1) {
                            out .= "meta " . A_LoopField . Chr(10)
                    ; --- ORYX IR (if3 < -> jge) ---
                    strLhs := str2
                    if (str2 = "rax") { strLhs := "r0" }
                    else if (str2 = "A_Index") { strLhs := "r20" }
                    
                    strRhs := str3
                    if (str3 = "rax") { strRhs := "r0" }
                    else if (str3 = "A_Index") { strRhs := "r20" }
                    
                    out .= "cmp " . strLhs . ", " . strRhs . Chr(10)
                    out .= "jge end_if3_" . STR(ifCount3) . Chr(10)
                }
                else {
                    if (isNum = 1) {
                        out .= "mov rax, [" . str2 . "]" . Chr(10) . "cmp rax, " . str3 . Chr(10) . "jge .end_if3_" . STR(ifCount3) . Chr(10)
                    }
                    else {
                        out .= "mov rax, [" . str2 . "]" . Chr(10) . "cmp rax, [" . str3 . "]" . Chr(10) . "jge .end_if3_" . STR(ifCount3) . Chr(10)
                    }
                }
            }
            else if (InStr(str1, " >= ")) {
                str2 := Trim(StrSplit(str1, " >= ", 1))
                str3 := Trim(StrSplit(str1, " >= ", 2))
                isNum := RegExMatch(str3, "^\d+$")
                if (is_arm = 1) {
                    int isLhsStackVar := 0
                    if (inFunc = 1) {
                        Loop, % funcArgsArr.size() {
                            if (Trim(funcArgsArr[A_Index]) = str2) {
                                isLhsStackVar := 1
                                break
                            }
                        }
                    }
                    if (str2 = "rax") {
                        out .= "    mov x9, x0" . Chr(10)
                    }
                    else if (str2 = "A_Index") {
                        out .= "    mov x9, x20" . Chr(10)
                    }
                    else if (isLhsStackVar = 1) {
                        out .= "    ldr x9, =" . str2 . Chr(10)
                    }
                    else {
                        out .= "    ldr x9, =" . str2 . Chr(10) . "    ldr x9, [x9]" . Chr(10)
                    }
                    if (isNum = 1) {
                        out .= "    mov x10, #" . str3 . Chr(10)
                    }
                    else {
                        int isRhsStackVar := 0
                        if (inFunc = 1) {
                            Loop, % funcArgsArr.size() {
                                if (Trim(funcArgsArr[A_Index]) = str3) {
                                    isRhsStackVar := 1
                                    break
                                }
                            }
                        }
                        if (str3 = "rax") {
                            out .= "    mov x10, x0" . Chr(10)
                        }
                        else if (str3 = "A_Index") {
                            out .= "    mov x10, x20" . Chr(10)
                        }
                        else if (isRhsStackVar = 1) {
                            out .= "    ldr x10, =" . str3 . Chr(10)
                        }
                        else {
                            out .= "    ldr x10, =" . str3 . Chr(10) . "    ldr x10, [x10]" . Chr(10)
                        }
                    }
                    out .= "    cmp x9, x10" . Chr(10) . "    b.lt .end_if3_" . STR(ifCount3) . Chr(10)
                }
                else if (is_oryx = 1) {
                            out .= "meta " . A_LoopField . Chr(10)
                    ; --- ORYX IR (if3 >= -> jl) ---
                    strLhs := str2
                    if (str2 = "rax") { strLhs := "r0" }
                    else if (str2 = "A_Index") { strLhs := "r20" }
                    
                    strRhs := str3
                    if (str3 = "rax") { strRhs := "r0" }
                    else if (str3 = "A_Index") { strRhs := "r20" }
                    
                    out .= "cmp " . strLhs . ", " . strRhs . Chr(10)
                    out .= "jl end_if3_" . STR(ifCount3) . Chr(10)
                }
                else {
                    if (isNum = 1) {
                        out .= "mov rax, [" . str2 . "]" . Chr(10) . "cmp rax, " . str3 . Chr(10) . "jl .end_if3_" . STR(ifCount3) . Chr(10)
                    }
                    else {
                        out .= "mov rax, [" . str2 . "]" . Chr(10) . "cmp rax, [" . str3 . "]" . Chr(10) . "jl .end_if3_" . STR(ifCount3) . Chr(10)
                    }
                }
            }
            else if (InStr(str1, " <= ")) {
                str2 := Trim(StrSplit(str1, " <= ", 1))
                str3 := Trim(StrSplit(str1, " <= ", 2))
                isNum := RegExMatch(str3, "^\d+$")
                if (is_arm = 1) {
                    int isLhsStackVar := 0
                    if (inFunc = 1) {
                        Loop, % funcArgsArr.size() {
                            if (Trim(funcArgsArr[A_Index]) = str2) {
                                isLhsStackVar := 1
                                break
                            }
                        }
                    }
                    if (str2 = "rax") {
                        out .= "    mov x9, x0" . Chr(10)
                    }
                    else if (str2 = "A_Index") {
                        out .= "    mov x9, x20" . Chr(10)
                    }
                    else if (isLhsStackVar = 1) {
                        out .= "    ldr x9, =" . str2 . Chr(10)
                    }
                    else {
                        out .= "    ldr x9, =" . str2 . Chr(10) . "    ldr x9, [x9]" . Chr(10)
                    }
                    if (isNum = 1) {
                        out .= "    mov x10, #" . str3 . Chr(10)
                    }
                    else {
                        int isRhsStackVar := 0
                        if (inFunc = 1) {
                            Loop, % funcArgsArr.size() {
                                if (Trim(funcArgsArr[A_Index]) = str3) {
                                    isRhsStackVar := 1
                                    break
                                }
                            }
                        }
                        if (str3 = "rax") {
                            out .= "    mov x10, x0" . Chr(10)
                        }
                        else if (str3 = "A_Index") {
                            out .= "    mov x10, x20" . Chr(10)
                        }
                        else if (isRhsStackVar = 1) {
                            out .= "    ldr x10, =" . str3 . Chr(10)
                        }
                        else {
                            out .= "    ldr x10, =" . str3 . Chr(10) . "    ldr x10, [x10]" . Chr(10)
                        }
                    }
                    out .= "    cmp x9, x10" . Chr(10) . "    b.gt .end_if3_" . STR(ifCount3) . Chr(10)
                }
                else if (is_oryx = 1) {
                            out .= "meta " . A_LoopField . Chr(10)
                    ; --- ORYX IR (if3 <= -> jg) ---
                    strLhs := str2
                    if (str2 = "rax") { strLhs := "r0" }
                    else if (str2 = "A_Index") { strLhs := "r20" }
                    
                    strRhs := str3
                    if (str3 = "rax") { strRhs := "r0" }
                    else if (str3 = "A_Index") { strRhs := "r20" }
                    
                    out .= "cmp " . strLhs . ", " . strRhs . Chr(10)
                    out .= "jg end_if3_" . STR(ifCount3) . Chr(10)
                }
                else {
                    if (isNum = 1) {
                        out .= "mov rax, [" . str2 . "]" . Chr(10) . "cmp rax, " . str3 . Chr(10) . "jg .end_if3_" . STR(ifCount3) . Chr(10)
                    }
                    else {
                        out .= "mov rax, [" . str2 . "]" . Chr(10) . "cmp rax, [" . str3 . "]" . Chr(10) . "jg .end_if3_" . STR(ifCount3) . Chr(10)
                    }
                }
            }
        }
        else if (Trim(A_LoopField) = "ifend3") or (Trim(A_LoopField) = "endif3") {
            if (is_oryx = 1) {      out .= "meta " . A_LoopField . Chr(10) 
                        out .= "meta " . A_LoopField . Chr(10)
                out .= "end_if3_" . STR(ifCount3) . ":" . Chr(10)
            } else {
                out .= ".end_if3_" . STR(ifCount3) . ":" . Chr(10)
            }
            ifCount3++
        }
        else if (SubStr(StrLower(A_LoopField), 1, 4) = "if4 ") {
            isNum := 0
            str1 := Trim(StringTrimLeft(A_LoopField, 4))
            str1 := StringTrimLeft(str1, 1)
            str1 := StringTrimRight(str1, 1)
            if (InStr(str1, " = ")) {
                str2 := Trim(StrSplit(str1, " = ", 1))
                str3 := Trim(StrSplit(str1, " = ", 2))
                isNum := RegExMatch(str3, "^\d+$")
                if (is_arm = 1) {
                    int isLhsStackVar := 0
                    if (inFunc = 1) {
                        Loop, % funcArgsArr.size() {
                            if (Trim(funcArgsArr[A_Index]) = str2) {
                                isLhsStackVar := 1
                                break
                            }
                        }
                    }
                    if (str2 = "rax") {
                        out .= "    mov x9, x0" . Chr(10)
                    }
                    else if (str2 = "A_Index") {
                        out .= "    mov x9, x20" . Chr(10)
                    }
                    else if (isLhsStackVar = 1) {
                        out .= "    ldr x9, =" . str2 . Chr(10)
                    }
                    else {
                        out .= "    ldr x9, =" . str2 . Chr(10)
                        out .= "    ldr x9, [x9]" . Chr(10)
                    }
                    int isRhsStackVar := 0
                    if (inFunc = 1) {
                        Loop, % funcArgsArr.size() {
                            if (Trim(funcArgsArr[A_Index]) = str3) {
                                isRhsStackVar := 1
                                break
                            }
                        }
                    }
                    if (str3 = "rax") {
                        out .= "    mov x10, x0" . Chr(10)
                    }
                    else if (str3 = "A_Index") {
                        out .= "    mov x10, x20" . Chr(10)
                    }
                    else if (isNum = 1) {
                        out .= "    mov x10, #" . str3 . Chr(10)
                    }
                    else if (isRhsStackVar = 1) {
                        out .= "    ldr x10, =" . str3 . Chr(10)
                    }
                    else {
                        out .= "    ldr x10, =" . str3 . Chr(10)
                        out .= "    ldr x10, [x10]" . Chr(10)
                    }
                    out .= "    cmp x9, x10" . Chr(10)
                    out .= "    b.ne .end_if4_" . STR(ifCount4) . Chr(10)
                }
                else if (is_oryx = 1) {      out .= "meta " . A_LoopField . Chr(10)
                    strLhs := str2
                    if (str2 = "rax") { strLhs := "r0" }
                    else if (str2 = "A_Index") { strLhs := "r20" }
                    strRhs := str3
                    if (str3 = "rax") { strRhs := "r0" }
                    else if (str3 = "A_Index") { strRhs := "r20" }
                    out .= "cmp " . strLhs . ", " . strRhs . Chr(10)
                    out .= "jne end_if4_" . STR(ifCount4) . Chr(10)
                }
                else {
                    if (isNum = 1) {
                        out .= "mov rax, [" . str2 . "]" . Chr(10)
                        out .= "cmp rax, " . str3 . Chr(10)
                        out .= "jne .end_if4_" . STR(ifCount4) . Chr(10)
                    }
                    else {
                        out .= "mov rax, [" . str2 . "]" . Chr(10)
                        out .= "cmp rax, [" . str3 . "]" . Chr(10)
                        out .= "jne .end_if4_" . STR(ifCount4) . Chr(10)
                    }
                }
            }
            else if (InStr(str1, " != ")) {
                str2 := Trim(StrSplit(str1, " != ", 1))
                str3 := Trim(StrSplit(str1, " != ", 2))
                isNum := RegExMatch(str3, "^\d+$")
                if (is_arm = 1) {
                    int isLhsStackVar := 0
                    if (inFunc = 1) {
                        Loop, % funcArgsArr.size() {
                            if (Trim(funcArgsArr[A_Index]) = str2) {
                                isLhsStackVar := 1
                                break
                            }
                        }
                    }
                    if (str2 = "rax") {
                        out .= "    mov x9, x0" . Chr(10)
                    }
                    else if (str2 = "A_Index") {
                        out .= "    mov x9, x20" . Chr(10)
                    }
                    else if (isLhsStackVar = 1) {
                        out .= "    ldr x9, =" . str2 . Chr(10)
                    }
                    else {
                        out .= "    ldr x9, =" . str2 . Chr(10)
                        out .= "    ldr x9, [x9]" . Chr(10)
                    }
                    if (isNum = 1) {
                        out .= "    mov x10, #" . str3 . Chr(10)
                    }
                    else {
                        int isRhsStackVar := 0
                        if (inFunc = 1) {
                            Loop, % funcArgsArr.size() {
                                if (Trim(funcArgsArr[A_Index]) = str3) {
                                    isRhsStackVar := 1
                                    break
                                }
                            }
                        }
                        if (str3 = "rax") {
                            out .= "    mov x10, x0" . Chr(10)
                        }
                        else if (str3 = "A_Index") {
                            out .= "    mov x10, x20" . Chr(10)
                        }
                        else if (isRhsStackVar = 1) {
                            out .= "    ldr x10, =" . str3 . Chr(10)
                        }
                        else {
                            out .= "    ldr x10, =" . str3 . Chr(10)
                            out .= "    ldr x10, [x10]" . Chr(10)
                        }
                    }
                    out .= "    cmp x9, x10" . Chr(10)
                    out .= "    b.eq .end_if4_" . STR(ifCount4) . Chr(10)
                }
                else if (is_oryx = 1) {      out .= "meta " . A_LoopField . Chr(10)
                    strLhs := str2
                    if (str2 = "rax") { strLhs := "r0" }
                    else if (str2 = "A_Index") { strLhs := "r20" }
                    strRhs := str3
                    if (str3 = "rax") { strRhs := "r0" }
                    else if (str3 = "A_Index") { strRhs := "r20" }
                    out .= "cmp " . strLhs . ", " . strRhs . Chr(10)
                    out .= "je end_if4_" . STR(ifCount4) . Chr(10)
                }
                else {
                    if (isNum = 1) {
                        out .= "mov rax, [" . str2 . "]" . Chr(10)
                        out .= "cmp rax, " . str3 . Chr(10)
                        out .= "je .end_if4_" . STR(ifCount4) . Chr(10)
                    }
                    else {
                        out .= "mov rax, [" . str2 . "]" . Chr(10)
                        out .= "cmp rax, [" . str3 . "]" . Chr(10)
                        out .= "je .end_if4_" . STR(ifCount4) . Chr(10)
                    }
                }
            }
            else if (InStr(str1, " > ")) {
                str2 := Trim(StrSplit(str1, " > ", 1))
                str3 := Trim(StrSplit(str1, " > ", 2))
                isNum := RegExMatch(str3, "^\d+$")
                if (is_arm = 1) {
                    int isLhsStackVar := 0
                    if (inFunc = 1) {
                        Loop, % funcArgsArr.size() {
                            if (Trim(funcArgsArr[A_Index]) = str2) {
                                isLhsStackVar := 1
                                break
                            }
                        }
                    }
                    if (str2 = "rax") {
                        out .= "    mov x9, x0" . Chr(10)
                    }
                    else if (str2 = "A_Index") {
                        out .= "    mov x9, x20" . Chr(10)
                    }
                    else if (isLhsStackVar = 1) {
                        out .= "    ldr x9, =" . str2 . Chr(10)
                    }
                    else {
                        out .= "    ldr x9, =" . str2 . Chr(10)
                        out .= "    ldr x9, [x9]" . Chr(10)
                    }
                    if (isNum = 1) {
                        out .= "    mov x10, #" . str3 . Chr(10)
                    }
                    else {
                        int isRhsStackVar := 0
                        if (inFunc = 1) {
                            Loop, % funcArgsArr.size() {
                                if (Trim(funcArgsArr[A_Index]) = str3) {
                                    isRhsStackVar := 1
                                    break
                                }
                            }
                        }
                        if (str3 = "rax") {
                            out .= "    mov x10, x0" . Chr(10)
                        }
                        else if (str3 = "A_Index") {
                            out .= "    mov x10, x20" . Chr(10)
                        }
                        else if (isRhsStackVar = 1) {
                            out .= "    ldr x10, =" . str3 . Chr(10)
                        }
                        else {
                            out .= "    ldr x10, =" . str3 . Chr(10)
                            out .= "    ldr x10, [x10]" . Chr(10)
                        }
                    }
                    out .= "    cmp x9, x10" . Chr(10)
                    out .= "    b.le .end_if4_" . STR(ifCount4) . Chr(10)
                }
                else if (is_oryx = 1) {      out .= "meta " . A_LoopField . Chr(10)
                    strLhs := str2
                    if (str2 = "rax") { strLhs := "r0" }
                    else if (str2 = "A_Index") { strLhs := "r20" }
                    strRhs := str3
                    if (str3 = "rax") { strRhs := "r0" }
                    else if (str3 = "A_Index") { strRhs := "r20" }
                    out .= "cmp " . strLhs . ", " . strRhs . Chr(10)
                    out .= "jle end_if4_" . STR(ifCount4) . Chr(10)
                }
                else {
                    if (isNum = 1) {
                        out .= "mov rax, [" . str2 . "]" . Chr(10)
                        out .= "cmp rax, " . str3 . Chr(10)
                        out .= "jle .end_if4_" . STR(ifCount4) . Chr(10)
                    }
                    else {
                        out .= "mov rax, [" . str2 . "]" . Chr(10)
                        out .= "cmp rax, [" . str3 . "]" . Chr(10)
                        out .= "jle .end_if4_" . STR(ifCount4) . Chr(10)
                    }
                }
            }
            else if (InStr(str1, " < ")) {
                str2 := Trim(StrSplit(str1, " < ", 1))
                str3 := Trim(StrSplit(str1, " < ", 2))
                isNum := RegExMatch(str3, "^\d+$")
                if (is_arm = 1) {
                    int isLhsStackVar := 0
                    if (inFunc = 1) {
                        Loop, % funcArgsArr.size() {
                            if (Trim(funcArgsArr[A_Index]) = str2) {
                                isLhsStackVar := 1
                                break
                            }
                        }
                    }
                    if (str2 = "rax") {
                        out .= "    mov x9, x0" . Chr(10)
                    }
                    else if (str2 = "A_Index") {
                        out .= "    mov x9, x20" . Chr(10)
                    }
                    else if (isLhsStackVar = 1) {
                        out .= "    ldr x9, =" . str2 . Chr(10)
                    }
                    else {
                        out .= "    ldr x9, =" . str2 . Chr(10)
                        out .= "    ldr x9, [x9]" . Chr(10)
                    }
                    if (isNum = 1) {
                        out .= "    mov x10, #" . str3 . Chr(10)
                    }
                    else {
                        int isRhsStackVar := 0
                        if (inFunc = 1) {
                            Loop, % funcArgsArr.size() {
                                if (Trim(funcArgsArr[A_Index]) = str3) {
                                    isRhsStackVar := 1
                                    break
                                }
                            }
                        }
                        if (str3 = "rax") {
                            out .= "    mov x10, x0" . Chr(10)
                        }
                        else if (str3 = "A_Index") {
                            out .= "    mov x10, x20" . Chr(10)
                        }
                        else if (isRhsStackVar = 1) {
                            out .= "    ldr x10, =" . str3 . Chr(10)
                        }
                        else {
                            out .= "    ldr x10, =" . str3 . Chr(10)
                            out .= "    ldr x10, [x10]" . Chr(10)
                        }
                    }
                    out .= "    cmp x9, x10" . Chr(10)
                    out .= "    b.ge .end_if4_" . STR(ifCount4) . Chr(10)
                }
                else if (is_oryx = 1) {      out .= "meta " . A_LoopField . Chr(10)
                    strLhs := str2
                    if (str2 = "rax") { strLhs := "r0" }
                    else if (str2 = "A_Index") { strLhs := "r20" }
                    strRhs := str3
                    if (str3 = "rax") { strRhs := "r0" }
                    else if (str3 = "A_Index") { strRhs := "r20" }
                    out .= "cmp " . strLhs . ", " . strRhs . Chr(10)
                    out .= "jge end_if4_" . STR(ifCount4) . Chr(10)
                }
                else {
                    if (isNum = 1) {
                        out .= "mov rax, [" . str2 . "]" . Chr(10)
                        out .= "cmp rax, " . str3 . Chr(10)
                        out .= "jge .end_if4_" . STR(ifCount4) . Chr(10)
                    }
                    else {
                        out .= "mov rax, [" . str2 . "]" . Chr(10)
                        out .= "cmp rax, [" . str3 . "]" . Chr(10)
                        out .= "jge .end_if4_" . STR(ifCount4) . Chr(10)
                    }
                }
            }
            else if (InStr(str1, " >= ")) {
                str2 := Trim(StrSplit(str1, " >= ", 1))
                str3 := Trim(StrSplit(str1, " >= ", 2))
                isNum := RegExMatch(str3, "^\d+$")
                if (is_arm = 1) {
                    int isLhsStackVar := 0
                    if (inFunc = 1) {
                        Loop, % funcArgsArr.size() {
                            if (Trim(funcArgsArr[A_Index]) = str2) {
                                isLhsStackVar := 1
                                break
                            }
                        }
                    }
                    if (str2 = "rax") {
                        out .= "    mov x9, x0" . Chr(10)
                    }
                    else if (str2 = "A_Index") {
                        out .= "    mov x9, x20" . Chr(10)
                    }
                    else if (isLhsStackVar = 1) {
                        out .= "    ldr x9, =" . str2 . Chr(10)
                    }
                    else {
                        out .= "    ldr x9, =" . str2 . Chr(10)
                        out .= "    ldr x9, [x9]" . Chr(10)
                    }
                    if (isNum = 1) {
                        out .= "    mov x10, #" . str3 . Chr(10)
                    }
                    else {
                        int isRhsStackVar := 0
                        if (inFunc = 1) {
                            Loop, % funcArgsArr.size() {
                                if (Trim(funcArgsArr[A_Index]) = str3) {
                                    isRhsStackVar := 1
                                    break
                                }
                            }
                        }
                        if (str3 = "rax") {
                            out .= "    mov x10, x0" . Chr(10)
                        }
                        else if (str3 = "A_Index") {
                            out .= "    mov x10, x20" . Chr(10)
                        }
                        else if (isRhsStackVar = 1) {
                            out .= "    ldr x10, =" . str3 . Chr(10)
                        }
                        else {
                            out .= "    ldr x10, =" . str3 . Chr(10)
                            out .= "    ldr x10, [x10]" . Chr(10)
                        }
                    }
                    out .= "    cmp x9, x10" . Chr(10)
                    out .= "    b.lt .end_if4_" . STR(ifCount4) . Chr(10)
                }
                else if (is_oryx = 1) {      out .= "meta " . A_LoopField . Chr(10)
                    strLhs := str2
                    if (str2 = "rax") { strLhs := "r0" }
                    else if (str2 = "A_Index") { strLhs := "r20" }
                    strRhs := str3
                    if (str3 = "rax") { strRhs := "r0" }
                    else if (str3 = "A_Index") { strRhs := "r20" }
                    out .= "cmp " . strLhs . ", " . strRhs . Chr(10)
                    out .= "jl end_if4_" . STR(ifCount4) . Chr(10)
                }
                else {
                    if (isNum = 1) {
                        out .= "mov rax, [" . str2 . "]" . Chr(10)
                        out .= "cmp rax, " . str3 . Chr(10)
                        out .= "jl .end_if4_" . STR(ifCount4) . Chr(10)
                    }
                    else {
                        out .= "mov rax, [" . str2 . "]" . Chr(10)
                        out .= "cmp rax, [" . str3 . "]" . Chr(10)
                        out .= "jl .end_if4_" . STR(ifCount4) . Chr(10)
                    }
                }
            }
            else if (InStr(str1, " <= ")) {
                str2 := Trim(StrSplit(str1, " <= ", 1))
                str3 := Trim(StrSplit(str1, " <= ", 2))
                isNum := RegExMatch(str3, "^\d+$")
                if (is_arm = 1) {
                    int isLhsStackVar := 0
                    if (inFunc = 1) {
                        Loop, % funcArgsArr.size() {
                            if (Trim(funcArgsArr[A_Index]) = str2) {
                                isLhsStackVar := 1
                                break
                            }
                        }
                    }
                    if (str2 = "rax") {
                        out .= "    mov x9, x0" . Chr(10)
                    }
                    else if (str2 = "A_Index") {
                        out .= "    mov x9, x20" . Chr(10)
                    }
                    else if (isLhsStackVar = 1) {
                        out .= "    ldr x9, =" . str2 . Chr(10)
                    }
                    else {
                        out .= "    ldr x9, =" . str2 . Chr(10)
                        out .= "    ldr x9, [x9]" . Chr(10)
                    }
                    if (isNum = 1) {
                        out .= "    mov x10, #" . str3 . Chr(10)
                    }
                    else {
                        int isRhsStackVar := 0
                        if (inFunc = 1) {
                            Loop, % funcArgsArr.size() {
                                if (Trim(funcArgsArr[A_Index]) = str3) {
                                    isRhsStackVar := 1
                                    break
                                }
                            }
                        }
                        if (str3 = "rax") {
                            out .= "    mov x10, x0" . Chr(10)
                        }
                        else if (str3 = "A_Index") {
                            out .= "    mov x10, x20" . Chr(10)
                        }
                        else if (isRhsStackVar = 1) {
                            out .= "    ldr x10, =" . str3 . Chr(10)
                        }
                        else {
                            out .= "    ldr x10, =" . str3 . Chr(10)
                            out .= "    ldr x10, [x10]" . Chr(10)
                        }
                    }
                    out .= "    cmp x9, x10" . Chr(10)
                    out .= "    b.gt .end_if4_" . STR(ifCount4) . Chr(10)
                }
                else if (is_oryx = 1) {      out .= "meta " . A_LoopField . Chr(10)
                    strLhs := str2
                    if (str2 = "rax") { strLhs := "r0" }
                    else if (str2 = "A_Index") { strLhs := "r20" }
                    strRhs := str3
                    if (str3 = "rax") { strRhs := "r0" }
                    else if (str3 = "A_Index") { strRhs := "r20" }
                    out .= "cmp " . strLhs . ", " . strRhs . Chr(10)
                    out .= "jg end_if4_" . STR(ifCount4) . Chr(10)
                }
                else {
                    if (isNum = 1) {
                        out .= "mov rax, [" . str2 . "]" . Chr(10)
                        out .= "cmp rax, " . str3 . Chr(10)
                        out .= "jg .end_if4_" . STR(ifCount4) . Chr(10)
                    }
                    else {
                        out .= "mov rax, [" . str2 . "]" . Chr(10)
                        out .= "cmp rax, [" . str3 . "]" . Chr(10)
                        out .= "jg .end_if4_" . STR(ifCount4) . Chr(10)
                    }
                }
            }
        }
        else if (Trim(A_LoopField) = "ifend4") or (Trim(A_LoopField) = "endif4") {
            if (is_oryx = 1) {      out .= "meta " . A_LoopField . Chr(10)
                out .= "end_if4_" . STR(ifCount4) . ":" . Chr(10)
            } else {
                out .= ".end_if4_" . STR(ifCount4) . ":" . Chr(10)
            }
            ifCount4++
        }
        else if (SubStr(StrLower(A_LoopField), 1, 4) = "if5 ") {
            isNum := 0
            str1 := Trim(StringTrimLeft(A_LoopField, 4))
            str1 := StringTrimLeft(str1, 1)
            str1 := StringTrimRight(str1, 1)
            if (InStr(str1, " = ")) {
                str2 := Trim(StrSplit(str1, " = ", 1))
                str3 := Trim(StrSplit(str1, " = ", 2))
                isNum := RegExMatch(str3, "^\d+$")
                if (is_arm = 1) {
                    int isLhsStackVar := 0
                    if (inFunc = 1) {
                        Loop, % funcArgsArr.size() {
                            if (Trim(funcArgsArr[A_Index]) = str2) {
                                isLhsStackVar := 1
                                break
                            }
                        }
                    }
                    if (str2 = "rax") {
                        out .= "    mov x9, x0" . Chr(10)
                    }
                    else if (str2 = "A_Index") {
                        out .= "    mov x9, x20" . Chr(10)
                    }
                    else if (isLhsStackVar = 1) {
                        out .= "    ldr x9, =" . str2 . Chr(10)
                    }
                    else {
                        out .= "    ldr x9, =" . str2 . Chr(10)
                        out .= "    ldr x9, [x9]" . Chr(10)
                    }
                    int isRhsStackVar := 0
                    if (inFunc = 1) {
                        Loop, % funcArgsArr.size() {
                            if (Trim(funcArgsArr[A_Index]) = str3) {
                                isRhsStackVar := 1
                                break
                            }
                        }
                    }
                    if (str3 = "rax") {
                        out .= "    mov x10, x0" . Chr(10)
                    }
                    else if (str3 = "A_Index") {
                        out .= "    mov x10, x20" . Chr(10)
                    }
                    else if (isNum = 1) {
                        out .= "    mov x10, #" . str3 . Chr(10)
                    }
                    else if (isRhsStackVar = 1) {
                        out .= "    ldr x10, =" . str3 . Chr(10)
                    }
                    else {
                        out .= "    ldr x10, =" . str3 . Chr(10)
                        out .= "    ldr x10, [x10]" . Chr(10)
                    }
                    out .= "    cmp x9, x10" . Chr(10)
                    out .= "    b.ne .end_if5_" . STR(ifCount5) . Chr(10)
                }
                else if (is_oryx = 1) {      out .= "meta " . A_LoopField . Chr(10)
                    strLhs := str2
                    if (str2 = "rax") { strLhs := "r0" }
                    else if (str2 = "A_Index") { strLhs := "r20" }
                    strRhs := str3
                    if (str3 = "rax") { strRhs := "r0" }
                    else if (str3 = "A_Index") { strRhs := "r20" }
                    out .= "cmp " . strLhs . ", " . strRhs . Chr(10)
                    out .= "jne end_if5_" . STR(ifCount5) . Chr(10)
                }
                else {
                    if (isNum = 1) {
                        out .= "mov rax, [" . str2 . "]" . Chr(10)
                        out .= "cmp rax, " . str3 . Chr(10)
                        out .= "jne .end_if5_" . STR(ifCount5) . Chr(10)
                    }
                    else {
                        out .= "mov rax, [" . str2 . "]" . Chr(10)
                        out .= "cmp rax, [" . str3 . "]" . Chr(10)
                        out .= "jne .end_if5_" . STR(ifCount5) . Chr(10)
                    }
                }
            }
            else if (InStr(str1, " != ")) {
                str2 := Trim(StrSplit(str1, " != ", 1))
                str3 := Trim(StrSplit(str1, " != ", 2))
                isNum := RegExMatch(str3, "^\d+$")
                if (is_arm = 1) {
                    int isLhsStackVar := 0
                    if (inFunc = 1) {
                        Loop, % funcArgsArr.size() {
                            if (Trim(funcArgsArr[A_Index]) = str2) {
                                isLhsStackVar := 1
                                break
                            }
                        }
                    }
                    if (str2 = "rax") {
                        out .= "    mov x9, x0" . Chr(10)
                    }
                    else if (str2 = "A_Index") {
                        out .= "    mov x9, x20" . Chr(10)
                    }
                    else if (isLhsStackVar = 1) {
                        out .= "    ldr x9, =" . str2 . Chr(10)
                    }
                    else {
                        out .= "    ldr x9, =" . str2 . Chr(10)
                        out .= "    ldr x9, [x9]" . Chr(10)
                    }
                    if (isNum = 1) {
                        out .= "    mov x10, #" . str3 . Chr(10)
                    }
                    else {
                        int isRhsStackVar := 0
                        if (inFunc = 1) {
                            Loop, % funcArgsArr.size() {
                                if (Trim(funcArgsArr[A_Index]) = str3) {
                                    isRhsStackVar := 1
                                    break
                                }
                            }
                        }
                        if (str3 = "rax") {
                            out .= "    mov x10, x0" . Chr(10)
                        }
                        else if (str3 = "A_Index") {
                            out .= "    mov x10, x20" . Chr(10)
                        }
                        else if (isRhsStackVar = 1) {
                            out .= "    ldr x10, =" . str3 . Chr(10)
                        }
                        else {
                            out .= "    ldr x10, =" . str3 . Chr(10)
                            out .= "    ldr x10, [x10]" . Chr(10)
                        }
                    }
                    out .= "    cmp x9, x10" . Chr(10)
                    out .= "    b.eq .end_if5_" . STR(ifCount5) . Chr(10)
                }
                else if (is_oryx = 1) {      out .= "meta " . A_LoopField . Chr(10)
                    strLhs := str2
                    if (str2 = "rax") { strLhs := "r0" }
                    else if (str2 = "A_Index") { strLhs := "r20" }
                    strRhs := str3
                    if (str3 = "rax") { strRhs := "r0" }
                    else if (str3 = "A_Index") { strRhs := "r20" }
                    out .= "cmp " . strLhs . ", " . strRhs . Chr(10)
                    out .= "je end_if5_" . STR(ifCount5) . Chr(10)
                }
                else {
                    if (isNum = 1) {
                        out .= "mov rax, [" . str2 . "]" . Chr(10)
                        out .= "cmp rax, " . str3 . Chr(10)
                        out .= "je .end_if5_" . STR(ifCount5) . Chr(10)
                    }
                    else {
                        out .= "mov rax, [" . str2 . "]" . Chr(10)
                        out .= "cmp rax, [" . str3 . "]" . Chr(10)
                        out .= "je .end_if5_" . STR(ifCount5) . Chr(10)
                    }
                }
            }
            else if (InStr(str1, " > ")) {
                str2 := Trim(StrSplit(str1, " > ", 1))
                str3 := Trim(StrSplit(str1, " > ", 2))
                isNum := RegExMatch(str3, "^\d+$")
                if (is_arm = 1) {
                    int isLhsStackVar := 0
                    if (inFunc = 1) {
                        Loop, % funcArgsArr.size() {
                            if (Trim(funcArgsArr[A_Index]) = str2) {
                                isLhsStackVar := 1
                                break
                            }
                        }
                    }
                    if (str2 = "rax") {
                        out .= "    mov x9, x0" . Chr(10)
                    }
                    else if (str2 = "A_Index") {
                        out .= "    mov x9, x20" . Chr(10)
                    }
                    else if (isLhsStackVar = 1) {
                        out .= "    ldr x9, =" . str2 . Chr(10)
                    }
                    else {
                        out .= "    ldr x9, =" . str2 . Chr(10)
                        out .= "    ldr x9, [x9]" . Chr(10)
                    }
                    if (isNum = 1) {
                        out .= "    mov x10, #" . str3 . Chr(10)
                    }
                    else {
                        int isRhsStackVar := 0
                        if (inFunc = 1) {
                            Loop, % funcArgsArr.size() {
                                if (Trim(funcArgsArr[A_Index]) = str3) {
                                    isRhsStackVar := 1
                                    break
                                }
                            }
                        }
                        if (str3 = "rax") {
                            out .= "    mov x10, x0" . Chr(10)
                        }
                        else if (str3 = "A_Index") {
                            out .= "    mov x10, x20" . Chr(10)
                        }
                        else if (isRhsStackVar = 1) {
                            out .= "    ldr x10, =" . str3 . Chr(10)
                        }
                        else {
                            out .= "    ldr x10, =" . str3 . Chr(10)
                            out .= "    ldr x10, [x10]" . Chr(10)
                        }
                    }
                    out .= "    cmp x9, x10" . Chr(10)
                    out .= "    b.le .end_if5_" . STR(ifCount5) . Chr(10)
                }
                else if (is_oryx = 1) {      out .= "meta " . A_LoopField . Chr(10)
                    strLhs := str2
                    if (str2 = "rax") { strLhs := "r0" }
                    else if (str2 = "A_Index") { strLhs := "r20" }
                    strRhs := str3
                    if (str3 = "rax") { strRhs := "r0" }
                    else if (str3 = "A_Index") { strRhs := "r20" }
                    out .= "cmp " . strLhs . ", " . strRhs . Chr(10)
                    out .= "jle end_if5_" . STR(ifCount5) . Chr(10)
                }
                else {
                    if (isNum = 1) {
                        out .= "mov rax, [" . str2 . "]" . Chr(10)
                        out .= "cmp rax, " . str3 . Chr(10)
                        out .= "jle .end_if5_" . STR(ifCount5) . Chr(10)
                    }
                    else {
                        out .= "mov rax, [" . str2 . "]" . Chr(10)
                        out .= "cmp rax, [" . str3 . "]" . Chr(10)
                        out .= "jle .end_if5_" . STR(ifCount5) . Chr(10)
                    }
                }
            }
            else if (InStr(str1, " < ")) {
                str2 := Trim(StrSplit(str1, " < ", 1))
                str3 := Trim(StrSplit(str1, " < ", 2))
                isNum := RegExMatch(str3, "^\d+$")
                if (is_arm = 1) {
                    int isLhsStackVar := 0
                    if (inFunc = 1) {
                        Loop, % funcArgsArr.size() {
                            if (Trim(funcArgsArr[A_Index]) = str2) {
                                isLhsStackVar := 1
                                break
                            }
                        }
                    }
                    if (str2 = "rax") {
                        out .= "    mov x9, x0" . Chr(10)
                    }
                    else if (str2 = "A_Index") {
                        out .= "    mov x9, x20" . Chr(10)
                    }
                    else if (isLhsStackVar = 1) {
                        out .= "    ldr x9, =" . str2 . Chr(10)
                    }
                    else {
                        out .= "    ldr x9, =" . str2 . Chr(10)
                        out .= "    ldr x9, [x9]" . Chr(10)
                    }
                    if (isNum = 1) {
                        out .= "    mov x10, #" . str3 . Chr(10)
                    }
                    else {
                        int isRhsStackVar := 0
                        if (inFunc = 1) {
                            Loop, % funcArgsArr.size() {
                                if (Trim(funcArgsArr[A_Index]) = str3) {
                                    isRhsStackVar := 1
                                    break
                                }
                            }
                        }
                        if (str3 = "rax") {
                            out .= "    mov x10, x0" . Chr(10)
                        }
                        else if (str3 = "A_Index") {
                            out .= "    mov x10, x20" . Chr(10)
                        }
                        else if (isRhsStackVar = 1) {
                            out .= "    ldr x10, =" . str3 . Chr(10)
                        }
                        else {
                            out .= "    ldr x10, =" . str3 . Chr(10)
                            out .= "    ldr x10, [x10]" . Chr(10)
                        }
                    }
                    out .= "    cmp x9, x10" . Chr(10)
                    out .= "    b.ge .end_if5_" . STR(ifCount5) . Chr(10)
                }
                else if (is_oryx = 1) {      out .= "meta " . A_LoopField . Chr(10)
                    strLhs := str2
                    if (str2 = "rax") { strLhs := "r0" }
                    else if (str2 = "A_Index") { strLhs := "r20" }
                    strRhs := str3
                    if (str3 = "rax") { strRhs := "r0" }
                    else if (str3 = "A_Index") { strRhs := "r20" }
                    out .= "cmp " . strLhs . ", " . strRhs . Chr(10)
                    out .= "jge end_if5_" . STR(ifCount5) . Chr(10)
                }
                else {
                    if (isNum = 1) {
                        out .= "mov rax, [" . str2 . "]" . Chr(10)
                        out .= "cmp rax, " . str3 . Chr(10)
                        out .= "jge .end_if5_" . STR(ifCount5) . Chr(10)
                    }
                    else {
                        out .= "mov rax, [" . str2 . "]" . Chr(10)
                        out .= "cmp rax, [" . str3 . "]" . Chr(10)
                        out .= "jge .end_if5_" . STR(ifCount5) . Chr(10)
                    }
                }
            }
            else if (InStr(str1, " >= ")) {
                str2 := Trim(StrSplit(str1, " >= ", 1))
                str3 := Trim(StrSplit(str1, " >= ", 2))
                isNum := RegExMatch(str3, "^\d+$")
                if (is_arm = 1) {
                    int isLhsStackVar := 0
                    if (inFunc = 1) {
                        Loop, % funcArgsArr.size() {
                            if (Trim(funcArgsArr[A_Index]) = str2) {
                                isLhsStackVar := 1
                                break
                            }
                        }
                    }
                    if (str2 = "rax") {
                        out .= "    mov x9, x0" . Chr(10)
                    }
                    else if (str2 = "A_Index") {
                        out .= "    mov x9, x20" . Chr(10)
                    }
                    else if (isLhsStackVar = 1) {
                        out .= "    ldr x9, =" . str2 . Chr(10)
                    }
                    else {
                        out .= "    ldr x9, =" . str2 . Chr(10)
                        out .= "    ldr x9, [x9]" . Chr(10)
                    }
                    if (isNum = 1) {
                        out .= "    mov x10, #" . str3 . Chr(10)
                    }
                    else {
                        int isRhsStackVar := 0
                        if (inFunc = 1) {
                            Loop, % funcArgsArr.size() {
                                if (Trim(funcArgsArr[A_Index]) = str3) {
                                    isRhsStackVar := 1
                                    break
                                }
                            }
                        }
                        if (str3 = "rax") {
                            out .= "    mov x10, x0" . Chr(10)
                        }
                        else if (str3 = "A_Index") {
                            out .= "    mov x10, x20" . Chr(10)
                        }
                        else if (isRhsStackVar = 1) {
                            out .= "    ldr x10, =" . str3 . Chr(10)
                        }
                        else {
                            out .= "    ldr x10, =" . str3 . Chr(10)
                            out .= "    ldr x10, [x10]" . Chr(10)
                        }
                    }
                    out .= "    cmp x9, x10" . Chr(10)
                    out .= "    b.lt .end_if5_" . STR(ifCount5) . Chr(10)
                }
                else if (is_oryx = 1) {      out .= "meta " . A_LoopField . Chr(10)
                    strLhs := str2
                    if (str2 = "rax") { strLhs := "r0" }
                    else if (str2 = "A_Index") { strLhs := "r20" }
                    strRhs := str3
                    if (str3 = "rax") { strRhs := "r0" }
                    else if (str3 = "A_Index") { strRhs := "r20" }
                    out .= "cmp " . strLhs . ", " . strRhs . Chr(10)
                    out .= "jl end_if5_" . STR(ifCount5) . Chr(10)
                }
                else {
                    if (isNum = 1) {
                        out .= "mov rax, [" . str2 . "]" . Chr(10)
                        out .= "cmp rax, " . str3 . Chr(10)
                        out .= "jl .end_if5_" . STR(ifCount5) . Chr(10)
                    }
                    else {
                        out .= "mov rax, [" . str2 . "]" . Chr(10)
                        out .= "cmp rax, [" . str3 . "]" . Chr(10)
                        out .= "jl .end_if5_" . STR(ifCount5) . Chr(10)
                    }
                }
            }
            else if (InStr(str1, " <= ")) {
                str2 := Trim(StrSplit(str1, " <= ", 1))
                str3 := Trim(StrSplit(str1, " <= ", 2))
                isNum := RegExMatch(str3, "^\d+$")
                if (is_arm = 1) {
                    int isLhsStackVar := 0
                    if (inFunc = 1) {
                        Loop, % funcArgsArr.size() {
                            if (Trim(funcArgsArr[A_Index]) = str2) {
                                isLhsStackVar := 1
                                break
                            }
                        }
                    }
                    if (str2 = "rax") {
                        out .= "    mov x9, x0" . Chr(10)
                    }
                    else if (str2 = "A_Index") {
                        out .= "    mov x9, x20" . Chr(10)
                    }
                    else if (isLhsStackVar = 1) {
                        out .= "    ldr x9, =" . str2 . Chr(10)
                    }
                    else {
                        out .= "    ldr x9, =" . str2 . Chr(10)
                        out .= "    ldr x9, [x9]" . Chr(10)
                    }
                    if (isNum = 1) {
                        out .= "    mov x10, #" . str3 . Chr(10)
                    }
                    else {
                        int isRhsStackVar := 0
                        if (inFunc = 1) {
                            Loop, % funcArgsArr.size() {
                                if (Trim(funcArgsArr[A_Index]) = str3) {
                                    isRhsStackVar := 1
                                    break
                                }
                            }
                        }
                        if (str3 = "rax") {
                            out .= "    mov x10, x0" . Chr(10)
                        }
                        else if (str3 = "A_Index") {
                            out .= "    mov x10, x20" . Chr(10)
                        }
                        else if (isRhsStackVar = 1) {
                            out .= "    ldr x10, =" . str3 . Chr(10)
                        }
                        else {
                            out .= "    ldr x10, =" . str3 . Chr(10)
                            out .= "    ldr x10, [x10]" . Chr(10)
                        }
                    }
                    out .= "    cmp x9, x10" . Chr(10)
                    out .= "    b.gt .end_if5_" . STR(ifCount5) . Chr(10)
                }
                else if (is_oryx = 1) {      out .= "meta " . A_LoopField . Chr(10)
                    strLhs := str2
                    if (str2 = "rax") { strLhs := "r0" }
                    else if (str2 = "A_Index") { strLhs := "r20" }
                    strRhs := str3
                    if (str3 = "rax") { strRhs := "r0" }
                    else if (str3 = "A_Index") { strRhs := "r20" }
                    out .= "cmp " . strLhs . ", " . strRhs . Chr(10)
                    out .= "jg end_if5_" . STR(ifCount5) . Chr(10)
                }
                else {
                    if (isNum = 1) {
                        out .= "mov rax, [" . str2 . "]" . Chr(10)
                        out .= "cmp rax, " . str3 . Chr(10)
                        out .= "jg .end_if5_" . STR(ifCount5) . Chr(10)
                    }
                    else {
                        out .= "mov rax, [" . str2 . "]" . Chr(10)
                        out .= "cmp rax, [" . str3 . "]" . Chr(10)
                        out .= "jg .end_if5_" . STR(ifCount5) . Chr(10)
                    }
                }
            }
        }
        else if (Trim(A_LoopField) = "ifend5") or (Trim(A_LoopField) = "endif5") {
            if (is_oryx = 1) {      out .= "meta " . A_LoopField . Chr(10)
                out .= "end_if5_" . STR(ifCount5) . ":" . Chr(10)
            } else {
                out .= ".end_if5_" . STR(ifCount5) . ":" . Chr(10)
            }
            ifCount5++
        }
        else if (SubStr(StrLower(A_LoopField), 1, 4) = "if6 ") {
            isNum := 0
            str1 := Trim(StringTrimLeft(A_LoopField, 4))
            str1 := StringTrimLeft(str1, 1)
            str1 := StringTrimRight(str1, 1)
            if (InStr(str1, " = ")) {
                str2 := Trim(StrSplit(str1, " = ", 1))
                str3 := Trim(StrSplit(str1, " = ", 2))
                isNum := RegExMatch(str3, "^\d+$")
                if (is_arm = 1) {
                    int isLhsStackVar := 0
                    if (inFunc = 1) {
                        Loop, % funcArgsArr.size() {
                            if (Trim(funcArgsArr[A_Index]) = str2) {
                                isLhsStackVar := 1
                                break
                            }
                        }
                    }
                    if (str2 = "rax") {
                        out .= "    mov x9, x0" . Chr(10)
                    }
                    else if (str2 = "A_Index") {
                        out .= "    mov x9, x20" . Chr(10)
                    }
                    else if (isLhsStackVar = 1) {
                        out .= "    ldr x9, =" . str2 . Chr(10)
                    }
                    else {
                        out .= "    ldr x9, =" . str2 . Chr(10)
                        out .= "    ldr x9, [x9]" . Chr(10)
                    }
                    int isRhsStackVar := 0
                    if (inFunc = 1) {
                        Loop, % funcArgsArr.size() {
                            if (Trim(funcArgsArr[A_Index]) = str3) {
                                isRhsStackVar := 1
                                break
                            }
                        }
                    }
                    if (str3 = "rax") {
                        out .= "    mov x10, x0" . Chr(10)
                    }
                    else if (str3 = "A_Index") {
                        out .= "    mov x10, x20" . Chr(10)
                    }
                    else if (isNum = 1) {
                        out .= "    mov x10, #" . str3 . Chr(10)
                    }
                    else if (isRhsStackVar = 1) {
                        out .= "    ldr x10, =" . str3 . Chr(10)
                    }
                    else {
                        out .= "    ldr x10, =" . str3 . Chr(10)
                        out .= "    ldr x10, [x10]" . Chr(10)
                    }
                    out .= "    cmp x9, x10" . Chr(10)
                    out .= "    b.ne .end_if6_" . STR(ifCount6) . Chr(10)
                }
                else if (is_oryx = 1) {      out .= "meta " . A_LoopField . Chr(10)
                    strLhs := str2
                    if (str2 = "rax") { strLhs := "r0" }
                    else if (str2 = "A_Index") { strLhs := "r20" }
                    strRhs := str3
                    if (str3 = "rax") { strRhs := "r0" }
                    else if (str3 = "A_Index") { strRhs := "r20" }
                    out .= "cmp " . strLhs . ", " . strRhs . Chr(10)
                    out .= "jne end_if6_" . STR(ifCount6) . Chr(10)
                }
                else {
                    if (isNum = 1) {
                        out .= "mov rax, [" . str2 . "]" . Chr(10)
                        out .= "cmp rax, " . str3 . Chr(10)
                        out .= "jne .end_if6_" . STR(ifCount6) . Chr(10)
                    }
                    else {
                        out .= "mov rax, [" . str2 . "]" . Chr(10)
                        out .= "cmp rax, [" . str3 . "]" . Chr(10)
                        out .= "jne .end_if6_" . STR(ifCount6) . Chr(10)
                    }
                }
            }
            else if (InStr(str1, " != ")) {
                str2 := Trim(StrSplit(str1, " != ", 1))
                str3 := Trim(StrSplit(str1, " != ", 2))
                isNum := RegExMatch(str3, "^\d+$")
                if (is_arm = 1) {
                    int isLhsStackVar := 0
                    if (inFunc = 1) {
                        Loop, % funcArgsArr.size() {
                            if (Trim(funcArgsArr[A_Index]) = str2) {
                                isLhsStackVar := 1
                                break
                            }
                        }
                    }
                    if (str2 = "rax") {
                        out .= "    mov x9, x0" . Chr(10)
                    }
                    else if (str2 = "A_Index") {
                        out .= "    mov x9, x20" . Chr(10)
                    }
                    else if (isLhsStackVar = 1) {
                        out .= "    ldr x9, =" . str2 . Chr(10)
                    }
                    else {
                        out .= "    ldr x9, =" . str2 . Chr(10)
                        out .= "    ldr x9, [x9]" . Chr(10)
                    }
                    if (isNum = 1) {
                        out .= "    mov x10, #" . str3 . Chr(10)
                    }
                    else {
                        int isRhsStackVar := 0
                        if (inFunc = 1) {
                            Loop, % funcArgsArr.size() {
                                if (Trim(funcArgsArr[A_Index]) = str3) {
                                    isRhsStackVar := 1
                                    break
                                }
                            }
                        }
                        if (str3 = "rax") {
                            out .= "    mov x10, x0" . Chr(10)
                        }
                        else if (str3 = "A_Index") {
                            out .= "    mov x10, x20" . Chr(10)
                        }
                        else if (isRhsStackVar = 1) {
                            out .= "    ldr x10, =" . str3 . Chr(10)
                        }
                        else {
                            out .= "    ldr x10, =" . str3 . Chr(10)
                            out .= "    ldr x10, [x10]" . Chr(10)
                        }
                    }
                    out .= "    cmp x9, x10" . Chr(10)
                    out .= "    b.eq .end_if6_" . STR(ifCount6) . Chr(10)
                }
                else if (is_oryx = 1) {      out .= "meta " . A_LoopField . Chr(10)
                    strLhs := str2
                    if (str2 = "rax") { strLhs := "r0" }
                    else if (str2 = "A_Index") { strLhs := "r20" }
                    strRhs := str3
                    if (str3 = "rax") { strRhs := "r0" }
                    else if (str3 = "A_Index") { strRhs := "r20" }
                    out .= "cmp " . strLhs . ", " . strRhs . Chr(10)
                    out .= "je end_if6_" . STR(ifCount6) . Chr(10)
                }
                else {
                    if (isNum = 1) {
                        out .= "mov rax, [" . str2 . "]" . Chr(10)
                        out .= "cmp rax, " . str3 . Chr(10)
                        out .= "je .end_if6_" . STR(ifCount6) . Chr(10)
                    }
                    else {
                        out .= "mov rax, [" . str2 . "]" . Chr(10)
                        out .= "cmp rax, [" . str3 . "]" . Chr(10)
                        out .= "je .end_if6_" . STR(ifCount6) . Chr(10)
                    }
                }
            }
            else if (InStr(str1, " > ")) {
                str2 := Trim(StrSplit(str1, " > ", 1))
                str3 := Trim(StrSplit(str1, " > ", 2))
                isNum := RegExMatch(str3, "^\d+$")
                if (is_arm = 1) {
                    int isLhsStackVar := 0
                    if (inFunc = 1) {
                        Loop, % funcArgsArr.size() {
                            if (Trim(funcArgsArr[A_Index]) = str2) {
                                isLhsStackVar := 1
                                break
                            }
                        }
                    }
                    if (str2 = "rax") {
                        out .= "    mov x9, x0" . Chr(10)
                    }
                    else if (str2 = "A_Index") {
                        out .= "    mov x9, x20" . Chr(10)
                    }
                    else if (isLhsStackVar = 1) {
                        out .= "    ldr x9, =" . str2 . Chr(10)
                    }
                    else {
                        out .= "    ldr x9, =" . str2 . Chr(10)
                        out .= "    ldr x9, [x9]" . Chr(10)
                    }
                    if (isNum = 1) {
                        out .= "    mov x10, #" . str3 . Chr(10)
                    }
                    else {
                        int isRhsStackVar := 0
                        if (inFunc = 1) {
                            Loop, % funcArgsArr.size() {
                                if (Trim(funcArgsArr[A_Index]) = str3) {
                                    isRhsStackVar := 1
                                    break
                                }
                            }
                        }
                        if (str3 = "rax") {
                            out .= "    mov x10, x0" . Chr(10)
                        }
                        else if (str3 = "A_Index") {
                            out .= "    mov x10, x20" . Chr(10)
                        }
                        else if (isRhsStackVar = 1) {
                            out .= "    ldr x10, =" . str3 . Chr(10)
                        }
                        else {
                            out .= "    ldr x10, =" . str3 . Chr(10)
                            out .= "    ldr x10, [x10]" . Chr(10)
                        }
                    }
                    out .= "    cmp x9, x10" . Chr(10)
                    out .= "    b.le .end_if6_" . STR(ifCount6) . Chr(10)
                }
                else if (is_oryx = 1) {      out .= "meta " . A_LoopField . Chr(10)
                    strLhs := str2
                    if (str2 = "rax") { strLhs := "r0" }
                    else if (str2 = "A_Index") { strLhs := "r20" }
                    strRhs := str3
                    if (str3 = "rax") { strRhs := "r0" }
                    else if (str3 = "A_Index") { strRhs := "r20" }
                    out .= "cmp " . strLhs . ", " . strRhs . Chr(10)
                    out .= "jle end_if6_" . STR(ifCount6) . Chr(10)
                }
                else {
                    if (isNum = 1) {
                        out .= "mov rax, [" . str2 . "]" . Chr(10)
                        out .= "cmp rax, " . str3 . Chr(10)
                        out .= "jle .end_if6_" . STR(ifCount6) . Chr(10)
                    }
                    else {
                        out .= "mov rax, [" . str2 . "]" . Chr(10)
                        out .= "cmp rax, [" . str3 . "]" . Chr(10)
                        out .= "jle .end_if6_" . STR(ifCount6) . Chr(10)
                    }
                }
            }
            else if (InStr(str1, " < ")) {
                str2 := Trim(StrSplit(str1, " < ", 1))
                str3 := Trim(StrSplit(str1, " < ", 2))
                isNum := RegExMatch(str3, "^\d+$")
                if (is_arm = 1) {
                    int isLhsStackVar := 0
                    if (inFunc = 1) {
                        Loop, % funcArgsArr.size() {
                            if (Trim(funcArgsArr[A_Index]) = str2) {
                                isLhsStackVar := 1
                                break
                            }
                        }
                    }
                    if (str2 = "rax") {
                        out .= "    mov x9, x0" . Chr(10)
                    }
                    else if (str2 = "A_Index") {
                        out .= "    mov x9, x20" . Chr(10)
                    }
                    else if (isLhsStackVar = 1) {
                        out .= "    ldr x9, =" . str2 . Chr(10)
                    }
                    else {
                        out .= "    ldr x9, =" . str2 . Chr(10)
                        out .= "    ldr x9, [x9]" . Chr(10)
                    }
                    if (isNum = 1) {
                        out .= "    mov x10, #" . str3 . Chr(10)
                    }
                    else {
                        int isRhsStackVar := 0
                        if (inFunc = 1) {
                            Loop, % funcArgsArr.size() {
                                if (Trim(funcArgsArr[A_Index]) = str3) {
                                    isRhsStackVar := 1
                                    break
                                }
                            }
                        }
                        if (str3 = "rax") {
                            out .= "    mov x10, x0" . Chr(10)
                        }
                        else if (str3 = "A_Index") {
                            out .= "    mov x10, x20" . Chr(10)
                        }
                        else if (isRhsStackVar = 1) {
                            out .= "    ldr x10, =" . str3 . Chr(10)
                        }
                        else {
                            out .= "    ldr x10, =" . str3 . Chr(10)
                            out .= "    ldr x10, [x10]" . Chr(10)
                        }
                    }
                    out .= "    cmp x9, x10" . Chr(10)
                    out .= "    b.ge .end_if6_" . STR(ifCount6) . Chr(10)
                }
                else if (is_oryx = 1) {      out .= "meta " . A_LoopField . Chr(10)
                    strLhs := str2
                    if (str2 = "rax") { strLhs := "r0" }
                    else if (str2 = "A_Index") { strLhs := "r20" }
                    strRhs := str3
                    if (str3 = "rax") { strRhs := "r0" }
                    else if (str3 = "A_Index") { strRhs := "r20" }
                    out .= "cmp " . strLhs . ", " . strRhs . Chr(10)
                    out .= "jge end_if6_" . STR(ifCount6) . Chr(10)
                }
                else {
                    if (isNum = 1) {
                        out .= "mov rax, [" . str2 . "]" . Chr(10)
                        out .= "cmp rax, " . str3 . Chr(10)
                        out .= "jge .end_if6_" . STR(ifCount6) . Chr(10)
                    }
                    else {
                        out .= "mov rax, [" . str2 . "]" . Chr(10)
                        out .= "cmp rax, [" . str3 . "]" . Chr(10)
                        out .= "jge .end_if6_" . STR(ifCount6) . Chr(10)
                    }
                }
            }
            else if (InStr(str1, " >= ")) {
                str2 := Trim(StrSplit(str1, " >= ", 1))
                str3 := Trim(StrSplit(str1, " >= ", 2))
                isNum := RegExMatch(str3, "^\d+$")
                if (is_arm = 1) {
                    int isLhsStackVar := 0
                    if (inFunc = 1) {
                        Loop, % funcArgsArr.size() {
                            if (Trim(funcArgsArr[A_Index]) = str2) {
                                isLhsStackVar := 1
                                break
                            }
                        }
                    }
                    if (str2 = "rax") {
                        out .= "    mov x9, x0" . Chr(10)
                    }
                    else if (str2 = "A_Index") {
                        out .= "    mov x9, x20" . Chr(10)
                    }
                    else if (isLhsStackVar = 1) {
                        out .= "    ldr x9, =" . str2 . Chr(10)
                    }
                    else {
                        out .= "    ldr x9, =" . str2 . Chr(10)
                        out .= "    ldr x9, [x9]" . Chr(10)
                    }
                    if (isNum = 1) {
                        out .= "    mov x10, #" . str3 . Chr(10)
                    }
                    else {
                        int isRhsStackVar := 0
                        if (inFunc = 1) {
                            Loop, % funcArgsArr.size() {
                                if (Trim(funcArgsArr[A_Index]) = str3) {
                                    isRhsStackVar := 1
                                    break
                                }
                            }
                        }
                        if (str3 = "rax") {
                            out .= "    mov x10, x0" . Chr(10)
                        }
                        else if (str3 = "A_Index") {
                            out .= "    mov x10, x20" . Chr(10)
                        }
                        else if (isRhsStackVar = 1) {
                            out .= "    ldr x10, =" . str3 . Chr(10)
                        }
                        else {
                            out .= "    ldr x10, =" . str3 . Chr(10)
                            out .= "    ldr x10, [x10]" . Chr(10)
                        }
                    }
                    out .= "    cmp x9, x10" . Chr(10)
                    out .= "    b.lt .end_if6_" . STR(ifCount6) . Chr(10)
                }
                else if (is_oryx = 1) {      out .= "meta " . A_LoopField . Chr(10)
                    strLhs := str2
                    if (str2 = "rax") { strLhs := "r0" }
                    else if (str2 = "A_Index") { strLhs := "r20" }
                    strRhs := str3
                    if (str3 = "rax") { strRhs := "r0" }
                    else if (str3 = "A_Index") { strRhs := "r20" }
                    out .= "cmp " . strLhs . ", " . strRhs . Chr(10)
                    out .= "jl end_if6_" . STR(ifCount6) . Chr(10)
                }
                else {
                    if (isNum = 1) {
                        out .= "mov rax, [" . str2 . "]" . Chr(10)
                        out .= "cmp rax, " . str3 . Chr(10)
                        out .= "jl .end_if6_" . STR(ifCount6) . Chr(10)
                    }
                    else {
                        out .= "mov rax, [" . str2 . "]" . Chr(10)
                        out .= "cmp rax, [" . str3 . "]" . Chr(10)
                        out .= "jl .end_if6_" . STR(ifCount6) . Chr(10)
                    }
                }
            }
            else if (InStr(str1, " <= ")) {
                str2 := Trim(StrSplit(str1, " <= ", 1))
                str3 := Trim(StrSplit(str1, " <= ", 2))
                isNum := RegExMatch(str3, "^\d+$")
                if (is_arm = 1) {
                    int isLhsStackVar := 0
                    if (inFunc = 1) {
                        Loop, % funcArgsArr.size() {
                            if (Trim(funcArgsArr[A_Index]) = str2) {
                                isLhsStackVar := 1
                                break
                            }
                        }
                    }
                    if (str2 = "rax") {
                        out .= "    mov x9, x0" . Chr(10)
                    }
                    else if (str2 = "A_Index") {
                        out .= "    mov x9, x20" . Chr(10)
                    }
                    else if (isLhsStackVar = 1) {
                        out .= "    ldr x9, =" . str2 . Chr(10)
                    }
                    else {
                        out .= "    ldr x9, =" . str2 . Chr(10)
                        out .= "    ldr x9, [x9]" . Chr(10)
                    }
                    if (isNum = 1) {
                        out .= "    mov x10, #" . str3 . Chr(10)
                    }
                    else {
                        int isRhsStackVar := 0
                        if (inFunc = 1) {
                            Loop, % funcArgsArr.size() {
                                if (Trim(funcArgsArr[A_Index]) = str3) {
                                    isRhsStackVar := 1
                                    break
                                }
                            }
                        }
                        if (str3 = "rax") {
                            out .= "    mov x10, x0" . Chr(10)
                        }
                        else if (str3 = "A_Index") {
                            out .= "    mov x10, x20" . Chr(10)
                        }
                        else if (isRhsStackVar = 1) {
                            out .= "    ldr x10, =" . str3 . Chr(10)
                        }
                        else {
                            out .= "    ldr x10, =" . str3 . Chr(10)
                            out .= "    ldr x10, [x10]" . Chr(10)
                        }
                    }
                    out .= "    cmp x9, x10" . Chr(10)
                    out .= "    b.gt .end_if6_" . STR(ifCount6) . Chr(10)
                }
                else if (is_oryx = 1) {      out .= "meta " . A_LoopField . Chr(10)
                    strLhs := str2
                    if (str2 = "rax") { strLhs := "r0" }
                    else if (str2 = "A_Index") { strLhs := "r20" }
                    strRhs := str3
                    if (str3 = "rax") { strRhs := "r0" }
                    else if (str3 = "A_Index") { strRhs := "r20" }
                    out .= "cmp " . strLhs . ", " . strRhs . Chr(10)
                    out .= "jg end_if6_" . STR(ifCount6) . Chr(10)
                }
                else {
                    if (isNum = 1) {
                        out .= "mov rax, [" . str2 . "]" . Chr(10)
                        out .= "cmp rax, " . str3 . Chr(10)
                        out .= "jg .end_if6_" . STR(ifCount6) . Chr(10)
                    }
                    else {
                        out .= "mov rax, [" . str2 . "]" . Chr(10)
                        out .= "cmp rax, [" . str3 . "]" . Chr(10)
                        out .= "jg .end_if6_" . STR(ifCount6) . Chr(10)
                    }
                }
            }
        }
        else if (Trim(A_LoopField) = "ifend6") or (Trim(A_LoopField) = "endif6") {
            if (is_oryx = 1) {      out .= "meta " . A_LoopField . Chr(10)
                out .= "end_if6_" . STR(ifCount6) . ":" . Chr(10)
            } else {
                out .= ".end_if6_" . STR(ifCount6) . ":" . Chr(10)
            }
            ifCount6++
        }
        else if (SubStr(StrLower(A_LoopField), 1, 4) = "if7 ") {
            isNum := 0
            str1 := Trim(StringTrimLeft(A_LoopField, 4))
            str1 := StringTrimLeft(str1, 1)
            str1 := StringTrimRight(str1, 1)
            if (InStr(str1, " = ")) {
                str2 := Trim(StrSplit(str1, " = ", 1))
                str3 := Trim(StrSplit(str1, " = ", 2))
                isNum := RegExMatch(str3, "^\d+$")
                if (is_arm = 1) {
                    int isLhsStackVar := 0
                    if (inFunc = 1) {
                        Loop, % funcArgsArr.size() {
                            if (Trim(funcArgsArr[A_Index]) = str2) {
                                isLhsStackVar := 1
                                break
                            }
                        }
                    }
                    if (str2 = "rax") {
                        out .= "    mov x9, x0" . Chr(10)
                    }
                    else if (str2 = "A_Index") {
                        out .= "    mov x9, x20" . Chr(10)
                    }
                    else if (isLhsStackVar = 1) {
                        out .= "    ldr x9, =" . str2 . Chr(10)
                    }
                    else {
                        out .= "    ldr x9, =" . str2 . Chr(10)
                        out .= "    ldr x9, [x9]" . Chr(10)
                    }
                    int isRhsStackVar := 0
                    if (inFunc = 1) {
                        Loop, % funcArgsArr.size() {
                            if (Trim(funcArgsArr[A_Index]) = str3) {
                                isRhsStackVar := 1
                                break
                            }
                        }
                    }
                    if (str3 = "rax") {
                        out .= "    mov x10, x0" . Chr(10)
                    }
                    else if (str3 = "A_Index") {
                        out .= "    mov x10, x20" . Chr(10)
                    }
                    else if (isNum = 1) {
                        out .= "    mov x10, #" . str3 . Chr(10)
                    }
                    else if (isRhsStackVar = 1) {
                        out .= "    ldr x10, =" . str3 . Chr(10)
                    }
                    else {
                        out .= "    ldr x10, =" . str3 . Chr(10)
                        out .= "    ldr x10, [x10]" . Chr(10)
                    }
                    out .= "    cmp x9, x10" . Chr(10)
                    out .= "    b.ne .end_if7_" . STR(ifCount7) . Chr(10)
                }
                else if (is_oryx = 1) {      out .= "meta " . A_LoopField . Chr(10)
                    strLhs := str2
                    if (str2 = "rax") { strLhs := "r0" }
                    else if (str2 = "A_Index") { strLhs := "r20" }
                    strRhs := str3
                    if (str3 = "rax") { strRhs := "r0" }
                    else if (str3 = "A_Index") { strRhs := "r20" }
                    out .= "cmp " . strLhs . ", " . strRhs . Chr(10)
                    out .= "jne end_if7_" . STR(ifCount7) . Chr(10)
                }
                else {
                    if (isNum = 1) {
                        out .= "mov rax, [" . str2 . "]" . Chr(10)
                        out .= "cmp rax, " . str3 . Chr(10)
                        out .= "jne .end_if7_" . STR(ifCount7) . Chr(10)
                    }
                    else {
                        out .= "mov rax, [" . str2 . "]" . Chr(10)
                        out .= "cmp rax, [" . str3 . "]" . Chr(10)
                        out .= "jne .end_if7_" . STR(ifCount7) . Chr(10)
                    }
                }
            }
            else if (InStr(str1, " != ")) {
                str2 := Trim(StrSplit(str1, " != ", 1))
                str3 := Trim(StrSplit(str1, " != ", 2))
                isNum := RegExMatch(str3, "^\d+$")
                if (is_arm = 1) {
                    int isLhsStackVar := 0
                    if (inFunc = 1) {
                        Loop, % funcArgsArr.size() {
                            if (Trim(funcArgsArr[A_Index]) = str2) {
                                isLhsStackVar := 1
                                break
                            }
                        }
                    }
                    if (str2 = "rax") {
                        out .= "    mov x9, x0" . Chr(10)
                    }
                    else if (str2 = "A_Index") {
                        out .= "    mov x9, x20" . Chr(10)
                    }
                    else if (isLhsStackVar = 1) {
                        out .= "    ldr x9, =" . str2 . Chr(10)
                    }
                    else {
                        out .= "    ldr x9, =" . str2 . Chr(10)
                        out .= "    ldr x9, [x9]" . Chr(10)
                    }
                    if (isNum = 1) {
                        out .= "    mov x10, #" . str3 . Chr(10)
                    }
                    else {
                        int isRhsStackVar := 0
                        if (inFunc = 1) {
                            Loop, % funcArgsArr.size() {
                                if (Trim(funcArgsArr[A_Index]) = str3) {
                                    isRhsStackVar := 1
                                    break
                                }
                            }
                        }
                        if (str3 = "rax") {
                            out .= "    mov x10, x0" . Chr(10)
                        }
                        else if (str3 = "A_Index") {
                            out .= "    mov x10, x20" . Chr(10)
                        }
                        else if (isRhsStackVar = 1) {
                            out .= "    ldr x10, =" . str3 . Chr(10)
                        }
                        else {
                            out .= "    ldr x10, =" . str3 . Chr(10)
                            out .= "    ldr x10, [x10]" . Chr(10)
                        }
                    }
                    out .= "    cmp x9, x10" . Chr(10)
                    out .= "    b.eq .end_if7_" . STR(ifCount7) . Chr(10)
                }
                else if (is_oryx = 1) {      out .= "meta " . A_LoopField . Chr(10)
                    strLhs := str2
                    if (str2 = "rax") { strLhs := "r0" }
                    else if (str2 = "A_Index") { strLhs := "r20" }
                    strRhs := str3
                    if (str3 = "rax") { strRhs := "r0" }
                    else if (str3 = "A_Index") { strRhs := "r20" }
                    out .= "cmp " . strLhs . ", " . strRhs . Chr(10)
                    out .= "je end_if7_" . STR(ifCount7) . Chr(10)
                }
                else {
                    if (isNum = 1) {
                        out .= "mov rax, [" . str2 . "]" . Chr(10)
                        out .= "cmp rax, " . str3 . Chr(10)
                        out .= "je .end_if7_" . STR(ifCount7) . Chr(10)
                    }
                    else {
                        out .= "mov rax, [" . str2 . "]" . Chr(10)
                        out .= "cmp rax, [" . str3 . "]" . Chr(10)
                        out .= "je .end_if7_" . STR(ifCount7) . Chr(10)
                    }
                }
            }
            else if (InStr(str1, " > ")) {
                str2 := Trim(StrSplit(str1, " > ", 1))
                str3 := Trim(StrSplit(str1, " > ", 2))
                isNum := RegExMatch(str3, "^\d+$")
                if (is_arm = 1) {
                    int isLhsStackVar := 0
                    if (inFunc = 1) {
                        Loop, % funcArgsArr.size() {
                            if (Trim(funcArgsArr[A_Index]) = str2) {
                                isLhsStackVar := 1
                                break
                            }
                        }
                    }
                    if (str2 = "rax") {
                        out .= "    mov x9, x0" . Chr(10)
                    }
                    else if (str2 = "A_Index") {
                        out .= "    mov x9, x20" . Chr(10)
                    }
                    else if (isLhsStackVar = 1) {
                        out .= "    ldr x9, =" . str2 . Chr(10)
                    }
                    else {
                        out .= "    ldr x9, =" . str2 . Chr(10)
                        out .= "    ldr x9, [x9]" . Chr(10)
                    }
                    if (isNum = 1) {
                        out .= "    mov x10, #" . str3 . Chr(10)
                    }
                    else {
                        int isRhsStackVar := 0
                        if (inFunc = 1) {
                            Loop, % funcArgsArr.size() {
                                if (Trim(funcArgsArr[A_Index]) = str3) {
                                    isRhsStackVar := 1
                                    break
                                }
                            }
                        }
                        if (str3 = "rax") {
                            out .= "    mov x10, x0" . Chr(10)
                        }
                        else if (str3 = "A_Index") {
                            out .= "    mov x10, x20" . Chr(10)
                        }
                        else if (isRhsStackVar = 1) {
                            out .= "    ldr x10, =" . str3 . Chr(10)
                        }
                        else {
                            out .= "    ldr x10, =" . str3 . Chr(10)
                            out .= "    ldr x10, [x10]" . Chr(10)
                        }
                    }
                    out .= "    cmp x9, x10" . Chr(10)
                    out .= "    b.le .end_if7_" . STR(ifCount7) . Chr(10)
                }
                else if (is_oryx = 1) {      out .= "meta " . A_LoopField . Chr(10)
                    strLhs := str2
                    if (str2 = "rax") { strLhs := "r0" }
                    else if (str2 = "A_Index") { strLhs := "r20" }
                    strRhs := str3
                    if (str3 = "rax") { strRhs := "r0" }
                    else if (str3 = "A_Index") { strRhs := "r20" }
                    out .= "cmp " . strLhs . ", " . strRhs . Chr(10)
                    out .= "jle end_if7_" . STR(ifCount7) . Chr(10)
                }
                else {
                    if (isNum = 1) {
                        out .= "mov rax, [" . str2 . "]" . Chr(10)
                        out .= "cmp rax, " . str3 . Chr(10)
                        out .= "jle .end_if7_" . STR(ifCount7) . Chr(10)
                    }
                    else {
                        out .= "mov rax, [" . str2 . "]" . Chr(10)
                        out .= "cmp rax, [" . str3 . "]" . Chr(10)
                        out .= "jle .end_if7_" . STR(ifCount7) . Chr(10)
                    }
                }
            }
            else if (InStr(str1, " < ")) {
                str2 := Trim(StrSplit(str1, " < ", 1))
                str3 := Trim(StrSplit(str1, " < ", 2))
                isNum := RegExMatch(str3, "^\d+$")
                if (is_arm = 1) {
                    int isLhsStackVar := 0
                    if (inFunc = 1) {
                        Loop, % funcArgsArr.size() {
                            if (Trim(funcArgsArr[A_Index]) = str2) {
                                isLhsStackVar := 1
                                break
                            }
                        }
                    }
                    if (str2 = "rax") {
                        out .= "    mov x9, x0" . Chr(10)
                    }
                    else if (str2 = "A_Index") {
                        out .= "    mov x9, x20" . Chr(10)
                    }
                    else if (isLhsStackVar = 1) {
                        out .= "    ldr x9, =" . str2 . Chr(10)
                    }
                    else {
                        out .= "    ldr x9, =" . str2 . Chr(10)
                        out .= "    ldr x9, [x9]" . Chr(10)
                    }
                    if (isNum = 1) {
                        out .= "    mov x10, #" . str3 . Chr(10)
                    }
                    else {
                        int isRhsStackVar := 0
                        if (inFunc = 1) {
                            Loop, % funcArgsArr.size() {
                                if (Trim(funcArgsArr[A_Index]) = str3) {
                                    isRhsStackVar := 1
                                    break
                                }
                            }
                        }
                        if (str3 = "rax") {
                            out .= "    mov x10, x0" . Chr(10)
                        }
                        else if (str3 = "A_Index") {
                            out .= "    mov x10, x20" . Chr(10)
                        }
                        else if (isRhsStackVar = 1) {
                            out .= "    ldr x10, =" . str3 . Chr(10)
                        }
                        else {
                            out .= "    ldr x10, =" . str3 . Chr(10)
                            out .= "    ldr x10, [x10]" . Chr(10)
                        }
                    }
                    out .= "    cmp x9, x10" . Chr(10)
                    out .= "    b.ge .end_if7_" . STR(ifCount7) . Chr(10)
                }
                else if (is_oryx = 1) {      out .= "meta " . A_LoopField . Chr(10)
                    strLhs := str2
                    if (str2 = "rax") { strLhs := "r0" }
                    else if (str2 = "A_Index") { strLhs := "r20" }
                    strRhs := str3
                    if (str3 = "rax") { strRhs := "r0" }
                    else if (str3 = "A_Index") { strRhs := "r20" }
                    out .= "cmp " . strLhs . ", " . strRhs . Chr(10)
                    out .= "jge end_if7_" . STR(ifCount7) . Chr(10)
                }
                else {
                    if (isNum = 1) {
                        out .= "mov rax, [" . str2 . "]" . Chr(10)
                        out .= "cmp rax, " . str3 . Chr(10)
                        out .= "jge .end_if7_" . STR(ifCount7) . Chr(10)
                    }
                    else {
                        out .= "mov rax, [" . str2 . "]" . Chr(10)
                        out .= "cmp rax, [" . str3 . "]" . Chr(10)
                        out .= "jge .end_if7_" . STR(ifCount7) . Chr(10)
                    }
                }
            }
            else if (InStr(str1, " >= ")) {
                str2 := Trim(StrSplit(str1, " >= ", 1))
                str3 := Trim(StrSplit(str1, " >= ", 2))
                isNum := RegExMatch(str3, "^\d+$")
                if (is_arm = 1) {
                    int isLhsStackVar := 0
                    if (inFunc = 1) {
                        Loop, % funcArgsArr.size() {
                            if (Trim(funcArgsArr[A_Index]) = str2) {
                                isLhsStackVar := 1
                                break
                            }
                        }
                    }
                    if (str2 = "rax") {
                        out .= "    mov x9, x0" . Chr(10)
                    }
                    else if (str2 = "A_Index") {
                        out .= "    mov x9, x20" . Chr(10)
                    }
                    else if (isLhsStackVar = 1) {
                        out .= "    ldr x9, =" . str2 . Chr(10)
                    }
                    else {
                        out .= "    ldr x9, =" . str2 . Chr(10)
                        out .= "    ldr x9, [x9]" . Chr(10)
                    }
                    if (isNum = 1) {
                        out .= "    mov x10, #" . str3 . Chr(10)
                    }
                    else {
                        int isRhsStackVar := 0
                        if (inFunc = 1) {
                            Loop, % funcArgsArr.size() {
                                if (Trim(funcArgsArr[A_Index]) = str3) {
                                    isRhsStackVar := 1
                                    break
                                }
                            }
                        }
                        if (str3 = "rax") {
                            out .= "    mov x10, x0" . Chr(10)
                        }
                        else if (str3 = "A_Index") {
                            out .= "    mov x10, x20" . Chr(10)
                        }
                        else if (isRhsStackVar = 1) {
                            out .= "    ldr x10, =" . str3 . Chr(10)
                        }
                        else {
                            out .= "    ldr x10, =" . str3 . Chr(10)
                            out .= "    ldr x10, [x10]" . Chr(10)
                        }
                    }
                    out .= "    cmp x9, x10" . Chr(10)
                    out .= "    b.lt .end_if7_" . STR(ifCount7) . Chr(10)
                }
                else if (is_oryx = 1) {      out .= "meta " . A_LoopField . Chr(10)
                    strLhs := str2
                    if (str2 = "rax") { strLhs := "r0" }
                    else if (str2 = "A_Index") { strLhs := "r20" }
                    strRhs := str3
                    if (str3 = "rax") { strRhs := "r0" }
                    else if (str3 = "A_Index") { strRhs := "r20" }
                    out .= "cmp " . strLhs . ", " . strRhs . Chr(10)
                    out .= "jl end_if7_" . STR(ifCount7) . Chr(10)
                }
                else {
                    if (isNum = 1) {
                        out .= "mov rax, [" . str2 . "]" . Chr(10)
                        out .= "cmp rax, " . str3 . Chr(10)
                        out .= "jl .end_if7_" . STR(ifCount7) . Chr(10)
                    }
                    else {
                        out .= "mov rax, [" . str2 . "]" . Chr(10)
                        out .= "cmp rax, [" . str3 . "]" . Chr(10)
                        out .= "jl .end_if7_" . STR(ifCount7) . Chr(10)
                    }
                }
            }
            else if (InStr(str1, " <= ")) {
                str2 := Trim(StrSplit(str1, " <= ", 1))
                str3 := Trim(StrSplit(str1, " <= ", 2))
                isNum := RegExMatch(str3, "^\d+$")
                if (is_arm = 1) {
                    int isLhsStackVar := 0
                    if (inFunc = 1) {
                        Loop, % funcArgsArr.size() {
                            if (Trim(funcArgsArr[A_Index]) = str2) {
                                isLhsStackVar := 1
                                break
                            }
                        }
                    }
                    if (str2 = "rax") {
                        out .= "    mov x9, x0" . Chr(10)
                    }
                    else if (str2 = "A_Index") {
                        out .= "    mov x9, x20" . Chr(10)
                    }
                    else if (isLhsStackVar = 1) {
                        out .= "    ldr x9, =" . str2 . Chr(10)
                    }
                    else {
                        out .= "    ldr x9, =" . str2 . Chr(10)
                        out .= "    ldr x9, [x9]" . Chr(10)
                    }
                    if (isNum = 1) {
                        out .= "    mov x10, #" . str3 . Chr(10)
                    }
                    else {
                        int isRhsStackVar := 0
                        if (inFunc = 1) {
                            Loop, % funcArgsArr.size() {
                                if (Trim(funcArgsArr[A_Index]) = str3) {
                                    isRhsStackVar := 1
                                    break
                                }
                            }
                        }
                        if (str3 = "rax") {
                            out .= "    mov x10, x0" . Chr(10)
                        }
                        else if (str3 = "A_Index") {
                            out .= "    mov x10, x20" . Chr(10)
                        }
                        else if (isRhsStackVar = 1) {
                            out .= "    ldr x10, =" . str3 . Chr(10)
                        }
                        else {
                            out .= "    ldr x10, =" . str3 . Chr(10)
                            out .= "    ldr x10, [x10]" . Chr(10)
                        }
                    }
                    out .= "    cmp x9, x10" . Chr(10)
                    out .= "    b.gt .end_if7_" . STR(ifCount7) . Chr(10)
                }
                else if (is_oryx = 1) {      out .= "meta " . A_LoopField . Chr(10)
                    strLhs := str2
                    if (str2 = "rax") { strLhs := "r0" }
                    else if (str2 = "A_Index") { strLhs := "r20" }
                    strRhs := str3
                    if (str3 = "rax") { strRhs := "r0" }
                    else if (str3 = "A_Index") { strRhs := "r20" }
                    out .= "cmp " . strLhs . ", " . strRhs . Chr(10)
                    out .= "jg end_if7_" . STR(ifCount7) . Chr(10)
                }
                else {
                    if (isNum = 1) {
                        out .= "mov rax, [" . str2 . "]" . Chr(10)
                        out .= "cmp rax, " . str3 . Chr(10)
                        out .= "jg .end_if7_" . STR(ifCount7) . Chr(10)
                    }
                    else {
                        out .= "mov rax, [" . str2 . "]" . Chr(10)
                        out .= "cmp rax, [" . str3 . "]" . Chr(10)
                        out .= "jg .end_if7_" . STR(ifCount7) . Chr(10)
                    }
                }
            }
        }
        else if (Trim(A_LoopField) = "ifend7") or (Trim(A_LoopField) = "endif7") {
            if (is_oryx = 1) {      out .= "meta " . A_LoopField . Chr(10)
                out .= "end_if7_" . STR(ifCount7) . ":" . Chr(10)
            } else {
                out .= ".end_if7_" . STR(ifCount7) . ":" . Chr(10)
            }
            ifCount7++
        }
        else if (SubStr(StrLower(A_LoopField), 1, 4) = "if8 ") {
            isNum := 0
            str1 := Trim(StringTrimLeft(A_LoopField, 4))
            str1 := StringTrimLeft(str1, 1)
            str1 := StringTrimRight(str1, 1)
            if (InStr(str1, " = ")) {
                str2 := Trim(StrSplit(str1, " = ", 1))
                str3 := Trim(StrSplit(str1, " = ", 2))
                isNum := RegExMatch(str3, "^\d+$")
                if (is_arm = 1) {
                    int isLhsStackVar := 0
                    if (inFunc = 1) {
                        Loop, % funcArgsArr.size() {
                            if (Trim(funcArgsArr[A_Index]) = str2) {
                                isLhsStackVar := 1
                                break
                            }
                        }
                    }
                    if (str2 = "rax") {
                        out .= "    mov x9, x0" . Chr(10)
                    }
                    else if (str2 = "A_Index") {
                        out .= "    mov x9, x20" . Chr(10)
                    }
                    else if (isLhsStackVar = 1) {
                        out .= "    ldr x9, =" . str2 . Chr(10)
                    }
                    else {
                        out .= "    ldr x9, =" . str2 . Chr(10)
                        out .= "    ldr x9, [x9]" . Chr(10)
                    }
                    int isRhsStackVar := 0
                    if (inFunc = 1) {
                        Loop, % funcArgsArr.size() {
                            if (Trim(funcArgsArr[A_Index]) = str3) {
                                isRhsStackVar := 1
                                break
                            }
                        }
                    }
                    if (str3 = "rax") {
                        out .= "    mov x10, x0" . Chr(10)
                    }
                    else if (str3 = "A_Index") {
                        out .= "    mov x10, x20" . Chr(10)
                    }
                    else if (isNum = 1) {
                        out .= "    mov x10, #" . str3 . Chr(10)
                    }
                    else if (isRhsStackVar = 1) {
                        out .= "    ldr x10, =" . str3 . Chr(10)
                    }
                    else {
                        out .= "    ldr x10, =" . str3 . Chr(10)
                        out .= "    ldr x10, [x10]" . Chr(10)
                    }
                    out .= "    cmp x9, x10" . Chr(10)
                    out .= "    b.ne .end_if8_" . STR(ifCount8) . Chr(10)
                }
                else if (is_oryx = 1) {      out .= "meta " . A_LoopField . Chr(10)
                    strLhs := str2
                    if (str2 = "rax") { strLhs := "r0" }
                    else if (str2 = "A_Index") { strLhs := "r20" }
                    strRhs := str3
                    if (str3 = "rax") { strRhs := "r0" }
                    else if (str3 = "A_Index") { strRhs := "r20" }
                    out .= "cmp " . strLhs . ", " . strRhs . Chr(10)
                    out .= "jne end_if8_" . STR(ifCount8) . Chr(10)
                }
                else {
                    if (isNum = 1) {
                        out .= "mov rax, [" . str2 . "]" . Chr(10)
                        out .= "cmp rax, " . str3 . Chr(10)
                        out .= "jne .end_if8_" . STR(ifCount8) . Chr(10)
                    }
                    else {
                        out .= "mov rax, [" . str2 . "]" . Chr(10)
                        out .= "cmp rax, [" . str3 . "]" . Chr(10)
                        out .= "jne .end_if8_" . STR(ifCount8) . Chr(10)
                    }
                }
            }
            else if (InStr(str1, " != ")) {
                str2 := Trim(StrSplit(str1, " != ", 1))
                str3 := Trim(StrSplit(str1, " != ", 2))
                isNum := RegExMatch(str3, "^\d+$")
                if (is_arm = 1) {
                    int isLhsStackVar := 0
                    if (inFunc = 1) {
                        Loop, % funcArgsArr.size() {
                            if (Trim(funcArgsArr[A_Index]) = str2) {
                                isLhsStackVar := 1
                                break
                            }
                        }
                    }
                    if (str2 = "rax") {
                        out .= "    mov x9, x0" . Chr(10)
                    }
                    else if (str2 = "A_Index") {
                        out .= "    mov x9, x20" . Chr(10)
                    }
                    else if (isLhsStackVar = 1) {
                        out .= "    ldr x9, =" . str2 . Chr(10)
                    }
                    else {
                        out .= "    ldr x9, =" . str2 . Chr(10)
                        out .= "    ldr x9, [x9]" . Chr(10)
                    }
                    if (isNum = 1) {
                        out .= "    mov x10, #" . str3 . Chr(10)
                    }
                    else {
                        int isRhsStackVar := 0
                        if (inFunc = 1) {
                            Loop, % funcArgsArr.size() {
                                if (Trim(funcArgsArr[A_Index]) = str3) {
                                    isRhsStackVar := 1
                                    break
                                }
                            }
                        }
                        if (str3 = "rax") {
                            out .= "    mov x10, x0" . Chr(10)
                        }
                        else if (str3 = "A_Index") {
                            out .= "    mov x10, x20" . Chr(10)
                        }
                        else if (isRhsStackVar = 1) {
                            out .= "    ldr x10, =" . str3 . Chr(10)
                        }
                        else {
                            out .= "    ldr x10, =" . str3 . Chr(10)
                            out .= "    ldr x10, [x10]" . Chr(10)
                        }
                    }
                    out .= "    cmp x9, x10" . Chr(10)
                    out .= "    b.eq .end_if8_" . STR(ifCount8) . Chr(10)
                }
                else if (is_oryx = 1) {      out .= "meta " . A_LoopField . Chr(10)
                    strLhs := str2
                    if (str2 = "rax") { strLhs := "r0" }
                    else if (str2 = "A_Index") { strLhs := "r20" }
                    strRhs := str3
                    if (str3 = "rax") { strRhs := "r0" }
                    else if (str3 = "A_Index") { strRhs := "r20" }
                    out .= "cmp " . strLhs . ", " . strRhs . Chr(10)
                    out .= "je end_if8_" . STR(ifCount8) . Chr(10)
                }
                else {
                    if (isNum = 1) {
                        out .= "mov rax, [" . str2 . "]" . Chr(10)
                        out .= "cmp rax, " . str3 . Chr(10)
                        out .= "je .end_if8_" . STR(ifCount8) . Chr(10)
                    }
                    else {
                        out .= "mov rax, [" . str2 . "]" . Chr(10)
                        out .= "cmp rax, [" . str3 . "]" . Chr(10)
                        out .= "je .end_if8_" . STR(ifCount8) . Chr(10)
                    }
                }
            }
            else if (InStr(str1, " > ")) {
                str2 := Trim(StrSplit(str1, " > ", 1))
                str3 := Trim(StrSplit(str1, " > ", 2))
                isNum := RegExMatch(str3, "^\d+$")
                if (is_arm = 1) {
                    int isLhsStackVar := 0
                    if (inFunc = 1) {
                        Loop, % funcArgsArr.size() {
                            if (Trim(funcArgsArr[A_Index]) = str2) {
                                isLhsStackVar := 1
                                break
                            }
                        }
                    }
                    if (str2 = "rax") {
                        out .= "    mov x9, x0" . Chr(10)
                    }
                    else if (str2 = "A_Index") {
                        out .= "    mov x9, x20" . Chr(10)
                    }
                    else if (isLhsStackVar = 1) {
                        out .= "    ldr x9, =" . str2 . Chr(10)
                    }
                    else {
                        out .= "    ldr x9, =" . str2 . Chr(10)
                        out .= "    ldr x9, [x9]" . Chr(10)
                    }
                    if (isNum = 1) {
                        out .= "    mov x10, #" . str3 . Chr(10)
                    }
                    else {
                        int isRhsStackVar := 0
                        if (inFunc = 1) {
                            Loop, % funcArgsArr.size() {
                                if (Trim(funcArgsArr[A_Index]) = str3) {
                                    isRhsStackVar := 1
                                    break
                                }
                            }
                        }
                        if (str3 = "rax") {
                            out .= "    mov x10, x0" . Chr(10)
                        }
                        else if (str3 = "A_Index") {
                            out .= "    mov x10, x20" . Chr(10)
                        }
                        else if (isRhsStackVar = 1) {
                            out .= "    ldr x10, =" . str3 . Chr(10)
                        }
                        else {
                            out .= "    ldr x10, =" . str3 . Chr(10)
                            out .= "    ldr x10, [x10]" . Chr(10)
                        }
                    }
                    out .= "    cmp x9, x10" . Chr(10)
                    out .= "    b.le .end_if8_" . STR(ifCount8) . Chr(10)
                }
                else if (is_oryx = 1) {      out .= "meta " . A_LoopField . Chr(10)
                    strLhs := str2
                    if (str2 = "rax") { strLhs := "r0" }
                    else if (str2 = "A_Index") { strLhs := "r20" }
                    strRhs := str3
                    if (str3 = "rax") { strRhs := "r0" }
                    else if (str3 = "A_Index") { strRhs := "r20" }
                    out .= "cmp " . strLhs . ", " . strRhs . Chr(10)
                    out .= "jle end_if8_" . STR(ifCount8) . Chr(10)
                }
                else {
                    if (isNum = 1) {
                        out .= "mov rax, [" . str2 . "]" . Chr(10)
                        out .= "cmp rax, " . str3 . Chr(10)
                        out .= "jle .end_if8_" . STR(ifCount8) . Chr(10)
                    }
                    else {
                        out .= "mov rax, [" . str2 . "]" . Chr(10)
                        out .= "cmp rax, [" . str3 . "]" . Chr(10)
                        out .= "jle .end_if8_" . STR(ifCount8) . Chr(10)
                    }
                }
            }
            else if (InStr(str1, " < ")) {
                str2 := Trim(StrSplit(str1, " < ", 1))
                str3 := Trim(StrSplit(str1, " < ", 2))
                isNum := RegExMatch(str3, "^\d+$")
                if (is_arm = 1) {
                    int isLhsStackVar := 0
                    if (inFunc = 1) {
                        Loop, % funcArgsArr.size() {
                            if (Trim(funcArgsArr[A_Index]) = str2) {
                                isLhsStackVar := 1
                                break
                            }
                        }
                    }
                    if (str2 = "rax") {
                        out .= "    mov x9, x0" . Chr(10)
                    }
                    else if (str2 = "A_Index") {
                        out .= "    mov x9, x20" . Chr(10)
                    }
                    else if (isLhsStackVar = 1) {
                        out .= "    ldr x9, =" . str2 . Chr(10)
                    }
                    else {
                        out .= "    ldr x9, =" . str2 . Chr(10)
                        out .= "    ldr x9, [x9]" . Chr(10)
                    }
                    if (isNum = 1) {
                        out .= "    mov x10, #" . str3 . Chr(10)
                    }
                    else {
                        int isRhsStackVar := 0
                        if (inFunc = 1) {
                            Loop, % funcArgsArr.size() {
                                if (Trim(funcArgsArr[A_Index]) = str3) {
                                    isRhsStackVar := 1
                                    break
                                }
                            }
                        }
                        if (str3 = "rax") {
                            out .= "    mov x10, x0" . Chr(10)
                        }
                        else if (str3 = "A_Index") {
                            out .= "    mov x10, x20" . Chr(10)
                        }
                        else if (isRhsStackVar = 1) {
                            out .= "    ldr x10, =" . str3 . Chr(10)
                        }
                        else {
                            out .= "    ldr x10, =" . str3 . Chr(10)
                            out .= "    ldr x10, [x10]" . Chr(10)
                        }
                    }
                    out .= "    cmp x9, x10" . Chr(10)
                    out .= "    b.ge .end_if8_" . STR(ifCount8) . Chr(10)
                }
                else if (is_oryx = 1) {      out .= "meta " . A_LoopField . Chr(10)
                    strLhs := str2
                    if (str2 = "rax") { strLhs := "r0" }
                    else if (str2 = "A_Index") { strLhs := "r20" }
                    strRhs := str3
                    if (str3 = "rax") { strRhs := "r0" }
                    else if (str3 = "A_Index") { strRhs := "r20" }
                    out .= "cmp " . strLhs . ", " . strRhs . Chr(10)
                    out .= "jge end_if8_" . STR(ifCount8) . Chr(10)
                }
                else {
                    if (isNum = 1) {
                        out .= "mov rax, [" . str2 . "]" . Chr(10)
                        out .= "cmp rax, " . str3 . Chr(10)
                        out .= "jge .end_if8_" . STR(ifCount8) . Chr(10)
                    }
                    else {
                        out .= "mov rax, [" . str2 . "]" . Chr(10)
                        out .= "cmp rax, [" . str3 . "]" . Chr(10)
                        out .= "jge .end_if8_" . STR(ifCount8) . Chr(10)
                    }
                }
            }
            else if (InStr(str1, " >= ")) {
                str2 := Trim(StrSplit(str1, " >= ", 1))
                str3 := Trim(StrSplit(str1, " >= ", 2))
                isNum := RegExMatch(str3, "^\d+$")
                if (is_arm = 1) {
                    int isLhsStackVar := 0
                    if (inFunc = 1) {
                        Loop, % funcArgsArr.size() {
                            if (Trim(funcArgsArr[A_Index]) = str2) {
                                isLhsStackVar := 1
                                break
                            }
                        }
                    }
                    if (str2 = "rax") {
                        out .= "    mov x9, x0" . Chr(10)
                    }
                    else if (str2 = "A_Index") {
                        out .= "    mov x9, x20" . Chr(10)
                    }
                    else if (isLhsStackVar = 1) {
                        out .= "    ldr x9, =" . str2 . Chr(10)
                    }
                    else {
                        out .= "    ldr x9, =" . str2 . Chr(10)
                        out .= "    ldr x9, [x9]" . Chr(10)
                    }
                    if (isNum = 1) {
                        out .= "    mov x10, #" . str3 . Chr(10)
                    }
                    else {
                        int isRhsStackVar := 0
                        if (inFunc = 1) {
                            Loop, % funcArgsArr.size() {
                                if (Trim(funcArgsArr[A_Index]) = str3) {
                                    isRhsStackVar := 1
                                    break
                                }
                            }
                        }
                        if (str3 = "rax") {
                            out .= "    mov x10, x0" . Chr(10)
                        }
                        else if (str3 = "A_Index") {
                            out .= "    mov x10, x20" . Chr(10)
                        }
                        else if (isRhsStackVar = 1) {
                            out .= "    ldr x10, =" . str3 . Chr(10)
                        }
                        else {
                            out .= "    ldr x10, =" . str3 . Chr(10)
                            out .= "    ldr x10, [x10]" . Chr(10)
                        }
                    }
                    out .= "    cmp x9, x10" . Chr(10)
                    out .= "    b.lt .end_if8_" . STR(ifCount8) . Chr(10)
                }
                else if (is_oryx = 1) {      out .= "meta " . A_LoopField . Chr(10)
                    strLhs := str2
                    if (str2 = "rax") { strLhs := "r0" }
                    else if (str2 = "A_Index") { strLhs := "r20" }
                    strRhs := str3
                    if (str3 = "rax") { strRhs := "r0" }
                    else if (str3 = "A_Index") { strRhs := "r20" }
                    out .= "cmp " . strLhs . ", " . strRhs . Chr(10)
                    out .= "jl end_if8_" . STR(ifCount8) . Chr(10)
                }
                else {
                    if (isNum = 1) {
                        out .= "mov rax, [" . str2 . "]" . Chr(10)
                        out .= "cmp rax, " . str3 . Chr(10)
                        out .= "jl .end_if8_" . STR(ifCount8) . Chr(10)
                    }
                    else {
                        out .= "mov rax, [" . str2 . "]" . Chr(10)
                        out .= "cmp rax, [" . str3 . "]" . Chr(10)
                        out .= "jl .end_if8_" . STR(ifCount8) . Chr(10)
                    }
                }
            }
            else if (InStr(str1, " <= ")) {
                str2 := Trim(StrSplit(str1, " <= ", 1))
                str3 := Trim(StrSplit(str1, " <= ", 2))
                isNum := RegExMatch(str3, "^\d+$")
                if (is_arm = 1) {
                    int isLhsStackVar := 0
                    if (inFunc = 1) {
                        Loop, % funcArgsArr.size() {
                            if (Trim(funcArgsArr[A_Index]) = str2) {
                                isLhsStackVar := 1
                                break
                            }
                        }
                    }
                    if (str2 = "rax") {
                        out .= "    mov x9, x0" . Chr(10)
                    }
                    else if (str2 = "A_Index") {
                        out .= "    mov x9, x20" . Chr(10)
                    }
                    else if (isLhsStackVar = 1) {
                        out .= "    ldr x9, =" . str2 . Chr(10)
                    }
                    else {
                        out .= "    ldr x9, =" . str2 . Chr(10)
                        out .= "    ldr x9, [x9]" . Chr(10)
                    }
                    if (isNum = 1) {
                        out .= "    mov x10, #" . str3 . Chr(10)
                    }
                    else {
                        int isRhsStackVar := 0
                        if (inFunc = 1) {
                            Loop, % funcArgsArr.size() {
                                if (Trim(funcArgsArr[A_Index]) = str3) {
                                    isRhsStackVar := 1
                                    break
                                }
                            }
                        }
                        if (str3 = "rax") {
                            out .= "    mov x10, x0" . Chr(10)
                        }
                        else if (str3 = "A_Index") {
                            out .= "    mov x10, x20" . Chr(10)
                        }
                        else if (isRhsStackVar = 1) {
                            out .= "    ldr x10, =" . str3 . Chr(10)
                        }
                        else {
                            out .= "    ldr x10, =" . str3 . Chr(10)
                            out .= "    ldr x10, [x10]" . Chr(10)
                        }
                    }
                    out .= "    cmp x9, x10" . Chr(10)
                    out .= "    b.gt .end_if8_" . STR(ifCount8) . Chr(10)
                }
                else if (is_oryx = 1) {      out .= "meta " . A_LoopField . Chr(10)
                    strLhs := str2
                    if (str2 = "rax") { strLhs := "r0" }
                    else if (str2 = "A_Index") { strLhs := "r20" }
                    strRhs := str3
                    if (str3 = "rax") { strRhs := "r0" }
                    else if (str3 = "A_Index") { strRhs := "r20" }
                    out .= "cmp " . strLhs . ", " . strRhs . Chr(10)
                    out .= "jg end_if8_" . STR(ifCount8) . Chr(10)
                }
                else {
                    if (isNum = 1) {
                        out .= "mov rax, [" . str2 . "]" . Chr(10)
                        out .= "cmp rax, " . str3 . Chr(10)
                        out .= "jg .end_if8_" . STR(ifCount8) . Chr(10)
                    }
                    else {
                        out .= "mov rax, [" . str2 . "]" . Chr(10)
                        out .= "cmp rax, [" . str3 . "]" . Chr(10)
                        out .= "jg .end_if8_" . STR(ifCount8) . Chr(10)
                    }
                }
            }
        }
        else if (Trim(A_LoopField) = "ifend8") or (Trim(A_LoopField) = "endif8") {
            if (is_oryx = 1) {      out .= "meta " . A_LoopField . Chr(10)
                out .= "end_if8_" . STR(ifCount8) . ":" . Chr(10)
            } else {
                out .= ".end_if8_" . STR(ifCount8) . ":" . Chr(10)
            }
            ifCount8++
        }
        else if (SubStr(StrLower(A_LoopField), 1, 4) = "if9 ") {
            isNum := 0
            str1 := Trim(StringTrimLeft(A_LoopField, 4))
            str1 := StringTrimLeft(str1, 1)
            str1 := StringTrimRight(str1, 1)
            if (InStr(str1, " = ")) {
                str2 := Trim(StrSplit(str1, " = ", 1))
                str3 := Trim(StrSplit(str1, " = ", 2))
                isNum := RegExMatch(str3, "^\d+$")
                if (is_arm = 1) {
                    int isLhsStackVar := 0
                    if (inFunc = 1) {
                        Loop, % funcArgsArr.size() {
                            if (Trim(funcArgsArr[A_Index]) = str2) {
                                isLhsStackVar := 1
                                break
                            }
                        }
                    }
                    if (str2 = "rax") {
                        out .= "    mov x9, x0" . Chr(10)
                    }
                    else if (str2 = "A_Index") {
                        out .= "    mov x9, x20" . Chr(10)
                    }
                    else if (isLhsStackVar = 1) {
                        out .= "    ldr x9, =" . str2 . Chr(10)
                    }
                    else {
                        out .= "    ldr x9, =" . str2 . Chr(10)
                        out .= "    ldr x9, [x9]" . Chr(10)
                    }
                    int isRhsStackVar := 0
                    if (inFunc = 1) {
                        Loop, % funcArgsArr.size() {
                            if (Trim(funcArgsArr[A_Index]) = str3) {
                                isRhsStackVar := 1
                                break
                            }
                        }
                    }
                    if (str3 = "rax") {
                        out .= "    mov x10, x0" . Chr(10)
                    }
                    else if (str3 = "A_Index") {
                        out .= "    mov x10, x20" . Chr(10)
                    }
                    else if (isNum = 1) {
                        out .= "    mov x10, #" . str3 . Chr(10)
                    }
                    else if (isRhsStackVar = 1) {
                        out .= "    ldr x10, =" . str3 . Chr(10)
                    }
                    else {
                        out .= "    ldr x10, =" . str3 . Chr(10)
                        out .= "    ldr x10, [x10]" . Chr(10)
                    }
                    out .= "    cmp x9, x10" . Chr(10)
                    out .= "    b.ne .end_if9_" . STR(ifCount9) . Chr(10)
                }
                else if (is_oryx = 1) {      out .= "meta " . A_LoopField . Chr(10)
                    strLhs := str2
                    if (str2 = "rax") { strLhs := "r0" }
                    else if (str2 = "A_Index") { strLhs := "r20" }
                    strRhs := str3
                    if (str3 = "rax") { strRhs := "r0" }
                    else if (str3 = "A_Index") { strRhs := "r20" }
                    out .= "cmp " . strLhs . ", " . strRhs . Chr(10)
                    out .= "jne end_if9_" . STR(ifCount9) . Chr(10)
                }
                else {
                    if (isNum = 1) {
                        out .= "mov rax, [" . str2 . "]" . Chr(10)
                        out .= "cmp rax, " . str3 . Chr(10)
                        out .= "jne .end_if9_" . STR(ifCount9) . Chr(10)
                    }
                    else {
                        out .= "mov rax, [" . str2 . "]" . Chr(10)
                        out .= "cmp rax, [" . str3 . "]" . Chr(10)
                        out .= "jne .end_if9_" . STR(ifCount9) . Chr(10)
                    }
                }
            }
            else if (InStr(str1, " != ")) {
                str2 := Trim(StrSplit(str1, " != ", 1))
                str3 := Trim(StrSplit(str1, " != ", 2))
                isNum := RegExMatch(str3, "^\d+$")
                if (is_arm = 1) {
                    int isLhsStackVar := 0
                    if (inFunc = 1) {
                        Loop, % funcArgsArr.size() {
                            if (Trim(funcArgsArr[A_Index]) = str2) {
                                isLhsStackVar := 1
                                break
                            }
                        }
                    }
                    if (str2 = "rax") {
                        out .= "    mov x9, x0" . Chr(10)
                    }
                    else if (str2 = "A_Index") {
                        out .= "    mov x9, x20" . Chr(10)
                    }
                    else if (isLhsStackVar = 1) {
                        out .= "    ldr x9, =" . str2 . Chr(10)
                    }
                    else {
                        out .= "    ldr x9, =" . str2 . Chr(10)
                        out .= "    ldr x9, [x9]" . Chr(10)
                    }
                    if (isNum = 1) {
                        out .= "    mov x10, #" . str3 . Chr(10)
                    }
                    else {
                        int isRhsStackVar := 0
                        if (inFunc = 1) {
                            Loop, % funcArgsArr.size() {
                                if (Trim(funcArgsArr[A_Index]) = str3) {
                                    isRhsStackVar := 1
                                    break
                                }
                            }
                        }
                        if (str3 = "rax") {
                            out .= "    mov x10, x0" . Chr(10)
                        }
                        else if (str3 = "A_Index") {
                            out .= "    mov x10, x20" . Chr(10)
                        }
                        else if (isRhsStackVar = 1) {
                            out .= "    ldr x10, =" . str3 . Chr(10)
                        }
                        else {
                            out .= "    ldr x10, =" . str3 . Chr(10)
                            out .= "    ldr x10, [x10]" . Chr(10)
                        }
                    }
                    out .= "    cmp x9, x10" . Chr(10)
                    out .= "    b.eq .end_if9_" . STR(ifCount9) . Chr(10)
                }
                else if (is_oryx = 1) {      out .= "meta " . A_LoopField . Chr(10)
                    strLhs := str2
                    if (str2 = "rax") { strLhs := "r0" }
                    else if (str2 = "A_Index") { strLhs := "r20" }
                    strRhs := str3
                    if (str3 = "rax") { strRhs := "r0" }
                    else if (str3 = "A_Index") { strRhs := "r20" }
                    out .= "cmp " . strLhs . ", " . strRhs . Chr(10)
                    out .= "je end_if9_" . STR(ifCount9) . Chr(10)
                }
                else {
                    if (isNum = 1) {
                        out .= "mov rax, [" . str2 . "]" . Chr(10)
                        out .= "cmp rax, " . str3 . Chr(10)
                        out .= "je .end_if9_" . STR(ifCount9) . Chr(10)
                    }
                    else {
                        out .= "mov rax, [" . str2 . "]" . Chr(10)
                        out .= "cmp rax, [" . str3 . "]" . Chr(10)
                        out .= "je .end_if9_" . STR(ifCount9) . Chr(10)
                    }
                }
            }
            else if (InStr(str1, " > ")) {
                str2 := Trim(StrSplit(str1, " > ", 1))
                str3 := Trim(StrSplit(str1, " > ", 2))
                isNum := RegExMatch(str3, "^\d+$")
                if (is_arm = 1) {
                    int isLhsStackVar := 0
                    if (inFunc = 1) {
                        Loop, % funcArgsArr.size() {
                            if (Trim(funcArgsArr[A_Index]) = str2) {
                                isLhsStackVar := 1
                                break
                            }
                        }
                    }
                    if (str2 = "rax") {
                        out .= "    mov x9, x0" . Chr(10)
                    }
                    else if (str2 = "A_Index") {
                        out .= "    mov x9, x20" . Chr(10)
                    }
                    else if (isLhsStackVar = 1) {
                        out .= "    ldr x9, =" . str2 . Chr(10)
                    }
                    else {
                        out .= "    ldr x9, =" . str2 . Chr(10)
                        out .= "    ldr x9, [x9]" . Chr(10)
                    }
                    if (isNum = 1) {
                        out .= "    mov x10, #" . str3 . Chr(10)
                    }
                    else {
                        int isRhsStackVar := 0
                        if (inFunc = 1) {
                            Loop, % funcArgsArr.size() {
                                if (Trim(funcArgsArr[A_Index]) = str3) {
                                    isRhsStackVar := 1
                                    break
                                }
                            }
                        }
                        if (str3 = "rax") {
                            out .= "    mov x10, x0" . Chr(10)
                        }
                        else if (str3 = "A_Index") {
                            out .= "    mov x10, x20" . Chr(10)
                        }
                        else if (isRhsStackVar = 1) {
                            out .= "    ldr x10, =" . str3 . Chr(10)
                        }
                        else {
                            out .= "    ldr x10, =" . str3 . Chr(10)
                            out .= "    ldr x10, [x10]" . Chr(10)
                        }
                    }
                    out .= "    cmp x9, x10" . Chr(10)
                    out .= "    b.le .end_if9_" . STR(ifCount9) . Chr(10)
                }
                else if (is_oryx = 1) {      out .= "meta " . A_LoopField . Chr(10)
                    strLhs := str2
                    if (str2 = "rax") { strLhs := "r0" }
                    else if (str2 = "A_Index") { strLhs := "r20" }
                    strRhs := str3
                    if (str3 = "rax") { strRhs := "r0" }
                    else if (str3 = "A_Index") { strRhs := "r20" }
                    out .= "cmp " . strLhs . ", " . strRhs . Chr(10)
                    out .= "jle end_if9_" . STR(ifCount9) . Chr(10)
                }
                else {
                    if (isNum = 1) {
                        out .= "mov rax, [" . str2 . "]" . Chr(10)
                        out .= "cmp rax, " . str3 . Chr(10)
                        out .= "jle .end_if9_" . STR(ifCount9) . Chr(10)
                    }
                    else {
                        out .= "mov rax, [" . str2 . "]" . Chr(10)
                        out .= "cmp rax, [" . str3 . "]" . Chr(10)
                        out .= "jle .end_if9_" . STR(ifCount9) . Chr(10)
                    }
                }
            }
            else if (InStr(str1, " < ")) {
                str2 := Trim(StrSplit(str1, " < ", 1))
                str3 := Trim(StrSplit(str1, " < ", 2))
                isNum := RegExMatch(str3, "^\d+$")
                if (is_arm = 1) {
                    int isLhsStackVar := 0
                    if (inFunc = 1) {
                        Loop, % funcArgsArr.size() {
                            if (Trim(funcArgsArr[A_Index]) = str2) {
                                isLhsStackVar := 1
                                break
                            }
                        }
                    }
                    if (str2 = "rax") {
                        out .= "    mov x9, x0" . Chr(10)
                    }
                    else if (str2 = "A_Index") {
                        out .= "    mov x9, x20" . Chr(10)
                    }
                    else if (isLhsStackVar = 1) {
                        out .= "    ldr x9, =" . str2 . Chr(10)
                    }
                    else {
                        out .= "    ldr x9, =" . str2 . Chr(10)
                        out .= "    ldr x9, [x9]" . Chr(10)
                    }
                    if (isNum = 1) {
                        out .= "    mov x10, #" . str3 . Chr(10)
                    }
                    else {
                        int isRhsStackVar := 0
                        if (inFunc = 1) {
                            Loop, % funcArgsArr.size() {
                                if (Trim(funcArgsArr[A_Index]) = str3) {
                                    isRhsStackVar := 1
                                    break
                                }
                            }
                        }
                        if (str3 = "rax") {
                            out .= "    mov x10, x0" . Chr(10)
                        }
                        else if (str3 = "A_Index") {
                            out .= "    mov x10, x20" . Chr(10)
                        }
                        else if (isRhsStackVar = 1) {
                            out .= "    ldr x10, =" . str3 . Chr(10)
                        }
                        else {
                            out .= "    ldr x10, =" . str3 . Chr(10)
                            out .= "    ldr x10, [x10]" . Chr(10)
                        }
                    }
                    out .= "    cmp x9, x10" . Chr(10)
                    out .= "    b.ge .end_if9_" . STR(ifCount9) . Chr(10)
                }
                else if (is_oryx = 1) {      out .= "meta " . A_LoopField . Chr(10)
                    strLhs := str2
                    if (str2 = "rax") { strLhs := "r0" }
                    else if (str2 = "A_Index") { strLhs := "r20" }
                    strRhs := str3
                    if (str3 = "rax") { strRhs := "r0" }
                    else if (str3 = "A_Index") { strRhs := "r20" }
                    out .= "cmp " . strLhs . ", " . strRhs . Chr(10)
                    out .= "jge end_if9_" . STR(ifCount9) . Chr(10)
                }
                else {
                    if (isNum = 1) {
                        out .= "mov rax, [" . str2 . "]" . Chr(10)
                        out .= "cmp rax, " . str3 . Chr(10)
                        out .= "jge .end_if9_" . STR(ifCount9) . Chr(10)
                    }
                    else {
                        out .= "mov rax, [" . str2 . "]" . Chr(10)
                        out .= "cmp rax, [" . str3 . "]" . Chr(10)
                        out .= "jge .end_if9_" . STR(ifCount9) . Chr(10)
                    }
                }
            }
            else if (InStr(str1, " >= ")) {
                str2 := Trim(StrSplit(str1, " >= ", 1))
                str3 := Trim(StrSplit(str1, " >= ", 2))
                isNum := RegExMatch(str3, "^\d+$")
                if (is_arm = 1) {
                    int isLhsStackVar := 0
                    if (inFunc = 1) {
                        Loop, % funcArgsArr.size() {
                            if (Trim(funcArgsArr[A_Index]) = str2) {
                                isLhsStackVar := 1
                                break
                            }
                        }
                    }
                    if (str2 = "rax") {
                        out .= "    mov x9, x0" . Chr(10)
                    }
                    else if (str2 = "A_Index") {
                        out .= "    mov x9, x20" . Chr(10)
                    }
                    else if (isLhsStackVar = 1) {
                        out .= "    ldr x9, =" . str2 . Chr(10)
                    }
                    else {
                        out .= "    ldr x9, =" . str2 . Chr(10)
                        out .= "    ldr x9, [x9]" . Chr(10)
                    }
                    if (isNum = 1) {
                        out .= "    mov x10, #" . str3 . Chr(10)
                    }
                    else {
                        int isRhsStackVar := 0
                        if (inFunc = 1) {
                            Loop, % funcArgsArr.size() {
                                if (Trim(funcArgsArr[A_Index]) = str3) {
                                    isRhsStackVar := 1
                                    break
                                }
                            }
                        }
                        if (str3 = "rax") {
                            out .= "    mov x10, x0" . Chr(10)
                        }
                        else if (str3 = "A_Index") {
                            out .= "    mov x10, x20" . Chr(10)
                        }
                        else if (isRhsStackVar = 1) {
                            out .= "    ldr x10, =" . str3 . Chr(10)
                        }
                        else {
                            out .= "    ldr x10, =" . str3 . Chr(10)
                            out .= "    ldr x10, [x10]" . Chr(10)
                        }
                    }
                    out .= "    cmp x9, x10" . Chr(10)
                    out .= "    b.lt .end_if9_" . STR(ifCount9) . Chr(10)
                }
                else if (is_oryx = 1) {      out .= "meta " . A_LoopField . Chr(10)
                    strLhs := str2
                    if (str2 = "rax") { strLhs := "r0" }
                    else if (str2 = "A_Index") { strLhs := "r20" }
                    strRhs := str3
                    if (str3 = "rax") { strRhs := "r0" }
                    else if (str3 = "A_Index") { strRhs := "r20" }
                    out .= "cmp " . strLhs . ", " . strRhs . Chr(10)
                    out .= "jl end_if9_" . STR(ifCount9) . Chr(10)
                }
                else {
                    if (isNum = 1) {
                        out .= "mov rax, [" . str2 . "]" . Chr(10)
                        out .= "cmp rax, " . str3 . Chr(10)
                        out .= "jl .end_if9_" . STR(ifCount9) . Chr(10)
                    }
                    else {
                        out .= "mov rax, [" . str2 . "]" . Chr(10)
                        out .= "cmp rax, [" . str3 . "]" . Chr(10)
                        out .= "jl .end_if9_" . STR(ifCount9) . Chr(10)
                    }
                }
            }
            else if (InStr(str1, " <= ")) {
                str2 := Trim(StrSplit(str1, " <= ", 1))
                str3 := Trim(StrSplit(str1, " <= ", 2))
                isNum := RegExMatch(str3, "^\d+$")
                if (is_arm = 1) {
                    int isLhsStackVar := 0
                    if (inFunc = 1) {
                        Loop, % funcArgsArr.size() {
                            if (Trim(funcArgsArr[A_Index]) = str2) {
                                isLhsStackVar := 1
                                break
                            }
                        }
                    }
                    if (str2 = "rax") {
                        out .= "    mov x9, x0" . Chr(10)
                    }
                    else if (str2 = "A_Index") {
                        out .= "    mov x9, x20" . Chr(10)
                    }
                    else if (isLhsStackVar = 1) {
                        out .= "    ldr x9, =" . str2 . Chr(10)
                    }
                    else {
                        out .= "    ldr x9, =" . str2 . Chr(10)
                        out .= "    ldr x9, [x9]" . Chr(10)
                    }
                    if (isNum = 1) {
                        out .= "    mov x10, #" . str3 . Chr(10)
                    }
                    else {
                        int isRhsStackVar := 0
                        if (inFunc = 1) {
                            Loop, % funcArgsArr.size() {
                                if (Trim(funcArgsArr[A_Index]) = str3) {
                                    isRhsStackVar := 1
                                    break
                                }
                            }
                        }
                        if (str3 = "rax") {
                            out .= "    mov x10, x0" . Chr(10)
                        }
                        else if (str3 = "A_Index") {
                            out .= "    mov x10, x20" . Chr(10)
                        }
                        else if (isRhsStackVar = 1) {
                            out .= "    ldr x10, =" . str3 . Chr(10)
                        }
                        else {
                            out .= "    ldr x10, =" . str3 . Chr(10)
                            out .= "    ldr x10, [x10]" . Chr(10)
                        }
                    }
                    out .= "    cmp x9, x10" . Chr(10)
                    out .= "    b.gt .end_if9_" . STR(ifCount9) . Chr(10)
                }
                else if (is_oryx = 1) {      out .= "meta " . A_LoopField . Chr(10)
                    strLhs := str2
                    if (str2 = "rax") { strLhs := "r0" }
                    else if (str2 = "A_Index") { strLhs := "r20" }
                    strRhs := str3
                    if (str3 = "rax") { strRhs := "r0" }
                    else if (str3 = "A_Index") { strRhs := "r20" }
                    out .= "cmp " . strLhs . ", " . strRhs . Chr(10)
                    out .= "jg end_if9_" . STR(ifCount9) . Chr(10)
                }
                else {
                    if (isNum = 1) {
                        out .= "mov rax, [" . str2 . "]" . Chr(10)
                        out .= "cmp rax, " . str3 . Chr(10)
                        out .= "jg .end_if9_" . STR(ifCount9) . Chr(10)
                    }
                    else {
                        out .= "mov rax, [" . str2 . "]" . Chr(10)
                        out .= "cmp rax, [" . str3 . "]" . Chr(10)
                        out .= "jg .end_if9_" . STR(ifCount9) . Chr(10)
                    }
                }
            }
        }
        else if (Trim(A_LoopField) = "ifend9") or (Trim(A_LoopField) = "endif9") {
            if (is_oryx = 1) {      out .= "meta " . A_LoopField . Chr(10)
                out .= "end_if9_" . STR(ifCount9) . ":" . Chr(10)
            } else {
                out .= ".end_if9_" . STR(ifCount9) . ":" . Chr(10)
            }
            ifCount9++
        }
        else if (SubStr(StrLower(A_LoopField), 1, 5) = "func ") {
            ; --- YOUR PARSING LOGIC IS UNCHANGED ---
            str1 := Trim(StringTrimLeft(Trim(A_LoopField), 5))
            str2 := ""
            Loop, Parse, str1 {
                if (A_LoopField = "(") {
                    break
                }
                else {
                    str2 .= A_LoopField
                }
            }
            str2 := Trim(str2)
            localVarNum := 1
            inFunc := 1
            funcArgsCount := (countChars(str1, ",") + 1)
            int1 := 0
            int2 := 0
            if (InStr(str1, ",")) or (InStr(str1, "()") = false) {
                funcArgsArr := []
                Loop, Parse, str1 {
                    if (A_LoopField = ")") {
                        break
                    }
                    if (int1 = 1) and (A_LoopField != ",") and (A_LoopField != " ") {
                        funcArgsArr[int2] := funcArgsArr[int2] . A_LoopField
                    }
                    if (A_LoopField = ",") {
                        funcArgsArr.add("")
                        int2++
                    }
                    if (A_LoopField = "(") {
                        funcArgsArr.add("")
                        int1 := 1
                    }
                }
            }
            funcName := str2
            ; --- ARCHITECTURE-SPECIFIC CODE GENERATION ---
            if (is_arm = 1) {
                out .= funcName . ":" . Chr(10)
                out .= "    stp x29, x30, [sp, #-16]!" . Chr(10)
                out .= "    mov x29, sp" . Chr(10)
                ; --- NEW REQUIRED LOGIC FOR ARM ---
                ; Calculate space needed for local vars AND for saving register arguments
                int args_to_save := funcArgsArr.size() > 8 ? 8 : funcArgsArr.size()
                int total_space := ( (localVarNum * 8) + (args_to_save * 8) + 15 ) & ~15
                out .= "    sub sp, sp, #" . STR(total_space) . Chr(10)
                ; Save the incoming register arguments to the stack
                Loop, % args_to_save {
                    int offset := (A_Index * 8)
                    out .= "    str x" . STR(A_Index) . ", [sp, #" . STR(offset) . "]" . Chr(10)
                }
                ; --- END NEW LOGIC ---
            }
            else if (is_oryx = 1) {      out .= "meta " . A_LoopField . Chr(10)
            
            isOryxFuncFirst++
            if (isOryxFuncFirst = 1) {
            out .= "jmp _start" . Chr(10)
            }
            
            ; --- ORYX IR (Function Definition with R50+ Convention) ---
                ; Clear the map for the new function
                oryx_param_map := [] 
                
                out .= "jmp " . funcName . "_end_skip_def" . Chr(10)
                out .= funcName . ":" . Chr(10)

                ; Build the map: "param_name" -> "r(50+N)"
                Loop, % funcArgsArr.size() {
                    str param_name := Trim(funcArgsArr[A_Index])
                    ; Arg1 -> r50, Arg2 -> r51, etc.
                    int non_volatile_reg_num := 50 + A_Index 
                    str safe_reg_name := "r" . STR(non_volatile_reg_num)
                    oryx_param_map.add(param_name . Chr(254) . safe_reg_name)

                    ; Copy the argument from the volatile register (r1, r2...) into the safe register
                    int arg_reg_num := A_Index + 1
                    out .= "mov " . safe_reg_name . ", r" . STR(arg_reg_num) . Chr(10)
                }
            }
            else {
                out .= str2 . ":" . Chr(10) . "push rbp" . Chr(10) . "mov rbp, rsp" . Chr(10) . "sub rsp, " . STR(8 + (localVarNum * 8)) . Chr(10)
            }
        }
        else if (Trim(A_LoopField) = "funcend") or (Trim(A_LoopField) = "endfunc") {
            if (is_arm = 1) {
                out .= "." . funcName . "_return:" . Chr(10)
                out .= "    mov sp, x29" . Chr(10)
                out .= "    ldp x29, x30, [sp], #16" . Chr(10)
                out .= "    ret" . Chr(10)
            }
            else if (is_oryx = 1) {      out .= "meta " . A_LoopField . Chr(10)
                oryx_param_map := []
                ; --- ORYX IR (Function End) ---
                out .= funcName . "_return:" . Chr(10)
                out .= "ret" . Chr(10)
                out .= funcName . "_end_skip_def:" . Chr(10)
            }
            else {
                out .= "." . funcName . "_return:" . Chr(10) . "add rsp, " . STR(8 + (localVarNum * 8)) . Chr(10) . "pop rbp" . Chr(10) . "ret" . Chr(10)
            }
            funcCount++
        }
        else if (Trim(A_LoopField) = "return") {
            if (is_arm = 1) {
                out .= "    b ." . funcName . "_return" . Chr(10)
            }
            else if (is_oryx = 1) {      out .= "meta " . A_LoopField . Chr(10)
                out .= "jmp " . funcName . "_return" . Chr(10)
            }
            else {
                out .= "jmp ." . funcName . "_return" . Chr(10)
            }
        }
        else if (SubStr(StrLower(A_LoopField), 1, 7) = "return ") {
            str1 := Trim(StringTrimLeft(Trim(A_LoopField), 7))
            if (is_arm = 1) {
                if (RegExMatch(str1, "^\d+$")) {
                    out .= "    mov x0, #" . str1 . Chr(10)
                }
                else if (str1 = "rax") {
                    ; Value is already in x0, no instruction needed.
                }
                else if (str1 = "A_Index") {
                    out .= "    mov x0, x20" . Chr(10)
                }
                else {
                    int isStackVar := 0
                    if (inFunc = 1) {
                        Loop, % funcArgsArr.size() {
                            if (Trim(funcArgsArr[A_Index]) = str1) {
                                isStackVar := 1
                                break
                            }
                        }
                    }
                    if (isStackVar = 1) {
                        out .= "    ldr x0, =" . str1 . Chr(10)
                    }
                    else {
                        out .= "    ldr x9, =" . str1 . Chr(10) . "    ldr x0, [x9]" . Chr(10)
                    }
                }
                out .= "    b ." . funcName . "_return" . Chr(10)
            }
            else if (is_oryx = 1) {      out .= "meta " . A_LoopField . Chr(10)
                ; --- ORYX IR (return value) ---
                if (RegExMatch(str1, "^\d+$")) {
                    out .= "mov r0, " . str1 . Chr(10)
                }
                else if (str1 = "rax") {
                    ; Already in r0
                }
                else if (str1 = "A_Index") {
                    out .= "mov r0, r20" . Chr(10)
                }
                else {
                    ; Variable
                    out .= "mov r0, " . str1 . Chr(10)
                }
                out .= "jmp " . funcName . "_return" . Chr(10)
            }
            else {
                if (RegExMatch(str1, "^\d+$")) {
                    out .= "mov rax, " . str1 . Chr(10) . "jmp ." . funcName . "_return" . Chr(10)
                }
                else {
                    out .= "mov rax, [" . str1 . "]" . Chr(10) . "jmp ." . funcName . "_return" . Chr(10)
                }
            }
        }
        else if (SubStr(StrLower(A_LoopField), 1, 4) = "arr ") {
            str1 := Trim(StringTrimLeft(Trim(A_LoopField), 4))
            if (is_arm = 1) {
                ; A struct of 3 quadwords is 24 bytes
                arrBss .= ".lcomm " . Trim(str1) . ", 24" . Chr(10)
            }
            else if (is_oryx = 1) {      out .= "meta " . A_LoopField . Chr(10)
                ; --- ORYX IR (Array Declaration) ---
                out .= "arr " . Trim(str1) . Chr(10)
            }
            else {
                arrBss .= "    " . Trim(str1) . " rq 3" . Chr(10)
            }
        }
        else if (InStr(A_LoopField, ".add ")) {
            str1 := Trim(StrSplit(A_LoopField, ".", 1))
            str2 := Trim(StrSplit(A_LoopField, ".add", 2))
            if (is_arm = 1) {
                out .= "    ldr x0, =" . str1 . Chr(10)
                if (RegExMatch(str2, "^\d+$")) {
                    out .= "    mov x1, #" . str2 . Chr(10)
                }
                else if (SubStr(str2, 1, 1) = "'") {
                    out .= "    mov x1, #" . str2 . Chr(10)
                }
                else if (str2 = "rax") {
                    out .= "    mov x1, x0" . Chr(10)
                }
                else if (str2 = "A_Index") {
                    out .= "    mov x1, x20" . Chr(10)
                }
                else {
                    int isStackVar := 0
                    if (inFunc = 1) {
                        Loop, % funcArgsArr.size() {
                            if (Trim(funcArgsArr[A_Index]) = str2) {
                                isStackVar := 1
                                break
                            }
                        }
                    }
                    if (isStackVar = 1) {
                        out .= "    ldr x1, =" . str2 . Chr(10)
                    }
                    else {
                        out .= "    ldr x9, =" . str2 . Chr(10) . "    ldr x1, [x9]" . Chr(10)
                    }
                }
                out .= "    bl array_append" . Chr(10)
            }
            else if (is_oryx = 1) {      out .= "meta " . A_LoopField . Chr(10)
                ; --- ORYX IR (arr.add) ---
                strVal := str2
                if (str2 = "rax") { strVal := "r0" }
                else if (str2 = "A_Index") { strVal := "r20" }
                else if (SubStr(str2, 1, 1) = "'") { 
                    ; Character literal 'A' -> "A" for Oryx
                    strVal := Chr(34) . SubStr(str2, 2, 1) . Chr(34)
                }
                
                out .= "arr.add " . str1 . ", " . strVal . Chr(10)
            }
            else {
                if (RegExMatch(str2, "^\d+$")) {
                    str3 := "mov rsi, " . str2 . Chr(10) . "mov rdi, " . str1 . Chr(10)
                }
                else {
                    str3 := "mov rsi, [" . str2 . "]" . Chr(10) . "mov rdi, " . str1 . Chr(10)
                }
                out .= str3 . Chr(10) . "call array_append" . Chr(10)
            }
        }
        else if (InStr(A_LoopField, ".pop")) {
            str1 := Trim(StrSplit(A_LoopField, ".", 1))
            if (is_arm = 1) {
                out .= "    ldr x0, =" . str1 . Chr(10)
                out .= "    bl array_pop" . Chr(10)
            }
              else if (is_oryx = 1) {      out .= "meta " . A_LoopField . Chr(10)
                ; Oryx doesn't have explicit .pop in your spec, but let's assume it does or map it
                ; If not, we skip or use a custom VM call. Assuming arr.pop exists:
                out .= "arr.pop " . str1 . Chr(10)
            }
            else {
                out .= "mov rdi, " . str1 . Chr(10) . "call array_pop" . Chr(10)
            }
        }    
        else if (InStr(A_LoopField, ".clear")) {
            str1 := Trim(StrSplit(A_LoopField, ".", 1))
            if (is_arm = 1) {
                out .= "    ldr x0, =" . str1 . Chr(10)
                out .= "    bl array_clear" . Chr(10)
            }
              else if (is_oryx = 1) {      out .= "meta " . A_LoopField . Chr(10)
                out .= "arr.clear " . str1 . Chr(10)
            }
            else {
                out .= "mov rdi, " . str1 . Chr(10) . "call array_clear" . Chr(10)
            }
        }
        else if (InStr(A_LoopField, ".copy ")) {
            str1 := Trim(StrSplit(A_LoopField, ".", 1))
            str2 := Trim(StrSplit(A_LoopField, ".copy", 2))
            if (is_arm = 1) {
                out .= "    ldr x0, =" . str1 . Chr(10)
                out .= "    ldr x1, =" . str2 . Chr(10)
                out .= "    bl array_copy" . Chr(10)
            }
              else if (is_oryx = 1) {      out .= "meta " . A_LoopField . Chr(10)
                out .= "arr.copy " . str2 . ", " . str1 . Chr(10)
            }
            else {
                out .= "mov rdi, " . str1 . Chr(10) . "mov rsi, " . str2 . Chr(10) . "call array_copy" . Chr(10)
            }
        }
        else if (InStr(A_LoopField, ".size")) {
            str1 := Trim(StrSplit(A_LoopField, ".", 1))
            if (is_arm = 1) {
                out .= "    ldr x9, =" . str1 . Chr(10)
                out .= "    ldr x0, [x9, #DynamicArray_size]" . Chr(10)
            }
                        else if (is_oryx = 1) {      out .= "meta " . A_LoopField . Chr(10)
                ; arr.size <array>, <dest_reg>
                out .= "arr.size " . str1 . ", r0" . Chr(10)
            }
            else {
                out .= "mov rax, [" . str1 . " + DynamicArray.size]" . Chr(10)
            }
        }
        else if (InStr(A_LoopField, ".index ")) {
            str1 := Trim(StrSplit(A_LoopField, ".", 1))
            str2 := Trim(StrSplit(A_LoopField, ".index", 2))
            if (is_arm = 1) {
                if (RegExMatch(str2, "^\d+$")) {
                    out .= "    mov x10, #" . str2 . Chr(10)
                }
                else if (str2 = "A_Index") {
                    out .= "    mov x10, x20" . Chr(10)
                }
                else if (str2 = "rax") {
                    out .= "    mov x10, x0" . Chr(10)
                }
                else {
                    int isStackVar := 0
                    if (inFunc = 1) {
                        Loop, % funcArgsArr.size() {
                            if (Trim(funcArgsArr[A_Index]) = str2) {
                                isStackVar := 1
                                break
                            }
                        }
                    }
                    if (isStackVar = 1) {
                        out .= "    ldr x10, =" . str2 . Chr(10)
                    }
                    else {
                        out .= "    ldr x9, =" . str2 . Chr(10) . "    ldr x10, [x9]" . Chr(10)
                    }
                }
                out .= "    ldr x9, =" . str1 . Chr(10)
                out .= "    ldr x9, [x9, #DynamicArray_pointer]" . Chr(10)
                out .= "    ldr x0, [x9, x10, lsl #3]" . Chr(10)
            }
                 else if (is_oryx = 1) {      out .= "meta " . A_LoopField . Chr(10)
                ; arr.get <array>, <index_src>, <dest_reg>
                strIndex := str2
                if (str2 = "rax") { strIndex := "r0" }
                else if (str2 = "A_Index") { strIndex := "r20" }
                
                ; If index is a variable, Oryx handles it. 
                ; If it's a raw number, Oryx handles it.
                
                out .= "arr.get " . str1 . ", " . strIndex . ", r0" . Chr(10)
            }
            else {
                if (RegExMatch(str2, "^\d+$")) {
                    str3 := "mov rcx, " . str2 . Chr(10)
                }
                else {
                    str3 := "mov rcx, [" . str2 . "]" . Chr(10)
                }
                out .= str3 . Chr(10) . "mov rbx, [" . str1 . " + DynamicArray.pointer]" . Chr(10) . "mov rax, [rbx + rcx*8]" . Chr(10)
            }
        }
        else if (InStr(A_LoopField, ".compile ")) {
            ; arrName.compile outArr
            str1 := Trim(StrSplit(A_LoopField, ".", 1))
            str2 := Trim(StrSplit(A_LoopField, ".compile", 2))
            isDotCompile := 1
            out .= "mov rdi, " . str1 . Chr(10) . "call array_pack_to_bytes" . Chr(10) . "mov [source_ptr], rax" . Chr(10) . "mov rdi, [source_ptr]" . Chr(10) . "call compiler_c" . Chr(10) . "mov [asm_code_ptr], rax" . Chr(10) . "mov rdi, " . str2 . Chr(10) . "mov rsi, [asm_code_ptr]" . Chr(10) . "call array_unpack_from_bytes" . Chr(10) . "mov rdi, [source_ptr]" . Chr(10) . "mov rsi, [source_ptr_size]" . Chr(10) . "call free_packed_string" . Chr(10) . "mov rdi, [asm_code_ptr]" . Chr(10) . "call free_string_c" . Chr(10)
        }
        else if (SubStr(StrLower(A_LoopField), 1, 5) = "goto ") {
            str1 := Trim(StringTrimLeft(A_LoopField, 5))
            if (is_arm = 1) {
                out .= "    b .__HTLL_HTLL_" . str1 . Chr(10)
            }
            else if (is_oryx = 1) {      out .= "meta " . A_LoopField . Chr(10)
                out .= "jmp __HTLL_HTLL_" . str1 . Chr(10)
            }
            else {
                out .= "jmp .__HTLL_HTLL_" . str1 . Chr(10)
            }
        }
        else if (SubStr(StrLower(A_LoopField), 1, 5) = "togo ") {
            str1 := Trim(StringTrimLeft(A_LoopField, 5))
            if (is_oryx = 1) {      out .= "meta " . A_LoopField . Chr(10)
                out .= "__HTLL_HTLL_" . str1 . ":" . Chr(10)
            }
            else {
                out .= ".__HTLL_HTLL_" . str1 . ":" . Chr(10)
            }
        }
        else if (SubStr(StrLower(A_LoopField), 1, 7) = "sleep, ") {
            str1 := Trim(StringTrimLeft(A_LoopField, 7))
            if (is_arm = 1) {
                if (RegExMatch(str1, "^\d+$")) {
                    out .= "    mov x0, #" . str1 . Chr(10)
                }
                else if (str1 = "A_Index") {
                    out .= "    mov x0, x20" . Chr(10)
                }
                else {
                    int isStackVar := 0
                    if (inFunc = 1) {
                        Loop, % funcArgsArr.size() {
                            if (Trim(funcArgsArr[A_Index]) = str1) {
                                isStackVar := 1
                                break
                            }
                        }
                    }
                    if (isStackVar = 1) {
                        out .= "    ldr x0, =" . str1 . Chr(10)
                    }
                    else {
                        out .= "    ldr x9, =" . str1 . Chr(10) . "    ldr x0, [x9]" . Chr(10)
                    }
                }
                out .= "    bl sleep_ms" . Chr(10)
            }
            else if (is_oryx = 1) {      out .= "meta " . A_LoopField . Chr(10)
                if (RegExMatch(str1, "^\d+$")) {
                    out .= "mov r1, " . str1 . Chr(10)
                }
                else if (str1 = "rax") {
                    out .= "mov r1, r0" . Chr(10)
                }
                else if (str1 = "A_Index") {
                    out .= "mov r1, r20" . Chr(10)
                }
                else {
                    out .= "mov r1, " . str1 . Chr(10)
                }
                out .= "call sleep" . Chr(10)
            }
            else {
                if (RegExMatch(str1, "^\d+$")) {
                    out .= "mov rdi, " . str1 . Chr(10)
                }
                else if (str1 = "rax") {
                    out .= "mov rdi, rax" . Chr(10)
                }
                else if (str1 = "A_Index") {
                    out .= "mov rdi, r13" . Chr(10)
                }
                else {
                    out .= "mov rdi, [" . str1 . "]" . Chr(10)
                }
                out .= "call sleep_ms" . Chr(10)
            }
        }
        else if (SubStr(StrLower(A_LoopField), 1, 13) = "fileread_arr ") {
            str1 := Trim(StringTrimLeft(A_LoopField, 13))
            str2 := Trim(StrSplit(str1, ",", 1))
            str3 := Trim(StrSplit(str1, ",", 2))
            if (is_arm = 1) {
                out .= "    ldr x0, =" . str3 . Chr(10) . "    bl array_pack_to_bytes" . Chr(10)
                out .= "    ldr x9, =filename_ptr" . Chr(10) . "    str x0, [x9]" . Chr(10)
                out .= "    ldr x9, =filename_ptr_size" . Chr(10) . "    str x1, [x9]" . Chr(10)
                out .= "    ldr x0, =" . str2 . Chr(10)
                out .= "    ldr x9, =filename_ptr" . Chr(10) . "    ldr x1, [x9]" . Chr(10)
                out .= "    bl fileread_from_ptr" . Chr(10)
                out .= "    ldr x9, =filename_ptr" . Chr(10) . "    ldr x0, [x9]" . Chr(10)
                out .= "    ldr x9, =filename_ptr_size" . Chr(10) . "    ldr x1, [x9]" . Chr(10)
                out .= "    bl free_packed_string" . Chr(10)
            }
else if (is_oryx = 1) {      out .= "meta " . A_LoopField . Chr(10)
    out .= "; --- INLINE CONVERT " . str3 . " ---" . Chr(10)
    out .= "arr.size " . str3 . ", r90" . Chr(10)
    out .= "mov __HTLL_HTLL_HTLL_HTLL_IO_BUFFER, " . Chr(34) . Chr(34) . Chr(10)
    out .= "mov r91, 0" . Chr(10)
    out .= "__HTLL_HTLL_inline_conv" . STR(HTLL_fix_int) . ":" . Chr(10)
    out .= "cmp r91, r90" . Chr(10)
    out .= "jge __HTLL_HTLL_inline_conv_end" . STR(HTLL_fix_int) . Chr(10)
    out .= "arr.get " . str3 . ", r91, r92" . Chr(10)
    out .= "num_to_char r92, r93" . Chr(10)
    out .= "add_str __HTLL_HTLL_HTLL_HTLL_IO_BUFFER, r93" . Chr(10)
    out .= "inc r91" . Chr(10)
    out .= "jmp __HTLL_HTLL_inline_conv" . STR(HTLL_fix_int) . Chr(10)
    out .= "__HTLL_HTLL_inline_conv_end" . STR(HTLL_fix_int) . ":" . Chr(10)
    out .= "file.read " . str2 . ", __HTLL_HTLL_HTLL_HTLL_IO_BUFFER" . Chr(10)
    HTLL_fix_int++
}
            else {
                out .= "mov rdi, " . str3 . Chr(10) . "call array_pack_to_bytes" . Chr(10)
                out .= "mov [filename_ptr], rax" . Chr(10) . "mov [filename_ptr_size], rdx" . Chr(10)
                out .= "mov rdi, " . str2 . Chr(10) . "mov rsi, [filename_ptr]" . Chr(10) . "call fileread_from_ptr" . Chr(10)
                out .= "mov rdi, [filename_ptr]" . Chr(10) . "mov rsi, [filename_ptr_size]" . Chr(10) . "call free_packed_string" . Chr(10)
            }
        }
        else if (SubStr(StrLower(A_LoopField), 1, 15) = "fileappend_arr ") {
            str1 := Trim(StringTrimLeft(A_LoopField, 15))
            str2 := Trim(StrSplit(str1, ",", 1))
            str3 := Trim(StrSplit(str1, ",", 2))
            if (is_arm = 1) {
                out .= "    ldr x0, =" . str2 . Chr(10) . "    bl array_pack_to_bytes" . Chr(10)
                out .= "    ldr x9, =filename_ptr" . Chr(10) . "    str x0, [x9]" . Chr(10)
                out .= "    ldr x9, =filename_ptr_size" . Chr(10) . "    str x1, [x9]" . Chr(10)
                out .= "    ldr x9, =filename_ptr" . Chr(10) . "    ldr x0, [x9]" . Chr(10)
                out .= "    ldr x1, =" . str3 . Chr(10)
                out .= "    bl fileappend_from_ptr" . Chr(10)
                out .= "    ldr x9, =filename_ptr" . Chr(10) . "    ldr x0, [x9]" . Chr(10)
                out .= "    ldr x9, =filename_ptr_size" . Chr(10) . "    ldr x1, [x9]" . Chr(10)
                out .= "    bl free_packed_string" . Chr(10)
            }
else if (is_oryx = 1) {      out .= "meta " . A_LoopField . Chr(10)
    ; --- INLINE CONVERT FILENAME (str2) ---
    out .= "; --- INLINE CONVERT " . str2 . " ---" . Chr(10)
    out .= "arr.size " . str2 . ", r90" . Chr(10)
    out .= "mov __HTLL_HTLL_HTLL_HTLL_IO_BUFFER, " . Chr(34) . Chr(34) . Chr(10)
    out .= "mov r91, 0" . Chr(10)
    out .= "__HTLL_HTLL_inline_convA" . STR(HTLL_fix_int) . ":" . Chr(10)
    out .= "cmp r91, r90" . Chr(10)
    out .= "jge __HTLL_HTLL_inline_convA_end" . STR(HTLL_fix_int) . Chr(10)
    out .= "arr.get " . str2 . ", r91, r92" . Chr(10)
    out .= "num_to_char r92, r93" . Chr(10)
    out .= "add_str __HTLL_HTLL_HTLL_HTLL_IO_BUFFER, r93" . Chr(10)
    out .= "inc r91" . Chr(10)
    out .= "jmp __HTLL_HTLL_inline_convA" . STR(HTLL_fix_int) . Chr(10)
    out .= "__HTLL_HTLL_inline_convA_end" . STR(HTLL_fix_int) . ":" . Chr(10)

    ; --- INLINE CONVERT CONTENT (str3) ---
    out .= "; --- INLINE CONVERT " . str3 . " ---" . Chr(10)
    out .= "arr.size " . str3 . ", r90" . Chr(10)
    out .= "mov __HTLL_HTLL_HTLL_HTLL_CONTENT_BUFFER, " . Chr(34) . Chr(34) . Chr(10)
    out .= "mov r91, 0" . Chr(10)
    out .= "__HTLL_HTLL_inline_convB" . STR(HTLL_fix_int) . ":" . Chr(10)
    out .= "cmp r91, r90" . Chr(10)
    out .= "jge __HTLL_HTLL_inline_convB_end" . STR(HTLL_fix_int) . Chr(10)
    out .= "arr.get " . str3 . ", r91, r92" . Chr(10)
    out .= "num_to_char r92, r93" . Chr(10)
    out .= "add_str __HTLL_HTLL_HTLL_HTLL_CONTENT_BUFFER, r93" . Chr(10)
    out .= "inc r91" . Chr(10)
    out .= "jmp __HTLL_HTLL_inline_convB" . STR(HTLL_fix_int) . Chr(10)
    out .= "__HTLL_HTLL_inline_convB_end" . STR(HTLL_fix_int) . ":" . Chr(10)
    
    out .= "file.append __HTLL_HTLL_HTLL_HTLL_IO_BUFFER, __HTLL_HTLL_HTLL_HTLL_CONTENT_BUFFER" . Chr(10)
    HTLL_fix_int++
}
            else {
                out .= "mov rdi, " . str2 . Chr(10) . "call array_pack_to_bytes" . Chr(10)
                out .= "mov [filename_ptr], rax" . Chr(10) . "mov [filename_ptr_size], rdx" . Chr(10)
                out .= "mov rdi, [filename_ptr]" . Chr(10) . "mov rsi, " . str3 . Chr(10) . "call fileappend_from_ptr" . Chr(10)
                out .= "mov rdi, [filename_ptr]" . Chr(10) . "mov rsi, [filename_ptr_size]" . Chr(10) . "call free_packed_string" . Chr(10)
            }
        }
        else if (SubStr(StrLower(A_LoopField), 1, 15) = "filedelete_arr ") {
            str1 := Trim(StringTrimLeft(A_LoopField, 15))
            if (is_arm = 1) {
                out .= "    ldr x0, =" . str1 . Chr(10) . "    bl array_pack_to_bytes" . Chr(10)
                out .= "    ldr x9, =filename_ptr" . Chr(10) . "    str x0, [x9]" . Chr(10)
                out .= "    ldr x9, =filename_ptr_size" . Chr(10) . "    str x1, [x9]" . Chr(10)
                out .= "    ldr x9, =filename_ptr" . Chr(10) . "    ldr x0, [x9]" . Chr(10)
                out .= "    bl filedelete_from_ptr" . Chr(10)
                out .= "    ldr x9, =filename_ptr" . Chr(10) . "    ldr x0, [x9]" . Chr(10)
                out .= "    ldr x9, =filename_ptr_size" . Chr(10) . "    ldr x1, [x9]" . Chr(10)
                out .= "    bl free_packed_string" . Chr(10)
            }
else if (is_oryx = 1) {      out .= "meta " . A_LoopField . Chr(10)
    out .= "; --- INLINE CONVERT " . str1 . " ---" . Chr(10)
    out .= "arr.size " . str1 . ", r90" . Chr(10)
    out .= "mov __HTLL_HTLL_HTLL_HTLL_IO_BUFFER, " . Chr(34) . Chr(34) . Chr(10)
    out .= "mov r91, 0" . Chr(10)
    out .= "__HTLL_HTLL_inline_conv" . STR(HTLL_fix_int) . ":" . Chr(10)
    out .= "cmp r91, r90" . Chr(10)
    out .= "jge __HTLL_HTLL_inline_conv_end" . STR(HTLL_fix_int) . Chr(10)
    out .= "arr.get " . str1 . ", r91, r92" . Chr(10)
    out .= "num_to_char r92, r93" . Chr(10)
    out .= "add_str __HTLL_HTLL_HTLL_HTLL_IO_BUFFER, r93" . Chr(10)
    out .= "inc r91" . Chr(10)
    out .= "jmp __HTLL_HTLL_inline_conv" . STR(HTLL_fix_int) . Chr(10)
    out .= "__HTLL_HTLL_inline_conv_end" . STR(HTLL_fix_int) . ":" . Chr(10)
    out .= "file.delete __HTLL_HTLL_HTLL_HTLL_IO_BUFFER" . Chr(10)
    HTLL_fix_int++
}
            else {
                out .= "mov rdi, " . str1 . Chr(10) . "call array_pack_to_bytes" . Chr(10)
                out .= "mov [filename_ptr], rax" . Chr(10) . "mov [filename_ptr_size], rdx" . Chr(10)
                out .= "mov rdi, [filename_ptr]" . Chr(10) . "call filedelete_from_ptr" . Chr(10)
                out .= "mov rdi, [filename_ptr]" . Chr(10) . "mov rsi, [filename_ptr_size]" . Chr(10) . "call free_packed_string" . Chr(10)
            }
        }
        else if (SubStr(StrLower(A_LoopField), 1, 9) = "fileread ") {
            str1 := Trim(StringTrimLeft(A_LoopField, 9))
            str2 := Trim(StrSplit(str1, ",", 1))
            str3 := Trim(StrSplit(str1, ",", 2))
            dot_data_print_temp_strings_count++
            path_label := "FILE_PATH_" . STR(dot_data_print_temp_strings_count)
            if (is_arm = 1) {
                dot_data_print_temp_strings .= path_label . ": .string " . str3 . Chr(10)
                out .= "    ldr x0, =" . str2 . Chr(10)
                out .= "    ldr x1, =" . path_label . Chr(10)
                out .= "    bl file_read" . Chr(10)
            }
               else if (is_oryx = 1) {      out .= "meta " . A_LoopField . Chr(10)
                ; Oryx: file.read dest, "file.txt"
                out .= "file.read " . str2 . ", " . str3 . Chr(10)
            }
            else {
                dot_data_print_temp_strings .= path_label . " db " . str3 . ", 0" . Chr(10)
                out .= "mov rdi, " . str2 . Chr(10) . "mov rsi, " . path_label . Chr(10) . "call file_read" . Chr(10)
            }
        }
        else if (SubStr(StrLower(A_LoopField), 1, 11) = "fileappend ") {
            str1 := Trim(StringTrimLeft(A_LoopField, 11))
            str2 := Trim(StrSplit(str1, ",", 1))
            str3 := Trim(StrSplit(str1, ",", 2))
            dot_data_print_temp_strings_count++
            path_label := "FILE_PATH_" . STR(dot_data_print_temp_strings_count)
            if (is_arm = 1) {
                dot_data_print_temp_strings .= path_label . ": .string " . str2 . Chr(10)
                out .= "    ldr x0, =" . path_label . Chr(10)
                out .= "    ldr x1, =" . str3 . Chr(10)
                out .= "    bl file_append" . Chr(10)
            }
               else if (is_oryx = 1) {      out .= "meta " . A_LoopField . Chr(10)
                out .= "file.append " . str2 . ", " . str3 . Chr(10)
            }
            else {
                dot_data_print_temp_strings .= path_label . " db " . str2 . ", 0" . Chr(10)
                out .= "mov rdi, " . path_label . Chr(10) . "mov rsi, " . str3 . Chr(10) . "call file_append" . Chr(10)
            }
        }
        else if (SubStr(StrLower(A_LoopField), 1, 11) = "filedelete ") {
            str1 := Trim(StringTrimLeft(A_LoopField, 11))
            dot_data_print_temp_strings_count++
            path_label := "FILE_PATH_" . STR(dot_data_print_temp_strings_count)
            if (is_arm = 1) {
                dot_data_print_temp_strings .= path_label . ": .string " . str1 . Chr(10)
                out .= "    ldr x0, =" . path_label . Chr(10)
                out .= "    bl file_delete" . Chr(10)
            }
              else if (is_oryx = 1) {
              out .= "meta " . A_LoopField . Chr(10)
                out .= "file.delete " . str1 . Chr(10)
            }
            else {
                dot_data_print_temp_strings .= path_label . " db " . str1 . ", 0" . Chr(10)
                out .= "mov rdi, " . path_label . Chr(10) . "call file_delete" . Chr(10)
            }
        }
        else if (SubStr(A_LoopField, 1, 6) = "input ") {
            str1 := Trim(StringTrimLeft(A_LoopField, 6))
            str2 := Trim(StrSplit(str1, ",", 1))
            str3 := Trim(StrSplit(str1, ",", 2))
            if (is_arm = 1) {
                out .= "    ldr x0, =" . str2 . Chr(10)
                out .= "    ldr x1, =" . str3 . Chr(10)
                out .= "    bl get_user_input" . Chr(10)
            }
else if (is_oryx = 1) {      out .= "meta " . A_LoopField . Chr(10)
    out .= "; --- INLINE CONVERT " . str3 . " ---" . Chr(10)
    out .= "arr.size " . str3 . ", r90" . Chr(10)
    out .= "mov __HTLL_HTLL_HTLL_HTLL_IO_BUFFER, " . Chr(34) . Chr(34) . Chr(10)
    out .= "mov r91, 0" . Chr(10)
    out .= "__HTLL_HTLL_inline_conv" . STR(HTLL_fix_int) . ":" . Chr(10)
    out .= "cmp r91, r90" . Chr(10)
    out .= "jge __HTLL_HTLL_inline_conv_end" . STR(HTLL_fix_int) . Chr(10)
    out .= "arr.get " . str3 . ", r91, r92" . Chr(10)
    out .= "num_to_char r92, r93" . Chr(10)
    out .= "add_str __HTLL_HTLL_HTLL_HTLL_IO_BUFFER, r93" . Chr(10)
    out .= "inc r91" . Chr(10)
    out .= "jmp __HTLL_HTLL_inline_conv" . STR(HTLL_fix_int) . Chr(10)
    out .= "__HTLL_HTLL_inline_conv_end" . STR(HTLL_fix_int) . ":" . Chr(10)
    out .= "input " . str2 . ", __HTLL_HTLL_HTLL_HTLL_IO_BUFFER" . Chr(10)
    HTLL_fix_int++
}
            else {
                out .= "mov rdi, " . str2 . Chr(10) . "mov rsi, " . str3 . Chr(10) . "call get_user_input" . Chr(10)
            }
        }
        else if (InStr(A_LoopField, ".set ")) {
            str1 := Trim(StrSplit(A_LoopField, ".", 1))
            str2 := Trim(StringTrimLeft(A_LoopField, StrLen(str1) + 5))
            str_index := Trim(StrSplit(str2, ",", 1))
            str_value := Trim(StrSplit(str2, ",", 2))
            if (is_arm = 1) {
                ; 1. Load Array Pointer into x9
                out .= "    ldr x9, =" . str1 . Chr(10)
                out .= "    ldr x9, [x9, #DynamicArray_pointer]" . Chr(10)
                ; 2. Load INDEX into x10
                if (str_index = "A_Index") {
                    out .= "    mov x10, x20" . Chr(10)
                }
                else if (str_index = "rax") {
                    out .= "    mov x10, x0" . Chr(10)
                }
                else if (RegExMatch(str_index, "^\d+$")) {
                    out .= "    mov x10, #" . str_index . Chr(10)
                }
                else {
                    int isStackVar := 0
                    if (inFunc = 1) {
                        Loop, % funcArgsArr.size() {
                            if (Trim(funcArgsArr[A_Index]) = str_index) {
                                isStackVar := 1
                                break
                            }
                        }
                    }
                    if (isStackVar = 1) {
                        out .= "    ldr x10, =" . str_index . Chr(10)
                    }
                    else {
                        out .= "    ldr x11, =" . str_index . Chr(10)
                        out .= "    ldr x10, [x11]" . Chr(10)
                    }
                }
                ; 3. Load VALUE into x11
                if (str_value = "A_Index") {
                    out .= "    mov x11, x20" . Chr(10)
                }
                else if (str_value = "rax") {
                    out .= "    mov x11, x0" . Chr(10)
                }
                else if (RegExMatch(str_value, "^\d+$")) {
                    out .= "    mov x11, #" . str_value . Chr(10)
                }
                else {
                    int isStackVar := 0
                    if (inFunc = 1) {
                        Loop, % funcArgsArr.size() {
                            if (Trim(funcArgsArr[A_Index]) = str_value) {
                                isStackVar := 1
                                break
                            }
                        }
                    }
                    if (isStackVar = 1) {
                        out .= "    ldr x11, =" . str_value . Chr(10)
                    }
                    else {
                        out .= "    ldr x12, =" . str_value . Chr(10)
                        out .= "    ldr x11, [x12]" . Chr(10)
                    }
                }
                ; 4. Store x11 into Array[x10]
                out .= "    str x11, [x9, x10, lsl #3]" . Chr(10)
            }
            else if (is_oryx = 1) {      out .= "meta " . A_LoopField . Chr(10)
                ; arr.set array, index, value
                
                ; Resolve Index
                idxSrc := str_index
                if (str_index = "rax") { idxSrc := "r0" }
                else if (str_index = "A_Index") { idxSrc := "r20" }
                
                ; Resolve Value
                valSrc := str_value
                if (str_value = "rax") { valSrc := "r0" }
                else if (str_value = "A_Index") { valSrc := "r20" }
                
                out .= "arr.set " . str1 . ", " . idxSrc . ", " . valSrc . Chr(10)
            }
            else {
                ; --- EXISTING x86 CODE (Unchanged) ---
                out .= "mov rbx, [" . str1 . " + DynamicArray.pointer]" . Chr(10)
                if (RegExMatch(str_index, "^\d+$")) {
                    out .= "mov rcx, " . str_index . Chr(10)
                }
                else {
                    out .= "mov rcx, [" . str_index . "]" . Chr(10)
                }
                if (RegExMatch(str_value, "^\d+$")) {
                    out .= "mov rsi, " . str_value . Chr(10)
                }
                else {
                    out .= "mov rsi, [" . str_value . "]" . Chr(10)
                }
                out .= "mov [rbx + rcx*8], rsi" . Chr(10)
            }
        }
       else if (Trim(A_LoopField) = "rax++") {
            if (is_arm = 1) {
                out .= "    add x0, x0, #1" . Chr(10)
            }
            else if (is_oryx = 1) {      out .= "meta " . A_LoopField . Chr(10)
                out .= "inc r0" . Chr(10)
            }
            else {
                out .= "inc rax" . Chr(10)
            }
        }
        else if (Trim(A_LoopField) = "rax--") {
            if (is_arm = 1) {
                out .= "    sub x0, x0, #1" . Chr(10)
            }
            else if (is_oryx = 1) {      out .= "meta " . A_LoopField . Chr(10)
                out .= "dec r0" . Chr(10)
            }
            else {
                out .= "dec rax" . Chr(10)
            }
        }
        else if (SubStrLastChars(Trim(A_LoopField), 1) = ")") {
            ; --- YOUR PARSING LOGIC IS UNCHANGED ---
            str1 := StringTrimRight(Trim(A_LoopField), 1)
            str2 := StrSplit(str1, "(", 1)
            Loop, Parse, str2, " " {
                str3 := A_LoopField
            }
            str2 := str3
            str3 := StrSplit(str1, "(", 2)
            str4 := ""
            int5 := 0
            int1 := 0
            if (Trim(str3) = "") {
                int1 := 1
            }
            if (is_arm = 1) {
                ; --- AArch64 CODE GENERATION ---
                int stack_arg_count := 0
                if (int1 = 0) {
                    Loop, Parse, str3, ", " {
                        if (A_Index > 8) {
                            stack_arg_count++
                        }
                    }
                    if (stack_arg_count > 0) {
                        str4 .= "    sub sp, sp, #" . STR(stack_arg_count * 8) . Chr(10)
                    }
                    Loop, Parse, str3, ", " {
                        int current_arg_num := A_Index
                        if (current_arg_num < 8) {
                            if (RegExMatch(A_LoopField, "^\d+$")) {
                                str4 .= "    mov x" . STR(current_arg_num) . ", #" . A_LoopField . Chr(10)
                            }
                            else if (A_LoopField = "rax") {
                                str4 .= "    mov x" . STR(current_arg_num) . ", x0" . Chr(10)
                            }
                            else if (A_LoopField = "A_Index") {
                                str4 .= "    mov x" . STR(current_arg_num) . ", x20" . Chr(10)
                            }
                            else {
                                int isStackVar := 0
                                if (inFunc = 1) {
                                    Loop, % funcArgsArr.size() {
                                        if (Trim(funcArgsArr[A_Index]) = A_LoopField) {
                                            isStackVar := 1
                                            break
                                        }
                                    }
                                }
                                if (isStackVar = 1) {
                                    str4 .= "    ldr x" . STR(current_arg_num) . ", =" . A_LoopField . Chr(10)
                                }
                                else {
                                    str4 .= "    ldr x9, =" . A_LoopField . Chr(10) . "    ldr x" . STR(current_arg_num) . ", [x9]" . Chr(10)
                                }
                            }
                        }
                        else {
                            int stack_offset := (current_arg_num - 8) * 8
                            if (RegExMatch(A_LoopField, "^\d+$")) {
                                str4 .= "    mov x9, #" . A_LoopField . Chr(10)
                            }
                            else if (A_LoopField = "rax") {
                                str4 .= "    mov x9, x0" . Chr(10)
                            }
                            else if (A_LoopField = "A_Index") {
                                str4 .= "    mov x9, x20" . Chr(10)
                            }
                            else {
                                int isStackVar := 0
                                if (inFunc = 1) {
                                    Loop, % funcArgsArr.size() {
                                        if (Trim(funcArgsArr[A_Index]) = A_LoopField) {
                                            isStackVar := 1
                                            break
                                        }
                                    }
                                }
                                if (isStackVar = 1) {
                                    str4 .= "    ldr x9, =" . A_LoopField . Chr(10)
                                }
                                else {
                                    str4 .= "    ldr x10, =" . A_LoopField . Chr(10) . "    ldr x9, [x10]" . Chr(10)
                                }
                            }
                            str4 .= "    str x9, [sp, #" . STR(stack_offset) . "]" . Chr(10)
                        }
                    }
                }
                out .= str4 . "    bl " . str2 . Chr(10)
                if (stack_arg_count > 0) {
                    out .= "    add sp, sp, #" . STR(stack_arg_count * 8) . Chr(10)
                }
            }
            else if (is_oryx = 1) {
            out .= "meta " . A_LoopField . Chr(10)
                ; --- ORYX IR (Function Call) ---
                if (int1 = 0) {
                    Loop, Parse, str3, ", " {
                        ; Move each argument to the corresponding register (r1, r2, etc.)
                        strArg := A_LoopField
                        strSrc := strArg
                        if (strArg = "rax") { strSrc := "r0" }
                        else if (strArg = "A_Index") { strSrc := "r20" }
                        
                        out .= "mov r" . STR(A_Index + 1) . ", " . strSrc . Chr(10)
                    }
                }
                out .= "call " . str2 . Chr(10)
            }
            else {
                ; --- YOUR EXISTING X86 CODE - UNCHANGED ---
                Loop, Parse, str3, ", " {
                    if (RegExMatch(A_LoopField, "^\d+$")) {
                        str4 .= "push " . A_LoopField . Chr(10)
                    }
                    else {
                        str4 .= "push qword [" . A_LoopField . "]" . Chr(10)
                    }
                    int5++
                }
                if (int1 = 0) {
                    out .= str4 . "call " . str2 . Chr(10) . "add rsp, " . STR(8 * int5) . Chr(10)
                }
                else {
                    out .= str4 . "call " . str2 . Chr(10)
                }
            }
        }
        else {
            out .= A_LoopField . Chr(10)
        }
        ; Place this AFTER your main compilation loop finishes generating 'out'
        Loop, % funcArgsArr.size() {
            if (is_arm = 1) {
                out := RegExReplace(out, Chr(61) . "\b" . Trim(funcArgsArr[A_Index]) . "\b", "[sp, #" . STR(8 + ( (funcArgsArr.size() - A_Index) * 8 )) . "]")
            }
            if (is_arm = 0) and (is_oryx = 1) {
                out := RegExReplace(out, "\b" . Trim(funcArgsArr[A_Index]) . "\b", "r" . STR(A_Index + 50))
            }
            if (is_arm = 0) and (is_oryx = 0) {
                ; Your existing x86 formula
                out := RegExReplace(out, "\b" . Trim(funcArgsArr[A_Index]) . "\b", "rbp + " . STR(8 + ( (funcArgsArr.size() - A_Index) * 8 )))
            }
        }
        ; ... after the main compilation loop ...
        if (is_arm = 0) {
            out := StrReplace(out, "']", "'")
            out := StrReplace(out, "['", "'")
            out := StrReplace(out, "push qword []", "")
            out := StrReplace(out, "[A_Index]", "r13")
        }
        ; This replacement is likely a mistake in your original code, as it would
        ; turn `mov rax, [my_var]` into `mov rax, my_var`, which is a different instruction.
        ; I'll keep it here but comment it out as a warning.
        ; codeOUT := StrReplace(codeOUT, " [rax]", " rax")
    }
    code := out
    arr str allFuncCALLS
    arr str allFuncCALLS_alredy
    str code_TEMP := code . Chr(10) . main_syntax
    Loop, Parse, code_TEMP, `n, `r {
        if (is_arm = 1) {
            if (SubStr(Trim(A_LoopField), 1, 3) = "bl ") or (SubStr(Trim(A_LoopField), 1, 2) = "b ") {
                allFuncCALLS.add(Trim(StringTrimLeft(Trim(A_LoopField), 2)))
            }
        }
        else {
            if (SubStr(Trim(A_LoopField), 1, 5) = "call ") or (SubStr(Trim(A_LoopField), 1, 4) = "jmp ") {
                allFuncCALLS.add(Trim(StringTrimLeft(Trim(A_LoopField), 4)))
            }
        }
    }
    str HTLL_Libs_x86_new := Chr(10)
    str temp_funcName := ""
    int temp_in_funcName := 0
    int canWeGetFunc := 0
    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
    Loop, Parse, HTLL_Libs_x86, `n, `r {
        if (InStr(A_LoopField, "$$$$") = false) and (InStr(A_LoopField, "%%%%") = false) and (temp_in_funcName = 1) and (canWeGetFunc = 1) {
            HTLL_Libs_x86_new .= A_LoopField . Chr(10)
        }
        if (InStr(A_LoopField, "$$$$")) {
            temp_funcName := StringTrimLeft(StringTrimRight(Trim(A_LoopField), 4), 4)
            temp_in_funcName := 1
            canWeGetFunc := 0
            Loop, allFuncCALLS.size() {
                if (temp_funcName = allFuncCALLS[A_Index]) {
                    canWeGetFunc := 1
                    allFuncCALLS_alredy.add(temp_funcName)
                    break
                }
            }
        }
        else if (InStr(A_LoopField, "%%%%")) {
            temp_in_funcName := 0
        }
    }
    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
    allFuncCALLS := []
    int anotherVar_INT_HELP_BUILD_IN_FUNCS_INT := 0
    str ALoopField := ""
    Loop, Parse, HTLL_Libs_x86_new, `n, `r {
        ALoopField := A_LoopField
        if (is_arm = 1) {
            if (SubStr(Trim(A_LoopField), 1, 3) = "bl ") or (SubStr(Trim(A_LoopField), 1, 2) = "b ") {
                anotherVar_INT_HELP_BUILD_IN_FUNCS_INT := 1
                Loop, allFuncCALLS_alredy.size() {
                    if (allFuncCALLS_alredy[A_Index] = Trim(StringTrimLeft(Trim(ALoopField), 2))) {
                        anotherVar_INT_HELP_BUILD_IN_FUNCS_INT := 0
                    }
                }
                if (anotherVar_INT_HELP_BUILD_IN_FUNCS_INT = 1) {
                    allFuncCALLS.add(Trim(StringTrimLeft(Trim(ALoopField), 4)))
                }
            }
        }
        else {
            if (SubStr(Trim(A_LoopField), 1, 5) = "call ") or (SubStr(Trim(A_LoopField), 1, 4) = "jmp ") {
                anotherVar_INT_HELP_BUILD_IN_FUNCS_INT := 1
                Loop, allFuncCALLS_alredy.size() {
                    if (allFuncCALLS_alredy[A_Index] = Trim(StringTrimLeft(Trim(ALoopField), 4))) {
                        anotherVar_INT_HELP_BUILD_IN_FUNCS_INT := 0
                    }
                }
                if (anotherVar_INT_HELP_BUILD_IN_FUNCS_INT = 1) {
                    allFuncCALLS.add(Trim(StringTrimLeft(Trim(ALoopField), 4)))
                }
            }
        }
    }
    temp_funcName := ""
    temp_in_funcName := 0
    canWeGetFunc := 0
    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
    Loop, Parse, HTLL_Libs_x86, `n, `r {
        if (InStr(A_LoopField, "$$$$") = false) and (InStr(A_LoopField, "%%%%") = false) and (temp_in_funcName = 1) and (canWeGetFunc = 1) {
            HTLL_Libs_x86_new .= A_LoopField . Chr(10)
        }
        if (InStr(A_LoopField, "$$$$")) {
            temp_funcName := StringTrimLeft(StringTrimRight(Trim(A_LoopField), 4), 4)
            temp_in_funcName := 1
            canWeGetFunc := 0
            Loop, allFuncCALLS.size() {
                if (temp_funcName = allFuncCALLS[A_Index]) {
                    canWeGetFunc := 1
                    break
                }
            }
        }
        else if (InStr(A_LoopField, "%%%%")) {
            temp_in_funcName := 0
        }
    }
    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
    ; =========================================================================
    ; FINAL FASM OBJECT FILE ASSEMBLY - THE TRUE BLUEPRINT
    ; =========================================================================
    dot_data .= dot_data_print_temp_strings . Chr(10)
    dot_data .= dot_data_ints . Chr(10)
    dot_bss .= dot_bss_str . Chr(10)
    ; ... inside your 'where:' block ...
    str fasm_header := ""
    ; --- FASM OBJECT FILE HEADER & LINKER DIRECTIVES ---
    if (is_oryx = 1) {
        
    fasm_header .= "string __HTLL_HTLL_HTLL_HTLL_IO_BUFFER: " . Chr(34) . Chr(34) . Chr(10)
    fasm_header .= "string __HTLL_HTLL_HTLL_HTLL_CONTENT_BUFFER: " . Chr(34) . Chr(34) . Chr(10)
        
        ; Inject the library code (you can load this from a file or have it as a string)
        fasm_header .= "jmp __HTLL_HTLL_HTLL_HTLL_main_entry_point" . Chr(10)
        fasm_header .= "; --- START INJECTED LIBRARY ---" . Chr(10)
        fasm_header .= "__HTLL_HTLL_HTLL_HTLL_convert_array_to_bytestring:" . Chr(10)
        fasm_header .= "    push r1" . Chr(10) . "    push r2" . Chr(10) . "    push r3" . Chr(10) . " push r4" . Chr(10) . " push r5" . Chr(10) . " push r6" . Chr(10)
        fasm_header .= "    mov r2, " . Chr(34) . Chr(34) . Chr(10)
        fasm_header .= "    arr.size r1, r3" . Chr(10)
        fasm_header .= "    mov r4, 0" . Chr(10)
        fasm_header .= "__HTLL_HTLL_HTLL_HTLL_convert_loop:" . Chr(10)
        fasm_header .= "    cmp r4, r3" . Chr(10)
        fasm_header .= "    jge __HTLL_HTLL_HTLL_HTLL_convert_loop_end" . Chr(10)
        fasm_header .= "    arr.get r1, r4, r5" . Chr(10)
        fasm_header .= "    num_to_char r5, r6" . Chr(10)
        fasm_header .= "    add_str r2, r6" . Chr(10)
        fasm_header .= "    inc r4" . Chr(10)
        fasm_header .= "    jmp __HTLL_HTLL_HTLL_HTLL_convert_loop" . Chr(10)
        fasm_header .= "__HTLL_HTLL_HTLL_HTLL_convert_loop_end:" . Chr(10)
        fasm_header .= "mov r0, r2" . Chr(10)
        fasm_header .= "    pop r6" . Chr(10) . " pop r5" . Chr(10) . " pop r4" . Chr(10) . " pop r3" . Chr(10) . " pop r2" . Chr(10) . " pop r1" . Chr(10)
        fasm_header .= "    ret" . Chr(10)
        fasm_header .= "; --- END INJECTED LIBRARY ---" . Chr(10)
        fasm_header .= "__HTLL_HTLL_HTLL_HTLL_main_entry_point:" . Chr(10)
    }
    else {
    if (is_arm = 1) {
        ; --- ARM GNU AS HEADER & CONSTANTS ---
        ; NOTE: GNU AS doesn't have a direct 'format' or 'entry' like FASM.
        ; Those are handled by the linker (ld). This header sets up constants.
        fasm_header := Chr(10)
        fasm_header .= ".equ SYS_READ, 63" . Chr(10)
        fasm_header .= ".equ SYS_WRITE, 64" . Chr(10)
        fasm_header .= ".equ SYS_OPENAT, 56" . Chr(10)
        fasm_header .= ".equ SYS_CLOSE, 57" . Chr(10)
        fasm_header .= ".equ SYS_MMAP, 222" . Chr(10)
        fasm_header .= ".equ SYS_MUNMAP, 215" . Chr(10)
        fasm_header .= ".equ SYS_EXIT, 93" . Chr(10)
        fasm_header .= ".equ SYS_NANOSLEEP, 101" . Chr(10)
        fasm_header .= ".equ SYS_UNLINKAT, 35" . Chr(10)
        fasm_header .= Chr(10)
        fasm_header .= ".equ AT_FDCWD, -100" . Chr(10)
        fasm_header .= ".equ O_RDONLY, 0" . Chr(10)
        fasm_header .= ".equ O_CREAT_WRONLY_TRUNC, 0101 | 01000 | 0100" . Chr(10)
        fasm_header .= ".equ PROT_READ_WRITE, 0x1 | 0x2" . Chr(10)
        fasm_header .= ".equ MAP_PRIVATE_ANONYMOUS, 0x20 | 0x02" . Chr(10)
        fasm_header .= Chr(10)
        fasm_header .= ".global _start" . Chr(10)
        fasm_header .= Chr(10)
        ; --- GNU AS STRUCTURE DEFINITION (using .equ) ---
        fasm_header .= ".equ DynamicArray_pointer, 0" . Chr(10)
        fasm_header .= ".equ DynamicArray_size, 8" . Chr(10)
        fasm_header .= ".equ DynamicArray_capacity, 16" . Chr(10)
        fasm_header .= ".equ INITIAL_CAPACITY, 4" . Chr(10)
    }
    else {
        ; --- THIS IS YOUR EXISTING x86 CODE, UNCHANGED ---
        if (isDotCompile = 1) {
            fasm_header := "format ELF64" . Chr(10)
            fasm_header .= "public _start" . Chr(10)
        }
        else {
            if (ring0 = 0) {
                fasm_header := "format ELF64 executable 3" . Chr(10)
                fasm_header .= "entry _start" . Chr(10)
            }
            else {
                fasm_header := "use64" . Chr(10)
                fasm_header .= "org 0x9400" . Chr(10)
                fasm_header .= "jmp _start" . Chr(10)
            }
        }
        if (isDotCompile = 1) {
            fasm_header .= "extrn compiler_c" . Chr(10)
            fasm_header .= "extrn free_string_c" . Chr(10)
        }
        fasm_header .= Chr(10)
        ; --- FASM STRUCTURE DEFINITION ---
        fasm_header .= "    DynamicArray.pointer  = 0" . Chr(10) . "    DynamicArray.size     = 8" . Chr(10) . "    DynamicArray.capacity = 16" . Chr(10) . "    sizeof.DynamicArray   = 24" . Chr(10) . Chr(10)
    }
    }
    
    ; Use simple section names WITH the correct ELF flags for object files.
    str upCode := ""
    ; --- FASM BODY ---
    if (is_oryx = 0) {
    if (is_arm = 1) {
        ; --- ARM GNU AS SECTIONS & DATA ---
        upCode := ".data" . Chr(10)
        upCode .= "SCALE_FACTOR:      .quad 1000000" . Chr(10)
        upCode .= "HTLL_dot:               .string " . Chr(34) . "." . Chr(34) . Chr(10)
        upCode .= "HTLL_minus_sign:        .string " . Chr(34) . "-" . Chr(34) . Chr(10)
        upCode .= "HTLL_nl:                .string " . Chr(34) . "\n" . Chr(34) . Chr(10)
        upCode .= dot_data
        upCode .= Chr(10) . ".bss" . Chr(10)
        upCode .= ".lcomm HTLL_input_buffer, 256" . Chr(10)
        upCode .= ".lcomm HTLL_file_read_buffer, 4096" . Chr(10)
        upCode .= ".lcomm filename_ptr_size, 8" . Chr(10)
        upCode .= ".lcomm source_ptr, 8" . Chr(10)
        upCode .= ".lcomm source_ptr_size, 8" . Chr(10)
        upCode .= ".lcomm args_array, 24" . Chr(10)
        upCode .= ".lcomm filename_ptr, 8" . Chr(10)
        upCode .= ".lcomm asm_code_ptr, 8" . Chr(10)
        upCode .= arrBss . dot_bss
        upCode .= Chr(10) . ".text" . Chr(10)
        upCode .= HTLL_Libs_x86_new
    }
    else {
        if (isDotCompile = 1) {
            upCode := "section '.data' writeable" . Chr(10) . "    SCALE_FACTOR   dq 1000000" . Chr(10) . "    INITIAL_CAPACITY = 2" . Chr(10) . "    print_buffer   rb 21" . Chr(10) . "    dot            db " . Chr(39) . "." . Chr(39) . Chr(10) . "    minus_sign     db " . Chr(39) . "-" . Chr(39) . " " . Chr(10) . "    nl   db 10" . Chr(10) . dot_data . Chr(10)
            upCode .= "section '.bss' writeable" . Chr(10) . "    input_buffer rb 256" . Chr(10) . "    file_read_buffer rb 4096" . Chr(10) . "    input_len    rq 1" . Chr(10) . "    filename_ptr_size  rq 1" . Chr(10) . "    source_ptr      rq 1" . Chr(10) . "    source_ptr_size rq 1" . Chr(10) . "    args_array rq 3" . Chr(10) . "    filename_ptr      rq 1" . Chr(10) . "    asm_code_ptr    rq 1" . Chr(10) . "    print_buffer_n rb 20" . Chr(10) . arrBss . dot_bss
            upCode .= "section '.text' executable" . Chr(10) . HTLL_Libs_x86_new . Chr(10)
        }
        else {
            if (ring0 = 0) {
                upCode := "segment readable writeable" . Chr(10) . "    SCALE_FACTOR   dq 1000000" . Chr(10) . "    INITIAL_CAPACITY = 2" . Chr(10) . "    print_buffer   rb 21" . Chr(10) . "    dot            db " . Chr(39) . "." . Chr(39) . "" . Chr(10) . "    minus_sign     db " . Chr(39) . "-" . Chr(39) . "" . Chr(10) . "    nl   db 10" . Chr(10) . dot_data . Chr(10)
                upCode .= Chr(10) . Chr(10) . "    input_buffer rb 256" . Chr(10) . "    file_read_buffer rb 4096" . Chr(10) . "    input_len    rq 1" . Chr(10) . "    filename_ptr_size  rq 1" . Chr(10) . "    source_ptr      rq 1" . Chr(10) . "    source_ptr_size rq 1" . Chr(10) . "    args_array rq 3" . Chr(10) . "    filename_ptr      rq 1" . Chr(10) . "    asm_code_ptr    rq 1" . Chr(10) . "    print_buffer_n rb 20" . Chr(10) . arrBss . dot_bss
                upCode .= "segment readable executable" . Chr(10) . HTLL_Libs_x86_new . Chr(10)
            }
            else {
                upCode := Chr(10) . "    SCALE_FACTOR   dq 1000000" . Chr(10) . "    INITIAL_CAPACITY = 2" . Chr(10) . "    print_buffer   rb 21" . Chr(10) . "    dot            db " . Chr(39) . "." . Chr(39) . "" . Chr(10) . "    minus_sign     db " . Chr(39) . "-" . Chr(39) . "" . Chr(10) . "    nl   db 10" . Chr(10) . dot_data . Chr(10)
                upCode .= Chr(10) . Chr(10) . "    input_buffer rb 256" . Chr(10) . "    file_read_buffer rb 4096" . Chr(10) . "    input_len    rq 1" . Chr(10) . "    filename_ptr_size  rq 1" . Chr(10) . "    source_ptr      rq 1" . Chr(10) . "    source_ptr_size rq 1" . Chr(10) . "    args_array rq 3" . Chr(10) . "    filename_ptr      rq 1" . Chr(10) . "    asm_code_ptr    rq 1" . Chr(10) . "    print_buffer_n rb 20" . Chr(10) . arrBss . dot_bss . Chr(10) . "; Global variables for the 64-bit Runtime" . Chr(10) . "cursor_x dq 0" . Chr(10) . "cursor_y dq 0" . Chr(10) . "heap_ptr dq 0x40000" . Chr(10) . "; Minimal Scancode Map (QWERTY) - You can expand this" . Chr(10) . "scan_map:" . Chr(10) . "db 0,27,'1','2','3','4','5','6','7','8','9','0','-','=',8,9" . Chr(10) . "db 'q','w','e','r','t','y','u','i','o','p','[',']',10,0,'a','s'" . Chr(10) . "db 'd','f','g','h','j','k','l',';',39,'" . Chr(96) . "',0,'\','z','x','c','v'" . Chr(10) . "db 'b','n','m',',','.','/',0,'*',0,32" . Chr(10) . "align 16" . Chr(10) . "video_buffer: rb 4000" . Chr(10)
                upCode .= Chr(10) . HTLL_Libs_x86_new . Chr(10)
            }
        }
    }
    }
    ; --- FASM FOOTER ---
    str downCode := ""
    if (is_oryx = 0) {
    if (is_arm = 1) {
        ; --- ARM AArch64 EXIT SEQUENCE ---
        ; NOTE: Your generated 'main' or other user code will go before this.
        ; The _start label needs to wrap your main program logic.
        downCode .= Chr(10) . "    mov x0, #0" . Chr(10)
        downCode .= "    mov x8, #SYS_EXIT" . Chr(10)
        downCode .= "    svc #0" . Chr(10)
    }
    else {
        ; --- THIS IS YOUR EXISTING x86 CODE, UNCHANGED ---
        if (ring0 = 0) {
            downCode .= Chr(10) . "    mov rsp, rbp" . Chr(10) . "    pop rbp" . Chr(10) . "    mov rax, 60" . Chr(10) . "    xor rdi, rdi" . Chr(10) . "    syscall" . Chr(10) . ""
        }
        else {
            downCode .= Chr(10) . "mov rsp, rbp" . Chr(10) . "pop rbp" . Chr(10) . "jmp .program_end" . Chr(10) . ".program_end:" . Chr(10) . "jmp $" . Chr(10)
        }
    }
    }
    ; --- ASSEMBLE THE FINAL STRING ---
    str codeOUT := ""
    if (seenMain = 0) {
        ; The 'main_syntax' variable will also need an 'if (is_arm)' block
        ; to generate the correct function prologue for the target architecture.
        codeOUT := Chr(10) . fasm_header . Chr(10) . upCode . Chr(10) . main_syntax . Chr(10) . code . Chr(10) . downCode . Chr(10)
    }
    else {
        ; The 'out' variable is the user's code. This must be generated as ARM or x86
        ; based on the 'is_arm' flag *before* this assembly stage.
        codeOUT := Chr(10) . fasm_header . Chr(10) . upCode . Chr(10) . code . Chr(10) . downCode . Chr(10)
    }
    codeOUT := StrReplace(codeOUT, " [rax]", " rax")
    ;;;;;;;;;;;;;;;;;;;;;;;;;;
    Loop, % theIdNumOfThe34 {
        if (theIdNumOfThe34 = A_Index + 1) {
            codeOUT := StrReplace(codeOUT, "VYIGUOYIYVIUCFCYIUCFCYIGCYGICFHYFHCTCFTFDFGYGFC" . Chr(65) . Chr(65) . STR(A_Index + 1) . Chr(65) . Chr(65), StrReplace(theIdNumOfThe34theVar[A_Index + 1], keyWordEscpaeChar, "\") . Chr(34))
        }
        else {
            codeOUT := StrReplace(codeOUT, "VYIGUOYIYVIUCFCYIUCFCYIGCYGICFHYFHCTCFTFDFGYGFC" . Chr(65) . Chr(65) . STR(A_Index + 1) . Chr(65) . Chr(65), StrReplace(theIdNumOfThe34theVar[A_Index + 1], keyWordEscpaeChar, "\"))
        }
    }
    int is_1_optimize := 0
    int is_2_optimize := 0
    int is_3_optimize := 0
    int is_4_optimize := 0
    int is_5_optimize := 0
    int is_6_optimize := 0
    int is_7_optimize := 0
    int is_8_optimize := 0
    int is_9_optimize := 0
    int is_10_optimize := 0
    int is_11_optimize := 0
    int is_12_optimize := 0
    int is_13_optimize := 0
    int is_14_optimize := 0
    int is_15_optimize := 0
    int is_16_optimize := 0
    int is_17_optimize := 0
    int is_18_optimize := 0
    int is_19_optimize := 0
    int is_20_optimize := 0
    int is_21_optimize := 0
    int is_22_optimize := 0
    int is_in_under := 0
    str allInOne_temp := ""
    int aredy_int := 0
    
    if (is_arm = 0) and (is_oryx = 0) {
    
    Loop, Parse, codeOUT, `n, `r {
        if (SubStr(Trim(A_LoopField), 1, 2) != "; ") {
            allInOne_temp .= Trim(A_LoopField) . Chr(10)
            ; Ignore definitions so they don't count as usage
            if (InStr(A_LoopField, " db ") = 0) and (InStr(A_LoopField, " rb ") = 0) and (InStr(A_LoopField, " rq ") = 0) and (InStr(A_LoopField, " dq ") = 0) and (InStr(A_LoopField, " = ") = 0) {
                ; CHANGED ALL "else if" TO "if" TO PREVENT OVERLAPPING REGEX BUGS
                if (RegExMatch(A_LoopField, "\bDynamicArray.pointer\b")) {
                    is_1_optimize := 1
                }
                if (RegExMatch(A_LoopField, "\bDynamicArray.size\b")) {
                    is_2_optimize := 1
                }
                if (RegExMatch(A_LoopField, "\bDynamicArray.capacity\b")) {
                    is_3_optimize := 1
                }
                if (RegExMatch(A_LoopField, "\bsizeof.DynamicArray\b")) {
                    is_4_optimize := 1
                }
                if (RegExMatch(A_LoopField, "\bSCALE" . Chr(95) . "FACTOR\b")) {
                    is_5_optimize := 1
                }
                if (RegExMatch(A_LoopField, "\bINITIAL" . Chr(95) . "CAPACITY\b")) {
                    is_6_optimize := 1
                }
                if (RegExMatch(A_LoopField, "\bprint" . Chr(95) . "buffer\b")) {
                    is_7_optimize := 1
                }
                if (RegExMatch(A_LoopField, "\bdot\b")) {
                    is_8_optimize := 1
                }
                if (RegExMatch(A_LoopField, "\bminus" . Chr(95) . "sign\b")) {
                    is_9_optimize := 1
                }
                if (RegExMatch(A_LoopField, "\b" . Chr(110) . Chr(108) . "\b")) {
                    is_10_optimize := 1
                }
                if (RegExMatch(A_LoopField, "\binput" . Chr(95) . "buffer\b")) {
                    is_11_optimize := 1
                }
                if (RegExMatch(A_LoopField, "\bfile" . Chr(95) . "read" . Chr(95) . "buffer\b")) {
                    is_12_optimize := 1
                }
                if (RegExMatch(A_LoopField, "\binput" . Chr(95) . "len\b")) {
                    is_13_optimize := 1
                }
                if (RegExMatch(A_LoopField, "\bfilename" . Chr(95) . "ptr" . Chr(95) . "size\b")) {
                    is_14_optimize := 1
                }
                ; FIXED REGEX FOR SOURCE_PTR (is_15)
                if (RegExMatch(A_LoopField, "\bsource" . Chr(95) . "ptr\b")) {
                    is_15_optimize := 1
                }
                if (RegExMatch(A_LoopField, "\bsource" . Chr(95) . "ptr" . Chr(95) . "size\b")) {
                    is_16_optimize := 1
                }
                if (RegExMatch(A_LoopField, "\bargs" . Chr(95) . "array\b")) {
                    is_17_optimize := 1
                }
                if (RegExMatch(A_LoopField, "\bfilename" . Chr(95) . "ptr\b")) {
                    is_18_optimize := 1
                }
                if (RegExMatch(A_LoopField, "\basm" . Chr(95) . "code" . Chr(95) . "ptr\b")) {
                    is_19_optimize := 1
                }
                if (RegExMatch(A_LoopField, "\bprint" . Chr(95) . "buffer" . Chr(95) . "n\b")) {
                    is_20_optimize := 1
                }
            }
        }
    }
    codeOUT := Trim(allInOne_temp)
    allInOne_temp := ""
    aredy_int := 0

    Loop, Parse, codeOUT, `n, `r {
        aredy_int := 0
        if (Trim(A_LoopField) = "DynamicArray.pointer  = 0") and (is_1_optimize = 0) {
            aredy_int := 1
        }
        else if (Trim(A_LoopField) = "DynamicArray.size     = 8") and (is_2_optimize = 0) {
            aredy_int := 1
        }
        else if (Trim(A_LoopField) = "DynamicArray.capacity = 16") and (is_3_optimize = 0) {
            aredy_int := 1
        }
        else if (Trim(A_LoopField) = "sizeof.DynamicArray   = 24") and (is_4_optimize = 0) {
            aredy_int := 1
        }
        else if (Trim(A_LoopField) = "SCALE_FACTOR   dq 1000000") and (is_5_optimize = 0) {
            aredy_int := 1
        }
        else if (Trim(A_LoopField) = "INITIAL_CAPACITY = 2") and (is_6_optimize = 0) {
            aredy_int := 1
        }
        else if (Trim(A_LoopField) = "print_buffer   rb 21") and (is_7_optimize = 0) {
            aredy_int := 1
        }
        else if (Trim(A_LoopField) = "dot            db " . Chr(39) . "." . Chr(39) . "") and (is_8_optimize = 0) {
            aredy_int := 1
        }
        else if (Trim(A_LoopField) = "minus_sign     db " . Chr(39) . Chr(45) . Chr(39)) and (is_9_optimize = 0) {
            aredy_int := 1
        }
        else if (Trim(A_LoopField) = Chr(110) . Chr(108) . "   db 10") and (is_10_optimize = 0) {
            aredy_int := 1
        }
        else if (Trim(A_LoopField) = "input_buffer rb 256") and (is_11_optimize = 0) {
            aredy_int := 1
        }
        else if (Trim(A_LoopField) = "file_read_buffer rb 4096") and (is_12_optimize = 0) {
            aredy_int := 1
        }
        else if (Trim(A_LoopField) = "input_len    rq 1") and (is_13_optimize = 0) {
            aredy_int := 1
        }
        else if (Trim(A_LoopField) = "filename_ptr_size  rq 1") and (is_14_optimize = 0) {
            aredy_int := 1
        }
        else if (Trim(A_LoopField) = "source_ptr      rq 1") and (is_15_optimize = 0) {
            aredy_int := 1
        }
        else if (Trim(A_LoopField) = "source_ptr_size rq 1") and (is_16_optimize = 0) {
            aredy_int := 1
        }
        else if (Trim(A_LoopField) = "args_array rq 3") and (is_17_optimize = 0) {
            aredy_int := 1
        }
        else if (Trim(A_LoopField) = "filename_ptr      rq 1") and (is_18_optimize = 0) {
            aredy_int := 1
        }
        else if (Trim(A_LoopField) = "asm_code_ptr    rq 1") and (is_19_optimize = 0) {
            aredy_int := 1
        }
        else if (Trim(A_LoopField) = "print_buffer_n rb 20") and (is_20_optimize = 0) {
            aredy_int := 1
        }
        if (aredy_int = 0) {
            allInOne_temp .= A_LoopField . Chr(10)
        }
    }
    codeOUT := Trim(allInOne_temp)
    
    
    }
    return codeOUT
}
main
str params := Trim(GetParams())
str paramsTemp := ""
str paramsTemp_fileName := ""
if (params = "") {
    print("Usage:" . Chr(10) . "./HTLL your_file.htll <target>" . Chr(10) . "Targets: x86-64, arm, oryx, x86-64-ring0")
}
else if (InStr(params, Chr(10)) = false) {
    print("Usage:" . Chr(10) . "./HTLL your_file.htll <target>" . Chr(10) . "Targets: x86-64, arm, oryx, x86-64-ring0")
}
else {
    Loop, Parse, params, `n, `r {
        paramsTemp := Trim(A_LoopField)
        if (A_Index = 0) {
            paramsTemp_fileName := Trim(StringTrimRight(paramsTemp, 5))          
        }
        if (A_Index = 1) {
            if (paramsTemp = "x86-64") {
                is_arm := 0
                is_oryx := 0
                ring0 := 0
                FileDelete(paramsTemp_fileName . ".s")
                FileAppend(compiler(FileRead(paramsTemp_fileName . ".htll")), paramsTemp_fileName . ".s")
                print("Compilation finished: " . paramsTemp_fileName . ".s generated.")
            }
            else if (paramsTemp = "arm") {
                is_arm := 1
                is_oryx := 0
                ring0 := 0
                FileDelete(paramsTemp_fileName . ".s")
                FileAppend(compiler(FileRead(paramsTemp_fileName . ".htll")), paramsTemp_fileName . ".s")
                print("Compilation finished: " . paramsTemp_fileName . ".s generated.")
            }
            else if (paramsTemp = "oryx") {
                is_arm := 0
                is_oryx := 1
                ring0 := 0
                FileDelete(paramsTemp_fileName . ".oryxir")
                FileAppend(compiler(FileRead(paramsTemp_fileName . ".htll")), paramsTemp_fileName . ".oryxir")
                print("Compilation finished: " . paramsTemp_fileName . ".oryxir generated.")
            }
            else if (paramsTemp = "x86-64-ring0") {
                is_arm := 0
                is_oryx := 0
                ring0 := 1
                FileDelete(paramsTemp_fileName . ".s")
                FileAppend(compiler(FileRead(paramsTemp_fileName . ".htll")), paramsTemp_fileName . ".s")
                print("Compilation finished: " . paramsTemp_fileName . ".s generated.")
            } else {
                print("Usage:" . Chr(10) . "./HTLL your_file.htll <target>" . Chr(10) . "Targets: x86-64, arm, oryx, x86-64-ring0")
            }
        }
    }
}