diff --git a/CHANGELOG.org b/CHANGELOG.org
index 022f199..e4d9c91 100644
--- a/CHANGELOG.org
+++ b/CHANGELOG.org
@@ -21,6 +21,7 @@
Tweaked cc_types.c to better match amd64 assembly
Replaced out with output_list in cc_core.c
For 32bit behavior on 64bit platforms
+Replaced generated seed with hand written seed in M1
** Fixed
diff --git a/README.md b/README.md
index 3c64dec..d1efd38 100644
--- a/README.md
+++ b/README.md
@@ -5,3 +5,12 @@ with introspective steps inbetween.
A lovely set of examples of M2-Planet programs are in tests but the most
surprising part of all M2-Planet can self-host M2-Planet.
+
+Further more M2-Planet is cross-platform and self-hosting across platforms
+with fully deterministic builds enabling prefect reproducibility.
+
+To bootstrap from assembly simple run ./bootstrap-x86.sh after cd into the
+bootstrap directory (the only requirement is mescc-tools to be installed)
+
+Or if you have no binaries to bootstrap from please use mescc-tools-seed;
+which will not only bootstrap mescc-tools but also M2-Planet
\ No newline at end of file
diff --git a/bootstrap.sh b/bootstrap.sh
deleted file mode 100755
index a7c8992..0000000
--- a/bootstrap.sh
+++ /dev/null
@@ -1,107 +0,0 @@
-#! /usr/bin/env bash
-## Copyright (C) 2017 Jeremiah Orians
-## This file is part of M2-Planet.
-##
-## M2-Planet is free software: you can redistribute it and/or modify
-## it under the terms of the GNU General Public License as published by
-## the Free Software Foundation, either version 3 of the License, or
-## (at your option) any later version.
-##
-## M2-Planet is distributed in the hope that it will be useful,
-## but WITHOUT ANY WARRANTY; without even the implied warranty of
-## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-## GNU General Public License for more details.
-##
-## You should have received a copy of the GNU General Public License
-## along with M2-Planet. If not, see .
-
-set -eux
-stage0_PREFIX=${stage0_PREFIX-../stage0}
-
-[ -e bin/M2-Planet ] && rm bin/M2-Planet
-
-# Refresh stage0's M2-Planet_x86.c
-# To execute this block ./bootstrap.sh refresh
-if [ "refresh" = "${1-NOPE}" ]
-then
-# Create header to prevent confusion
-{
-cat <<-EOF
-## This file was generated by running:
-## cat functions/file.c functions/malloc.c functions/calloc.c functions/exit.c functions/match.c -f functions/in_set.c functions/numerate_number.c functions/file_print.c functions/string.c cc.h cc_reader.c cc_strings.c cc_types.c cc_core.c cc.c >| ../stage0/stage3/M2-Planet_x86.c
-## inside M2-Planet's repo
-
-EOF
-} >| header
-
-# Update the C code in stage0's x86 bootstrap
-cat header \
- functions/file.c \
- functions/malloc.c \
- functions/calloc.c \
- functions/exit.c \
- functions/match.c \
- functions/in_set.c \
- functions/numerate_number.c \
- functions/file_print.c \
- functions/string.c \
- cc.h \
- cc_reader.c \
- cc_strings.c \
- cc_types.c \
- cc_core.c \
- cc.c >| $stage0_PREFIX/stage3/M2-Planet_x86.c
-
-# Clean up temp header
-rm header
-
-{
-# Create header to prevent confusion
-cat <<-EOF
-# This file was generated by running:
-# ./bin/vm --rom roms/cc_x86 --memory 4M --tape_01 stage3/M2-Planet_x86.c --tape_02 ../M2-Planet/seed.M1
-# In stage0
-EOF
-} >| preseed1
-
-# Create the seed
-$stage0_PREFIX/bin/vm --rom $stage0_PREFIX/roms/cc_x86 \
- --memory 4M \
- --tape_01 $stage0_PREFIX/stage3/M2-Planet_x86.c \
- --tape_02 preseed2
-
-# Combine to final seed
-cat preseed1 preseed2 >| seed.M1
-
-# Cleanup preseed values
-rm preseed1 preseed2
-fi
-
-
-# Make the required bin directry
-[ -d bin ] || mkdir bin
-
-# Build debug footer
-blood-elf -f seed.M1 \
- -o bin/seed-footer.M1 || exit 1
-
-# Macro assemble with libc written in M1-Macro
-M1 -f test/common_x86/x86_defs.M1 \
- -f test/common_x86/libc-core.M1 \
- -f seed.M1 \
- -f bin/seed-footer.M1 \
- --LittleEndian \
- --architecture x86 \
- -o bin/seed.hex2 || exit 2
-
-# Resolve all linkages
-hex2 -f test/common_x86/ELF-i386-debug.hex2 \
- -f bin/seed.hex2 \
- --LittleEndian \
- --architecture x86 \
- --BaseAddress 0x8048000 \
- -o bin/M2-Planet-seed \
- --exec_enable || exit 2
-
-# self-host
-./test/test100/hello.sh
diff --git a/bootstrap/.gitignore b/bootstrap/.gitignore
new file mode 100644
index 0000000..082c2c4
--- /dev/null
+++ b/bootstrap/.gitignore
@@ -0,0 +1,6 @@
+M2.M1
+M2.hex2
+cc_x86
+hold
+seed.hex2
+
diff --git a/bootstrap/bootstrap-x86.sh b/bootstrap/bootstrap-x86.sh
new file mode 100755
index 0000000..68e6d57
--- /dev/null
+++ b/bootstrap/bootstrap-x86.sh
@@ -0,0 +1,71 @@
+#! /usr/bin/env bash
+## Copyright (C) 2017 Jeremiah Orians
+## This file is part of M2-Planet.
+##
+## M2-Planet is free software: you can redistribute it and/or modify
+## it under the terms of the GNU General Public License as published by
+## the Free Software Foundation, either version 3 of the License, or
+## (at your option) any later version.
+##
+## M2-Planet is distributed in the hope that it will be useful,
+## but WITHOUT ANY WARRANTY; without even the implied warranty of
+## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+## GNU General Public License for more details.
+##
+## You should have received a copy of the GNU General Public License
+## along with M2-Planet. If not, see .
+
+set -eux
+[ -e ../bin/M2-Planet ] && rm ../bin/M2-Planet
+
+# Make the required bin directry
+[ -d ../bin ] || mkdir ../bin
+
+# Macro assemble with libc written in M1-Macro
+M1 -f x86/cc_x86.M1 \
+ --LittleEndian \
+ --architecture x86 \
+ -o seed.hex2 || exit 1
+
+# Resolve all linkages
+hex2 -f ../test/common_x86/ELF-i386.hex2 \
+ -f seed.hex2 \
+ --LittleEndian \
+ --architecture x86 \
+ --BaseAddress 0x8048000 \
+ -o cc_x86 \
+ --exec_enable || exit 2
+
+# Build M2-Planet from cc_x86
+catm hold ../test/common_x86/functions/file.c \
+ ../test/common_x86/functions/malloc.c \
+ ../functions/calloc.c \
+ ../test/common_x86/functions/exit.c \
+ ../functions/match.c \
+ ../functions/in_set.c \
+ ../functions/numerate_number.c \
+ ../functions/file_print.c \
+ ../functions/number_pack.c \
+ ../functions/fixup.c \
+ ../functions/string.c \
+ ../cc.h \
+ ../cc_reader.c \
+ ../cc_strings.c \
+ ../cc_types.c \
+ ../cc_core.c \
+ ../cc.c
+./cc_x86 hold M2.M1
+M1 --architecture x86 \
+ --LittleEndian \
+ -f ../test/common_x86/x86_defs.M1 \
+ -f ../test/common_x86/libc-core.M1 \
+ -f M2.M1 \
+ -o M2.hex2
+
+hex2 -f ../test/common_x86/ELF-i386.hex2 \
+ -f M2.hex2 \
+ --LittleEndian \
+ --architecture x86 \
+ --BaseAddress 0x8048000 \
+ -o ../bin/M2-Planet-seed \
+ --exec_enable
diff --git a/bootstrap/x86/cc_x86.M1 b/bootstrap/x86/cc_x86.M1
new file mode 100644
index 0000000..b725058
--- /dev/null
+++ b/bootstrap/x86/cc_x86.M1
@@ -0,0 +1,4974 @@
+;; Copyright (C) 2017 Jeremiah Orians
+;; This file is part of stage0.
+;;
+;; stage0 is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+;;
+;; stage0 is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+;; GNU General Public License for more details.
+;;
+;; You should have received a copy of the GNU General Public License
+;; along with stage0. If not, see .
+
+DEFINE ADDI8_EAX 83C0
+DEFINE ADDI8_EBX 83C3
+DEFINE ADDI8_ECX 83C1
+DEFINE ADDI8_EDX 83C2
+DEFINE ADDI8_ESI 83C6
+DEFINE ADD_eax_into_ebx 01C3
+DEFINE ADD_ebx_into_eax 01D8
+DEFINE ADD_ecx_into_eax 01C8
+DEFINE ADD_edi_into_ecx 01F9
+DEFINE AND_EAX_EBX 21D8
+DEFINE ANDI32_EAX 25
+DEFINE CALL_EAX FFD0
+DEFINE CALL32 E8
+DEFINE CMPI8_EAX 83F8
+DEFINE CMPI8_EBP 83fd
+DEFINE CMPI8_EBX 83FB
+DEFINE CMPI8_ECX 83F9
+DEFINE CMPI8_EDX 83FA
+DEFINE CMPI8_ESI 83FE
+DEFINE CMP_EAX_EBX 39D8
+DEFINE CMP_EAX_ECX 39C8
+DEFINE CMP_EBX_ECX 39D9
+DEFINE CMP_ECX_EBX 39CB
+DEFINE CMP_EDI_ESI 39FE
+DEFINE CMP_EBX_EDX 39D3
+DEFINE COPY_EAX_to_EBP 89C5
+DEFINE COPY_EAX_to_EBX 89C3
+DEFINE COPY_EAX_to_ECX 89C1
+DEFINE COPY_EAX_to_EDX 89C2
+DEFINE COPY_EAX_to_ESI 89C6
+DEFINE COPY_EBP_to_EAX 89E8
+DEFINE COPY_EBX_to_EAX 89D8
+DEFINE COPY_EBX_to_ECX 89D9
+DEFINE COPY_EBX_to_EDX 89DA
+DEFINE COPY_ECX_to_EAX 89C8
+DEFINE COPY_ECX_to_EBX 89CB
+DEFINE COPY_EDI_to_ESI 89FE
+DEFINE COPY_EDX_to_EAX 89D0
+DEFINE COPY_EDX_to_EBP 89D5
+DEFINE COPY_EDX_to_EBX 89D3
+DEFINE COPY_ESI_to_EAX 89F0
+DEFINE COPY_ESI_to_EDI 89F7
+DEFINE IDIV_EBX F7FB
+DEFINE IMUL_EAX_by_EBX 0FAFC3
+DEFINE IMULI8_EAX 6BC0
+DEFINE IMULI8_EBP 6BED
+DEFINE INT_80 CD80
+DEFINE JBE8 76
+DEFINE JE32 0F84
+DEFINE JG32 0F8F
+DEFINE JG8 7F
+DEFINE JL32 0F8C
+DEFINE JLE32 0F8E
+DEFINE JMP32 E9
+DEFINE JNE32 0F85
+DEFINE LEA32_ECX_from_esp 8D0C24
+DEFINE LOAD32_Absolute32_eax A1
+DEFINE LOAD32_Absolute32_ebx 8B1D
+DEFINE LOAD32_Absolute32_ecx 8B0D
+DEFINE LOAD32_EAX_from_EAX 8B00
+DEFINE LOAD32_EAX_from_EAX_Immediate8 8B40
+DEFINE LOAD32_EAX_from_EBP_Immediate8 8B45
+DEFINE LOAD32_EAX_from_EBX 8B03
+DEFINE LOAD32_EAX_from_EBX_Immediate8 8B43
+DEFINE LOAD32_EAX_from_ECX_Immediate8 8B41
+DEFINE LOAD32_EAX_from_EDX_Immediate8 8B42
+DEFINE LOAD32_EBP_from_EBP 8B6D00
+DEFINE LOAD32_EBX_from_EAX_Immediate8 8B58
+DEFINE LOAD32_EBX_from_EBX 8B1B
+DEFINE LOAD32_EBX_from_EBX_Immediate8 8B5B
+DEFINE LOAD32_EBX_from_ECX_Immediate8 8B59
+DEFINE LOAD32_ECX_from_EAX_Immediate8 8B48
+DEFINE LOAD32_ECX_from_EBX 8B0B
+DEFINE LOAD32_ECX_from_ECX 8B09
+DEFINE LOAD32_ECX_from_ECX_Immediate8 8B49
+DEFINE LOAD32_ECX_from_EDX_Immediate8 8B4A
+DEFINE LOAD32_EDI_from_EDX_Immediate8 8B7A
+DEFINE LOAD32_EDX_from_EDX_Immediate8 8B52
+DEFINE LOAD8_al_from_EAX 8A00
+DEFINE LOAD8_al_from_EBX 8A03
+DEFINE LOAD8_al_from_ECX 8A01
+DEFINE LOAD8_al_from_EDX 8A02
+DEFINE LOAD8_bl_from_EBX 8A1B
+DEFINE LOAD8_bl_from_ECX 8A19
+DEFINE LOAD8_bl_from_EDX 8A1A
+DEFINE LOAD8_cl_from_EBX 8A0B
+DEFINE LOAD8_cl_from_EBX_Immediate8 8A4B
+DEFINE LOADI32_EAX B8
+DEFINE LOADI32_EBX BB
+DEFINE LOADI32_ECX B9
+DEFINE LOADI32_EDI BF
+DEFINE LOADI32_EDX BA
+DEFINE LOADI32_ESI BE
+DEFINE MOVZX_al 0FB6C0
+DEFINE MOVZX_bl 0FB6DB
+DEFINE MOVZX_cl 0FB6C9
+DEFINE NULL 00000000
+DEFINE POP_EAX 58
+DEFINE POP_EBP 5D
+DEFINE POP_EBX 5B
+DEFINE POP_ECX 59
+DEFINE POP_EDI 5F
+DEFINE POP_EDX 5A
+DEFINE POP_ESI 5E
+DEFINE PUSH_EAX 50
+DEFINE PUSH_EBP 55
+DEFINE PUSH_EBX 53
+DEFINE PUSH_ECX 51
+DEFINE PUSH_EDI 57
+DEFINE PUSH_EDX 52
+DEFINE PUSH_ESI 56
+DEFINE RETURN C3
+DEFINE SALI8_EAX C1E0
+DEFINE SHRI8_EAX C1E8
+DEFINE SHRI8_EBX C1EB
+DEFINE STORE32_Absolute32_eax A3
+DEFINE STORE32_Absolute32_ebx 891D
+DEFINE STORE32_Absolute32_ecx 890D
+DEFINE STORE32_Absolute32_edx 8915
+DEFINE STORE32_EAX_into_EBP_Immediate8 8945
+DEFINE STORE32_EAX_into_EBX 8903
+DEFINE STORE32_EAX_into_ECX_Immediate8 8941
+DEFINE STORE32_EAX_into_EDX 8902
+DEFINE STORE32_EAX_into_EDX_Immediate8 8942
+DEFINE STORE32_EBP_into_EDX_Immediate8 896A
+DEFINE STORE32_EBX_into_EAX 8918
+DEFINE STORE32_EBX_into_EAX_Immediate8 8958
+DEFINE STORE32_EBX_into_EDX_Immediate8 895A
+DEFINE STORE32_ECX_into_EAX 8908
+DEFINE STORE32_ECX_into_EAX_Immediate8 8948
+DEFINE STORE32_ECX_into_EDX_Immediate8 894A
+DEFINE STORE32_EDX_into_EAX_Immediate8 8950
+DEFINE STORE32_EDX_into_EBP_Immediate8 8955
+DEFINE STORE32_ESI_into_EBP_Immedate8 8975
+DEFINE STORE32_ESI_into_EDX_Immedate8 8972
+DEFINE STORE8_al_into_Address_EBX 8803
+DEFINE STORE8_al_into_Address_ECX 8801
+DEFINE STORE8_al_into_Address_ESI 8806
+DEFINE STORE8_bl_into_Address_ECX 8819
+DEFINE SUBI8_EAX 83E8
+DEFINE SUBI8_ECX 83E9
+DEFINE SUBI8_ESI 83EE
+DEFINE SWAP_EAX_EBX 93
+
+
+ ;; Register usage:
+ ;; EAX => Temps
+
+ ;; Struct TYPE format: (size 28)
+ ;; NEXT => 0
+ ;; SIZE => 4
+ ;; OFFSET => 8
+ ;; INDIRECT => 12
+ ;; MEMBERS => 16
+ ;; TYPE => 20
+ ;; NAME => 24
+
+ ;; Struct TOKEN_LIST format: (size 20)
+ ;; NEXT => 0
+ ;; LOCALS/PREV => 4
+ ;; S => 8
+ ;; TYPE => 12
+ ;; ARGS/DEPTH => 16
+
+; Where the ELF Header is going to hit
+; Simply jump to _start
+; Our main function
+:_start
+ POP_EAX ;·Get·the·number·of·arguments
+ POP_EBX ;·Get·the·program·name
+ POP_EBX ;·Get·the·actual·input name
+ LOADI32_ECX %0 ;·prepare·read_only
+ LOADI32_EAX %5 ;·the·syscall·number·for·open()
+ INT_80 ; Now open that damn file
+ STORE32_Absolute32_eax &Input_file ; Preserve the file pointer we were given
+
+ POP_EBX ;·Get·the·actual·output name
+ LOADI32_ECX %577 ; Prepare file as O_WRONLY|O_CREAT|O_TRUNC
+ LOADI32_EDX %384 ; Prepare file as RW for owner only (600 in octal)
+ LOADI32_EAX %5 ;·the·syscall·number·for·open()
+ INT_80 ; Now open that damn file
+ CMPI8_EAX !0 ; Check for missing output
+ JG32 %_start_out ; Have real input
+ LOADI32_EAX %1 ; Use stdout
+
+:_start_out
+ STORE32_Absolute32_eax &Output_file ; Preserve the file pointer we were given
+
+ LOADI32_EAX %45 ; the Syscall # for SYS_BRK
+ LOADI32_EBX %0 ; Get current brk
+ INT_80 ; Let the kernel do the work
+ STORE32_Absolute32_eax &MALLOC ; Set our malloc pointer
+ LOADI32_EAX %0 ; HEAD = NULL
+ CALL32 %read_all_tokens ; Read all tokens
+ CALL32 %Reverse_List ; Reverse order
+; CALL32 %debug_list ; Try to figure out what is wrong
+ STORE32_Absolute32_eax &global_token ; Set global_token
+ CALL32 %program ; Convert into program
+ LOADI32_EAX &header_string1 ; Our header string
+ CALL32 %File_Print ; Print it
+ LOAD32_Absolute32_eax &output_list ; Our output_list
+ CALL32 %recursive_output ; Print core program
+; LOADI32_EAX &header_string2 ; Our Enable debug
+; CALL32 %File_Print ; Print it
+ LOADI32_EAX &header_string3 ; Our second label
+ CALL32 %File_Print ; Print it
+ LOAD32_Absolute32_eax &globals_list ; Our globals
+ CALL32 %recursive_output ; Get them
+ LOADI32_EAX &header_string4 ; Our final header
+ CALL32 %File_Print ; Print it
+ LOAD32_Absolute32_eax &strings_list ; Our strings
+ CALL32 %recursive_output ; Get them
+ LOADI32_EAX &header_string5 ; Make this a bare assembly
+ CALL32 %File_Print ; Print it
+
+:Done
+ ; program completed Successfully
+ LOADI32_EBX %0 ; All is well
+ LOADI32_EAX %1 ; put the exit syscall number in eax
+ INT_80 ; Call it a good day
+
+:header_string1 "
+# Core program
+"
+:header_string2 "
+:ELF_data
+"
+:header_string3 "
+# Program global variables
+"
+:header_string4 "
+# Program strings
+"
+:header_string5 "
+:ELF_end
+"
+
+
+;; read_all_tokens function
+;; Recieves Token_List* in EAX
+;; Tokenizes all input and returns updated list in EAX
+;; Returns TOKEN in EAX
+;; Uses EAX for C
+:read_all_tokens
+ STORE32_Absolute32_eax &Token
+ CALL32 %fgetc
+:read_all_tokens_loop
+ CMPI8_EAX !-4 ; Check for EOF
+ JE32 %read_all_tokens_done ; Stop if found
+ CALL32 %get_token ; Read all tokens
+ JMP32 %read_all_tokens_loop ; Loop
+:read_all_tokens_done
+ LOAD32_Absolute32_eax &Token
+ RETURN
+
+
+;; get_token function
+;; Recieves INT in EAX
+;; Makes a list of TOKEN_LIST
+;; C and STRING_INDEX are stored in memory, ECX is used for S and EDX is used for current
+;; Returns C in EAX
+:get_token
+ PUSH_EBX ; Protect EBX
+ PUSH_ECX ; Protect ECX
+ PUSH_EDX ; Protect EDX
+
+ STORE32_Absolute32_eax &C ; Set C
+
+ LOADI32_EAX %20 ; Malloc CURRENT
+ CALL32 %malloc ; Get Pointer
+ COPY_EAX_to_EDX ; Set CURRENT
+
+ LOADI32_EAX %256 ; Malloc the string
+ CALL32 %malloc ; Get pointer to S
+ COPY_EAX_to_ECX ; Set S
+ STORE32_ECX_into_EDX_Immediate8 !8 ; CURRENT->S = S
+:reset
+ STORE32_Absolute32_ecx &string_index ; S[0]
+ LOAD32_Absolute32_eax &C ; Using C
+
+ CALL32 %clear_white_space ; Clear WhiteSpace
+ STORE32_Absolute32_eax &C ; Set C
+
+ CMPI8_EAX !-4 ; Check for EOF
+ JE32 %get_token_abort ; if EOF abort
+
+ CMPI8_EAX !35 ; Check for '#'
+ JNE32 %get_token_alpha ; Nope
+
+ ;; Deal with # line comments
+ CALL32 %purge_macro ; Let it handle it
+ STORE32_Absolute32_eax &C ; Set C
+ JMP32 %reset ; Try again
+
+:get_token_alpha
+ LOAD32_Absolute32_eax &C ; Send C
+ LOADI32_EBX &alphas ; Get alphanumerics
+ CALL32 %In_Set ; See if in set
+ CMPI8_EAX !1 ; IF TRUE
+ JNE32 %get_token_symbol ; Otherwise
+
+ ;; Store keywords
+ LOAD32_Absolute32_eax &C ; Send C
+ CALL32 %preserve_keyword ; Store
+ STORE32_Absolute32_eax &C ; Set C
+ JMP32 %get_token_done ; Be done with this token
+
+:get_token_symbol
+ LOAD32_Absolute32_eax &C ; Send C
+ LOADI32_EBX &symbols ; Get symbols
+ CALL32 %In_Set ; See if in set
+ CMPI8_EAX !1 ; IF TRUE
+ JNE32 %get_token_strings ; Otherwise
+
+ ;; Store symbols
+ LOAD32_Absolute32_eax &C ; Send C
+ CALL32 %preserve_symbol ; Store
+ STORE32_Absolute32_eax &C ; Set C
+ JMP32 %get_token_done ; Be done with this token
+
+:get_token_strings
+ LOAD32_Absolute32_eax &C ; Send C
+ LOADI32_EBX &strings ; Get symbols
+ CALL32 %In_Set ; See if in set
+ CMPI8_EAX !1 ; IF TRUE
+ JNE32 %get_token_comment ; Otherwise
+
+ ;; Store String
+ LOAD32_Absolute32_eax &C ; Send C
+ CALL32 %consume_word ; Store
+ STORE32_Absolute32_eax &C ; Set C
+ JMP32 %get_token_done ; Be done with this token
+
+:get_token_comment
+ LOAD32_Absolute32_eax &C ; Send C
+ CMPI8_EAX !47 ; IF '/' == C
+ JNE32 %get_token_else ; Otherwise
+
+ CALL32 %consume_byte ; Hope it just is '/'
+ STORE32_Absolute32_eax &C ; Set C
+
+ CMPI8_EAX !42 ; IF '*' we have '/*'
+ JNE32 %get_token_comment_line ; Check for '//'
+
+ ;; Deal with /* block comments */
+ CALL32 %fgetc ; get next C
+ STORE32_Absolute32_eax &C ; Set C
+:get_token_comment_block_outer
+ LOAD32_Absolute32_eax &C ; Using C
+ CMPI8_EAX !47 ; IF '/' != C
+ JE32 %get_token_comment_block_done ; be done
+
+:get_token_comment_block_inner
+ LOAD32_Absolute32_eax &C ; Using C
+ CMPI8_EAX !42 ; IF '*' != C
+ JE32 %get_token_comment_block_iter ; jump over
+
+ ;; Deal with inner loop
+ CALL32 %fgetc ; get next C
+ STORE32_Absolute32_eax &C ; Set C
+ JMP32 %get_token_comment_block_inner ; keep going
+
+:get_token_comment_block_iter
+ CALL32 %fgetc ; get next C
+ STORE32_Absolute32_eax &C ; Set C
+ JMP32 %get_token_comment_block_outer
+
+:get_token_comment_block_done
+ CALL32 %fgetc ; get next C
+ STORE32_Absolute32_eax &C ; Set C
+ JMP32 %reset ; throw away, try again
+
+:get_token_comment_line
+ CMPI8_EAX !47 ; IF '/' we have //
+ JNE32 %get_token_done ; keep if just '/'
+
+ ;; Deal with // line comment
+ CALL32 %fgetc ; drop to match
+ STORE32_Absolute32_eax &C ; Set C
+ JMP32 %reset ; throw away, try again
+
+:get_token_else
+ LOAD32_Absolute32_eax &C ; Send C
+ CALL32 %consume_byte
+ STORE32_Absolute32_eax &C ; Set C
+
+:get_token_done
+ LOAD32_Absolute32_eax &Token ; TOKEN
+ STORE32_EAX_into_EDX_Immediate8 !4 ; CURRENT->PREV = TOKEN
+ STORE32_EAX_into_EDX ; CURRENT->NEXT = TOKEN
+ STORE32_Absolute32_edx &Token ; TOKEN = CURRENT
+
+:get_token_abort
+ POP_EDX ; Restore EDX
+ POP_ECX ; Restore ECX
+ POP_EBX ; Restore EBX
+ LOAD32_Absolute32_eax &C ; Return C
+ RETURN
+
+
+;; Malloc isn't actually required if the program being built fits in the initial memory
+;; However, it doesn't take much to add it.
+;; Requires [MALLOC] to be initialized and EAX to have the number of desired bytes
+:malloc
+ PUSH_EBX ; Protect EBX
+ PUSH_ECX ; Protect ECX
+ PUSH_EDX ; Protect EDX
+ LOAD32_Absolute32_ebx &MALLOC ; Using the current pointer
+ ADD_eax_into_ebx ; Request the number of desired bytes
+ LOADI32_EAX %45 ; the Syscall # for SYS_BRK
+ INT_80 ; call the Kernel
+ LOAD32_Absolute32_eax &MALLOC ; Return pointer
+ STORE32_Absolute32_ebx &MALLOC ; Update pointer
+ POP_EDX ; Restore EDX
+ POP_ECX ; Restore ECX
+ POP_EBX ; Restore EBX
+ RETURN
+
+
+;; clear_white_space function
+;; Recieves INT C in EAX
+;; Returns first non-whitespace char in EAX
+:clear_white_space
+ CMPI8_EAX !32 ; Check for ' '
+ JE32 %clear_white_space_wipe ; wipe it out
+
+ CMPI8_EAX !10 ; Check for '\n'
+ JE32 %clear_white_space_wipe ; wipe it output
+
+ CMPI8_EAX !9 ; Check for '\t'
+ JNE32 %clear_white_space_done ; looks like non-whitespace
+
+:clear_white_space_wipe
+ CALL32 %fgetc ; Read a new byte
+ CMPI8_EAX !-4 ; Check for EOF
+ JE32 %clear_white_space_done ; Short circuit
+ JMP32 %clear_white_space ; iterate
+
+:clear_white_space_done
+ RETURN
+
+
+;; In_Set function
+;; Recieves Char C in EAX and CHAR* in EBX
+;; Returns 1 if true, zero if false in EAX
+:In_Set
+ PUSH_EBX ; Protect EBX
+ PUSH_ECX ; Protect ECX
+:In_Set_loop
+ LOAD8_cl_from_EBX ; Read char
+ MOVZX_cl ; Zero extend it
+
+ CMP_EAX_ECX ; See if they match
+ JE32 %In_Set_True ; return true
+
+ CMPI8_ECX !0 ; Check for NULL
+ JE32 %In_Set_False ; return false
+
+ ADDI8_EBX !1 ; s = s + 1
+ JMP32 %In_Set_loop ; Keep looping
+
+:In_Set_True
+ LOADI32_EAX %1 ; Set True
+ POP_ECX ; Restore ECX
+ POP_EBX ; Restore EBX
+ RETURN
+
+:In_Set_False
+ LOADI32_EAX %0 ; Set FALSE
+ POP_ECX ; Restore ECX
+ POP_EBX ; Restore EBX
+ RETURN
+
+:alphas "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz"
+:symbols "<=>|&!-"
+:strings '22 27 00'
+
+
+;; purge_macro function
+;; Recieves CH in EAX
+;; Reads chars until Line feed is read
+;; returns line feed
+:purge_macro
+ CALL32 %fgetc ; read next char
+ CMPI8_EAX !10 ; Check for '\n'
+ JNE32 %purge_macro ; Keep going
+ RETURN
+
+
+;; preserve_keyword function
+;; Recieves INT C in EAX
+;; collects all chars in keyword
+;; Returns C in EAX
+;; Uses ECX for INT C
+:preserve_keyword
+ PUSH_EBX ; Protect EBX
+ PUSH_ECX ; Protect ECX
+ COPY_EAX_to_ECX ; Setup C
+ LOADI32_EBX &alphas ; Concerning ourselves with "abc.."
+:preserve_keyword_loop
+ CALL32 %In_Set ; Check if alphanumerics
+ CMPI8_EAX !1 ; IF TRUE
+ JNE32 %preserve_keyword_label ; Otherwise check for label
+
+ COPY_ECX_to_EAX ; Pass C
+ CALL32 %consume_byte ; consume that byte
+ COPY_EAX_to_ECX ; Update C
+ JMP32 %preserve_keyword_loop ; keep looping
+
+:preserve_keyword_label
+ COPY_ECX_to_EAX ; Fix return
+ CMPI8_EAX !58 ; Check for ':'
+ JNE32 %preserve_keyword_done ; be done
+
+ ;; Fix our goto label
+ CALL32 %fixup_label ; Fix the label
+ LOADI32_EAX %32 ; Return Whitespace
+
+:preserve_keyword_done
+ POP_ECX ; Restore ECX
+ POP_EBX ; Restore EBX
+ RETURN
+
+
+;; preserve_symbol function
+;; Recieves INT C in EAX
+;; collects all chars in symbol
+;; Returns C in EAX
+;; Uses ECX for INT C
+:preserve_symbol
+ PUSH_EBX ; Protect EBX
+ PUSH_ECX ; Protect ECX
+ COPY_EAX_to_ECX ; Setup C
+ LOADI32_EBX &symbols ; Concerning ourselves with "<=>.."
+:preserve_symbol_loop
+ CALL32 %In_Set ; Check if alphanumerics
+ CMPI8_EAX !1 ; IF TRUE
+ JNE32 %preserve_symbol_done ; Otherwise be done
+
+ COPY_ECX_to_EAX ; Pass C
+ CALL32 %consume_byte ; consume that byte
+ COPY_EAX_to_ECX ; Update C
+ JMP32 %preserve_symbol_loop ; keep looping
+
+:preserve_symbol_done
+ COPY_ECX_to_EAX ; Fix return
+ POP_ECX ; Restore ECX
+ POP_EBX ; Restore EBX
+ RETURN
+
+
+;; consume_word function
+;; recieves INT C in EAX
+;; returns INT C in EAX
+;; Uses EAX for C, EBX for FREQ and ECX for ESCAPE
+:consume_word
+ PUSH_EBX ; Protect EBX
+ PUSH_ECX ; Protect ECX
+ COPY_EAX_to_EBX ; FREQ = C
+ LOADI32_ECX %0 ; ESCAPE = FALSE
+:consume_word_loop
+ CMPI8_ECX !0 ; IF !ESCAPE
+ JNE32 %consume_word_escape ; Enable escape
+
+ CMPI8_EAX !92 ; if '\\'
+ JNE32 %consume_word_iter ; keep state
+
+ LOADI32_ECX %1 ; ESCAPE = TRUE
+ JMP32 %consume_word_iter ; keep going
+
+:consume_word_escape
+ LOADI32_ECX %0 ; ESCAPE = FALSE
+
+:consume_word_iter
+ CALL32 %consume_byte ; read next char
+
+ CMPI8_ECX !0 ; IF ESCAPE
+ JNE32 %consume_word_loop ; keep looping
+
+ CMP_EAX_EBX ; IF C != FREQ
+ JNE32 %consume_word_loop ; keep going
+
+ CALL32 %fgetc ; return next char
+ POP_ECX ; Restore ECX
+ POP_EBX ; Restore EBX
+ RETURN
+
+
+;; consume_byte function
+;; Recieves INT C in EAX
+;; Inserts C into string S, updates String S
+;; Returns Next char in EAX
+:consume_byte
+ PUSH_EBX ; Protect EBX
+ LOAD32_Absolute32_ebx &string_index ; S[0]
+ STORE8_al_into_Address_EBX ; S[0] = C
+ ADDI8_EBX !1 ; S = S + 1
+ STORE32_Absolute32_ebx &string_index ; Update S
+ CALL32 %fgetc
+ POP_EBX ; Restore EBX
+ RETURN
+
+
+;; fixup_label function
+;; Recieves S in ECX
+;; prepends ':' to string and returns registers un changed
+;; Uses EAX for HOLD, EBX for PREV and ECX for S[0]
+:fixup_label
+ PUSH_EAX ; Protect EAX
+ PUSH_EBX ; Protect EBX
+ PUSH_ECX ; Protect ECX
+ LOADI32_EAX %58 ; HOLD = ':'
+ LOAD32_ECX_from_EDX_Immediate8 !8 ; HOLD_STRING[0]
+:fixup_label_loop
+ COPY_EAX_to_EBX ; PREV = HOLD
+ LOAD8_al_from_ECX ; HOLD = HOLD_STRING[I]
+ MOVZX_al ; make useful
+ STORE8_bl_into_Address_ECX ; HOLD_STRING[I] = PREV
+ ADDI8_ECX !1 ; I = I + 1
+ CMPI8_EAX !0 ; IF NULL == HOLD
+ JNE32 %fixup_label_loop ; Keep looping
+
+ POP_ECX ; Restore ECX
+ POP_EBX ; Restore EBX
+ POP_EAX ; Restore EAX
+ RETURN
+
+
+;; fgetc function
+;; Loads FILE* from [INPUT_FILE]
+;; Returns -4 (EOF) or char in EAX
+:fgetc
+ PUSH_EBX ; Protect EBX
+ PUSH_ECX ; Protect ECX
+ PUSH_EDX ; Protect EDX
+ LOADI32_EAX %-4 ; Put EOF in eax
+ PUSH_EAX ; Assume bad (If nothing read, value will remain EOF)
+ LEA32_ECX_from_esp ; Get stack address
+ LOAD32_Absolute32_ebx &Input_file ; Where are we reading from
+ LOADI32_EAX %3 ; the syscall number for read
+ LOADI32_EDX %1 ; set the size of chars we want
+ INT_80 ; call the Kernel
+ POP_EAX ; Get either char or EOF
+ CMPI8_EAX !-4 ; Check for EOF
+ JE32 %fgetc_done ; Return as is
+ MOVZX_al ; Make it useful
+:fgetc_done
+ POP_EDX ; Restore EDX
+ POP_ECX ; Restore ECX
+ POP_EBX ; Restore EBX
+ RETURN
+
+
+;; Reverse_List function
+;; Recieves List in EAX
+;; Returns the list reversed in EAX
+:Reverse_List
+ PUSH_EBX ; Protect EBX
+ PUSH_ECX ; Protect ECX
+ COPY_EAX_to_EBX ; Set HEAD
+ LOADI32_EAX %0 ; ROOT = NULL
+:Reverse_List_Loop
+ CMPI8_EBX !0 ; WHILE HEAD != NULL
+ JE32 %Reverse_List_Done ; Stop otherwise
+
+ LOAD32_ECX_from_EBX ; NEXT = HEAD->NEXT
+ STORE32_EAX_into_EBX ; HEAD->NEXT = ROOT
+ COPY_EBX_to_EAX ; ROOT = HEAD
+ COPY_ECX_to_EBX ; HEAD = NEXT
+ JMP32 %Reverse_List_Loop ; Keep Going
+
+:Reverse_List_Done
+ POP_ECX ; Restore ECX
+ POP_EBX ; Restore EBX
+ RETURN
+
+
+;; recursive_output function
+;; Recieves list in EAX
+;; walks the list and prints the I->S for all nodes backwards
+;; Uses EBX for I
+:recursive_output
+ PUSH_EBX ; Protect EBX
+ PUSH_ECX ; Protect ECX
+ CMPI8_EAX !0 ; Check for NULL
+ JE32 %recursive_output_done ; Skip the work
+ COPY_EAX_to_EBX ; I = Head
+
+ LOAD32_EAX_from_EBX ; Iterate to next Token
+ CALL32 %recursive_output ; Recurse
+
+ LOAD32_EAX_from_EBX_Immediate8 !8 ; Using S
+ CALL32 %File_Print ; Print it
+
+:recursive_output_done
+ POP_ECX ; Restore ECX
+ POP_EBX ; Restore EBX
+ RETURN
+
+
+;; File_Print function
+;; Recieves CHAR* in EAX
+;; calls fputc for every non-null char
+:File_Print
+ PUSH_EBX ; Protect EBX
+ PUSH_ECX ; Protect ECX
+ COPY_EAX_to_EBX ; Protect S
+ CMPI8_EAX !0 ; Protect against nulls
+ JE32 %File_Print_Done ; Simply don't try to print them
+:File_Print_Loop
+ LOAD8_al_from_EBX ; Read byte
+ MOVZX_al ; zero extend
+ CMPI8_EAX !0 ; Check for NULL
+ JE32 %File_Print_Done ; Stop at NULL
+
+ CALL32 %fputc ; write it
+ ADDI8_EBX !1 ; S = S + 1
+ JMP32 %File_Print_Loop ; Keep going
+
+:File_Print_Done
+ POP_ECX ; Restore ECX
+ POP_EBX ; Restore EBX
+ RETURN
+
+
+;; fputc function
+;; recieves CHAR in EAX and load FILE* from [OUTPUT_FILE]
+;; writes char and returns
+:fputc
+ PUSH_EBX ; Protect EBX
+ PUSH_ECX ; Protect ECX
+ PUSH_EDX ; Protect EDX
+ PUSH_EAX ; We are writing eax
+ LEA32_ECX_from_esp ; Get stack address
+ LOAD32_Absolute32_ebx &Output_file ; Write to target file
+ LOADI32_EAX %4 ; the syscall number for write
+ LOADI32_EDX %1 ; set the size of chars we want
+ INT_80 ; call the Kernel
+ POP_EAX ; Restore stack
+ POP_EDX ; Restore EDX
+ POP_ECX ; Restore ECX
+ POP_EBX ; Restore EBX
+ RETURN
+
+
+;; program function
+;; recieves nothing, returns nothing
+;; Uses EAX for type_size
+:program
+ ;; The binary initialized the globals to null, so we can skip those steps
+ PUSH_EBX ; Protect EBX
+ PUSH_ECX ; Protect ECX
+
+:new_type
+ LOAD32_Absolute32_eax &global_token ; Using global_token
+ CMPI8_EAX !0 ; Check if NULL
+ JE32 %program_done ; Be done if null
+
+ LOAD32_EBX_from_EAX_Immediate8 !8 ; GLOBAL_TOKEN->S
+ LOADI32_EAX &constant ; "CONSTANT"
+ CALL32 %match ; IF GLOBAL_TOKEN->S == "CONSTANT"
+ CMPI8_EAX !0 ; If true
+ JNE32 %program_else ; Looks like not a constant
+
+ ;; Deal with minimal constant case
+ LOAD32_Absolute32_eax &global_token ; Using global_token
+ LOAD32_EAX_from_EAX ; global_token->next
+ STORE32_Absolute32_eax &global_token ; global_token = global_token->next
+
+ LOAD32_EAX_from_EAX_Immediate8 !8 ; global_token->S
+ LOADI32_EBX %0 ; NULL
+ LOAD32_Absolute32_ecx &global_constant_list ; global_constant_list
+ CALL32 %sym_declare ; Declare that constant
+ STORE32_Absolute32_eax &global_constant_list ; global_constant_list = sym_declare(global_token->s, NULL, global_constant_list);
+
+ LOAD32_Absolute32_ebx &global_token ; Using global_token
+ LOAD32_EBX_from_EBX ; global_token->next
+ STORE32_EBX_into_EAX_Immediate8 !16 ; global_constant_list->arguments = global_token->next
+
+ LOAD32_EBX_from_EBX ; global_token->next->next
+ STORE32_Absolute32_ebx &global_token ; global_token = global_token->next->next
+ JMP32 %new_type ; go around again
+
+:program_else
+ CALL32 %type_name ; Figure out the type_size
+ CMPI8_EAX !0 ; IF NULL == type_size
+ JE32 %new_type ; it was a new type
+
+ ;; Add to global symbol table
+ COPY_EAX_to_EBX ; put type_size in the right spot
+ LOAD32_Absolute32_eax &global_token ; Using global token
+ LOAD32_EAX_from_EAX_Immediate8 !8 ; global_token->S
+ LOAD32_Absolute32_ecx &global_symbol_list ; Using global_symbol_list
+ CALL32 %sym_declare ; Declare symbol
+ STORE32_Absolute32_eax &global_symbol_list ; global_symbol_list = sym_declare(global_token->s, type_size, global_symbol_list);
+ LOAD32_Absolute32_ebx &global_token ; Using global token
+ LOAD32_EBX_from_EBX ; global_token->next
+ STORE32_Absolute32_ebx &global_token ; global_token = global_token->next
+
+ LOAD32_Absolute32_ebx &global_token ; Using global token
+ LOAD32_EBX_from_EBX_Immediate8 !8 ; global_token->S
+ LOADI32_EAX &semicolon ; ";"
+ CALL32 %match ; if(match(";", global_token->s))
+ CMPI8_EAX !0 ; If true
+ JNE32 %program_function ; looks like not a match
+
+ ;; Deal with the global variable
+ LOAD32_Absolute32_ebx &globals_list ; Using globals_list
+ LOADI32_EAX &program_string_0 ; ":GLOBAL_"
+ CALL32 %emit ; Emit it
+ COPY_EAX_to_EBX ; update globals_list
+
+ LOAD32_Absolute32_eax &global_token ; Using global token
+ LOAD32_EAX_from_EAX_Immediate8 !4 ; global token->prev
+ LOAD32_EAX_from_EAX_Immediate8 !8 ; global token->prev->s
+ CALL32 %emit ; Emit it
+
+ COPY_EAX_to_EBX ; update globals_list
+ LOADI32_EAX &program_string_1 ; "\nNOP\n"
+ CALL32 %emit ; Emit it
+ STORE32_Absolute32_eax &globals_list ; update globals_list
+
+ LOAD32_Absolute32_eax &global_token ; Using global token
+ LOAD32_EAX_from_EAX ; global_token->next
+ STORE32_Absolute32_eax &global_token ; global_token = global_token->next
+ JMP32 %new_type ; go around again
+
+:program_function
+ LOAD32_Absolute32_ebx &global_token ; Using global token
+ LOAD32_EBX_from_EBX_Immediate8 !8 ; global_token->S
+ LOADI32_EAX &open_paren ; "("
+ CALL32 %match ; if(match(";", global_token->s))
+ CMPI8_EAX !0 ; If true
+ JNE32 %program_error ; Otherwise deal with error case
+
+ ;; Deal with function definition
+ CALL32 %declare_function ; Lets get the parsing rolling
+ JMP32 %new_type ; Keep looping through functions
+
+:program_error
+ ;; Deal with the case of something we don't support
+ ;; NOT IMPLEMENTED
+
+:program_done
+ POP_ECX ; Restore ECX
+ POP_EBX ; Restore EBX
+ RETURN
+
+;; Strings needed by the program function
+:program_string_0 ":GLOBAL_"
+:program_string_1 "
+NOP
+"
+
+
+;; declare_function function
+;; Recieves nothing and returns nothing
+;; Sets current function and adds it to the global function list
+:declare_function
+ PUSH_EBX ; Protect EBX
+ PUSH_ECX ; Protect ECX
+ LOADI32_EAX %0 ; Using NULL
+ STORE32_Absolute32_eax ¤t_count ; current_count = 0
+
+ LOAD32_Absolute32_eax &global_token ; Using global token
+ LOAD32_EAX_from_EAX_Immediate8 !4 ; global token->prev
+ LOAD32_EAX_from_EAX_Immediate8 !8 ; global token->prev->s
+ LOADI32_EBX %0 ; NULL
+ LOAD32_Absolute32_ecx &global_function_list ; global_function_list
+ CALL32 %sym_declare ; sym_declare(global_token->prev->s, NULL, global_function_list);
+ STORE32_Absolute32_eax &function ; function = sym_declare(global_token->prev->s, NULL, global_function_list);
+ STORE32_Absolute32_eax &global_function_list ; global_function_list = function
+
+ CALL32 %collect_arguments ; collect all of the function arguments
+
+ LOAD32_Absolute32_eax &global_token ; Using global token
+ LOAD32_EAX_from_EAX_Immediate8 !8 ; global token->s
+ LOADI32_EBX &semicolon ; ";"
+ CALL32 %match ; IF global token->s == ";"
+ CMPI8_EAX !0 ; If true
+ JNE32 %declare_function_full ; It was a prototype
+
+ ;; Deal with prototypes
+ LOAD32_Absolute32_eax &global_token ; Using global token
+ LOAD32_EAX_from_EAX ; global token->next
+ STORE32_Absolute32_eax &global_token ; global token = global token->next
+ JMP32 %declare_function_done ; Move on
+
+:declare_function_full
+ ;; Deal will full function definitions
+ LOADI32_EAX &declare_function_string_0 ; "# Defining function "
+ CALL32 %emit_out ; emit it
+
+ LOAD32_Absolute32_eax &function ; function
+ LOAD32_EAX_from_EAX_Immediate8 !8 ; function->s
+ CALL32 %emit_out ; emit it
+
+ LOADI32_EAX &declare_function_string_1 ; "\n:FUNCTION_"
+ CALL32 %emit_out ; emit it
+
+ LOAD32_Absolute32_eax &function ; function
+ LOAD32_EAX_from_EAX_Immediate8 !8 ; function->s
+ CALL32 %emit_out ; emit it
+
+ LOADI32_EAX &declare_function_string_3 ; "\n"
+ CALL32 %emit_out ; emit it
+
+ CALL32 %statement ; Recursively get the function pieces
+
+ LOAD32_Absolute32_eax &output_list ; output
+ LOAD32_EAX_from_EAX_Immediate8 !8 ; output->s
+ LOADI32_EBX &declare_function_string_2 ; "RETURN\n"
+ CALL32 %match ; IF output->s == "RETURN\n"
+ CMPI8_EAX !0 ; If true we can skip adding it
+ JE32 %declare_function_done ; otherwise we need to add it
+
+ ;; Add the return to the end of a function lacking a return;
+ LOADI32_EAX &declare_function_string_2 ; "RETURN\n"
+ CALL32 %emit_out ; emit it
+
+:declare_function_done
+ POP_ECX ; Restore ECX
+ POP_EBX ; Restore EBX
+ RETURN
+
+:declare_function_string_0 "# Defining function "
+:declare_function_string_1 "
+:FUNCTION_"
+:declare_function_string_2 "RETURN
+"
+:declare_function_string_3 "
+"
+
+
+;; collect_arguments function
+;; Recieves nothing
+;; Returns Nothing
+;; Adds arguments to the function definition
+;; holds struct type* type_size in ECX, then replace with struct token_list* a in ECX when type_size is used
+:collect_arguments
+ PUSH_EBX ; Protect EBX
+ PUSH_ECX ; Protect ECX
+ LOAD32_Absolute32_eax &global_token ; Using global_token
+ LOAD32_EAX_from_EAX ; global_token->next
+ STORE32_Absolute32_eax &global_token ; global_token = global_token->next
+:collect_arguments_loop
+ LOAD32_Absolute32_ebx &global_token ; Using global_token
+ LOAD32_EBX_from_EBX_Immediate8 !8 ; global_token->S
+ LOADI32_EAX &close_paren ; ")"
+ CALL32 %match ; IF global_token->S == ")"
+ CMPI8_EAX !0 ; we reached the end
+ JE32 %collect_arguments_done ; be done
+
+ ;; deal with the case of there are arguments
+ CALL32 %type_name ; Get the type
+ COPY_EAX_to_ECX ; put type_size safely out of the way
+
+ LOAD32_Absolute32_ebx &global_token ; Using global_token
+ LOAD32_EBX_from_EBX_Immediate8 !8 ; global_token->S
+ LOADI32_EAX &close_paren ; ")"
+ CALL32 %match ; IF global_token->S == ")"
+ CMPI8_EAX !0 ; is a foo(int, char,void) case
+ JE32 %collect_arguments_common ; deal with commas
+
+ ;; Trying second else
+ LOAD32_Absolute32_ebx &global_token ; Using global_token
+ LOAD32_EBX_from_EBX_Immediate8 !8 ; global_token->S
+ LOADI32_EAX &comma ; ","
+ CALL32 %match ; IF global_token->S == ","
+ CMPI8_EAX !0 ; then deal with the common
+ JE32 %collect_arguments_common ; case of commas between arguments
+
+ ;; deal with foo(int a, char b)
+ LOAD32_Absolute32_eax &global_token ; Using global_token
+ LOAD32_EAX_from_EAX_Immediate8 !8 ; global_token->S
+ COPY_ECX_to_EBX ; put type_size in the right place
+ LOAD32_Absolute32_ecx &function ; Using function
+ LOAD32_ECX_from_ECX_Immediate8 !16 ; function->args
+ CALL32 %sym_declare ; sym_declare(global_token->s, type_size, function->arguments);
+ COPY_EAX_to_ECX ; put a in a safe place
+
+ LOAD32_Absolute32_eax &function ; Using function
+ LOAD32_EAX_from_EAX_Immediate8 !16 ; function->args
+ CMPI8_EAX !0 ; IF function->args == NULL
+ JNE32 %collect_arguments_another ; otherwise it isn't the first
+
+ ;; Deal with the case of first argument in the function
+ LOADI32_EAX %-4 ; -4
+ STORE32_EAX_into_ECX_Immediate8 !16 ; a->depth = -4
+ JMP32 %collect_arguments_next ; get to next
+
+:collect_arguments_another
+ ;; deal with the case of non-first arguments
+ LOAD32_Absolute32_eax &function ; Using function
+ LOAD32_EAX_from_EAX_Immediate8 !16 ; function->args
+ LOAD32_EAX_from_EAX_Immediate8 !16 ; function->args->depth
+ SUBI8_EAX !4 ; function->args->depth - 4
+ STORE32_EAX_into_ECX_Immediate8 !16 ; a->depth = function->args->depth - 4
+
+:collect_arguments_next
+ LOAD32_Absolute32_eax &global_token ; Using global_token
+ LOAD32_EAX_from_EAX ; global_token->next
+ STORE32_Absolute32_eax &global_token ; global_token = global_token->next
+
+ LOAD32_Absolute32_eax &function ; Using function
+ STORE32_ECX_into_EAX_Immediate8 !16 ; function->args = a
+
+:collect_arguments_common
+ LOAD32_Absolute32_ebx &global_token ; Using global_token
+ LOAD32_EBX_from_EBX_Immediate8 !8 ; global_token->S
+ LOADI32_EAX &comma ; ","
+ CALL32 %match ; IF global_token->S == ","
+ CMPI8_EAX !0 ; then deal with the comma
+ JNE32 %collect_arguments_loop ; otherwise loop
+
+ ;; keep foo(bar(), 1) expressions working
+ LOAD32_Absolute32_eax &global_token ; Using global_token
+ LOAD32_EAX_from_EAX ; global_token->next
+ STORE32_Absolute32_eax &global_token ; global_token = global_token->next
+ JMP32 %collect_arguments_loop ; keep going
+
+:collect_arguments_done
+ LOAD32_Absolute32_eax &global_token ; Using global_token
+ LOAD32_EAX_from_EAX ; global_token->next
+ STORE32_Absolute32_eax &global_token ; global_token = global_token->next
+ POP_ECX ; Restore ECX
+ POP_EBX ; Restore EBX
+ RETURN
+
+
+;; statement function
+;; Recieves nothing
+;; Returns nothing
+;; Walks down global_token recursively to collect the contents of the function
+:statement
+ PUSH_EBX ; Protect EBX
+ PUSH_ECX ; Protect ECX
+
+ LOAD32_Absolute32_ebx &global_token ; Using global_token
+ LOAD32_EBX_from_EBX_Immediate8 !8 ; global_token->S
+ LOADI32_EAX &open_curly_brace ; "{"
+ CALL32 %match ; IF global_token->S == "{"
+ JNE32 %statement_label ; otherwise try label
+
+ ;; deal with { statement }
+ CALL32 %recursive_statement ; Statements inside of statements for days
+ JMP32 %statement_done ; Be done
+
+:statement_label
+ LOAD8_al_from_EBX ; global_token->S[0]
+ MOVZX_al ; make it useful
+ CMPI8_EAX !58 ; IF global_token->S == ':'
+ JNE32 %statement_local ; otherwise try locals
+
+ ;; deal with labels
+ COPY_EBX_to_EAX ; put global_token->S in the right spot
+ CALL32 %emit_out ; emit it
+
+ LOADI32_EAX &statement_string_0 ; Using "\t#C goto label\n"
+ CALL32 %emit_out ; emit it
+
+ LOAD32_Absolute32_eax &global_token ; Using global_token
+ LOAD32_EAX_from_EAX ; global_token->next
+ STORE32_Absolute32_eax &global_token ; global_token = global_token->next
+ JMP32 %statement_done ; be done
+
+:statement_local
+ COPY_EBX_to_EAX ; put global_token->S in the right place
+ LOADI32_EBX &prim_types ; pointer to primative types
+ CALL32 %lookup_type ; See if found
+ CMPI8_EAX !0 ; IF NULL == lookup_type(global_token->S, prim_types)
+ JNE32 %statement_local_success ; Sweet a new local
+
+ ;; Second chance
+ LOAD32_Absolute32_ebx &global_token ; Using global_token
+ LOAD32_EBX_from_EBX_Immediate8 !8 ; global_token->S
+ LOADI32_EAX &struct ; "struct"
+ CALL32 %match ; IF global_token->S == "struct"
+ CMPI8_EAX !0 ; then we are a local
+ JNE32 %statement_if ; otherwise try IF
+
+:statement_local_success
+ CALL32 %collect_local ; Grab those locals
+ JMP32 %statement_done ; be done
+
+:statement_if
+ LOADI32_EAX &if_string ; Using "if"
+ CALL32 %match ; IF global_token->S == "if"
+ CMPI8_EAX !0 ; then we have an if statement
+ JNE32 %statement_do ; otherwise try DO
+
+ ;; Deal with IF statement
+ CALL32 %process_if ; DO IT
+ JMP32 %statement_done ; be done
+
+:statement_do
+ LOADI32_EAX &do_string ; Using "do"
+ CALL32 %match ; IF global_token->S == "do"
+ CMPI8_EAX !0 ; then we have a do statement
+ JNE32 %statement_while ; otherwise try WHILE
+
+ ;; Deal with DO statement
+ CALL32 %process_do ; DO IT
+ JMP32 %statement_done ; be done
+
+:statement_while
+ LOADI32_EAX &while_string ; Using "while"
+ CALL32 %match ; IF global_token->S == "while"
+ CMPI8_EAX !0 ; then we have a while statement
+ JNE32 %statement_for ; otherwise try FOR
+
+ ;; Deal with WHILE statement
+ CALL32 %process_while ; DO IT
+ JMP32 %statement_done ; be done
+
+:statement_for
+ LOADI32_EAX &for_string ; Using "for"
+ CALL32 %match ; IF global_token->S == "for"
+ CMPI8_EAX !0 ; then we have a for statement
+ JNE32 %statement_asm ; otherwise try ASM
+
+ ;; Deal with FOR statement
+ CALL32 %process_for ; DO IT
+ JMP32 %statement_done ; be done
+
+:statement_asm
+ LOADI32_EAX &asm_string ; Using "asm"
+ CALL32 %match ; IF global_token->S == "asm"
+ CMPI8_EAX !0 ; then we have an asm statement
+ JNE32 %statement_goto ; otherwise try GOTO
+
+ ;; Deal with ASM statement
+ CALL32 %process_asm ; Hit it
+ JMP32 %statement_done ; be done
+
+:statement_goto
+ LOADI32_EAX &goto_string ; Using "goto"
+ CALL32 %match ; IF global_token->S == "goto"
+ CMPI8_EAX !0 ; then we have a goto statement
+ JNE32 %statement_return ; Otherwise try RETURN
+
+ ;; Deal with GOTO statement
+ LOADI32_EAX &statement_string_1 ; Using "JUMP %"
+ CALL32 %emit_out ; emit it
+
+ LOAD32_Absolute32_eax &global_token ; Using global_token
+ LOAD32_EAX_from_EAX ; global_token->next
+ STORE32_Absolute32_eax &global_token ; global_token = global_token->next
+
+ LOAD32_EAX_from_EAX_Immediate8 !8 ; global_token->S
+ CALL32 %emit_out ; emit it
+
+ LOADI32_EAX &statement_string_2 ; Using "\n"
+ CALL32 %emit_out ; emit it
+
+ LOAD32_Absolute32_eax &global_token ; Using global_token
+ LOAD32_EAX_from_EAX ; global_token->next
+ STORE32_Absolute32_eax &global_token ; global_token = global_token->next
+
+ LOADI32_EAX &statement_string_4 ; Using "ERROR in statement\nMissing ;\n"
+ LOADI32_EBX &semicolon ; Using ";"
+ CALL32 %require_match ; Make sure it has the required
+ JMP32 %statement_done ; Be done
+
+:statement_return
+ LOADI32_EAX &return_string ; Using "return"
+ CALL32 %match ; IF global_token->S == "return"
+ CMPI8_EAX !0 ; then we have a return statement
+ JNE32 %statement_break ; Otherwise try BREAK
+
+ ;; Deal with RETURN Statement
+ CALL32 %return_result ; Return anything they want
+ JMP32 %statement_done ; be done
+
+:statement_break
+ LOADI32_EAX &break_string ; Using "break"
+ CALL32 %match ; IF global_token->S == "break"
+ CMPI8_EAX !0 ; then we have a break statement
+ JNE32 %statement_continue ; Otherwise try CONTINUE
+
+ ;; Deal with BREAK statement
+ CALL32 %process_break ; Lets do some damage
+ JMP32 %statement_done ; be done
+
+:statement_continue
+ LOADI32_EAX &continue_string ; Using "continue"
+ CALL32 %match ; IF global_token->S == "continue"
+ CMPI8_EAX !0 ; then we have a continue statement
+ JNE32 %statement_else ; Otherwise we are punting to an expression
+
+ ;; Deal with CONTINUE statement
+ LOAD32_Absolute32_eax &global_token ; Using global_token
+ LOAD32_EAX_from_EAX ; global_token->next
+ STORE32_Absolute32_eax &global_token ; global_token = global_token->next
+
+ LOADI32_EAX &statement_string_3 ; Using "\n#continue statement\n"
+ CALL32 %emit_out ; emit it
+
+ LOADI32_EAX &statement_string_4 ; Using "ERROR in statement\nMissing ;\n"
+ LOADI32_EBX &semicolon ; Using ";"
+ CALL32 %require_match ; Don't forget the ";"
+ JMP32 %statement_done ; Be done
+
+:statement_else
+ CALL32 %expression ; Collect expression
+ LOADI32_EAX &statement_string_4 ; Using "ERROR in statement\nMissing ;\n"
+ LOADI32_EBX &semicolon ; Using ";"
+ CALL32 %require_match ; make sure we have it
+
+:statement_done
+ POP_ECX ; Restore ECX
+ POP_EBX ; Restore EBX
+ RETURN
+
+:statement_string_0 " #C goto label
+"
+:statement_string_1 "JUMP %"
+:statement_string_2 "
+"
+:statement_string_3 "
+#continue statement
+"
+:statement_string_4 "ERROR in statement
+Missing ;
+"
+
+
+;; recursive_statement function
+;; Recieves nothing
+;; Returns nothing
+;; Walks the global_token list to build the contents of statements
+;; Uses struct token_list* frame in ECX
+:recursive_statement
+ PUSH_EBX ; Protect EBX
+ PUSH_ECX ; Protect ECX
+
+ LOAD32_Absolute32_eax &global_token ; Using global_token
+ LOAD32_EAX_from_EAX ; global_token->next
+ STORE32_Absolute32_eax &global_token ; global_token = global_token->next
+
+ LOAD32_Absolute32_ecx &function ; Using function
+ LOAD32_ECX_from_ECX_Immediate8 !4 ; frame = function->locals
+
+:recursive_statement_loop
+ LOAD32_Absolute32_ebx &global_token ; Using global_token
+ LOAD32_EBX_from_EBX_Immediate8 !8 ; global_token->S
+ LOADI32_EAX &close_curly_brace ; Using "}"
+ CALL32 %match ; IF global_token->S == "}"
+ CMPI8_EAX !0 ; Then we are done recuring
+ JE32 %recursive_statement_cleanup ; and then we clean up
+
+ ;; Deal with the recursive calls
+ CALL32 %statement ; Deal with another statement
+ JMP32 %recursive_statement_loop ; loop some more
+
+:recursive_statement_cleanup
+ LOAD32_Absolute32_eax &global_token ; Using global_token
+ LOAD32_EAX_from_EAX ; global_token->next
+ STORE32_Absolute32_eax &global_token ; global_token = global_token->next
+
+ LOADI32_EAX &recursive_statement_string_0 ; Using "RETURN\n"
+ LOAD32_Absolute32_ebx &output_list ; Using output
+ LOAD32_EBX_from_EBX_Immediate8 !8 ; output->S
+ CALL32 %match ; IF output->S == "RETURN\n"
+ CMPI8_EAX !0 ; Then we can skip the clean up
+ JE32 %recursive_statement_done ; and be done
+
+ ;; Deal with cleanup
+ LOAD32_Absolute32_ebx &function ; Using function
+ LOAD32_EBX_from_EBX_Immediate8 !4 ; i = function->locals
+ LOADI32_EAX &recursive_statement_string_1 ; Using "POP_ebx\t# _recursive_statement_locals\n"
+
+:recursive_statement_locals
+ CMP_ECX_EBX ; IF frame != i
+ JE32 %recursive_statement_done ; Otherwise be done
+
+ ;; Lets emit
+ CALL32 %emit_out ; emit it
+ LOAD32_EBX_from_EBX ; i = i->next
+ JMP32 %recursive_statement_locals ; keep going
+
+:recursive_statement_done
+ LOAD32_Absolute32_eax &function ; Using function
+ STORE32_ECX_into_EAX_Immediate8 !4 ; function->locals = frame
+ POP_ECX ; Restore ECX
+ POP_EBX ; Restore EBX
+ RETURN
+
+:recursive_statement_string_0 "RETURN
+"
+:recursive_statement_string_1 "POP_ebx # _recursive_statement_locals
+"
+
+
+;; return_result function
+;; Recieves nothing
+;; Returns nothing
+;; Cleans up function and generates return
+;; Also handles returing expressions
+:return_result
+ PUSH_EBX ; Protect EBX
+ PUSH_ECX ; Protect ECX
+ LOAD32_Absolute32_eax &global_token ; Using global_token
+ LOAD32_EAX_from_EAX ; global_token->next
+ STORE32_Absolute32_eax &global_token ; global_token = global_token->next
+
+ LOAD32_EAX_from_EAX_Immediate8 !8 ; global_token->S
+ LOAD8_al_from_EAX ; global_token->S[0]
+ MOVZX_al ; make it useful
+ CMPI8_EAX !59 ; If global_token->S[0] == ';'
+ JE32 %return_result_cleanup ; Go straight to cleanup
+
+ CALL32 %expression ; get the expression we are returning
+
+:return_result_cleanup
+ LOADI32_EAX &return_result_string_0 ; Using "ERROR in return_result\nMISSING ;\n"
+ LOADI32_EBX &semicolon ; Using ";"
+ CALL32 %require_match ; Make sure we have it
+
+ LOAD32_Absolute32_ebx &function ; Using function
+ LOAD32_EBX_from_EBX_Immediate8 !4 ; function->locals
+ LOADI32_EAX &return_result_string_1 ; Using "POP_ebx\t# _return_result_locals\n"
+:return_result_locals
+ CMPI8_EBX !0 ; IF NULL == i
+ JE32 %return_result_done ; Be done
+
+ CALL32 %emit_out ; Emit out pop
+ LOAD32_EBX_from_EBX ; i = i->NEXT
+ JMP32 %return_result_locals ; Keep going
+
+:return_result_done
+ LOADI32_EAX &return_result_string_2 ; Using "RETURN\n"
+ CALL32 %emit_out ; Emit it
+ POP_ECX ; Restore ECX
+ POP_EBX ; Restore EBX
+ RETURN
+
+:return_result_string_0 "ERROR in return_result
+MISSING ;
+"
+:return_result_string_1 "POP_ebx # _return_result_locals
+"
+:return_result_string_2 "RETURN
+"
+
+
+;; collect_local function
+;; Recieves nothing
+;; Returns nothing
+;; Walks global_token list to create function locals
+;; Uses ECX for struct token_list* A
+:collect_local
+ PUSH_EBX ; Protect EBX
+ PUSH_ECX ; Protect ECX
+ CALL32 %type_name ; Get the local's type
+
+ COPY_EAX_to_EBX ; Put struct type* type_size in the right place
+ LOAD32_Absolute32_eax &global_token ; Using global_token
+ LOAD32_EAX_from_EAX_Immediate8 !8 ; global_token->S
+ LOAD32_Absolute32_ecx &function ; Using function
+ LOAD32_ECX_from_ECX_Immediate8 !4 ; function->locals
+ CALL32 %sym_declare ; Declare it
+ COPY_EAX_to_ECX ; put it away safely
+
+ ;; Try for main
+ LOADI32_EAX &main_string ; Using "main"
+ LOAD32_Absolute32_ebx &function ; Using function
+ LOAD32_EBX_from_EBX_Immediate8 !8 ; function->S
+ CALL32 %match ; IF match("main", function->s)
+ CMPI8_EAX !0 ; possible
+ JNE32 %collect_local_fresh ; try to see if fresh function
+
+ ;; Ok we are in main, now to see if main is fresh
+ LOAD32_Absolute32_eax &function ; Using function
+ LOAD32_EAX_from_EAX_Immediate8 !4 ; function->locals
+ CMPI8_EAX !0 ; IF NULL == function->locals
+ JNE32 %collect_local_fresh ; try to see if fresh function
+
+ ;; Sweet we are in a fresh main
+ LOADI32_EAX %-20 ; We start at -20
+ STORE32_EAX_into_ECX_Immediate8 !16 ; a->DEPTH = -20
+ JMP32 %collect_local_common ; Go to the commons
+
+:collect_local_fresh
+ LOAD32_Absolute32_eax &function ; Using function
+ LOAD32_EAX_from_EAX_Immediate8 !16 ; function->args
+ CMPI8_EAX !0 ; IF NULL == function->locals
+ JNE32 %collect_local_first ; Otherwise see if first
+
+ LOAD32_Absolute32_eax &function ; Using function
+ LOAD32_EAX_from_EAX_Immediate8 !4 ; function->locals
+ CMPI8_EAX !0 ; IF NULL == function->locals
+ JNE32 %collect_local_first ; Otherwise try first
+
+ ;; Sweet we are in a fresh function
+ LOADI32_EAX %-8 ; We start at -8
+ STORE32_EAX_into_ECX_Immediate8 !16 ; a->DEPTH = -8
+ JMP32 %collect_local_common ; Go to the commons
+
+:collect_local_first
+ LOAD32_Absolute32_eax &function ; Using function
+ LOAD32_EAX_from_EAX_Immediate8 !4 ; function->locals
+ CMPI8_EAX !0 ; IF NULL == function->locals
+ JNE32 %collect_local_else ; Looks like we are just another local
+
+ ;; Ok we are the first local
+ LOAD32_Absolute32_eax &function ; Using function
+ LOAD32_EAX_from_EAX_Immediate8 !16 ; function->args
+ LOAD32_EAX_from_EAX_Immediate8 !16 ; function->args->depth
+ SUBI8_EAX !8 ; function->arguments->depth - 8
+ STORE32_EAX_into_ECX_Immediate8 !16 ; a->DEPTH = function->arguments->depth - 8
+ JMP32 %collect_local_common ; Go to the commons
+
+:collect_local_else
+ ;; Always the last to know
+ LOAD32_Absolute32_eax &function ; Using function
+ LOAD32_EAX_from_EAX_Immediate8 !4 ; function->locals
+ LOAD32_EAX_from_EAX_Immediate8 !16 ; function->locals->depth
+ SUBI8_EAX !4 ; function->locals->depth - 4
+ STORE32_EAX_into_ECX_Immediate8 !16 ; a->DEPTH = function->locals->depth - 4
+
+:collect_local_common
+ LOAD32_Absolute32_eax &function ; Using function
+
+ STORE32_ECX_into_EAX_Immediate8 !4 ; function->locals = a
+ LOAD32_ECX_from_ECX_Immediate8 !8 ; a->S
+
+ LOADI32_EAX &collect_local_string_0 ; Using "# Defining local "
+ CALL32 %emit_out ; emit it
+
+ LOAD32_Absolute32_eax &global_token ; Using global_token
+ LOAD32_EAX_from_EAX_Immediate8 !8 ; global_token->S
+ CALL32 %emit_out ; emit it
+
+ LOADI32_EAX &collect_local_string_1 ; Using "\n"
+ CALL32 %emit_out ; emit it
+
+ LOAD32_Absolute32_eax &global_token ; Using global_token
+ LOAD32_EAX_from_EAX ; global_token->NEXT
+ STORE32_Absolute32_eax &global_token ; global_token = global_token->NEXT
+
+ LOAD32_EBX_from_EAX_Immediate8 !8 ; global_token->S
+ LOADI32_EAX &equal ; Using "="
+ CALL32 %match ; IF match("=", global_token->s)
+ CMPI8_EAX !0 ; Deal with assignment
+ JNE32 %collect_local_done ; Otherwise finish it
+
+ ;; Deal with assignment
+ LOAD32_Absolute32_eax &global_token ; Using global_token
+ LOAD32_EAX_from_EAX ; global_token->NEXT
+ STORE32_Absolute32_eax &global_token ; global_token = global_token->NEXT
+
+ CALL32 %expression ; Recurse
+
+:collect_local_done
+ LOADI32_EAX &collect_local_string_2 ; Using "ERROR in collect_local\nMissing ;\n"
+ LOADI32_EBX &semicolon ; Using ";"
+ CALL32 %require_match ; Make sure we have it
+
+ LOADI32_EAX &collect_local_string_3 ; Using "PUSH_eax\t#"
+ CALL32 %emit_out ; emit it
+
+ COPY_ECX_to_EAX ; put A->S where it belongs
+ CALL32 %emit_out ; emit it
+
+ LOADI32_EAX &collect_local_string_1 ; Using "\n"
+ CALL32 %emit_out ; emit it
+
+ POP_ECX ; Restore ECX
+ POP_EBX ; Restore EBX
+ RETURN
+
+:collect_local_string_0 "# Defining local "
+:collect_local_string_1 "
+"
+:collect_local_string_2 "ERROR in collect_local
+Missing ;
+"
+:collect_local_string_3 "PUSH_eax #"
+
+
+;; process_asm function
+;; Recieves nothing
+;; Returns nothing
+;; Simply inlines the asm statements
+;; Uses EBX for global_token temp storage
+:process_asm
+ PUSH_EBX ; Protect EBX
+ LOAD32_Absolute32_eax &global_token ; Using global_token
+ LOAD32_EAX_from_EAX ; global_token->NEXT
+ STORE32_Absolute32_eax &global_token ; global_token = global_token->NEXT
+
+ LOADI32_EAX &process_asm_string_0 ; Using "ERROR in process_asm\nMISSING (\n"
+ LOADI32_EBX &open_paren ; Using "("
+ CALL32 %require_match ; Make sure we have it
+
+ LOAD32_Absolute32_ebx &global_token ; Using global_token
+:process_asm_iter
+ LOAD32_EAX_from_EBX_Immediate8 !8 ; global_token->S
+ LOAD8_al_from_EAX ; global_token->S[0]
+ MOVZX_al ; Make it useful
+ CMPI8_EAX !34 ; IF global_token->S[0] == '\"'
+ JNE32 %process_asm_done ; Otherwise be done
+
+ LOAD32_EAX_from_EBX_Immediate8 !8 ; global_token->S
+ ADDI8_EAX !1 ; global_token->S + 1
+ CALL32 %emit_out ; Emit it
+
+ LOADI32_EAX &process_asm_string_1 ; Using "\n"
+ CALL32 %emit_out ; Emit it
+
+ LOAD32_EBX_from_EBX ; global_token->NEXT
+ STORE32_Absolute32_ebx &global_token ; global_token = global_token->NEXT
+ JMP32 %process_asm_iter ; keep going
+
+:process_asm_done
+ LOADI32_EAX &process_asm_string_2 ; Using "ERROR in process_asm\nMISSING )\n"
+ LOADI32_EBX &close_paren ; Using ")"
+ CALL32 %require_match ; Make sure we have it
+
+ LOADI32_EAX &process_asm_string_3 ; Using "ERROR in process_asm\nMISSING ;\n"
+ LOADI32_EBX &semicolon ; Using ";"
+ CALL32 %require_match ; Make sure we have it
+
+ POP_EBX ; Restore EBX
+ RETURN
+
+:process_asm_string_0 "ERROR in process_asm
+MISSING (
+"
+:process_asm_string_1 "
+"
+:process_asm_string_2 "ERROR in process_asm
+MISSING )
+"
+:process_asm_string_3 "ERROR in process_asm
+MISSING ;
+"
+
+
+;; process_if function
+;; Recieves nothing
+;; Returns Nothing
+;; Increments current_count recurses into expression + statement
+;; Uses ECX for char* NUMBER_STRING
+:process_if
+ PUSH_EBX ; Protect EBX
+ PUSH_ECX ; Protect ECX
+ LOAD32_Absolute32_eax ¤t_count ; Using current count
+ COPY_EAX_to_EBX ; Preparing for update
+ ADDI8_EBX !1 ; current_count + 1
+ STORE32_Absolute32_ebx ¤t_count ; current_count = current_count + 1
+ CALL32 %numerate_number ; convert to string
+ COPY_EAX_to_ECX ; put NUMBER_STRING in place
+
+ LOADI32_EAX &process_if_string_0 ; Using "# IF_"
+ CALL32 %emit_out ; Emit it
+
+ LOAD32_Absolute32_eax &function ; Using function
+ LOAD32_EAX_from_EAX_Immediate8 !8 ; function->S
+ COPY_ECX_to_EBX ; Passing NUMBER_STRING
+ CALL32 %uniqueID_out ; uniqueID_out(function->s, number_string)
+
+ LOAD32_Absolute32_eax &global_token ; Using global_token
+ LOAD32_EAX_from_EAX ; global_token->NEXT
+ STORE32_Absolute32_eax &global_token ; global_token = global_token->NEXT
+
+ LOADI32_EAX &process_if_string_1 ; Using "ERROR in process_if\nMISSING (\n"
+ LOADI32_EBX &open_paren ; Using "("
+ CALL32 %require_match ; Make sure we have it
+
+ CALL32 %expression ; Recurse to get the IF(...) part
+
+ LOADI32_EAX &process_if_string_2 ; Using "TEST\nJUMP_EQ %ELSE_"
+ CALL32 %emit_out ; Emit it
+
+ LOAD32_Absolute32_eax &function ; Using function
+ LOAD32_EAX_from_EAX_Immediate8 !8 ; function->S
+ COPY_ECX_to_EBX ; Passing NUMBER_STRING
+ CALL32 %uniqueID_out ; uniqueID_out(function->s, number_string)
+
+ LOADI32_EAX &process_if_string_3 ; Using "ERROR in process_if\nMISSING )\n"
+ LOADI32_EBX &close_paren ; Using ")"
+ CALL32 %require_match ; Make sure we have it
+
+ CALL32 %statement ; Recursive to get the IF(){...} part
+
+ LOADI32_EAX &process_if_string_4 ; Using "JUMP %_END_IF_"
+ CALL32 %emit_out ; Emit it
+
+ LOAD32_Absolute32_eax &function ; Using function
+ LOAD32_EAX_from_EAX_Immediate8 !8 ; function->S
+ COPY_ECX_to_EBX ; Passing NUMBER_STRING
+ CALL32 %uniqueID_out ; uniqueID_out(function->s, number_string)
+
+ LOADI32_EAX &process_if_string_5 ; Using ":ELSE_"
+ CALL32 %emit_out ; Emit it
+
+ LOAD32_Absolute32_eax &function ; Using function
+ LOAD32_EAX_from_EAX_Immediate8 !8 ; function->S
+ CALL32 %uniqueID_out ; uniqueID_out(function->s, number_string)
+
+ LOAD32_Absolute32_ebx &global_token ; Using global_token
+ LOAD32_EBX_from_EBX_Immediate8 !8 ; global_token->S
+ LOADI32_EAX &else_string ; Using "else"
+ CALL32 %match ; IF global_token->S == "else"
+ CMPI8_EAX !0 ; Then we need to collect the else too
+ JNE32 %process_if_done ; Otherwise finish up
+
+ ;; deal with else statement
+ LOAD32_Absolute32_eax &global_token ; Using global_token
+ LOAD32_EAX_from_EAX ; global_token->NEXT
+ STORE32_Absolute32_eax &global_token ; global_token = global_token->NEXT
+
+ CALL32 %statement ; Recurse to get the ELSE {...} part
+
+:process_if_done
+ LOADI32_EAX &process_if_string_6 ; Using ":_END_IF_"
+ CALL32 %emit_out ; Emit it
+
+ LOAD32_Absolute32_eax &function ; Using function
+ LOAD32_EAX_from_EAX_Immediate8 !8 ; function->S
+ COPY_ECX_to_EBX ; Passing NUMBER_STRING
+ CALL32 %uniqueID_out ; uniqueID_out(function->s, number_string)
+
+ POP_ECX ; Restore ECX
+ POP_EBX ; Restore EBX
+ RETURN
+
+:process_if_string_0 "# IF_"
+:process_if_string_1 "ERROR in process_if
+MISSING (
+"
+:process_if_string_2 "TEST
+JUMP_EQ %ELSE_"
+:process_if_string_3 "ERROR in process_if
+MISSING )
+"
+:process_if_string_4 "JUMP %_END_IF_"
+:process_if_string_5 ":ELSE_"
+:process_if_string_6 ":_END_IF_"
+
+
+;; save_break_frame microfunction
+;; Overwrites EAX abd EBX
+;; Saves break frame on stack
+;; Returns to caller
+:save_break_frame
+ POP_EBX ; Save return Address
+ LOAD32_Absolute32_eax &break_frame ; Get break_frame
+ PUSH_EAX ; Store as nested_locals
+ LOAD32_Absolute32_eax &break_target_head ; Get break_target_head
+ PUSH_EAX ; Store as nested_break_head
+ LOAD32_Absolute32_eax &break_target_func ; Get break_target_func
+ PUSH_EAX ; Store as nested_break_func
+ LOAD32_Absolute32_eax &break_target_num ; Get break_target_num
+ PUSH_EAX ; Store as nested_break_num
+ PUSH_EBX ; Put return back in place
+ RETURN ; Return to caller
+
+
+;; restore_break_frame microfunction
+;; Overwrites EAX and EBX
+;; Restores break frame from stack
+;; Returns to caller
+:restore_break_frame
+ POP_EBX ; Save return Address
+ POP_EAX ; Get nested_break_num
+ STORE32_Absolute32_eax &break_target_num ; Restore break_target_num
+ POP_EAX ; Get nested_break_func
+ STORE32_Absolute32_eax &break_target_func ; Restore break_target_func
+ POP_EAX ; Get nested_break_head
+ STORE32_Absolute32_eax &break_target_head ; Restore break_target_head
+ POP_EAX ; Get nested_locals
+ STORE32_Absolute32_eax &break_frame ; Restore break_frame
+ PUSH_EBX ; Put return back in place
+ RETURN ; Return to caller
+
+
+;; set_break_frame microfunction
+;; Recieves char* head in EAX and char* num in EBX
+;; Overwrites EAX and EBX
+;; Returns to calling function
+:set_break_frame
+ STORE32_Absolute32_eax &break_target_head ; update break_target_head
+ STORE32_Absolute32_ebx &break_target_num ; update break_target_num
+ LOAD32_Absolute32_ebx &function ; Using function
+ LOAD32_EAX_from_EBX_Immediate8 !4 ; function->LOCALS
+ STORE32_Absolute32_eax &break_frame ; break_frame = function->LOCALS
+ LOAD32_EAX_from_EBX_Immediate8 !8 ; function->S
+ STORE32_Absolute32_eax &break_target_func ; break_target_func = function->S
+ RETURN ; Return to sender
+
+
+;; process_do function
+;; Recieves Nothing
+;; Returns Nothing
+;; Increments current_count and leverages save/restore_break_frame pieces
+;; Uses ECX for char* NUMBER_STRING
+:process_do
+ PUSH_EBX ; Protect EBX
+ PUSH_ECX ; Protect ECX
+ CALL32 %save_break_frame ; Save the frame
+
+ LOAD32_Absolute32_eax ¤t_count ; Using current count
+ COPY_EAX_to_EBX ; Preparing for update
+ ADDI8_EBX !1 ; current_count + 1
+ STORE32_Absolute32_ebx ¤t_count ; current_count = current_count + 1
+ CALL32 %numerate_number ; convert to string
+ COPY_EAX_to_ECX ; put NUMBER_STRING in place
+
+ LOADI32_EAX &process_do_string_0 ; Using "DO_END_"
+ COPY_ECX_to_EBX ; Passing NUMBER_STRING
+ CALL32 %set_break_frame ; Set the frame
+
+ LOADI32_EAX &process_do_string_1 ; Using ":DO_"
+ CALL32 %emit_out ; Emit it
+
+ LOAD32_Absolute32_eax &function ; Using function
+ LOAD32_EAX_from_EAX_Immediate8 !8 ; function->S
+ COPY_ECX_to_EBX ; Passing NUMBER_STRING
+ CALL32 %uniqueID_out ; uniqueID_out(function->s, number_string)
+
+ LOAD32_Absolute32_eax &global_token ; Using global_token
+ LOAD32_EAX_from_EAX ; global_token->NEXT
+ STORE32_Absolute32_eax &global_token ; global_token = global_token->NEXT
+
+ CALL32 %statement ; Do the DO {...} part
+
+ LOADI32_EAX &process_do_string_2 ; Using "ERROR in process_do\nMISSING while\n"
+ LOADI32_EBX &while_string ; Using "while"
+ CALL32 %require_match ; Make sure we have it
+
+ LOADI32_EAX &process_do_string_3 ; Using "ERROR in process_do\nMISSING (\n"
+ LOADI32_EBX &open_paren ; Using "("
+ CALL32 %require_match ; Make sure we have it
+
+ CALL32 %expression ; Do the WHILE (...) part
+
+ LOADI32_EAX &process_do_string_4 ; Using "ERROR in process_do\nMISSING )\n"
+ LOADI32_EBX &close_paren ; Using ")"
+ CALL32 %require_match ; Make sure we have it
+
+ LOADI32_EAX &process_do_string_5 ; Using "ERROR in process_do\nMISSING ;\n"
+ LOADI32_EBX &semicolon ; Using ";"
+ CALL32 %require_match ; Make sure we have it
+
+ LOADI32_EAX &process_do_string_6 ; Using "TEST\nJUMP_NE %DO_"
+ CALL32 %emit_out ; Emit it
+
+ LOAD32_Absolute32_eax &function ; Using function
+ LOAD32_EAX_from_EAX_Immediate8 !8 ; function->S
+ COPY_ECX_to_EBX ; Passing NUMBER_STRING
+ CALL32 %uniqueID_out ; uniqueID_out(function->s, number_string)
+
+ LOADI32_EAX &process_do_string_7 ; Using ":DO_END_"
+ CALL32 %emit_out ; Emit it
+
+ LOAD32_Absolute32_eax &function ; Using function
+ LOAD32_EAX_from_EAX_Immediate8 !8 ; function->S
+ CALL32 %uniqueID_out ; uniqueID_out(function->s, number_string)
+
+ CALL32 %restore_break_frame ; Restore the old break frame
+
+ POP_ECX ; Restore ECX
+ POP_EBX ; Restore EBX
+ RETURN
+
+:process_do_string_0 "DO_END_"
+:process_do_string_1 ":DO_"
+:process_do_string_2 "ERROR in process_do
+MISSING while
+"
+:process_do_string_3 "ERROR in process_do
+MISSING (
+"
+:process_do_string_4 "ERROR in process_do
+MISSING )
+"
+:process_do_string_5 "ERROR in process_do
+MISSING ;
+"
+:process_do_string_6 "TEST
+JUMP_NE %DO_"
+:process_do_string_7 ":DO_END_"
+
+
+;; process_while function
+;; Recieves nothing
+;; Returns nothing
+;; Increments current_count and leverages save/restore_break_frame pieces
+;; Uses ECX for char* NUMBER_STRING
+:process_while
+ PUSH_EBX ; Protect EBX
+ PUSH_ECX ; Protect ECX
+ CALL32 %save_break_frame ; Save break_frame
+
+ LOAD32_Absolute32_eax ¤t_count ; Using current count
+ COPY_EAX_to_EBX ; Preparing for update
+ ADDI8_EBX !1 ; current_count + 1
+ STORE32_Absolute32_ebx ¤t_count ; current_count = current_count + 1
+ CALL32 %numerate_number ; convert to string
+ COPY_EAX_to_ECX ; put NUMBER_STRING in place
+
+ LOADI32_EAX &process_while_string_0 ; Using "END_WHILE_"
+ COPY_ECX_to_EBX ; Passing NUMBER_STRING
+ CALL32 %set_break_frame ; Set it and forget it
+
+ LOADI32_EAX &process_while_string_1 ; Using ":WHILE_"
+ CALL32 %emit_out ; Emit it
+
+ LOAD32_Absolute32_eax &function ; Using function
+ LOAD32_EAX_from_EAX_Immediate8 !8 ; function->S
+ COPY_ECX_to_EBX ; Passing NUMBER_STRING
+ CALL32 %uniqueID_out ; uniqueID_out(function->s, number_string)
+
+ LOAD32_Absolute32_eax &global_token ; Using global_token
+ LOAD32_EAX_from_EAX ; global_token->NEXT
+ STORE32_Absolute32_eax &global_token ; global_token = global_token->NEXT
+
+ LOADI32_EAX &process_while_string_2 ; Using "ERROR in process_while\nMISSING (\n"
+ LOADI32_EBX &open_paren ; Using "("
+ CALL32 %require_match ; Make sure we have it
+
+ CALL32 %expression ; Deal with the WHILE (...) part
+
+ LOADI32_EAX &process_while_string_3 ; Using "TEST\nJUMP_EQ %END_WHILE_"
+ CALL32 %emit_out ; Emit it
+
+ LOAD32_Absolute32_eax &function ; Using function
+ LOAD32_EAX_from_EAX_Immediate8 !8 ; function->S
+ COPY_ECX_to_EBX ; Passing NUMBER_STRING
+ CALL32 %uniqueID_out ; uniqueID_out(function->s, number_string)
+
+ LOADI32_EAX &process_while_string_4 ; Using "# THEN_while_"
+ CALL32 %emit_out ; Emit it
+
+ LOAD32_Absolute32_eax &function ; Using function
+ LOAD32_EAX_from_EAX_Immediate8 !8 ; function->S
+ CALL32 %uniqueID_out ; uniqueID_out(function->s, number_string)
+
+ LOADI32_EAX &process_while_string_5 ; Using "ERROR in process_while\nMISSING )\n"
+ LOADI32_EBX &close_paren ; Using ")"
+ CALL32 %require_match ; Make sure we have it
+
+ CALL32 %statement ; Deal with the {....} part
+
+ LOADI32_EAX &process_while_string_6 ; Using "JUMP %WHILE_"
+ CALL32 %emit_out ; Emit it
+
+ LOAD32_Absolute32_eax &function ; Using function
+ LOAD32_EAX_from_EAX_Immediate8 !8 ; function->S
+ COPY_ECX_to_EBX ; Passing NUMBER_STRING
+ CALL32 %uniqueID_out ; uniqueID_out(function->s, number_string)
+
+ LOADI32_EAX &process_while_string_7 ; Using ":END_WHILE_"
+ CALL32 %emit_out ; Emit it
+
+ LOAD32_Absolute32_eax &function ; Using function
+ LOAD32_EAX_from_EAX_Immediate8 !8 ; function->S
+ CALL32 %uniqueID_out ; uniqueID_out(function->s, number_string)
+
+ CALL32 %restore_break_frame ; Restore the old break frame
+
+ POP_ECX ; Restore ECX
+ POP_EBX ; Restore EBX
+ RETURN
+
+:process_while_string_0 "END_WHILE_"
+:process_while_string_1 ":WHILE_"
+:process_while_string_2 "ERROR in process_while
+MISSING (
+"
+:process_while_string_3 "TEST
+JUMP_EQ %END_WHILE_"
+:process_while_string_4 "# THEN_while_"
+:process_while_string_5 "ERROR in process_while
+MISSING )
+"
+:process_while_string_6 "JUMP %WHILE_"
+:process_while_string_7 ":END_WHILE_"
+
+
+;; process_for function
+;; Recieves Nothing
+;; Returns Nothing
+;; Increments current_count and leverages save/restore_break_frame pieces
+;; Uses ECX for char* NUMBER_STRING
+:process_for
+ PUSH_EBX ; Protect EBX
+ PUSH_ECX ; Protect ECX
+ CALL32 %save_break_frame ; Save the frame
+
+ LOAD32_Absolute32_eax ¤t_count ; Using current count
+ COPY_EAX_to_EBX ; Preparing for update
+ ADDI8_EBX !1 ; current_count + 1
+ STORE32_Absolute32_ebx ¤t_count ; current_count = current_count + 1
+ CALL32 %numerate_number ; convert to string
+ COPY_EAX_to_ECX ; put NUMBER_STRING in place
+
+ LOADI32_EAX &process_for_string_0 ; Using "FOR_END_"
+ COPY_ECX_to_EBX ; Passing NUMBER_STRING
+ CALL32 %set_break_frame ; Set it and forget it
+
+ LOADI32_EAX &process_for_string_1 ; Using "# FOR_initialization_"
+ CALL32 %emit_out ; Emit it
+
+ LOAD32_Absolute32_eax &function ; Using function
+ LOAD32_EAX_from_EAX_Immediate8 !8 ; function->S
+ COPY_ECX_to_EBX ; Passing NUMBER_STRING
+ CALL32 %uniqueID_out ; uniqueID_out(function->s, number_string)
+
+ LOAD32_Absolute32_eax &global_token ; Using global_token
+ LOAD32_EAX_from_EAX ; global_token->NEXT
+ STORE32_Absolute32_eax &global_token ; global_token = global_token->NEXT
+
+ LOADI32_EAX &process_for_string_2 ; Using "ERROR in process_for\nMISSING (\n"
+ LOADI32_EBX &open_paren ; Using "("
+ CALL32 %require_match ; Make Sure we have it
+
+ LOAD32_Absolute32_ebx &global_token ; Using global_token
+ LOAD32_EBX_from_EBX_Immediate8 !8 ; global_token->S
+ LOADI32_EAX &semicolon ; Using ";"
+ CALL32 %match ; IF global_token->S == ";"
+ CMPI8_EAX !0 ; Then no initializer
+ JE32 %process_for_terminator ; And skip getting the expression
+
+ ;; Deal with FOR (...; case
+ CALL32 %expression ; Get the FOR ( ... ; part
+
+:process_for_terminator
+ LOADI32_EAX &process_for_string_3 ; Using ":FOR_"
+ CALL32 %emit_out ; Emit it
+
+ LOAD32_Absolute32_eax &function ; Using function
+ LOAD32_EAX_from_EAX_Immediate8 !8 ; function->S
+ COPY_ECX_to_EBX ; Passing NUMBER_STRING
+ CALL32 %uniqueID_out ; uniqueID_out(function->s, number_string)
+
+ LOADI32_EAX &process_for_string_4 ; Using "ERROR in process_for\nMISSING ;1\n"
+ LOADI32_EBX &semicolon ; Using ";"
+ CALL32 %require_match ; Make sure we have it
+
+ CALL32 %expression ; Get the FOR ( ; ... ; Part
+
+ LOADI32_EAX &process_for_string_5 ; Using "TEST\nJUMP_EQ %FOR_END_"
+ CALL32 %emit_out ; Emit it
+
+ LOAD32_Absolute32_eax &function ; Using function
+ LOAD32_EAX_from_EAX_Immediate8 !8 ; function->S
+ COPY_ECX_to_EBX ; Passing NUMBER_STRING
+ CALL32 %uniqueID_out ; uniqueID_out(function->s, number_string)
+
+ LOADI32_EAX &process_for_string_6 ; Using "JUMP %FOR_THEN_"
+ CALL32 %emit_out ; Emit it
+
+ LOAD32_Absolute32_eax &function ; Using function
+ LOAD32_EAX_from_EAX_Immediate8 !8 ; function->S
+ CALL32 %uniqueID_out ; uniqueID_out(function->s, number_string)
+
+ LOADI32_EAX &process_for_string_7 ; Using ":FOR_ITER_"
+ CALL32 %emit_out ; Emit it
+
+ LOAD32_Absolute32_eax &function ; Using function
+ LOAD32_EAX_from_EAX_Immediate8 !8 ; function->S
+ CALL32 %uniqueID_out ; uniqueID_out(function->s, number_string)
+
+ LOADI32_EAX &process_for_string_8 ; Using "ERROR in process_for\nMISSING ;2\n"
+ LOADI32_EBX &semicolon ; Using ";"
+ CALL32 %require_match ; Make sure we have it
+
+ CALL32 %expression ; Get the FOR (;;...) part
+
+ LOADI32_EAX &process_for_string_9 ; Using "JUMP %FOR_"
+ CALL32 %emit_out ; Emit it
+
+ LOAD32_Absolute32_eax &function ; Using function
+ LOAD32_EAX_from_EAX_Immediate8 !8 ; function->S
+ COPY_ECX_to_EBX ; Passing NUMBER_STRING
+ CALL32 %uniqueID_out ; uniqueID_out(function->s, number_string)
+
+ LOADI32_EAX &process_for_string_10 ; Using ":FOR_THEN_"
+ CALL32 %emit_out ; Emit it
+
+ LOAD32_Absolute32_eax &function ; Using function
+ LOAD32_EAX_from_EAX_Immediate8 !8 ; function->S
+ CALL32 %uniqueID_out ; uniqueID_out(function->s, number_string)
+
+ LOADI32_EAX &process_for_string_11 ; Using "ERROR in process_for\nMISSING )\n"
+ LOADI32_EBX &close_paren ; Using ")"
+ CALL32 %require_match ; Make sure we have it
+
+ CALL32 %statement ; Get FOR (;;) {...} part
+
+ LOADI32_EAX &process_for_string_12 ; Using "JUMP %FOR_ITER_"
+ CALL32 %emit_out ; Emit it
+
+ LOAD32_Absolute32_eax &function ; Using function
+ LOAD32_EAX_from_EAX_Immediate8 !8 ; function->S
+ COPY_ECX_to_EBX ; Passing NUMBER_STRING
+ CALL32 %uniqueID_out ; uniqueID_out(function->s, number_string)
+
+ LOADI32_EAX &process_for_string_13 ; Using ":FOR_END_"
+ CALL32 %emit_out ; Emit it
+
+ LOAD32_Absolute32_eax &function ; Using function
+ LOAD32_EAX_from_EAX_Immediate8 !8 ; function->S
+ CALL32 %uniqueID_out ; uniqueID_out(function->s, number_string)
+
+ CALL32 %restore_break_frame ; Restore the old break frame
+
+ POP_ECX ; Restore ECX
+ POP_EBX ; Restore EBX
+ RETURN
+
+:process_for_string_0 "FOR_END_"
+:process_for_string_1 "# FOR_initialization_"
+:process_for_string_2 "ERROR in process_for
+MISSING (
+"
+:process_for_string_3 ":FOR_"
+:process_for_string_4 "ERROR in process_for
+MISSING ;1
+"
+:process_for_string_5 "TEST
+JUMP_EQ %FOR_END_"
+:process_for_string_6 "JUMP %FOR_THEN_"
+:process_for_string_7 ":FOR_ITER_"
+:process_for_string_8 "ERROR in process_for
+MISSING ;2
+"
+:process_for_string_9 "JUMP %FOR_"
+:process_for_string_10 ":FOR_THEN_"
+:process_for_string_11 "ERROR in process_for
+MISSING )
+"
+:process_for_string_12 "JUMP %FOR_ITER_"
+:process_for_string_13 ":FOR_END_"
+
+
+;; process_break function
+;; Recieves nothing
+;; Returns nothing
+;; Handles the break out of loops case
+;; Uses EBX for struct token_list* break_frame and ECX for struct token_list* I
+:process_break
+ PUSH_EBX ; Protect EBX
+ PUSH_ECX ; Protect ECX
+ LOAD32_Absolute32_eax &break_target_head ; Catch big error
+ CMPI8_EAX !0 ; IF(NULL == break_target_head)
+ JE32 %process_break_bad ; I'm sorry Mr White but you have stage-3 lung cancer
+
+ LOAD32_Absolute32_eax &function ; Using function
+ LOAD32_ECX_from_EAX_Immediate8 !4 ; I = function->LOCALS
+ LOAD32_Absolute32_ebx &break_frame ; Put break_frame in the right spot
+ LOADI32_EAX &process_break_string_1 ; Using "POP_ebx\t# break_cleanup_locals\n"
+
+:process_break_iter
+ CMPI8_ECX !0 ; IF (NULL == I)
+ JE32 %process_break_cleaned ; We are done
+
+ CMP_EBX_ECX ; IF I != break_frame
+ JE32 %process_break_cleaned ; We are done
+
+ CALL32 %emit_out ; Emit it
+ LOAD32_ECX_from_ECX ; I = I->NEXT
+ JMP32 %process_break_iter ; Keep looping
+
+:process_break_cleaned
+ LOAD32_Absolute32_eax &global_token ; Using global_token
+ LOAD32_EAX_from_EAX ; global_token->NEXT
+ STORE32_Absolute32_eax &global_token ; global_token = global_token->NEXT
+
+ LOADI32_EAX &process_break_string_2 ; Using "JUMP %"
+ CALL32 %emit_out ; Emit it
+
+ LOAD32_Absolute32_eax &break_target_head ; Get what we are in
+ CALL32 %emit_out ; Emit it
+
+ LOAD32_Absolute32_eax &break_target_func ; Get what function we are in
+ CALL32 %emit_out ; Emit it
+
+ LOADI32_EAX &underline ; Using "_"
+ CALL32 %emit_out ; Emit it
+
+ LOAD32_Absolute32_eax &break_target_num ; Get dem digits
+ CALL32 %emit_out ; Emit it
+
+ LOADI32_EAX &process_break_string_3 ; Using "\n"
+ CALL32 %emit_out ; Emit it
+
+ LOADI32_EAX &process_break_string_4 ; Using "ERROR in break statement\nMissing ;\n"
+ LOADI32_EBX &semicolon ; Using ";"
+ CALL32 %require_match ; Make sure we have it
+
+ POP_ECX ; Restore ECX
+ POP_EBX ; Restore EBX
+ RETURN
+
+:process_break_bad
+ ;; Breaking badly
+ LOADI32_EAX %2 ; Using standard error
+ STORE32_Absolute32_eax &Output_file ; write to standard error
+; CALL32 %line_error ; Write useful debug info
+ COPY_ECX_to_EAX ; put S in the right place
+ CALL32 %File_Print ; print it
+
+ LOADI32_EAX &process_break_string_0 ; Ending string
+ CALL32 %File_Print ; print it
+ JMP32 %Exit_Failure ; Abort Hard
+
+:process_break_string_0 "Not inside of a loop or case statement"
+:process_break_string_1 "POP_ebx # break_cleanup_locals
+"
+:process_break_string_2 "JUMP %"
+:process_break_string_3 "
+"
+:process_break_string_4 "ERROR in break statement
+Missing ;
+"
+
+
+;; expression function
+;; Recieves Nothing
+;; Returns Nothing
+;; Walks global_token and updates output_list
+;; Uses EAX and EBX for match and ECX for char* store
+:expression
+ PUSH_EBX ; Protect EBX
+ PUSH_ECX ; Protect ECX
+ CALL32 %bitwise_expr ; Collect bitwise expressions
+
+ LOAD32_Absolute32_ebx &global_token ; Using global_token
+ LOAD32_EBX_from_EBX_Immediate8 !8 ; global_token->S
+ LOADI32_EAX &equal ; "="
+ CALL32 %match ; IF global_token->S == "="
+ CMPI8_EAX !0 ; We have to deal with assignment
+ JNE32 %expression_done ; Looks like nope
+
+ ;; Deal with possible assignment
+ LOADI32_ECX &expression_string_1 ; Assume "STORE_CHAR\n" by default
+ LOAD32_Absolute32_ebx &global_token ; Using global_token
+ LOAD32_EBX_from_EBX_Immediate8 !4 ; global_token->PREV
+ LOAD32_EBX_from_EBX_Immediate8 !8 ; global_token->PREV->S
+ LOADI32_EAX &close_bracket ; Using "]"
+ CALL32 %match ; IF global_token->S == "]"
+ CMPI8_EAX !0 ; Then we might have a char
+ JNE32 %expression_int ; Otherwise INT
+
+ LOAD32_Absolute32_ebx ¤t_target ; Using current_target
+ LOAD32_EBX_from_EBX_Immediate8 !24 ; current_target->NAME
+ LOADI32_EAX &type_char_indirect_name ; Using "char*"
+ CALL32 %match ; Intensional inefficency because I feel like it
+ CMPI8_EAX !0 ; IF current_target->NAME == "char*"
+ JNE32 %expression_int ; Do char anyway
+
+ JMP32 %expression_common ; Looks like we have to use "STORE_CHAR\n"
+
+:expression_int
+ LOADI32_ECX &expression_string_0 ; Use "STORE_INTEGER\n"
+
+:expression_common
+ LOADI32_EAX &expression ; Passing expression
+ CALL32 %common_recursion ; Recurse
+ COPY_ECX_to_EAX ; Using Store
+ CALL32 %emit_out ; Emit it
+ LOADI32_EAX %0 ; Using NULL
+ STORE32_Absolute32_eax ¤t_target ; current_target = NULL
+
+:expression_done
+ POP_ECX ; Restore ECX
+ POP_EBX ; Restore EBX
+ RETURN
+
+:expression_string_0 "STORE_INTEGER
+"
+:expression_string_1 "STORE_CHAR
+"
+
+
+;; bitwise_expr function
+;; Recieves nothing
+;; Returns nothing
+;; Walks global_token list and updates output list
+;; Just calls other functions
+:bitwise_expr
+ CALL32 %relational_expr ; Walk up the tree
+ CALL32 %bitwise_expr_stub ; Let general recursion do the work
+ RETURN
+
+
+;; bitwise_expr_stub function
+;; Recieves nothing
+;; Returns Nothing
+;; Just calls general_recursion a bunch
+;; Uses EAX, EBX, ECX and EDX for passing constants to general recursion
+:bitwise_expr_stub
+ PUSH_EBX ; Protect EBX
+ PUSH_ECX ; Protect ECX
+ PUSH_EDX ; Protect EDX
+
+ LOADI32_EAX &relational_expr ; Using relational_expr
+ LOADI32_EBX &bitwise_expr_stub_string_0 ; Using "AND_eax_ebx\n"
+ LOADI32_ECX &bitwise_and ; Using "&"
+ LOADI32_EDX &bitwise_expr_stub ; And recurse
+ CALL32 %general_recursion ; Hit it
+
+ LOADI32_EAX &relational_expr ; Using relational_expr
+ LOADI32_EBX &bitwise_expr_stub_string_0 ; Using "AND_eax_ebx\n"
+ LOADI32_ECX &logical_and ; Using "&&"
+ LOADI32_EDX &bitwise_expr_stub ; And recurse
+ CALL32 %general_recursion ; Hit it
+
+ LOADI32_EAX &relational_expr ; Using relational_expr
+ LOADI32_EBX &bitwise_expr_stub_string_1 ; Using "OR_eax_ebx\n"
+ LOADI32_ECX &bitwise_or ; Using "|"
+ LOADI32_EDX &bitwise_expr_stub ; And recurse
+ CALL32 %general_recursion ; Hit it
+
+ LOADI32_EAX &relational_expr ; Using relational_expr
+ LOADI32_EBX &bitwise_expr_stub_string_1 ; Using "OR_eax_ebx\n"
+ LOADI32_ECX &logical_or ; Using "||"
+ LOADI32_EDX &bitwise_expr_stub ; And recurse
+ CALL32 %general_recursion ; Hit it
+
+ LOADI32_EAX &relational_expr ; Using relational_expr
+ LOADI32_EBX &bitwise_expr_stub_string_2 ; Using "XOR_ebx_eax_into_eax\n"
+ LOADI32_ECX &bitwise_xor ; Using "^"
+ LOADI32_EDX &bitwise_expr_stub ; And recurse
+ CALL32 %general_recursion ; Hit it
+
+ POP_EDX ; Restore EDX
+ POP_ECX ; Restore ECX
+ POP_EBX ; Restore EBX
+ RETURN
+
+:bitwise_expr_stub_string_0 "AND_eax_ebx
+"
+:bitwise_expr_stub_string_1 "OR_eax_ebx
+"
+:bitwise_expr_stub_string_2 "XOR_ebx_eax_into_eax
+"
+
+
+;; relational_expr function
+;; Recieves nothing
+;; Returns Nothing
+;; Walks global_token list and updates output list
+;; just calls other function
+:relational_expr
+ CALL32 %additive_expr ; Walk up the tree
+ CALL32 %relational_expr_stub ; Recurse
+ RETURN
+
+
+;; relational_expr_stub function
+;; Recieves nothing
+;; Returns Nothing
+;; Just calls general_recursion a bunch
+;; Uses EAX, EBX, ECX and EDX for passing constants to general recursion
+:relational_expr_stub
+ PUSH_EBX ; Protect EBX
+ PUSH_ECX ; Protect ECX
+ PUSH_EDX ; Protect EDX
+
+ LOADI32_EAX &additive_expr ; Using additive_expr
+ LOADI32_EBX &relational_expr_stub_string_0 ; Using "CMP\nSETL\nMOVEZBL\n"
+ LOADI32_ECX &less_than_string ; Using "<"
+ LOADI32_EDX &relational_expr_stub ; And recurse
+ CALL32 %general_recursion ; Hit it
+
+ LOADI32_EAX &additive_expr ; Using additive_expr
+ LOADI32_EBX &relational_expr_stub_string_1 ; Using "CMP\nSETLE\nMOVEZBL\n"
+ LOADI32_ECX &less_than_equal_string ; Using "<="
+ LOADI32_EDX &relational_expr_stub ; And recurse
+ CALL32 %general_recursion ; Hit it
+
+ LOADI32_EAX &additive_expr ; Using additive_expr
+ LOADI32_EBX &relational_expr_stub_string_2 ; Using "CMP\nSETGE\nMOVEZBL\n"
+ LOADI32_ECX &greater_than_equal_string ; Using ">="
+ LOADI32_EDX &relational_expr_stub ; And recurse
+ CALL32 %general_recursion ; Hit it
+
+ LOADI32_EAX &additive_expr ; Using additive_expr
+ LOADI32_EBX &relational_expr_stub_string_3 ; Using "CMP\nSETG\nMOVEZBL\n"
+ LOADI32_ECX &greater_than_string ; Using ">"
+ LOADI32_EDX &relational_expr_stub ; And recurse
+ CALL32 %general_recursion ; Hit it
+
+ LOADI32_EAX &additive_expr ; Using additive_expr
+ LOADI32_EBX &relational_expr_stub_string_4 ; Using "CMP\nSETE\nMOVEZBL\n"
+ LOADI32_ECX &equal_to_string ; Using "=="
+ LOADI32_EDX &relational_expr_stub ; And recurse
+ CALL32 %general_recursion ; Hit it
+
+ LOADI32_EAX &additive_expr ; Using additive_expr
+ LOADI32_EBX &relational_expr_stub_string_5 ; Using "CMP\nSETNE\nMOVEZBL\n"
+ LOADI32_ECX ¬_equal_string ; Using "!="
+ LOADI32_EDX &relational_expr_stub ; And recurse
+ CALL32 %general_recursion ; Hit it
+
+ POP_EDX ; Restore EDX
+ POP_ECX ; Restore ECX
+ POP_EBX ; Restore EBX
+ RETURN
+
+:relational_expr_stub_string_0 "CMP
+SETL
+MOVEZBL
+"
+:relational_expr_stub_string_1 "CMP
+SETLE
+MOVEZBL
+"
+:relational_expr_stub_string_2 "CMP
+SETGE
+MOVEZBL
+"
+:relational_expr_stub_string_3 "CMP
+SETG
+MOVEZBL
+"
+:relational_expr_stub_string_4 "CMP
+SETE
+MOVEZBL
+"
+:relational_expr_stub_string_5 "CMP
+SETNE
+MOVEZBL
+"
+
+
+;; additive_expr function
+;; Recieves nothing
+;; Returns Nothing
+;; Walks global_token list and updates output list
+;; just calls other function
+:additive_expr
+ CALL32 %postfix_expr ; Walk up the tree
+ CALL32 %additive_expr_stub ; Recurse
+ RETURN
+
+
+;; additive_expr_stub function
+;; Recieves nothing
+;; Returns Nothing
+;; Just calls general_recursion a bunch
+;; Uses EAX, EBX, ECX and EDX for passing constants to general recursion
+:additive_expr_stub
+ PUSH_EBX ; Protect EBX
+ PUSH_ECX ; Protect ECX
+ PUSH_EDX ; Protect EDX
+
+ LOADI32_EAX &postfix_expr ; Using postfix_expr
+ LOADI32_EBX &additive_expr_stub_string_0 ; Using "ADD_ebx_to_eax\n"
+ LOADI32_ECX &plus_string ; Using "+"
+ LOADI32_EDX &additive_expr_stub ; And recurse
+ CALL32 %general_recursion ; Hit it
+
+ LOADI32_EAX &postfix_expr ; Using postfix_expr
+ LOADI32_EBX &additive_expr_stub_string_1 ; Using "SUBTRACT_eax_from_ebx_into_ebx\nMOVE_ebx_to_eax\n"
+ LOADI32_ECX &minus_string ; Using "-"
+ LOADI32_EDX &additive_expr_stub ; And recurse
+ CALL32 %general_recursion ; Hit it
+
+ LOADI32_EAX &postfix_expr ; Using postfix_expr
+ LOADI32_EBX &additive_expr_stub_string_2 ; Using "MULTIPLY_eax_by_ebx_into_eax\n"
+ LOADI32_ECX &multiply_string ; Using "*"
+ LOADI32_EDX &additive_expr_stub ; And recurse
+ CALL32 %general_recursion ; Hit it
+
+ LOADI32_EAX &postfix_expr ; Using postfix_expr
+ LOADI32_EBX &additive_expr_stub_string_3 ; Using "XCHG_eax_ebx\nLOAD_IMMEDIATE_edx %0\nDIVIDE_eax_by_ebx_into_eax\n"
+ LOADI32_ECX ÷_string ; Using "/"
+ LOADI32_EDX &additive_expr_stub ; And recurse
+ CALL32 %general_recursion ; Hit it
+
+ LOADI32_EAX &postfix_expr ; Using postfix_expr
+ LOADI32_EBX &additive_expr_stub_string_4 ; Using "XCHG_eax_ebx\nLOAD_IMMEDIATE_edx %0\nMODULUS_eax_from_ebx_into_ebx\nMOVE_edx_to_eax\n"
+ LOADI32_ECX &modulus_string ; Using "%"
+ LOADI32_EDX &additive_expr_stub ; And recurse
+ CALL32 %general_recursion ; Hit it
+
+ LOADI32_EAX &postfix_expr ; Using postfix_expr
+ LOADI32_EBX &additive_expr_stub_string_5 ; Using "COPY_eax_to_ecx\nCOPY_ebx_to_eax\nSAL_eax_cl\n"
+ LOADI32_ECX &left_shift_string ; Using "<<"
+ LOADI32_EDX &additive_expr_stub ; And recurse
+ CALL32 %general_recursion ; Hit it
+
+ LOADI32_EAX &postfix_expr ; Using postfix_expr
+ LOADI32_EBX &additive_expr_stub_string_6 ; Using "COPY_eax_to_ecx\nCOPY_ebx_to_eax\nSAR_eax_cl\n"
+ LOADI32_ECX &right_shift_string ; Using ">>"
+ LOADI32_EDX &additive_expr_stub ; And recurse
+ CALL32 %general_recursion ; Hit it
+
+ POP_EDX ; Restore EDX
+ POP_ECX ; Restore ECX
+ POP_EBX ; Restore EBX
+ RETURN
+
+:additive_expr_stub_string_0 "ADD_ebx_to_eax
+"
+:additive_expr_stub_string_1 "SUBTRACT_eax_from_ebx_into_ebx
+MOVE_ebx_to_eax
+"
+:additive_expr_stub_string_2 "MULTIPLY_eax_by_ebx_into_eax
+"
+:additive_expr_stub_string_3 "XCHG_eax_ebx
+LOAD_IMMEDIATE_edx %0
+DIVIDE_eax_by_ebx_into_eax
+"
+:additive_expr_stub_string_4 "XCHG_eax_ebx
+LOAD_IMMEDIATE_edx %0
+MODULUS_eax_from_ebx_into_ebx
+MOVE_edx_to_eax
+"
+:additive_expr_stub_string_5 "COPY_eax_to_ecx
+COPY_ebx_to_eax
+SAL_eax_cl
+"
+:additive_expr_stub_string_6 "COPY_eax_to_ecx
+COPY_ebx_to_eax
+SAR_eax_cl
+"
+
+
+;; postfix_expr function
+;; Recieves nothing
+;; Returns Nothing
+;; Walks global_token list and updates output list
+;; just calls other function
+:postfix_expr
+ CALL32 %primary_expr ; Walk up the tree
+ CALL32 %postfix_expr_stub ; Recurse
+ RETURN
+
+
+;; postfix_expr_stub function
+;; Recieves nothing
+;; Returns Nothing
+;; Checks for "[" and "->" and deals with them otherwise does nothing
+;; Uses EAX, EBX, ECX and EDX for passing constants to general recursion
+:postfix_expr_stub
+ PUSH_EBX ; Protect EBX
+ LOAD32_Absolute32_ebx &global_token ; Using global_token
+ LOAD32_EBX_from_EBX_Immediate8 !8 ; global_token->S
+ LOADI32_EAX &open_bracket ; Using "["
+ CALL32 %match ; IF global_token->S == "["
+ CMPI8_EAX !0 ; then we have an array
+ JNE32 %postfix_expr_stub_arrow ; Otherwise try arrow
+
+ ;; Deal with array
+ CALL32 %postfix_expr_array ; Get it
+ CALL32 %postfix_expr_stub ; Recurse
+
+:postfix_expr_stub_arrow
+ LOADI32_EAX &arrow_string ; Using "->"
+ CALL32 %match ; IF global_token->S == "->"
+ CMPI8_EAX !0 ; Then we need to deal with struct offsets
+ JNE32 %postfix_expr_stub_done ; Otherwise be done
+
+ ;; Deal with arrow
+ CALL32 %postfix_expr_arrow ; Get it
+ CALL32 %postfix_expr_stub ; Recurse
+
+:postfix_expr_stub_done
+ POP_EBX ; Restore EBX
+ RETURN
+
+
+;; unary_expr_sizeof function
+;; Recieves nothing
+;; Returns nothing
+;; Uses ECX for A->SIZE
+:unary_expr_sizeof
+ PUSH_EBX ; Protect EBX
+ PUSH_ECX ; Protect ECX
+ LOAD32_Absolute32_eax &global_token ; Using global_token
+ LOAD32_EAX_from_EAX ; global_token->NEXT
+ STORE32_Absolute32_eax &global_token ; global_token = global_token->NEXT
+
+ LOADI32_EAX &unary_expr_sizeof_string_0 ; Using "ERROR in unary_expr\nMissing (\n"
+ LOADI32_EBX &open_paren ; Using "("
+ CALL32 %require_match ; Make sure we have it
+
+ CALL32 %type_name ; Get the type
+ LOAD32_ECX_from_EAX_Immediate8 !4 ; Set A->TYPE
+
+ LOADI32_EAX &unary_expr_sizeof_string_1 ; Using "ERROR in unary_expr\nMissing )\n"
+ LOADI32_EBX &close_paren ; Using ")"
+ CALL32 %require_match ; Make sure we have it
+
+ LOADI32_EAX &unary_expr_sizeof_string_2 ; Using "LOAD_IMMEDIATE_eax %"
+ CALL32 %emit_out ; Emit it
+
+ COPY_ECX_to_EAX ; Put A->SIZE in the right place
+ CALL32 %numerate_number ; Turn into string
+ CALL32 %emit_out ; Emit it
+
+ LOADI32_EAX &unary_expr_sizeof_string_3 ; Using "\n"
+ CALL32 %emit_out ; Emit it
+
+ POP_ECX ; Restore ECX
+ POP_EBX ; Restore EBX
+ RETURN
+
+:unary_expr_sizeof_string_0 "ERROR in unary_expr
+Missing (
+"
+:unary_expr_sizeof_string_1 "ERROR in unary_expr
+Missing )
+"
+:unary_expr_sizeof_string_2 "LOAD_IMMEDIATE_eax %"
+:unary_expr_sizeof_string_3 "
+"
+
+
+;; postfix_expr_array function
+;; Recieves Nothing
+;; Returns Nothing
+;; Uses EBX for struct type* ARRAY and ECX for char* ASSIGN
+:postfix_expr_array
+ PUSH_EBX ; Protect EBX
+ PUSH_ECX ; Protect ECX
+ LOAD32_Absolute32_eax ¤t_target ; ARRAY = current_target
+ PUSH_EAX ; Protect it
+
+ LOADI32_EAX &expression ; Using expression
+ CALL32 %common_recursion ; Recurse
+
+ POP_EBX ; Restore array
+ STORE32_Absolute32_ebx ¤t_target ; current_target = ARRAY
+
+ LOADI32_ECX &postfix_expr_array_string_0 ; ASSIGN = "LOAD_INTEGER\n"
+
+ LOADI32_EAX &type_char_indirect_name ; Using "char*"
+ LOAD32_EBX_from_EBX_Immediate8 !24 ; current_target->NAME
+ CALL32 %match ; IF current_target->NAME == "char*"
+ CMPI8_EAX !0 ; load a byte
+ JNE32 %postfix_expr_array_large ; Otherwise adjust
+
+ ;; Deal with loading byte
+ LOADI32_ECX &postfix_expr_array_string_1 ; ASSIGN = "LOAD_BYTE\n"
+ JMP32 %postfix_expr_array_common ; Do the next bit
+
+:postfix_expr_array_large
+ ;; deal with arrays made of things other than chars
+ LOADI32_EAX &postfix_expr_array_string_2 ; Using "SAL_eax_Immediate8 !"
+ CALL32 %emit_out ; Emit it
+
+ LOAD32_Absolute32_eax ¤t_target ; Using current_target
+ LOAD32_EAX_from_EAX_Immediate8 !12 ; current_target->INDIRECT
+ LOAD32_EAX_from_EAX_Immediate8 !4 ; current_target->INDIRECT->SIZE
+ CALL32 %ceil_log2 ; ceil_log2(current_target->indirect->size)
+ CALL32 %numerate_number ; numerate_number(ceil_log2(current_target->indirect->size))
+ CALL32 %emit_out ; Emit it
+
+ LOADI32_EAX &postfix_expr_array_string_3 ; Using "\n"
+ CALL32 %emit_out ; Emit it
+
+:postfix_expr_array_common
+ LOADI32_EAX &postfix_expr_array_string_4 ; Using "ADD_ebx_to_eax\n"
+ CALL32 %emit_out ; Emit it
+
+ LOADI32_EAX &postfix_expr_array_string_5 ; Using "ERROR in postfix_expr\nMissing ]\n"
+ LOADI32_EBX &close_bracket ; Using "]"
+ CALL32 %require_match ; Make sure we have it
+
+ LOAD32_Absolute32_ebx &global_token ; Using global_token
+ LOAD32_EBX_from_EBX_Immediate8 !8 ; global_token->S
+ LOADI32_EAX &equal ; Using "="
+ CALL32 %match ; IF global_token->S == "="
+ CMPI8_EAX !0 ; We need to preserve address
+ JNE32 %postfix_expr_array_done ; Otherwise be done
+
+ ;; Clearing out assign
+ LOADI32_ECX &postfix_expr_array_string_6 ; ASSIGN = ""
+
+:postfix_expr_array_done
+ COPY_ECX_to_EAX ; Using ASSIGN
+ CALL32 %emit_out ; Emit it
+
+ POP_ECX ; Restore ECX
+ POP_EBX ; Restore EBX
+ RETURN
+
+:postfix_expr_array_string_0 "LOAD_INTEGER
+"
+:postfix_expr_array_string_1 "LOAD_BYTE
+"
+:postfix_expr_array_string_2 "SAL_eax_Immediate8 !"
+:postfix_expr_array_string_3 "
+"
+:postfix_expr_array_string_4 "ADD_ebx_to_eax
+"
+:postfix_expr_array_string_5 "ERROR in postfix_expr
+Missing ]
+"
+:postfix_expr_array_string_6 ""
+
+
+;; ceil_log2 function
+;; Recieves int a in EAX
+;; Performs log2 on A and
+;; Returns result in EAX
+;; Uses EBX for INT A and ECX for INT RESULT
+:ceil_log2
+ PUSH_EBX ; Protect EBX
+ PUSH_ECX ; Protect ECX
+ LOADI32_ECX %0 ; RESULT = 0
+
+ COPY_EAX_to_EBX ; put A in right place
+ SUBI8_EAX !1 ; (A - 1)
+ AND_EAX_EBX ; A & (A - 1)
+ CMPI8_EAX !0 ; IF 0 == (A & (A - 1))
+ JNE32 %ceil_log2_iter ; Starting from -1
+
+ LOADI32_ECX %-1 ; RESULT = -1
+
+:ceil_log2_iter
+ CMPI8_EBX !0 ; IF A > 0
+ JLE32 %ceil_log2_done ; Otherwise be done
+
+ ADDI8_ECX !1 ; RESULT = RESULT + 1
+ SHRI8_EBX !1 ; A = A >> 1
+ JMP32 %ceil_log2_iter ; Keep looping
+
+:ceil_log2_done
+ COPY_ECX_to_EAX ; Return RESULT
+ POP_ECX ; Restore ECX
+ POP_EBX ; Restore EBX
+ RETURN
+
+
+;; postfix_expr_arrow function
+;; Recieves nothing
+;; Returns nothing
+;; Emits a bunch and updates current_target
+;; Uses EBX for struct type* I
+:postfix_expr_arrow
+ PUSH_EBX ; Protect EBX
+ LOADI32_EAX &postfix_expr_arrow_string_0 ; Using "# looking up offset\n"
+ CALL32 %emit_out ; Emit it
+
+ LOAD32_Absolute32_eax &global_token ; Using global_token
+ LOAD32_EAX_from_EAX ; global_token->NEXT
+ STORE32_Absolute32_eax &global_token ; global_token = global_token->NEXT
+
+ LOAD32_EBX_from_EAX_Immediate8 !8 ; Using global_token->S
+ LOAD32_Absolute32_eax ¤t_target ; Using current_target
+ CALL32 %lookup_member ; lookup_member(current_target, global_token->s)
+ COPY_EAX_to_EBX ; struct type* I = lookup_member(current_target, global_token->s)
+
+ LOAD32_EAX_from_EAX_Immediate8 !20 ; I->TYPE
+ STORE32_Absolute32_eax ¤t_target ; current_target = I->TYPE
+
+ LOAD32_Absolute32_eax &global_token ; Using global_token
+ LOAD32_EAX_from_EAX ; global_token->NEXT
+ STORE32_Absolute32_eax &global_token ; global_token = global_token->NEXT
+
+ LOAD32_EAX_from_EBX_Immediate8 !8 ; I->OFFSET
+ CMPI8_EAX !0 ; IF 0 != I->OFFSET
+ JE32 %postfix_expr_arrow_first ; Then we don't need to do an offset
+
+ ;; Deal with needing an offset
+ LOADI32_EAX &postfix_expr_arrow_string_1 ; Using "# -> offset calculation\nLOAD_IMMEDIATE_ebx %"
+ CALL32 %emit_out ; Emit it
+
+ LOAD32_EAX_from_EBX_Immediate8 !8 ; I->OFFSET
+ CALL32 %numerate_number ; Convert to string
+ CALL32 %emit_out ; Emit it
+
+ LOADI32_EAX &postfix_expr_arrow_string_2 ; Using "\nADD_ebx_to_eax\n"
+ CALL32 %emit_out ; Emit it
+
+:postfix_expr_arrow_first
+ LOAD32_EAX_from_EBX_Immediate8 !4 ; I->SIZE
+ CMPI8_EAX !4 ; IF I->SIZE >= 4
+ JL32 %postfix_expr_arrow_done ; Otherwise be done
+
+ ;; Last chance for load
+ LOAD32_Absolute32_eax &global_token ; Using global_token
+ LOAD32_EBX_from_EAX_Immediate8 !8 ; global_token->S
+ LOADI32_EAX &equal ; Using "="
+ CALL32 %match ; IF global_token->S == "="
+ CMPI8_EAX !0 ; Then we have assignment and should not load
+ JE32 %postfix_expr_arrow_done ; Be done
+
+ ;; Deal with load case
+ LOADI32_EAX &postfix_expr_arrow_string_3 ; Using "LOAD_INTEGER\n"
+ CALL32 %emit_out ; Emit it
+
+:postfix_expr_arrow_done
+ POP_EBX ; Restore EBX
+ RETURN
+
+:postfix_expr_arrow_string_0 "# looking up offset
+"
+:postfix_expr_arrow_string_1 "# -> offset calculation
+LOAD_IMMEDIATE_ebx %"
+:postfix_expr_arrow_string_2 "
+ADD_ebx_to_eax
+"
+:postfix_expr_arrow_string_3 "LOAD_INTEGER
+"
+
+
+;; primary_expr function
+;; Recieves nothing
+;; Returns nothing
+:primary_expr
+ PUSH_EBX ; Protect EBX
+
+ LOAD32_Absolute32_eax &global_token ; Using global_token
+ LOAD32_EBX_from_EAX_Immediate8 !8 ; global_token->S
+ LOADI32_EAX &sizeof_string ; Using "sizeof"
+ CALL32 %match ; See if match
+ CMPI8_EAX !0 ; IF match
+ JNE32 %primary_expr_neg ; Otherwise try negatives
+
+ ;; Deal with sizeof
+ CALL32 %unary_expr_sizeof ; Lets do this
+ JMP32 %primary_expr_done ; Be done
+
+:primary_expr_neg
+ LOAD32_Absolute32_eax &global_token ; Using global_token
+ LOAD32_EAX_from_EAX_Immediate8 !8 ; global_token->S
+ LOAD8_al_from_EAX ; global_token->S[0]
+ MOVZX_al ; Make it useful
+ CMPI8_EAX !45 ; IF global_token->S[0] == "-"
+ JNE32 %primary_expr_not ; Otherwise try logical NOT
+
+ ;; Deal with negative numbers
+ LOADI32_EAX &primary_expr_string_0 ; Using "LOAD_IMMEDIATE_eax %0\n"
+ CALL32 %emit_out ; Emit it
+
+ LOADI32_EAX &postfix_expr ; Passing postfix_expr
+ CALL32 %common_recursion ; Get what it is notting
+
+ LOADI32_EAX &primary_expr_string_1 ; Using "SUBTRACT_eax_from_ebx_into_ebx\nMOVE_ebx_to_eax\n"
+ CALL32 %emit_out ; Emit it
+ JMP32 %primary_expr_done ; Be done
+
+:primary_expr_not
+ LOAD32_Absolute32_eax &global_token ; Using global_token
+ LOAD32_EAX_from_EAX_Immediate8 !8 ; global_token->S
+ LOAD8_al_from_EAX ; global_token->S[0]
+ MOVZX_al ; Make it useful
+ CMPI8_EAX !33 ; IF global_token->S[0] == "!"
+ JNE32 %primary_expr_bin ; Otherwise try '~'
+
+ ;; Deal with logical not
+ LOADI32_EAX &primary_expr_string_2 ; Using "LOAD_IMMEDIATE_eax %1\n"
+ CALL32 %emit_out ; Emit it
+
+ LOADI32_EAX &postfix_expr ; Passing postfix_expr
+ CALL32 %common_recursion ; Get what it is notting
+
+ LOADI32_EAX &primary_expr_string_3 ; Using "XOR_ebx_eax_into_eax\n"
+ CALL32 %emit_out ; Emit it
+ JMP32 %primary_expr_done ; Be done
+
+:primary_expr_bin
+ LOAD32_Absolute32_eax &global_token ; Using global_token
+ LOAD32_EAX_from_EAX_Immediate8 !8 ; global_token->S
+ LOAD8_al_from_EAX ; global_token->S[0]
+ MOVZX_al ; Make it useful
+ CMPI8_EAX !126 ; IF global_token->S[0] == "~"
+ JNE32 %primary_expr_paren ; Otherwise try paren
+
+ ;; Deal with binary NOT
+ LOADI32_EAX &postfix_expr ; Passing postfix_expr
+ CALL32 %common_recursion ; Get what it is notting
+ LOADI32_EAX &primary_expr_string_4 ; Using "NOT_eax\n"
+ CALL32 %emit_out ; Emit it
+ JMP32 %primary_expr_done ; Be done
+
+:primary_expr_paren
+ LOAD32_Absolute32_eax &global_token ; Using global_token
+ LOAD32_EAX_from_EAX_Immediate8 !8 ; global_token->S
+ LOAD8_al_from_EAX ; global_token->S[0]
+ MOVZX_al ; Make it useful
+ CMPI8_EAX !40 ; IF global_token->S[0] == "("
+ JNE32 %primary_expr_ch ; Otherwise try char
+
+ ;; deal with nesting
+ LOAD32_Absolute32_eax &global_token ; Using global_token
+ LOAD32_EAX_from_EAX ; global_token->NEXT
+ STORE32_Absolute32_eax &global_token ; global_token = global_token->NEXT
+ CALL32 %expression ; Lets recurse
+ LOADI32_EAX &primary_expr_string_5 ; Using "Error in Primary expression\nDidn't get )\n"
+ LOADI32_EBX &close_paren ; Using ")"
+ CALL32 %require_match ; Make sure we have it
+ JMP32 %primary_expr_done ; Be done
+
+:primary_expr_ch
+ LOAD32_Absolute32_eax &global_token ; Using global_token
+ LOAD32_EAX_from_EAX_Immediate8 !8 ; global_token->S
+ LOAD8_al_from_EAX ; global_token->S[0]
+ MOVZX_al ; Make it useful
+ CMPI8_EAX !39 ; Using "'"
+ JNE32 %primary_expr_str ; Otherwise try string
+
+ ;; Deal with chars
+ CALL32 %primary_expr_char ; Handle that char
+ JMP32 %primary_expr_done ; Be done
+
+:primary_expr_str
+ LOAD32_Absolute32_eax &global_token ; Using global_token
+ LOAD32_EAX_from_EAX_Immediate8 !8 ; global_token->S
+ LOAD8_al_from_EAX ; global_token->S[0]
+ MOVZX_al ; Make it useful
+ CMPI8_EAX !34 ; Using '\"'
+ JNE32 %primary_expr_var ; Otherwise try a variable
+
+ ;; Deal with strings
+ CALL32 %primary_expr_string ; Handle that string
+ JMP32 %primary_expr_done ; Be done
+
+:primary_expr_var
+ LOAD32_Absolute32_eax &global_token ; Using global_token
+ LOAD32_EAX_from_EAX_Immediate8 !8 ; global_token->S
+ LOAD8_al_from_EAX ; global_token->S[0]
+ MOVZX_al ; Make it useful
+ LOADI32_EBX &primary_expr_string_6 ; Using "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_"
+ CALL32 %In_Set ; See if we have a match
+ CMPI8_EAX !1 ; IF match
+ JNE32 %primary_expr_num ; otherwise try number
+
+ ;; Deal with variables
+ CALL32 %primary_expr_variable ; Deal with variable
+ JMP32 %primary_expr_done ; Be done
+
+:primary_expr_num
+ LOAD32_Absolute32_eax &global_token ; Using global_token
+ LOAD32_EAX_from_EAX_Immediate8 !8 ; global_token->S
+ LOAD8_al_from_EAX ; global_token->S[0]
+ MOVZX_al ; Make it useful
+ LOADI32_EBX &primary_expr_string_7 ; Using "0123456789"
+ CALL32 %In_Set ; See if we have a match
+ CMPI8_EAX !1 ; IF match
+ JNE32 %primary_expr_fail ; otherwise we failed hard
+
+ ;; Deal with numbers
+ CALL32 %primary_expr_number ; Collect the number
+ JMP32 %primary_expr_done ; Be done
+
+:primary_expr_fail
+ ;; looks like we hit bad input
+ ;; abort before it gets bad
+ CALL32 %primary_expr_failure ; No match means failure
+:primary_expr_done
+ POP_EBX ; Restore EBX
+ RETURN
+
+:primary_expr_string_0 "LOAD_IMMEDIATE_eax %0
+"
+:primary_expr_string_1 "SUBTRACT_eax_from_ebx_into_ebx
+MOVE_ebx_to_eax
+"
+:primary_expr_string_2 "LOAD_IMMEDIATE_eax %1
+"
+:primary_expr_string_3 "XOR_ebx_eax_into_eax
+"
+:primary_expr_string_4 "NOT_eax
+"
+:primary_expr_string_5 "Error in Primary expression
+Didn't get )
+"
+:primary_expr_string_6 "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_"
+:primary_expr_string_7 "0123456789"
+
+
+;; primary_expr_variable function
+;; Recieves nothing
+;; Returns nothing
+;; Walks global and updates output
+;; Uses EAX for struct token_list* a and ECX for char* S
+:primary_expr_variable
+ PUSH_EBX ; Protect EBX
+ PUSH_ECX ; Protect ECX
+ LOAD32_Absolute32_eax &global_token ; Using global_token
+ LOAD32_ECX_from_EAX_Immediate8 !8 ; S = global_token->S
+ LOAD32_EAX_from_EAX ; global_token->NEXT
+ STORE32_Absolute32_eax &global_token ; global_token = global_token->NEXT
+
+ COPY_ECX_to_EAX ; Using S
+ LOAD32_Absolute32_ebx &global_constant_list ; Using global_constant_list
+ CALL32 %sym_lookup ; sym_lookup(s, global_constant_list)
+ CMPI8_EAX !0 ; IF NULL == sym_lookup(s, global_constant_list)
+ JE32 %primary_expr_variable_local ; Try locals next
+
+ ;; Deal with constant load
+ LOAD32_EBX_from_EAX_Immediate8 !16 ; a->ARGS
+ LOADI32_EAX &primary_expr_variable_string_2 ; Using "LOAD_IMMEDIATE_eax %"
+ CALL32 %emit_out ; Emit it
+
+ LOAD32_EAX_from_EBX_Immediate8 !8 ; a->ARGS->S
+ CALL32 %emit_out ; Emit it
+
+ LOADI32_EAX &primary_expr_variable_string_1 ; Using "\n"
+ CALL32 %emit_out ; Emit it
+ JMP32 %primary_expr_variable_done ; Be done
+
+:primary_expr_variable_local
+ COPY_ECX_to_EAX ; Using S
+ LOAD32_Absolute32_ebx &function ; Using function
+ LOAD32_EBX_from_EBX_Immediate8 !4 ; function->locals
+ CALL32 %sym_lookup ; sym_lookup(s, function->locals)
+ CMPI8_EAX !0 ; IF NULL == sym_lookup(s, global_constant_list)
+ JE32 %primary_expr_variable_arguments ; try arguments next
+
+ ;; Deal with local load
+ CALL32 %variable_load ; Collect it
+ JMP32 %primary_expr_variable_done ; Be done
+
+:primary_expr_variable_arguments
+ COPY_ECX_to_EAX ; Using S
+ LOAD32_Absolute32_ebx &function ; Using function
+ LOAD32_EBX_from_EBX_Immediate8 !16 ; function->args
+ CALL32 %sym_lookup ; sym_lookup(s, function->args)
+ CMPI8_EAX !0 ; IF NULL == sym_lookup(s, global_constant_list)
+ JE32 %primary_expr_variable_function ; try functions next
+
+ ;; Deal with argument load
+ CALL32 %variable_load ; Collect it
+ JMP32 %primary_expr_variable_done ; Be done
+
+:primary_expr_variable_function
+ COPY_ECX_to_EAX ; Using S
+ LOAD32_Absolute32_ebx &global_function_list ; Using global_function_list
+ CALL32 %sym_lookup ; sym_lookup(s, global_function_list)
+ CMPI8_EAX !0 ; IF NULL == sym_lookup(s, global_function_list)
+ JE32 %primary_expr_variable_global ; try globals next
+
+ ;; Deal with functions
+ CALL32 %function_load ; Deal with the function
+ JMP32 %primary_expr_variable_done ; Be done
+
+:primary_expr_variable_global
+ COPY_ECX_to_EAX ; Using S
+ LOAD32_Absolute32_ebx &global_symbol_list ; Using global_symbol_list
+ CALL32 %sym_lookup ; sym_lookup(s, global_symbol_list)
+ CMPI8_EAX !0 ; IF NULL == sym_lookup(s, global_symbol_list)
+ JE32 %primary_expr_variable_error ; Give up
+
+ ;; Deal with globals
+ CALL32 %global_load ; Collect that global
+ JMP32 %primary_expr_variable_done ; Be done
+
+:primary_expr_variable_error
+ LOADI32_EAX %2 ; Using standard error
+ STORE32_Absolute32_eax &Output_file ; write to standard error
+; CALL32 %line_error ; Write useful debug info
+ COPY_ECX_to_EAX ; put S in the right place
+ CALL32 %File_Print ; print it
+
+ LOADI32_EAX &primary_expr_variable_string_0 ; Ending string
+ CALL32 %File_Print ; print it
+ JMP32 %Exit_Failure ; Abort Hard
+
+:primary_expr_variable_done
+ POP_ECX ; Restore ECX
+ POP_EBX ; Restore EBX
+ RETURN
+
+:primary_expr_variable_string_0 " is not a defined symbol
+"
+:primary_expr_variable_string_1 "
+"
+:primary_expr_variable_string_2 "LOAD_IMMEDIATE_eax %"
+
+
+;; function_call function
+;; Recieves char* S in EAX and int BOOL in EBX
+;; Builds stack frames before and tears them down after function calls
+;; Uses ECX for char* S, EDX for int BOOL, ESI for PASSED
+:function_call
+ PUSH_EBX ; Protect EBX
+ PUSH_ECX ; Protect ECX
+ PUSH_EDX ; Protect EDX
+ PUSH_ESI ; Protect ESI
+ COPY_EAX_to_ECX ; Put S in place
+ COPY_EBX_to_EDX ; Put BOOL in place
+ LOADI32_ESI %0 ; PASSED = 0
+
+ LOADI32_EAX &function_call_string_0 ; Using "ERROR in process_expression_list\nNo ( was found\n"
+ LOADI32_EBX &open_paren ; Using "("
+ CALL32 %require_match ; Make sure we have it
+
+ LOADI32_EAX &function_call_string_1 ; Using "PUSH_edi\t# Prevent overwriting in recursion\n"
+ CALL32 %emit_out ; Emit it
+
+ LOADI32_EAX &function_call_string_2 ; Using "PUSH_ebp\t# Protect the old base pointer\n"
+ CALL32 %emit_out ; Emit it
+
+ LOADI32_EAX &function_call_string_3 ; Using "COPY_esp_to_edi\t# Copy new base pointer\n"
+ CALL32 %emit_out ; Emit it
+
+ LOAD32_Absolute32_eax &global_token ; Using global_token
+ LOAD32_EAX_from_EAX_Immediate8 !8 ; global_token->S
+ LOAD8_al_from_EAX ; global_token->S[0]
+ MOVZX_al ; Make it useful
+ CMPI8_EAX !41 ; IF global_token->S[0] == ")"
+ JE32 %function_call_gen_done ; Then no arguments to send
+
+ ;; looks like we have arguments to collect
+ CALL32 %expression ; Collect the argument
+
+ LOADI32_EAX &function_call_string_4 ; Using "PUSH_eax\t#_process_expression1\n"
+ CALL32 %emit_out ; Emit it
+ LOADI32_ESI %1 ; PASSED = 1
+
+:function_call_gen_iter
+ LOAD32_Absolute32_eax &global_token ; Using global_token
+ LOAD32_EAX_from_EAX_Immediate8 !8 ; global_token->S
+ LOAD8_al_from_EAX ; global_token->S[0]
+ MOVZX_al ; Make it useful
+ CMPI8_EAX !44 ; IF global_token->S[0] == ","
+ JNE32 %function_call_gen_done ; Otherwise we are done
+
+ LOAD32_Absolute32_eax &global_token ; Using global_token
+ LOAD32_EAX_from_EAX ; global_token->NEXT
+ STORE32_Absolute32_eax &global_token ; global_token = global_token->NEXT
+
+ CALL32 %expression ; Collect the argument
+
+ LOADI32_EAX &function_call_string_5 ; Using "PUSH_eax\t#_process_expression2\n"
+ CALL32 %emit_out ; Emit it
+ ADDI8_ESI !1 ; PASSED = PASSED + 1
+ JMP32 %function_call_gen_iter ; Keep trying
+
+:function_call_gen_done
+ ;; All is collected
+ LOADI32_EAX &function_call_string_6 ; Using "ERROR in process_expression_list\nNo ) was found\n"
+ LOADI32_EBX &close_paren ; Using ")"
+ CALL32 %require_match ; Make sure we have it
+
+ CMPI8_EDX !0 ; IF(BOOL == TRUE)
+ JNE32 %function_call_static ; Otherwise it is a static call
+
+ ;; Deal with a passed function pointer
+ LOADI32_EAX &function_call_string_7 ; Using "LOAD_BASE_ADDRESS_eax %"
+ CALL32 %emit_out ; Emit it
+
+ COPY_ECX_to_EAX ; Using S
+ CALL32 %emit_out ; Emit it
+
+ LOADI32_EAX &function_call_string_8 ; Using "\nLOAD_INTEGER\n"
+ CALL32 %emit_out ; Emit it
+
+ LOADI32_EAX &function_call_string_9 ; Using "COPY_edi_to_ebp\n"
+ CALL32 %emit_out ; Emit it
+
+ LOADI32_EAX &function_call_string_10 ; Using "CALL_eax\n"
+ CALL32 %emit_out ; Emit it
+
+ LOADI32_EAX &function_call_string_13 ; Using "POP_ebx\t# _process_expression_locals\n"
+ JMP32 %function_call_cleanup ; Clean up
+
+:function_call_static
+ ;; Deal with fixed function name
+ LOADI32_EAX &function_call_string_9 ; Using "COPY_edi_to_ebp\n"
+ CALL32 %emit_out ; Emit it
+
+ LOADI32_EAX &function_call_string_11 ; Using "CALL_IMMEDIATE %FUNCTION_"
+ CALL32 %emit_out ; Emit it
+
+ COPY_ECX_to_EAX ; Using S
+ CALL32 %emit_out ; Emit it
+
+ LOADI32_EAX &function_call_string_12 ; Using "\n"
+ CALL32 %emit_out ; Emit it
+
+ LOADI32_EAX &function_call_string_13 ; Using "POP_ebx\t# _process_expression_locals\n"
+
+:function_call_cleanup
+ CMPI8_ESI !0 ; IF PASSED > 0
+ JLE32 %function_call_done ; Otherwise be done
+
+ ;; The desired string is already in EAX
+ CALL32 %emit_out ; Emit it
+
+ SUBI8_ESI !1 ; PASSED = PASSED - 1
+ JMP32 %function_call_cleanup ; Keep going
+
+:function_call_done
+ LOADI32_EAX &function_call_string_14 ; Using "POP_ebp\t# Restore old base pointer\n"
+ CALL32 %emit_out ; Emit it
+
+ LOADI32_EAX &function_call_string_15 ; Using "POP_edi\t# Prevent overwrite\n"
+ CALL32 %emit_out ; Emit it
+
+ POP_ESI ; Restore ESI
+ POP_EDX ; Restore EDX
+ POP_ECX ; Restore ECX
+ POP_EBX ; Restore EBX
+ RETURN
+
+:function_call_string_0 "ERROR in process_expression_list
+No ( was found
+"
+:function_call_string_1 "PUSH_edi # Prevent overwriting in recursion
+"
+:function_call_string_2 "PUSH_ebp # Protect the old base pointer
+"
+:function_call_string_3 "COPY_esp_to_edi # Copy new base pointer
+"
+:function_call_string_4 "PUSH_eax #_process_expression1
+"
+:function_call_string_5 "PUSH_eax #_process_expression2
+"
+:function_call_string_6 "ERROR in process_expression_list
+No ) was found
+"
+:function_call_string_7 "LOAD_BASE_ADDRESS_eax %"
+:function_call_string_8 "
+LOAD_INTEGER
+"
+:function_call_string_9 "COPY_edi_to_ebp
+"
+:function_call_string_10 "CALL_eax
+"
+:function_call_string_11 "CALL_IMMEDIATE %FUNCTION_"
+:function_call_string_12 "
+"
+:function_call_string_13 "POP_ebx # _process_expression_locals
+"
+:function_call_string_14 "POP_ebp # Restore old base pointer
+"
+:function_call_string_15 "POP_edi # Prevent overwrite
+"
+
+
+;; variable_load function
+;; Recieves struct token_list* A in EAX
+;; Returns nothing
+;; Updates output and current_target
+;; Uses ECX for A
+:variable_load
+ PUSH_EBX ; Protect EBX
+ PUSH_ECX ; Protect ECX
+ COPY_EAX_to_ECX ; Protect A
+
+ LOAD32_Absolute32_ebx &global_token ; Using global_token
+ LOAD32_EBX_from_EBX_Immediate8 !8 ; global_token->S
+ LOADI32_EAX &open_paren ; Using "("
+ CALL32 %match ; IF global_token->S == "("
+ CMPI8_EAX !0 ; Then it might be a function
+ JNE32 %variable_load_regular ; Otherwise it is regular
+
+ LOAD32_EBX_from_ECX_Immediate8 !12 ; A->TYPE
+ LOAD32_EBX_from_EBX_Immediate8 !24 ; A->TYPE->NAME
+ LOADI32_EAX &type_function_name ; Using "FUNCTION"
+ CALL32 %match ; IF A->TYPE->NAME == "FUNCTION"
+ CMPI8_EAX !0 ; Then it must be a function
+ JNE32 %variable_load_regular ; otherwise just another regular
+
+ ;; deal with function
+ LOAD32_EAX_from_ECX_Immediate8 !16 ; A->DEPTH
+ CALL32 %numerate_number ; Convert to string
+ LOADI32_EBX %0 ; pass 0 for true
+ CALL32 %function_call ; Create the function call
+ JMP32 %variable_load_done ; Be done
+
+:variable_load_regular
+ LOAD32_EAX_from_ECX_Immediate8 !12 ; A->TYPE
+ STORE32_Absolute32_eax ¤t_target ; current_target = A->TYPE
+
+ LOADI32_EAX &variable_load_string_0 ; Using "LOAD_BASE_ADDRESS_eax %"
+ CALL32 %emit_out ; Emit it
+
+ LOAD32_EAX_from_ECX_Immediate8 !16 ; A->DEPTH
+ CALL32 %numerate_number ; Convert to string
+ CALL32 %emit_out ; Emit it
+
+ LOADI32_EAX &variable_load_string_1 ; Using "\n"
+ CALL32 %emit_out ; Emit it
+
+ ;; Check for special case of assignment
+ LOAD32_Absolute32_ebx &global_token ; Using global_token
+ LOAD32_EBX_from_EBX_Immediate8 !8 ; global_token->S
+ LOADI32_EAX &equal ; Using "="
+ CALL32 %match ; IF global_token->S == "="
+ CMPI8_EAX !0 ; Then we skip loading
+ JE32 %variable_load_done ; And be done
+
+ ;; Deal with common case
+ LOADI32_EAX &variable_load_string_2 ; Using "LOAD_INTEGER\n"
+ CALL32 %emit_out ; Emit it
+
+:variable_load_done
+ POP_ECX ; Restore ECX
+ POP_EBX ; Restore EBX
+ RETURN
+
+:variable_load_string_0 "LOAD_BASE_ADDRESS_eax %"
+:variable_load_string_1 "
+"
+:variable_load_string_2 "LOAD_INTEGER
+"
+
+
+;; function_load function
+;; Recieves struct token_list* a in EAX
+;; Returns nothing
+;; Uses ECX to hold A->S
+:function_load
+ PUSH_EBX ; Protect EBX
+ PUSH_ECX ; Protect ECX
+ LOAD32_EAX_from_EAX_Immediate8 !8 ; A->S
+ COPY_EAX_to_ECX ; Protect A->S
+ LOAD32_Absolute32_ebx &global_token ; Using global_token
+ LOAD32_EBX_from_EBX_Immediate8 !8 ; global_token->S
+ LOADI32_EAX &open_paren ; Using "("
+ CALL32 %match ; IF global_token->S == "("
+ CMPI8_EAX !0 ; The we need to do a function call
+ JNE32 %function_load_regular ; Otherwise just load it's address
+
+ ;; Deal with function call
+ COPY_ECX_to_EAX ; Using A->S
+ LOADI32_EBX %1 ; Using FALSE
+ CALL32 %function_call ; Deal with it
+ JMP32 %function_load_done ; Be done
+
+:function_load_regular
+ LOADI32_EAX &function_load_string_0 ; Using "LOAD_IMMEDIATE_eax &FUNCTION_"
+ CALL32 %emit_out ; Emit it
+
+ COPY_ECX_to_EAX ; Using A->S
+ CALL32 %emit_out ; Emit it
+
+ LOADI32_EAX &function_load_string_1 ; Using "\n"
+ CALL32 %emit_out ; Emit it
+
+:function_load_done
+ POP_ECX ; Restore ECX
+ POP_EBX ; Restore EBX
+ RETURN
+
+:function_load_string_0 "LOAD_IMMEDIATE_eax &FUNCTION_"
+:function_load_string_1 "
+"
+
+
+;; global_load function
+;; Recieves struct token_list* A in EAX
+;; Returns nothing
+;; Uses EBX to hold A->S
+:global_load
+ PUSH_EBX ; Protect EBX
+ COPY_EAX_to_EBX ; Set as A
+ LOAD32_EBX_from_EBX_Immediate8 !8 ; Set as A->S
+
+ LOAD32_EAX_from_EAX_Immediate8 !12 ; A->TYPE
+ STORE32_Absolute32_eax ¤t_target ; current_target = A->TYPE
+
+ LOADI32_EAX &global_load_string_0 ; Using "LOAD_IMMEDIATE_eax &GLOBAL_"
+ CALL32 %emit_out ; Emit it
+
+ COPY_EBX_to_EAX ; Using A->S
+ CALL32 %emit_out ; Emit it
+
+ LOADI32_EAX &global_load_string_1 ; Using "\n"
+ CALL32 %emit_out ; Emit it
+
+ LOAD32_Absolute32_ebx &global_token ; Using global_token
+ LOAD32_EBX_from_EBX_Immediate8 !8 ; global_token->S
+ LOADI32_EAX &equal ; "="
+ CALL32 %match ; IF global_token->S == "="
+ CMPI8_EAX !0 ; We need to skip for assignment
+ JE32 %global_load_done ; and be done
+
+ ;; Otherwise we are loading the contents
+ LOADI32_EAX &global_load_string_2 ; Using "LOAD_INTEGER\n"
+ CALL32 %emit_out ; Emit it
+
+:global_load_done
+ POP_EBX ; Restore EBX
+ RETURN
+
+:global_load_string_0 "LOAD_IMMEDIATE_eax &GLOBAL_"
+:global_load_string_1 "
+"
+:global_load_string_2 "LOAD_INTEGER
+"
+
+
+;; sym_lookup function
+;; Recieves char* S in EAX and struct token_list* symbol_list in EBX
+;; Uses I->S in EAX, S in EBX and I in ECX
+;; Returns match or NULL
+:sym_lookup
+ PUSH_EBX ; Protect EBX
+ PUSH_ECX ; Protect ECX
+ COPY_EBX_to_ECX ; I = symbol_list
+ COPY_EAX_to_EBX ; Put S in the right place
+:sym_lookup_iter
+ CMPI8_ECX !0 ; IF NULL == I
+ JE32 %sym_lookup_done ; We failed to find match
+
+ LOAD32_EAX_from_ECX_Immediate8 !8 ; Using I->S
+ CALL32 %match ; IF I->S == S
+ CMPI8_EAX !0 ; then be done
+ JE32 %sym_lookup_done ; Failed
+
+ LOAD32_ECX_from_ECX ; I = I->NEXT
+ JMP32 %sym_lookup_iter ; otherwise keep looping
+
+:sym_lookup_done
+ COPY_ECX_to_EAX ; Return I
+ POP_ECX ; Restore ECX
+ POP_EBX ; Restore EBX
+ RETURN
+
+
+;; primary_expr_number function
+;; Recieves nothing
+;; Returns nothing
+;; Simply uses current global token to update output and then steps to next global_token
+:primary_expr_number
+ LOADI32_EAX &primary_expr_number_string_0 ; Using "LOAD_IMMEDIATE_eax %"
+ CALL32 %emit_out ; Emit it
+
+ LOAD32_Absolute32_eax &global_token ; Using global_token
+ LOAD32_EAX_from_EAX_Immediate8 !8 ; global_token->S
+ CALL32 %emit_out ; Emit it
+
+ LOADI32_EAX &primary_expr_number_string_1 ; Using "\n"
+ CALL32 %emit_out ; Emit it
+
+ LOAD32_Absolute32_eax &global_token ; Using global_token
+ LOAD32_EAX_from_EAX ; global_token->NEXT
+ STORE32_Absolute32_eax &global_token ; global_token = global_token->NEXT
+ RETURN
+
+:primary_expr_number_string_0 "LOAD_IMMEDIATE_eax %"
+:primary_expr_number_string_1 "
+"
+
+
+;; primary_expr_string function
+;; recieves nothing
+;; Returns nothing
+;; creates entries for string and calls to generate string output
+;; uses ECX for char* number_string
+:primary_expr_string
+ PUSH_EBX ; Protect EBX
+ PUSH_ECX ; Protect ECX
+ LOAD32_Absolute32_ebx ¤t_count ; Using current_count
+ COPY_EBX_to_EAX ; And putting it in the right place
+ CALL32 %numerate_number ; Get the string
+ COPY_EAX_to_ECX ; protect number_string
+
+ ADDI8_EBX !1 ; current_count + 1
+ STORE32_Absolute32_ebx ¤t_count ; current_count = current_count + 1
+
+ LOADI32_EAX &primary_expr_string_string_0 ; Using "LOAD_IMMEDIATE_eax &STRING_"
+ CALL32 %emit_out ; Emit it
+
+ LOAD32_Absolute32_eax &function ; Using function
+ LOAD32_EAX_from_EAX_Immediate8 !8 ; function->S
+ COPY_ECX_to_EBX ; Put number_string in the right place
+ CALL32 %uniqueID_out ; Make it unique
+
+ ;; Generate the target
+ LOADI32_EAX &primary_expr_string_string_1 ; Using ":STRING_"
+ LOAD32_Absolute32_ebx &strings_list ; Using strings_list
+ CALL32 %emit ; Emit it
+ COPY_EAX_to_EBX ; put new strings_list in place
+
+ LOAD32_Absolute32_eax &function ; Using function
+ LOAD32_EAX_from_EAX_Immediate8 !8 ; function->S
+ CALL32 %uniqueID ; Make it unique
+ COPY_EAX_to_EBX ; put new strings_list in place
+
+ ;; Parse the string
+ LOAD32_Absolute32_eax &global_token ; Using global token
+ LOAD32_EAX_from_EAX_Immediate8 !8 ; global_token->S
+ CALL32 %parse_string ; convert to useful form
+ CALL32 %emit ; Emit it
+ STORE32_Absolute32_eax &strings_list ; Update Strings _list
+
+ LOAD32_Absolute32_eax &global_token ; Using global token
+ LOAD32_EAX_from_EAX ; global_token->NEXT
+ STORE32_Absolute32_eax &global_token ; global_token = global_token->NEXT
+
+ POP_ECX ; Restore ECX
+ POP_EBX ; Restore EBX
+ RETURN
+
+:primary_expr_string_string_0 "LOAD_IMMEDIATE_eax &STRING_"
+:primary_expr_string_string_1 ":STRING_"
+
+
+;; primary_expr_char function
+;; Recieves nothing
+;; Returns nothing
+;; Updates output_list using global_token
+:primary_expr_char
+ PUSH_EBX ; Protect EBX
+ PUSH_ECX ; Protect ECX
+ LOADI32_EAX &primary_expr_char_string_0 ; Using "LOAD_IMMEDIATE_eax %"
+ CALL32 %emit_out ; Emit it
+
+ LOAD32_Absolute32_eax &global_token ; Using global token
+ LOAD32_EAX_from_EAX_Immediate8 !8 ; global_token->S
+ ADDI8_EAX !1 ; global_token->S + 1
+ CALL32 %escape_lookup ; Get the char
+ CALL32 %numerate_number ; Convert to string
+ CALL32 %emit_out ; emit it
+
+ LOADI32_EAX &primary_expr_char_string_1 ; Using "\n"
+ CALL32 %emit_out ; Emit it
+
+ LOAD32_Absolute32_eax &global_token ; Using global token
+ LOAD32_EAX_from_EAX ; global_token->NEXT
+ STORE32_Absolute32_eax &global_token ; global_token = global_token->NEXT
+ POP_ECX ; Restore ECX
+ POP_EBX ; Restore EBX
+ RETURN
+
+:primary_expr_char_string_0 "LOAD_IMMEDIATE_eax %"
+:primary_expr_char_string_1 "
+"
+
+
+;; primary_expr_failure function
+;; Recieves nothing
+;; Does not return but aborts hard
+;; Complains about the bad input
+:primary_expr_failure
+; CALL32 %line_error ; Get line of issue
+ LOADI32_EAX %2 ; Using Standard error
+ STORE32_Absolute32_eax &Output_file ; write to standard error
+ LOADI32_EAX &primary_expr_failure_string_0 ; Using "Recieved "
+ CALL32 %File_Print ; Print it
+
+ LOAD32_Absolute32_eax &global_token ; Using global_token
+ LOAD32_EAX_from_EAX_Immediate8 !8 ; global_token->S
+ CALL32 %File_Print ; Print it
+
+ LOADI32_EAX &primary_expr_failure_string_1 ; Using " in primary_expr\n"
+ CALL32 %File_Print ; Print it
+ JMP32 %Exit_Failure ; Abort Hard
+
+:primary_expr_failure_string_0 "Recieved "
+:primary_expr_failure_string_1 " in primary_expr
+"
+
+
+;; general_recursion function
+;; Recieves FUNCTION F in EAX, char* S in EBX, char* name in ECX and FUNCTION iterate in EDX
+;; Returns nothing
+;; Uses ECX for char* S, EDX for FUNCTION iterate and EBP for FUNCTION F
+;; But generally recurses a shitload
+:general_recursion
+ PUSH_EBX ; Protect EBX
+ PUSH_ECX ; Protect ECX
+ PUSH_EDX ; Protect EDX
+ PUSH_EBP ; Protect EBP
+ COPY_EAX_to_EBP ; Protect F
+ COPY_ECX_to_EAX ; Put name in the right place
+ COPY_EBX_to_ECX ; Protect S
+
+ LOAD32_Absolute32_ebx &global_token ; Using global_token
+ LOAD32_EBX_from_EBX_Immediate8 !8 ; global_token->S
+ CALL32 %match ; IF match(name, global_token->s)
+ CMPI8_EAX !0 ; If true we do
+ JNE32 %general_recursion_done ; Otherwise skip it
+
+ ;; Deal with the recursion
+ COPY_EBP_to_EAX ; Put F in the right place
+ CALL32 %common_recursion ; Recurse
+
+ COPY_ECX_to_EAX ; Put S in the right place
+ CALL32 %emit_out ; Emit it
+
+ COPY_EDX_to_EAX ; Put iterate in the right place
+ CALL_EAX ; Down the rabbit hole
+
+:general_recursion_done
+ POP_EBP ; Restore EBP
+ POP_EDX ; Restore EDX
+ POP_ECX ; Restore ECX
+ POP_EBX ; Restore EBX
+ RETURN
+
+
+;; promote_type function
+;; Recieves struct type* a in EAX and struct type* b in EBX
+;; Returns the most recent type in EAX
+;; Uses EAX for struct type* I, ECX for struct type* A and EDX for struct type* B
+:promote_type
+ PUSH_EBX ; Protect EBX
+ PUSH_ECX ; Protect ECX
+ PUSH_EDX ; Protect EDX
+ CMPI8_EBX !0 ; IF NULL == A
+ JE32 %promote_type_done ; Just return A
+
+ COPY_EAX_to_ECX ; Put A in place
+ COPY_EBX_to_EDX ; Put B in place
+ COPY_EBX_to_EAX ; IF NULL == A
+ CMPI8_ECX !0 ; Then we just return B
+ JE32 %promote_type_done ; Be done
+
+ ;; Looks like we need to walk the list
+ LOAD32_ECX_from_ECX_Immediate8 !24 ; A->NAME
+ LOAD32_EDX_from_EDX_Immediate8 !24 ; B->NAME
+ LOAD32_Absolute32_eax &global_types ; I = global_types
+:promote_type_iter
+ CMPI8_EAX !0 ; IF NULL == I
+ JE32 %promote_type_done ; Just be done
+
+ LOAD32_EBX_from_EAX_Immediate8 !24 ; I->NAME
+ CMP_ECX_EBX ; IF(A->NAME == I->NAME)
+ JE32 %promote_type_done ; Be done
+
+ CMP_EBX_EDX ; IF(B->NAME == I->NAME)
+ JE32 %promote_type_done ; Be done
+
+ LOAD32_EBX_from_EAX_Immediate8 !12 ; I->INDIRECT
+ LOAD32_EBX_from_EBX_Immediate8 !24 ; I->INDIRECT->NAME
+
+ CMP_ECX_EBX ; IF(A->NAME == I->INDIRECT->NAME)
+ JE32 %promote_type_done ; Be done
+
+ CMP_EBX_EDX ; IF(B->NAME == I->INDIRECT->NAME)
+ JE32 %promote_type_done ; Be done
+
+ LOAD32_EAX_from_EAX ; I = I->NEXT
+ JMP32 %promote_type_iter ; Keep going
+
+:promote_type_done
+ POP_EDX ; Restore EDX
+ POP_ECX ; Restore ECX
+ POP_EBX ; Restore EBX
+ RETURN
+
+
+;; common_recursion function
+;; Recieves FUNCTION F in EAX
+;; Returns Nothing
+;; Walks global_token list and update output_list
+;; Updates current_target
+;; Uses EBX to hold FUNCTION F and struct type* last_type
+:common_recursion
+ PUSH_EBX ; Protect EBX
+ COPY_EAX_to_EBX ; Put FUNCTION F safely out of the way
+ LOADI32_EAX &common_recursion_string_0 ; Using "PUSH_eax\t#_common_recursion\n"
+ CALL32 %emit_out ; Emit it
+
+ LOAD32_Absolute32_eax &global_token ; Using global_token
+ LOAD32_EAX_from_EAX ; global_token->NEXT
+ STORE32_Absolute32_eax &global_token ; global_token = global_token->NEXT
+
+ COPY_EBX_to_EAX ; Prepare for function call
+ LOAD32_Absolute32_ebx ¤t_target ; Get last type
+ CALL_EAX ; F();
+ LOAD32_Absolute32_eax ¤t_target ; Get current_target
+ CALL32 %promote_type ; get the right type
+ STORE32_Absolute32_eax ¤t_target ; Set new current_target
+
+ LOADI32_EAX &common_recursion_string_1 ; Using "POP_ebx\t# _common_recursion\n"
+ CALL32 %emit_out ; Emit it
+ POP_EBX ; Restore EBX
+ RETURN
+
+:common_recursion_string_0 "PUSH_eax #_common_recursion
+"
+:common_recursion_string_1 "POP_ebx # _common_recursion
+"
+
+
+;; require_match function
+;; Recieves char* message in EAX and char* required in EBX
+;; Returns nothing
+;; Uses ECX to hold message and updates global_token
+:require_match
+ PUSH_EBX ; Protect EBX
+ PUSH_ECX ; Protect ECX
+ COPY_EAX_to_ECX ; put the message somewhere safe
+ LOAD32_Absolute32_eax &global_token ; Using global_token
+ LOAD32_EAX_from_EAX_Immediate8 !8 ; global_token->S
+ CALL32 %match ; IF required == global_token->S
+ CMPI8_EAX !0 ; we are fine
+ JE32 %require_match_good ; otherwise pain
+
+ ;; Deal will bad times
+; CALL32 %line_error ; Tell user what went wrong
+ LOADI32_EAX %2 ; Using standard error
+ STORE32_Absolute32_eax &Output_file ; write to standard error
+ COPY_ECX_to_EAX ; using our message
+ CALL32 %File_Print ; Print it
+ JMP32 %Exit_Failure ; Abort HARD
+
+:require_match_good
+ LOAD32_Absolute32_eax &global_token ; Using global_token
+ LOAD32_EAX_from_EAX ; global_token->next
+ STORE32_Absolute32_eax &global_token ; global_token = global_token->next
+ POP_ECX ; Restore ECX
+ POP_EBX ; Restore EBX
+ RETURN
+
+
+;; uniqueID Function
+;; Recieves char*S in EAX, struct token_list* l in EBX snd char* num in ECX
+;; Returns updated struct token_list* L in EAX
+:uniqueID
+ PUSH_EBX ; Protect EBX
+ PUSH_ECX ; Protect ECX
+ CALL32 %emit ; emit(s, l)
+ COPY_EAX_to_EBX ; Put L in correct place
+ LOADI32_EAX &underline ; Usinf "_"
+ CALL32 %emit ; emit("_", l)
+ COPY_EAX_to_EBX ; Put L in correct place
+ COPY_ECX_to_EAX ; Put num in correct place
+ CALL32 %emit ; emit(num, l)
+ COPY_EAX_to_EBX ; Put L in correct place
+ LOADI32_EAX &uniqueID_string_0 ; Using "\n"
+ CALL32 %emit ; emit("\n", l)
+ POP_ECX ; Restore ECX
+ POP_EBX ; Restore EBX
+ RETURN
+
+:uniqueID_string_0 "
+"
+
+
+;; uniqueID_out function
+;; Recieves char* S in EAX and char* num in EBX
+;; Returns nothing
+:uniqueID_out
+ PUSH_EAX ; Protect EAX
+ PUSH_EBX ; Protect EBX
+ PUSH_ECX ; Protect ECX
+ COPY_EBX_to_ECX ; Put num in right spot
+ LOAD32_Absolute32_ebx &output_list ; Using output_list
+ CALL32 %uniqueID ; Get updated list
+ STORE32_Absolute32_eax &output_list ; output_list = uniqueID(s, output_list, num)
+ POP_ECX ; Restore ECX
+ POP_EBX ; Restore EBX
+ POP_EAX ; Restore EAX
+ RETURN
+
+
+;; emit_out function
+;; Recieves char* S in EAX
+;; Returns nothing
+;; Updates output_list
+;; MUST NOT ALTER REGISTERS
+:emit_out
+ PUSH_EAX ; Protect EAX
+ PUSH_EBX ; Protect EBX
+ LOAD32_Absolute32_ebx &output_list ; Using output_list
+ CALL32 %emit ; emit it
+ STORE32_Absolute32_eax &output_list ; update it
+ POP_EBX ; Restore EBX
+ POP_EAX ; Restore EAX
+ RETURN
+
+
+;; emit function
+;; Recieves char *s in EAX and struct token_list* head in EBX
+;; Returns struct token_list* T in EAX
+:emit
+ PUSH_ECX ; Protect ECX
+ COPY_EAX_to_ECX ; put S out of the way
+ LOADI32_EAX %20 ; sizeof(struct token_list)
+ CALL32 %malloc ; get T
+ STORE32_EBX_into_EAX ; t->next = head;
+ STORE32_ECX_into_EAX_Immediate8 !8 ; t->s = s;
+ POP_ECX ; Restore ECX
+ RETURN
+
+
+;; escape_lookup function
+;; Recieves char* c in EAX
+;; Returns integer value of char in EAX
+;; Aborts hard if unknown escape is recieved
+;; Uses ECX to hold char* C
+:escape_lookup
+ PUSH_EBX ; Protect EBX
+ PUSH_ECX ; Protect ECX
+ COPY_EAX_to_ECX ; Put char* C in safe place
+ LOAD8_al_from_ECX ; Load c[0]
+ MOVZX_al ; make it useful
+ CMPI8_EAX !92 ; If '\\' != c[0]
+ JNE32 %escape_lookup_done ; Be done
+
+ COPY_ECX_to_EBX ; Prepare for walk
+ ADDI8_EBX !1 ; increment
+ LOAD8_bl_from_EBX ; load c[1]
+ MOVZX_bl ; make it useful
+
+ CMPI8_EBX !120 ; Check if \x??
+ JE32 %escape_lookup_hex ; Deal with hex
+
+ ;; Deal with \? escapes
+ LOADI32_EAX %10 ; Guess "\n"
+ CMPI8_EBX !110 ; If n
+ JE32 %escape_lookup_done ; Be done
+
+ LOADI32_EAX %9 ; Guess "\t"
+ CMPI8_EBX !116 ; If t
+ JE32 %escape_lookup_done ; Be done
+
+ COPY_EBX_to_EAX ; "\\", "'" and '\"' all encode as themselves
+ CMPI8_EBX !92 ; If "\\"
+ JE32 %escape_lookup_done ; Be done
+ CMPI8_EBX !39 ; IF "'"
+ JE32 %escape_lookup_done ; Be done
+ CMPI8_EBX !34 ; IF '\"'
+ JE32 %escape_lookup_done ; Be done
+
+ LOADI32_EAX %13 ; Guess "\r"
+ CMPI8_EBX !114 ; IF r
+ JE32 %escape_lookup_done ; Be done
+
+ ;; Looks like we have no clue what we are doing
+ ;; Aborting hard
+ LOADI32_EAX %2 ; Using Standard error
+ STORE32_Absolute32_eax &Output_file ; write to standard error
+ LOADI32_EAX &escape_lookup_string_0 ; Using "Unknown escape recieved: "
+ CALL32 %File_Print ; Print it
+ COPY_ECX_to_EAX ; Using C
+ CALL32 %File_Print ; Print it
+ LOADI32_EAX &escape_lookup_string_1 ; Using " Unable to process\n"
+ CALL32 %File_Print ; Print it
+ JMP32 %Exit_Failure ; Abort Hard
+
+:escape_lookup_done
+ POP_ECX ; Restore ECX
+ POP_EBX ; Restore EBX
+ RETURN
+
+:escape_lookup_hex
+ ;; Give up on C and just assume they know what they are doing
+ ADDI8_ECX !2 ; increment
+ LOAD8_al_from_ECX ; c[2]
+ MOVZX_al ; make it useful
+ ADDI8_ECX !1 ; increment
+ CALL32 %char2hex ; Get the hex value
+ SALI8_EAX !4 ; c << 4
+ LOAD8_bl_from_ECX ; c[3]
+ MOVZX_bl ; make it useful
+ SWAP_EAX_EBX ; protect c << 4
+ CALL32 %char2hex ; Get the hex value
+ ADD_ebx_into_eax ; hex(c[2]) << 4 + hex(c[3])
+ JMP32 %escape_lookup_done ; Be done
+
+:escape_lookup_string_0 "Unknown escape recieved: "
+:escape_lookup_string_1 " Unable to process
+"
+
+
+;; char2hex function
+;; Recieves char in EAX
+;; Returns hex or aborts hard
+:char2hex
+ SUBI8_EAX !48 ; Try 0-9
+ CMPI8_EAX !10 ; Otherwise fun times
+ JL32 %char2hex_done ; Be done
+
+ ;; Deal with A-F
+ ANDI32_EAX %0xDF ; Unset High bit turning a-f into A-F
+ SUBI8_EAX !7 ; Shift down into position
+ CMPI8_EAX !10 ; Everything below A is bad
+ JL32 %char2hex_fail ; And should fail
+ CMPI8_EAX !16 ; Make sure we are below F
+ JL32 %char2hex_done ; If so be done
+
+:char2hex_fail
+ ;; Time to fail hard
+ LOADI32_EAX %2 ; Using Standard error
+ STORE32_Absolute32_eax &Output_file ; write to standard error
+ LOADI32_EAX &char2hex_string_0 ; Using "Tried to print non-hex number\n"
+ CALL32 %File_Print ; Print it
+ JMP32 %Exit_Failure ; Abort Hard
+
+:char2hex_done
+ RETURN
+
+:char2hex_string_0 "Tried to print non-hex number
+"
+
+
+;; parse_string function
+;; Recieves char* string in EAX
+;; Returns cleaned up string
+;; Protects char* string in EBX
+:parse_string
+ PUSH_EBX ; Protect EBX
+ COPY_EAX_to_EBX ; Protect char* string
+ CALL32 %weird ; Determine if we have a weird string
+ CMPI8_EAX !0 ; If weird
+ JE32 %parse_string_weird ; Deal with it
+
+ ;; Dealing with regular string
+ COPY_EBX_to_EAX ; Passing Char* string
+ CALL32 %collect_regular_string ; Collect it
+ JMP32 %parse_string_done ; Be done
+
+:parse_string_weird
+ COPY_EBX_to_EAX ; Passing Char* string
+ CALL32 %collect_weird_string ; Collect it
+
+:parse_string_done
+ POP_EBX ; Restore EBX
+ RETURN
+
+
+;; weird function
+;; Recieves char* string in EAX
+;; Returns true(0) or false(1) in EAX
+;; Uses ECX to hold char* string
+:weird
+ PUSH_EBX ; Protect EBX
+ PUSH_ECX ; Protect ECX
+ COPY_EAX_to_ECX ; Place string in safe place
+ ADDI8_ECX !1 ; increment past the '\"'
+:weird_reset
+ LOAD8_al_from_ECX ; Load a char
+ MOVZX_al ; Make it useful
+ CMPI8_EAX !0 ; IF NULL == C
+ JE32 %weird_false ; Nothing weird found
+
+ CMPI8_EAX !92 ; IF '\\'
+ JNE32 %weird_escaped ; Deal with escaping
+
+ ;; Deal with escape
+ COPY_ECX_to_EAX ; We are passing the string
+ CALL32 %escape_lookup ; to look it up
+
+ ADDI8_ECX !1 ; string = string + 1
+ LOAD8_bl_from_ECX ; get string[1]
+ MOVZX_bl ; make it useful
+ CMPI8_EBX !120 ; IF 'x' == string[1]
+ JNE32 %weird_escaped ; otherwise skip the gap
+
+ ADDI8_ECX !2 ; string = string + 2
+
+:weird_escaped
+ PUSH_EAX ; Protect C in case we need it
+ LOADI32_EBX &weird_string_0 ; Use "\t\n !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~"
+ CALL32 %In_Set ; To find if weird
+ CMPI8_EAX !1 ; IF TRUE
+ POP_EAX ; Restore C
+ JNE32 %weird_true ; Then not weird
+
+ ADDI8_ECX !1 ; string = string + 1
+
+ ;; Last chance for weird
+ LOADI32_EBX &weird_string_1 ; Use "\t\n\r "
+ CALL32 %In_Set ; Check for special case
+ CMPI8_EAX !1 ; IF TRUE
+ JNE32 %weird_reset ; Otherwise not in the special case
+
+ ;; Deal with possible special case
+ LOAD8_al_from_ECX ; Load string[1]
+ MOVZX_al ; Make it useful
+ CMPI8_EAX !58 ; IF string[1] == ":"
+ JE32 %weird_true ; Then we hit the special case
+ JMP32 %weird_reset ; Keep trying
+
+:weird_done
+ POP_ECX ; Restore ECX
+ POP_EBX ; Restore EBX
+ RETURN
+
+:weird_true
+ LOADI32_EAX %0 ; Return true
+ JMP32 %weird_done ; Be done
+
+:weird_false
+ LOADI32_EAX %1 ; Return false
+ JMP32 %weird_done ; Be done
+
+:weird_string_0 "
+ !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~"
+:weird_string_1 '09 0A 0D 20' ; "\t\n\r "
+
+
+;; collect_regular_string function
+;; Recieves char* string in EAX
+;; Malloc and creates new string to return in EAX
+;; Uses ECX for return string and EDX for passed string
+:collect_regular_string
+ PUSH_EBX ; Protect EBX
+ PUSH_ECX ; Protect ECX
+ PUSH_EDX ; Protect EDX
+ COPY_EAX_to_EDX ; Protect our passed string
+ LOADI32_EAX %256 ; We need 256bytes of storage
+ CALL32 %malloc ; Get our new pointer
+ COPY_EAX_to_ECX ; put it in place
+ PUSH_EAX ; protect until done
+:collect_regular_string_reset
+ LOAD8_al_from_EDX ; string[0]
+ MOVZX_al ; Make it useful
+ CMPI8_EAX !0 ; See if we hit the end
+ JE32 %collect_regular_string_done ; And be done
+
+ CMPI8_EAX !92 ; IF string[0] == '\\'
+ JE32 %collect_regular_string_escaped ; Deal with that mess
+
+ ;; deal with boring char
+ STORE8_al_into_Address_ECX ; hold_string[index] = string[0]
+ ADDI8_ECX !1 ; Increment it
+ ADDI8_EDX !1 ; Increment it
+ JMP32 %collect_regular_string_reset ; And keep going
+
+:collect_regular_string_escaped
+ COPY_EDX_to_EAX ; Using string
+ CALL32 %escape_lookup ; Get the char
+ STORE8_al_into_Address_ECX ; hold_string[index] = escape_lookup(string)
+ ADDI8_EDX !1 ; Increment it
+ ADDI8_ECX !1 ; Increment it
+ LOAD8_al_from_EDX ; string[0]
+ MOVZX_al ; Make it useful
+ ADDI8_EDX !1 ; Increment it
+ CMPI8_EAX !120 ; IF 'x' == string[1]
+ JNE32 %collect_regular_string_reset ; Otherwise keep going
+
+ ADDI8_EDX !2 ; Increment it
+ JMP32 %collect_regular_string_reset ; Keep going
+
+:collect_regular_string_done
+ LOADI32_EAX %34 ; Using '\"'
+ STORE8_al_into_Address_ECX ; hold_string[index] = '\"'
+ ADDI8_ECX !1 ; Increment it
+ LOADI32_EAX %10 ; Using "\n"
+ STORE8_al_into_Address_ECX ; hold_string[index] = '\n'
+ POP_EAX ; Return our new string
+ POP_EDX ; Restore EDX
+ POP_ECX ; Restore ECX
+ POP_EBX ; Restore EBX
+ RETURN
+
+
+;; collect_weird_string function
+;; Recieves char* string in EAX
+;; Mallocs and returns char* hold in EAX
+;; Uses ECX for char* hold and EDX for char* string
+:collect_weird_string
+ PUSH_EBX ; Protect EBX
+ PUSH_ECX ; Protect ECX
+ PUSH_EDX ; Protect EDX
+ COPY_EAX_to_EDX ; Protect our passed string
+ LOADI32_EAX %512 ; We need 512bytes of storage
+ CALL32 %malloc ; Get our new pointer
+ COPY_EAX_to_ECX ; put it in place
+ PUSH_EAX ; protect until done
+
+ LOADI32_EAX %39 ; Using "'"
+ STORE8_al_into_Address_ECX ; hold_string[index] = "'"
+ ADDI8_ECX !1 ; Increment it
+ ADDI8_EDX !1 ; Increment it
+:collect_weird_string_reset
+ LOAD8_al_from_EDX ; Read a byte
+ MOVZX_al ; Make it useful
+ CMPI8_EAX !0 ; IF NULL == string[0]
+ JE32 %collect_weird_string_done ; Be done
+
+ LOADI32_EAX %32 ; Using ' '
+ STORE8_al_into_Address_ECX ; hold_string[index] = ' '
+ ADDI8_ECX !1 ; Increment it
+
+ COPY_EDX_to_EAX ; Using string
+ CALL32 %escape_lookup ; Get the char
+ CALL32 %hex8 ; Update ECX
+
+ LOAD8_al_from_EDX ; Read a byte
+ MOVZX_al ; Make it useful
+ ADDI8_EDX !1 ; Increment it
+ CMPI8_EAX !92 ; IF string[0] == '\\'
+ JNE32 %collect_weird_string_reset ; Otherwise keep going
+
+ LOAD8_al_from_EDX ; Read a byte
+ MOVZX_al ; Make it useful
+ ADDI8_EDX !1 ; Increment it
+ CMPI8_EAX !120 ; IF 'x' == string[1]
+ JNE32 %collect_weird_string_reset ; Otherwise keep going
+
+ ADDI8_EDX !2 ; Increment it
+ JMP32 %collect_weird_string_reset ; Keep going
+
+:collect_weird_string_done
+ LOADI32_EAX %32 ; Using ' '
+ STORE8_al_into_Address_ECX ; hold_string[index] = ' '
+ ADDI8_ECX !1 ; Increment it
+ LOADI32_EAX %48 ; Using '0'
+ STORE8_al_into_Address_ECX ; hold_string[index] = '0'
+ ADDI8_ECX !1 ; Increment it
+ STORE8_al_into_Address_ECX ; hold_string[index] = '0'
+ ADDI8_ECX !1 ; Increment it
+ LOADI32_EAX %39 ; Using "'"
+ STORE8_al_into_Address_ECX ; hold_string[index] = "'"
+ ADDI8_ECX !1 ; Increment it
+ LOADI32_EAX %10 ; Using "\n"
+ STORE8_al_into_Address_ECX ; hold_string[index] = '\n'
+ POP_EAX ; Return our new string
+ POP_EDX ; Restore EDX
+ POP_ECX ; Restore ECX
+ POP_EBX ; Restore EBX
+ RETURN
+
+
+;; HEX to ascii routine
+;; Recieves INT in EAX and CHAR* in ECX
+;; Stores ascii of INT in CHAR*
+;; Returns only modifying EAX and ECX
+:hex8
+ PUSH_EAX ; Protect bottom nibble
+ SHRI8_EAX !4 ; do high nibble first
+ CALL32 %hex4 ; Store it
+ POP_EAX ; do low nibble
+:hex4
+ ANDI32_EAX %0xF ; isolate nibble
+ ADDI8_EAX !48 ; convert to ascii
+ CMPI8_EAX !57 ; valid digit?
+ JBE8 !hex1 ; yes
+ ADDI8_EAX !7 ; use alpha range
+:hex1
+ STORE8_al_into_Address_ECX ; store result
+ ADDI8_ECX !1 ; next position
+ RETURN
+
+
+;; type_name function
+;; Recieves nothing
+;; Returns type_size in EAX
+;; Uses ECX for STRUCT TYPE* RET
+:type_name
+ PUSH_EBX ; Protect EBX
+ PUSH_ECX ; Protect ECX
+ LOAD32_Absolute32_ebx &global_token ; Using global_token
+ LOAD32_EBX_from_EBX_Immediate8 !8 ; global_token->S
+ LOADI32_EAX &struct ; Using "struct"
+ CALL32 %match ; IF global_token->S == "struct"
+ COPY_EAX_to_ECX ; Protect structure
+ CMPI8_EAX !0 ; need to skip over "struct"
+ JNE32 %type_name_native ; otherwise keep going
+
+ ;; Deal with possible STRUCTs
+ LOAD32_Absolute32_ebx &global_token ; Using global_token
+ LOAD32_EBX_from_EBX ; global_token->next
+ STORE32_Absolute32_ebx &global_token ; global_token = global_token->next
+ LOAD32_EAX_from_EBX_Immediate8 !8 ; global_token->S
+ LOAD32_Absolute32_ebx &global_types ; get all known types
+ CALL32 %lookup_type ; Find type if possible
+ COPY_EAX_to_ECX ; Set ret
+
+ CMPI8_EAX !0 ; IF NULL == ret
+ JNE32 %type_name_common ; We have to create struct
+
+ ;; Create a struct
+ CALL32 %create_struct ; Create a new struct
+ LOADI32_ECX %0 ; We wish to return NULL
+ JMP32 %type_name_done ; be done
+
+:type_name_native
+ ;; Deal only with native types
+ COPY_EBX_to_EAX ; Put global_token->S in the right place
+ LOAD32_Absolute32_ebx &global_types ; get all known types
+ CALL32 %lookup_type ; Find the type if possible
+ COPY_EAX_to_ECX ; Set ret
+
+ CMPI8_EAX !0 ; IF NULL == ret
+ JNE32 %type_name_common ; We need to abort hard
+
+ ;; Aborting hard
+ LOADI32_EAX %2 ; Using Standard error
+ STORE32_Absolute32_eax &Output_file ; write to standard error
+ LOADI32_EAX &type_name_string_0 ; Print header
+ CALL32 %File_Print ; Print it
+
+ LOAD32_Absolute32_eax &global_token ; Using global token
+ LOAD32_EAX_from_EAX_Immediate8 !8 ; global_token->S
+ CALL32 %File_Print ; Print it
+
+ LOADI32_EAX &type_name_string_1 ; Print footer
+ CALL32 %File_Print ; Print it
+
+; CALL32 %line_error ; Give details
+ JMP32 %Exit_Failure ; Abort
+
+:type_name_common
+ LOAD32_Absolute32_ebx &global_token ; Using global_token
+ LOAD32_EBX_from_EBX ; global_token->next
+ STORE32_Absolute32_ebx &global_token ; global_token = global_token->next
+
+:type_name_iter
+ LOAD32_EAX_from_EBX_Immediate8 !8 ; global_token->S
+ LOAD8_al_from_EAX ; global_token->S[0]
+ MOVZX_al ; make it useful
+ CMPI8_EAX !42 ; IF global_token->S[0] == '*'
+ JNE32 %type_name_done ; recurse
+
+ ;; Deal with char**
+ LOAD32_ECX_from_ECX_Immediate8 !12 ; ret = ret->indirect
+ LOAD32_Absolute32_ebx &global_token ; Using global_token
+ LOAD32_EBX_from_EBX ; global_token->next
+ STORE32_Absolute32_ebx &global_token ; global_token = global_token->next
+ JMP32 %type_name_iter ; keep looping
+
+:type_name_done
+ COPY_ECX_to_EAX ; put ret in the right place
+ POP_ECX ; Restore ECX
+ POP_EBX ; Restore EBX
+ RETURN
+
+:type_name_string_0 "Unknown type "
+:type_name_string_1 "
+"
+
+
+;; lookup_type function
+;; Recieves char* s in EAX and struct type* start in EBX
+;; Returns struct type* in EAX
+;; Uses EBX for S and ECX for I
+:lookup_type
+ PUSH_EBX ; Protect EBX
+ PUSH_ECX ; Protect ECX
+ COPY_EBX_to_ECX ; I = Start
+ COPY_EAX_to_EBX ; Put S in place
+:lookup_type_iter
+ CMPI8_ECX !0 ; Check if I == NULL
+ JE32 %lookup_type_done ; return NULL
+
+ LOAD32_EAX_from_ECX_Immediate8 !24 ; I->NAME
+ CALL32 %match ; Check if matching
+ CMPI8_EAX !0 ; IF I->NAME == S
+ JE32 %lookup_type_done ; return it
+
+ LOAD32_ECX_from_ECX ; Otherwise I = I->NEXT
+ JMP32 %lookup_type_iter ; And keep looping
+
+:lookup_type_done
+ COPY_ECX_to_EAX ; return either I or NULL
+ POP_ECX ; Restore ECX
+ POP_EBX ; Restore EBX
+ RETURN
+
+
+;; create_struct function
+;; Recieves nothing
+;; Returns nothing
+;; Uses global_token to malloc a struct's definition
+;; Uses ECX for int OFFSET, EDX for struct type* head, EBP for struct type* I,
+;; EDI for member_size (Which is passed) and ESI for LAST
+;; EAX and EBX are used for scratch
+:create_struct
+ PUSH_EBX ; Protect EBX
+ PUSH_ECX ; Protect ECX
+ PUSH_EDX ; Protect EDX
+ PUSH_EBP ; Protect EBP
+ PUSH_EDI ; Protect EDI
+ PUSH_ESI ; Protect ESI
+ LOADI32_ECX %0 ; OFFSET = 0
+ LOADI32_EDI %0 ; member_size = 0
+
+ LOADI32_EAX %28 ; sizeof(struct type)
+ CALL32 %malloc ; malloc(sizeof(struct type))
+ COPY_EAX_to_EDX ; Set HEAD
+
+ LOADI32_EAX %28 ; sizeof(struct type)
+ CALL32 %malloc ; malloc(sizeof(struct type))
+ COPY_EAX_to_EBP ; Set I
+
+ LOAD32_Absolute32_eax &global_token ; Using global_token
+ LOAD32_EAX_from_EAX_Immediate8 !8 ; global_token->S
+ STORE32_EAX_into_EDX_Immediate8 !24 ; HEAD->NAME = global_token->S
+ STORE32_EAX_into_EBP_Immediate8 !24 ; I->NAME = global_token->S
+
+ STORE32_EBP_into_EDX_Immediate8 !12 ; HEAD->INDIRECT = I
+ STORE32_EDX_into_EBP_Immediate8 !12 ; I->INDIRECT = HEAD
+
+ LOAD32_Absolute32_eax &global_types ; Using global_types
+ STORE32_EAX_into_EDX ; HEAD->NEXT = global_types
+ STORE32_Absolute32_edx &global_types ; global_types = HEAD
+
+ LOAD32_Absolute32_eax &global_token ; Using global_token
+ LOAD32_EAX_from_EAX ; global_token->NEXT
+ STORE32_Absolute32_eax &global_token ; global_token = global_token->NEXT
+
+ LOADI32_EAX %4 ; Using register size
+ STORE32_EAX_into_EBP_Immediate8 !4 ; I->SIZE = register size
+
+ LOADI32_EAX &create_struct_string_0 ; Using "ERROR in create_struct\n Missing {\n"
+ LOADI32_EBX &open_curly_brace ; Using "{"
+ CALL32 %require_match ; Make sure we have it
+
+ LOADI32_ESI %0 ; LAST = NULL
+
+:create_struct_iter
+ LOAD32_Absolute32_eax &global_token ; Using global_token
+ LOAD32_EAX_from_EAX_Immediate8 !8 ; global_token->S
+ LOAD8_al_from_EAX ; global_token->S[0]
+ MOVZX_al ; Make it useful
+ CMPI8_EAX !125 ; IF global_token->S[0] == "}"
+ JE32 %create_struct_done ; be done
+
+ ;; Looks like we are adding members
+ ;; Lets see if it is a union
+ LOAD32_Absolute32_eax &global_token ; Using global_token
+ LOAD32_EAX_from_EAX_Immediate8 !8 ; global_token->S
+ LOADI32_EBX &union ; Using "union"
+ CALL32 %match ; IF match(global_token->s, "union")
+ CMPI8_EAX !0 ; Deal with union
+ JNE32 %create_struct_single ; Otherwise deal with singles
+
+ ;; Deal with union
+ COPY_ESI_to_EAX ; Put last in right place
+ COPY_ECX_to_EBX ; put offset in right place
+ CALL32 %build_union ; ASSEMBLE
+ COPY_EAX_to_ESI ; last = build_union(last, offset)
+ ADD_edi_into_ecx ; offset = offset + member_size
+
+ LOADI32_EAX &create_struct_string_1 ; Using "ERROR in create_struct\n Missing ;\n"
+ LOADI32_EBX &semicolon ; Using ";"
+ CALL32 %require_match ; Make sure we have it
+ JMP32 %create_struct_iter ; keep going
+
+:create_struct_single
+ ;; deal with singles
+ COPY_ESI_to_EAX ; Put last in right place
+ COPY_ECX_to_EBX ; put offset in right place
+ CALL32 %build_member ; ASSEMBLE
+ COPY_EAX_to_ESI ; last = build_union(last, offset)
+ ADD_edi_into_ecx ; offset = offset + member_size
+
+ LOADI32_EAX &create_struct_string_1 ; Using "ERROR in create_struct\n Missing ;\n"
+ LOADI32_EBX &semicolon ; Using ";"
+ CALL32 %require_match ; Make sure we have it
+ JMP32 %create_struct_iter ; keep going
+
+:create_struct_done
+ LOAD32_Absolute32_eax &global_token ; Using global_token
+ LOAD32_EAX_from_EAX ; global_token->NEXT
+ STORE32_Absolute32_eax &global_token ; global_token = global_token->NEXT
+
+ LOADI32_EAX &create_struct_string_1 ; Using "ERROR in create_struct\n Missing ;\n"
+ LOADI32_EBX &semicolon ; Using ";"
+ CALL32 %require_match ; Make sure we have it
+
+ STORE32_ECX_into_EDX_Immediate8 !4 ; HEAD->SIZE = OFFSET
+ STORE32_ESI_into_EDX_Immedate8 !16 ; HEAD->MEMBERS = LAST
+ STORE32_ESI_into_EBP_Immedate8 !16 ; I->MEMBERS = LAST
+
+ POP_ESI ; Restore ESI
+ POP_EDI ; Restore EDI
+ POP_EBP ; Restore EBP
+ POP_EDX ; Restore EDX
+ POP_ECX ; Restore ECX
+ POP_EBX ; Restore EBX
+ RETURN
+
+:create_struct_string_0 "ERROR in create_struct
+ Missing {
+"
+:create_struct_string_1 "ERROR in create_struct
+ Missing ;
+"
+
+
+;; lookup_member function
+;; Recieves struct type* parent in EAX and char* name in EBX
+;; Returns struct type* I in EAX
+;; Uses char* NAME in EBX, ECX for struct type* I and EDX to hold parent for errors
+;; Aborts hard if not found
+:lookup_member
+ PUSH_EBX ; Protect EBX
+ PUSH_ECX ; Protect ECX
+ PUSH_EDX ; Protect EDX
+ COPY_EAX_to_EDX ; Protect Parent
+ LOAD32_ECX_from_EAX_Immediate8 !16 ; struct type* I = parent->MEMBERS
+:lookup_member_iter
+ CMPI8_ECX !0 ; IF I == NULL
+ JE32 %lookup_member_fail ; Abort HARD
+
+ LOAD32_EAX_from_ECX_Immediate8 !24 ; Using I->NAME
+ CALL32 %match ; IF I->NAME == NAME
+ CMPI8_EAX !0 ; Then we have found the member
+ COPY_ECX_to_EAX ; Prepare for return
+ LOAD32_ECX_from_ECX_Immediate8 !16 ; Prepare for loop I = I->MEMBERS
+ JNE32 %lookup_member_iter ; Looks like we are looping
+
+ ;; I is already in EAX
+ POP_EDX ; Restore EDX
+ POP_ECX ; Restore ECX
+ POP_EBX ; Restore EBX
+ RETURN
+
+:lookup_member_fail
+ LOADI32_EAX %2 ; Using Standard error
+ STORE32_Absolute32_eax &Output_file ; write to standard error
+ LOADI32_EAX &lookup_member_string_0 ; Using "ERROR in lookup_member "
+ CALL32 %File_Print ; print it
+
+ LOAD32_EAX_from_EDX_Immediate8 !24 ; PARENT->NAME
+ CALL32 %File_Print ; print it
+
+ LOADI32_EAX &arrow_string ; Using "->"
+ CALL32 %File_Print ; print it
+
+ LOAD32_Absolute32_eax &global_token ; Using global_token
+ LOAD32_EAX_from_EAX_Immediate8 !8 ; global_token->S
+ CALL32 %File_Print ; print it
+
+ LOADI32_EAX &lookup_member_string_1 ; Using " does not exist\n"
+ CALL32 %File_Print ; print it
+
+; CALL32 %line_error ; Write useful debug info
+
+ LOADI32_EAX &lookup_member_string_2 ; Using "\n"
+ CALL32 %File_Print ; print it
+ JMP32 %Exit_Failure ; Abort Hard
+
+:lookup_member_string_0 "ERROR in lookup_member "
+:lookup_member_string_1 " does not exist
+"
+:lookup_member_string_2 "
+"
+
+
+;; build_member function
+;; Recieves struct type* last in EAX, int offset in EBX and global member_size in EDI
+;; Updates member_size in EDI and returns struct type* I in EAX
+;; Uses ECX for struct type* member_type and EDX for struct type* I
+:build_member
+ PUSH_EBX ; Protect EBX
+ PUSH_ECX ; Protect ECX
+ PUSH_EDX ; Protect EDX
+ COPY_EAX_to_EDX ; Put last out of the way
+ LOADI32_EAX %28 ; Allocate type
+ CALL32 %malloc ; Get I
+ STORE32_EDX_into_EAX_Immediate8 !16 ; I->MEMBERS = LAST
+ STORE32_EBX_into_EAX_Immediate8 !8 ; I->OFFSET = OFFSET
+ COPY_EAX_to_EDX ; Put I in place
+
+ CALL32 %type_name ; Get member_type
+ COPY_EAX_to_ECX ; Put in place
+ STORE32_ECX_into_EDX_Immediate8 !20 ; I->TYPE = MEMBER_TYPE
+ LOAD32_Absolute32_eax &global_token ; Using global_token
+ LOAD32_EBX_from_EAX_Immediate8 !8 ; global_token->S
+ STORE32_EBX_into_EDX_Immediate8 !24 ; I->NAME = global_token->S
+ LOAD32_EAX_from_EAX ; global_token->NEXT
+ STORE32_Absolute32_eax &global_token ; global_token = global_token->NEXT
+
+ ;; Check if we have an array
+ LOAD32_EBX_from_EAX_Immediate8 !8 ; global_token->S
+ LOADI32_EAX &open_bracket ; Using "["
+ CALL32 %match ; IF global_token->S == "["
+ CMPI8_EAX !0 ; Then we have to deal with arrays in our structs
+ JE32 %build_member_array ; So deal with that pain
+
+ ;; Deal with non-array case
+ LOAD32_EAX_from_ECX_Immediate8 !4 ; member_type->SIZE
+ STORE32_EAX_into_EDX_Immediate8 !4 ; I->SIZE = member_type->SIZE
+ JMP32 %build_member_done ; Be done
+
+:build_member_array
+ LOAD32_Absolute32_eax &global_token ; Using global_token
+ LOAD32_EAX_from_EAX ; global_token->NEXT
+ STORE32_Absolute32_eax &global_token ; global_token = global_token->NEXT
+
+ LOAD32_EAX_from_EAX_Immediate8 !8 ; global_token->S
+ CALL32 %numerate_string ; convert number
+ LOAD32_EBX_from_ECX_Immediate8 !20 ; member_type->TYPE
+ LOAD32_EBX_from_EBX_Immediate8 !4 ; member_type->TYPE->SIZE
+ IMUL_EAX_by_EBX ; member_type->type->size * numerate_string(global_token->s)
+ STORE32_EAX_into_EDX_Immediate8 !4 ; I->SIZE = member_type->type->size * numerate_string(global_token->s)
+
+ LOAD32_Absolute32_eax &global_token ; Using global_token
+ LOAD32_EAX_from_EAX ; global_token->NEXT
+ STORE32_Absolute32_eax &global_token ; global_token = global_token->NEXT
+
+ LOADI32_EAX &build_member_string_0 ; Using "Struct only supports [num] form\n"
+ LOADI32_EBX &close_bracket ; Using "]"
+ CALL32 %require_match ; Make sure we have it
+
+:build_member_done
+ LOAD32_EDI_from_EDX_Immediate8 !4 ; MEMBER_SIZE = I->SIZE
+ STORE32_ECX_into_EDX_Immediate8 !20 ; I->TYPE = MEMBER_TYPE
+ COPY_EDX_to_EAX ; Return I
+
+ POP_EDX ; Restore EDX
+ POP_ECX ; Restore ECX
+ POP_EBX ; Restore EBX
+ RETURN
+
+:build_member_string_0 "Struct only supports [num] form
+"
+
+
+;; build_union function
+;; Recieves struct type* last in EAX, int offset in EBX and global member_size in EDI
+;; Updates member_size in EDI and returns struct type* LAST in EAX
+;; Uses ECX for struct type* last, EDX for int offset, ESI for int size and EDI for int member_size
+:build_union
+ PUSH_EBX ; Protect EBX
+ PUSH_ECX ; Protect ECX
+ PUSH_EDX ; Protect EDX
+ PUSH_ESI ; Protect ESI
+ COPY_EAX_to_ECX ; Put LAST in right spot
+ COPY_EBX_to_EDX ; Put OFFSET in right spot
+ LOADI32_ESI %0 ; SIZE = 0
+
+ LOAD32_Absolute32_eax &global_token ; Using global_token
+ LOAD32_EAX_from_EAX ; global_token->NEXT
+ STORE32_Absolute32_eax &global_token ; global_token = global_token->NEXT
+
+ LOADI32_EAX &build_union_string_0 ; Using "ERROR in build_union\nMissing {\n"
+ LOADI32_EBX &open_curly_brace ; Using "{"
+ CALL32 %require_match ; Make sure we have it
+
+:build_union_iter
+ LOAD32_Absolute32_eax &global_token ; Using global_token
+ LOAD32_EAX_from_EAX_Immediate8 !8 ; global_token->S
+ LOAD8_al_from_EAX ; global_token->S[0]
+ MOVZX_al ; make it useful
+ CMPI8_EAX !125 ; IF global_token->S[0] == "}"
+ JE32 %build_union_done ; Be done
+
+ ;; Collect union member
+ COPY_ECX_to_EAX ; Passing LAST
+ COPY_EDX_to_EBX ; Passing offset
+ CALL32 %build_member ; build_member(last, offset)
+ COPY_EAX_to_ECX ; last = build_member(last, offset)
+
+ CMP_EDI_ESI ; IF member_size > size
+ JG32 %build_union_size ; Then update size
+
+ ;; deal with member_size > size
+ COPY_EDI_to_ESI ; SIZE = MEMBER_SIZE
+
+:build_union_size
+ LOADI32_EAX &build_union_string_1 ; Using "ERROR in build_union\nMissing ;\n"
+ LOADI32_EBX &semicolon ; Using ";"
+ CALL32 %require_match ; Make sure we have it
+ JMP32 %build_union_iter ; Keep going
+
+:build_union_done
+ COPY_ESI_to_EDI ; MEMBER_SIZE = SIZE
+
+ LOAD32_Absolute32_eax &global_token ; Using global_token
+ LOAD32_EAX_from_EAX ; global_token->NEXT
+ STORE32_Absolute32_eax &global_token ; global_token = global_token->NEXT
+
+ COPY_ECX_to_EAX ; Return last
+
+ POP_ESI ; Restore ESI
+ POP_EDX ; Restore EDX
+ POP_ECX ; Restore ECX
+ POP_EBX ; Restore EBX
+ RETURN
+
+:build_union_string_0 "ERROR in build_union
+Missing {
+"
+:build_union_string_1 "ERROR in build_union
+Missing ;
+"
+
+
+;; sym_declare function
+;; Recieves char *s in EAX, struct type* t in EBX, and struct token_list* list in ECX
+;; Returns struct token_list* in EAX
+;; Uses EAX for A
+:sym_declare
+ PUSH_EDX ; Protect EDX
+ COPY_EAX_to_EDX ; Get char *S safely out of the way
+ LOADI32_EAX %20 ; Using sizeof(struct token_list)
+ CALL32 %malloc ; Get pointer to A
+ STORE32_ECX_into_EAX ; A->NEXT = LIST
+ STORE32_EDX_into_EAX_Immediate8 !8 ; A->S = S
+ STORE32_EBX_into_EAX_Immediate8 !12 ; A->TYPE = T
+ POP_EDX ; Restore EDX
+ RETURN
+
+
+;; match function
+;; Recieves CHAR* in EAX and CHAR* in EBX
+;; Returns 0 (TRUE) or 1 (FALSE) in EAX
+:match
+ PUSH_EBX ; Protect EBX
+ PUSH_ECX ; Protect ECX
+ PUSH_EDX ; Protect EDX
+ COPY_EAX_to_ECX ; S1 in place
+ COPY_EBX_to_EDX ; S2 in place
+:match_Loop
+ LOAD8_al_from_ECX ; S1[0]
+ MOVZX_al ; Make it useful
+ LOAD8_bl_from_EDX ; S2[0]
+ MOVZX_bl ; Make it useful
+ CMP_EAX_EBX ; See if they match
+ JNE32 %match_False ; If not
+
+ ADDI8_ECX !1 ; S1 = S1 + 1
+ ADDI8_EDX !1 ; S2 = S2 + 1
+ CMPI8_EAX !0 ; If reached end of string
+ JE32 %match_Done ; Perfect match
+ JMP32 %match_Loop ; Otherwise keep looping
+
+:match_False
+ LOADI32_EAX %1 ; Return false
+:match_Done
+ POP_EDX ; Restore EDX
+ POP_ECX ; Restore ECX
+ POP_EBX ; Restore EBX
+ RETURN
+
+
+;; numerate_number function
+;; Recieves an INT A in EAX
+;; Returns char* result in EAX
+;; Allocates 16 bytes of memory
+;; Behaves badly when given a negative number too large
+;; Uses EAX for temp, EBX for DIVISOR, EDX for mod/0, ESI for result[i] and EBP for A
+:numerate_number
+ PUSH_EBX ; Protect EBX
+ PUSH_ECX ; Protect ECX
+ PUSH_EDX ; Protect EDX
+ PUSH_ESI ; Protect ESI
+ PUSH_EBP ; Protect EBP
+ COPY_EAX_to_EBP ; Protect A
+
+ LOADI32_EAX %16 ; 16bytes
+ CALL32 %malloc ; Get our pointer
+ PUSH_EAX ; Protect our pointer
+ COPY_EAX_to_ESI ; put pointer in right place
+ LOADI32_EBX %0x3B9ACA00 ; Set divisor to largest positive number that fits in 32bits
+
+ CMPI8_EBP !0 ; Deal with 0 case
+ JE32 %numerate_number_ZERO ; If it is
+ JG32 %numerate_number_positive ; If it is positive
+
+ ;; Deal with negative case
+ LOADI32_EAX %45 ; Using "-"
+ STORE8_al_into_Address_ESI ; Write it
+ ADDI8_ESI !1 ; increment
+ IMULI8_EBP !-1 ; A = A * -1
+
+:numerate_number_positive
+ LOADI32_EDX %0 ; Set top to 0
+ COPY_EBP_to_EAX ; Using A as bottom
+ IDIV_EBX ; edx:eax % ebx -> edx + edx:eax / ebx -> eax [Even if we don't want it]
+ CMPI8_EAX !0 ; IF 0 == (a / divisor)
+ JNE32 %numerate_number_iter ; Clean up those leading Zeros
+
+ LOADI32_EDX %0 ; Set top to 0
+ COPY_EBX_to_EAX ; Using Divisor for bottom
+ LOADI32_EBX %10 ; Make this shit work because idiv 10 doesn't work
+ IDIV_EBX ; edx:eax % 10 -> edx + edx:eax / 10 -> eax [Even if we don't want it]
+ COPY_EAX_to_EBX ; Update divisor
+ JMP32 %numerate_number_positive ; Keep collecting
+
+:numerate_number_iter
+ CMPI8_EBX !0 ; IF DIVISOR < 0
+ JLE32 %numerate_number_done ; Be done
+
+ LOADI32_EDX %0 ; Set top to 0
+ COPY_EBP_to_EAX ; Using A as bottom
+ IDIV_EBX ; edx:eax % ebx -> edx + edx:eax / ebx -> eax [Even if we don't want it]
+ ADDI8_EAX !48 ; ((a / divisor) + 48)
+ STORE8_al_into_Address_ESI ; Write it
+ COPY_EDX_to_EBP ; a = a % divisor
+
+ LOADI32_EDX %0 ; Set top to 0
+ COPY_EBX_to_EAX ; Using Divisor for bottom
+ LOADI32_EBX %10 ; Make this shit work because idiv 10 doesn't work
+ IDIV_EBX ; edx:eax % 10 -> edx + edx:eax / 10 -> eax [Even if we don't want it]
+ COPY_EAX_to_EBX ; Update divisor
+
+ ADDI8_ESI !1 ; increment
+ JMP32 %numerate_number_iter ; Keep going
+
+:numerate_number_done
+ POP_EAX ; Restore our result
+ POP_EBP ; Restore EBP
+ POP_ESI ; Restore ESI
+ POP_EDX ; Restore EDX
+ POP_ECX ; Restore ECX
+ POP_EBX ; Restore EBX
+ RETURN
+
+:numerate_number_ZERO
+ LOADI32_EAX %48 ; Using '0'
+ STORE8_al_into_Address_ESI ; Write it
+ ADDI8_ESI !1 ; increment
+ JMP32 %numerate_number_done ; Be done
+
+
+;; numerate_string function
+;; Recieves CHAR* in EAX
+;; Returns value of CHAR* in EAX
+;; Uses EAX for VALUE, EBX for S, ECX for CH and ESI for NEGATIVE?
+:numerate_string
+ PUSH_EBX ; Protect EBX
+ PUSH_ECX ; Protect ECX
+ PUSH_EDX ; Protect EDX
+ PUSH_ESI ; Protect ESI
+ COPY_EAX_to_EBX ; put S in correct place
+ LOADI32_EAX %0 ; Initialize to Zero
+:numerate_string_loop
+ LOAD8_cl_from_EBX_Immediate8 !1 ; S[1]
+ MOVZX_cl ; make it useful
+ CMPI8_ECX !120 ; IF 'x' == S[1]
+ JE32 %numerate_hex ; Deal with hex input
+
+ ;; Assume decimal input
+ LOADI32_ESI %0 ; Assume no negation
+ LOAD8_cl_from_EBX ; S[0]
+ MOVZX_cl ; make it useful
+ CMPI8_ECX !45 ; IF '-' == S[0]
+ JNE32 %numerate_decimal ; Skip negation
+
+ LOADI32_ESI %1 ; Set FLAG
+ ADDI8_EBX !1 ; S = S + 1
+
+:numerate_decimal
+ LOAD8_cl_from_EBX ; S[0]
+ MOVZX_cl ; make it useful
+ CMPI8_ECX !0 ; IF NULL == S[0]
+ JE32 %numerate_decimal_done ; We are done
+
+ IMULI8_EAX !10 ; VALUE = VALUE * 10
+ SUBI8_ECX !48 ; CH = CH - '0'
+ CMPI8_ECX !9 ; Check for illegal
+ JG32 %numerate_string_fail ; If CH > '9'
+ CMPI8_ECX !0 ; Check for illegal
+ JL32 %numerate_string_fail ; IF CH < 0
+ ADD_ecx_into_eax ; VALUE = VALUE + CH
+ ADDI8_EBX !1 ; S = S + 1
+ JMP32 %numerate_decimal ; Keep looping
+
+:numerate_decimal_done
+ CMPI8_ESI !1 ; Check if need to negate
+ JNE32 %numerate_string_done ; Nope
+
+ IMULI8_EAX !-1 ; VALUE = VALUE * -1
+ JMP32 %numerate_string_done ; Done
+
+:numerate_hex
+ ADDI8_EBX !2 ; S = S + 2
+:numerate_hex_loop
+ LOAD8_cl_from_EBX ; S[0]
+ MOVZX_cl ; make it useful
+ CMPI8_ECX !0 ; IF NULL == S[0]
+ JE32 %numerate_string_done ; We are done
+
+ SALI8_EAX !4 ; VALUE = VALUE << 4
+ SUBI8_ECX !48 ; CH = CH - '0'
+ CMPI8_ECX !10 ; IF 10 >= CH
+ JL32 %numerate_hex_digit ; NO
+ SUBI8_ECX !7 ; Push A-F into range
+:numerate_hex_digit
+ CMPI8_ECX !15 ; Check for illegal
+ JG32 %numerate_string_fail ; If CH > 'F'
+ CMPI8_ECX !0 ; Check for illegal
+ JL32 %numerate_string_fail ; IF CH < 0
+ ADD_ecx_into_eax ; VALUE = VALUE + CH
+ ADDI8_EBX !1 ; S = S + 1
+ JMP32 %numerate_hex_loop ; Keep looping
+
+:numerate_string_fail
+ LOADI32_EAX %0 ; return ZERO
+
+:numerate_string_done
+ POP_ESI ; Restore ESI
+ POP_EDX ; Restore EDX
+ POP_ECX ; Restore ECX
+ POP_EBX ; Restore EBX
+ RETURN
+
+
+;; Exit_Failure function
+;; Recieves nothing
+;; And aborts hard
+;; Does NOT return
+:Exit_Failure
+ LOADI32_EBX %1 ; All is wrong
+ LOADI32_EAX %1 ; put the exit syscall number in eax
+ INT_80 ; Call it a bad day
+
+;; Keywords
+:union "union"
+:struct "struct"
+:constant "CONSTANT"
+:main_string "main"
+:argc_string "argc"
+:argv_string "argv"
+:if_string "if"
+:else_string "else"
+:do_string "do"
+:while_string "while"
+:for_string "for"
+:asm_string "asm"
+:goto_string "goto"
+:return_string "return"
+:break_string "break"
+:continue_string "continue"
+:sizeof_string "sizeof"
+:plus_string "+"
+:minus_string "-"
+:multiply_string "*"
+:divide_string "/"
+:modulus_string "%"
+:left_shift_string "<<"
+:right_shift_string ">>"
+:less_than_string "<"
+:less_than_equal_string "<="
+:greater_than_equal_string ">="
+:greater_than_string ">"
+:equal_to_string "=="
+:not_equal_string "!="
+:bitwise_and "&"
+:logical_and "&&"
+:bitwise_or "|"
+:logical_or "||"
+:bitwise_xor "^"
+:arrow_string "->"
+
+
+;; Frequently Used strings
+;; Generally used by require_match
+:open_curly_brace "{"
+:close_curly_brace "}"
+:open_paren "("
+:close_paren ")"
+:open_bracket "["
+:close_bracket "]"
+:comma ","
+:semicolon ";"
+:equal "="
+:percent "%"
+:newline "\n"
+:underline "_"
+
+
+:prim_types
+:type_void
+ &type_int ; NEXT
+ %4 ; SIZE
+ %0 ; OFFSET
+ &type_void ; INDIRECT
+ %0 ; MEMBERS
+ &type_void ; TYPE
+ &type_void_name ; NAME
+:type_void_name "void"
+
+:type_int
+ &type_char ; NEXT
+ %4 ; SIZE
+ %0 ; OFFSET
+ &type_int ; INDIRECT
+ %0 ; MEMBERS
+ &type_int ; TYPE
+ &type_int_name ; NAME
+:type_int_name "int"
+
+:type_char
+ &type_file ; NEXT
+ %1 ; SIZE
+ %0 ; OFFSET
+ &type_char_indirect ; INDIRECT
+ %0 ; MEMBERS
+ &type_char ; TYPE
+ &type_char_name ; NAME
+:type_char_name "char"
+
+:type_char_indirect
+ &type_file ; NEXT
+ %4 ; SIZE
+ %0 ; OFFSET
+ &type_char_double_indirect ; INDIRECT
+ %0 ; MEMBERS
+ &type_char_indirect ; TYPE
+ &type_char_indirect_name ; NAME
+:type_char_indirect_name "char*"
+
+:type_char_double_indirect
+ &type_file ; NEXT
+ %4 ; SIZE
+ %0 ; OFFSET
+ &type_char_double_indirect ; INDIRECT
+ %0 ; MEMBERS
+ &type_char_indirect ; TYPE
+ &type_char_double_indirect_name ; NAME
+:type_char_double_indirect_name "char**"
+
+:type_file
+ &type_function ; NEXT
+ %4 ; SIZE
+ %0 ; OFFSET
+ &type_file ; INDIRECT
+ %0 ; MEMBERS
+ &type_file ; TYPE
+ &type_file_name ; NAME
+:type_file_name "FILE"
+
+:type_function
+ &type_unsigned ; NEXT
+ %4 ; SIZE
+ %0 ; OFFSET
+ &type_function ; INDIRECT
+ %0 ; MEMBERS
+ &type_function ; TYPE
+ &type_function_name ; NAME
+:type_function_name "FUNCTION"
+
+:type_unsigned
+ %0 ; NEXT
+ %4 ; SIZE
+ %0 ; OFFSET
+ &type_unsigned ; INDIRECT
+ %0 ; MEMBERS
+ &type_unsigned ; TYPE
+ &type_unsigned_name ; NAME
+:type_unsigned_name "unsigned"
+
+
+;; debug_list function
+;; Recieves struct token_list* in EAX
+;; Prints contents of list and exits
+;; Does NOT return
+:debug_list
+ COPY_EAX_to_EBP ; Protect the list pointer
+ LOADI32_EAX %2 ; Using Standard error
+ STORE32_Absolute32_eax &Output_file ; write to standard error
+
+:debug_list_iter
+ ;; Header
+ LOADI32_EAX &debug_list_string0 ; Using our first string
+ CALL32 %File_Print ; Print it
+ COPY_EBP_to_EAX ; Use address of pointer
+ CALL32 %numerate_number ; Convert it into string
+ CALL32 %File_Print ; Print it
+
+ ;; NEXT
+ LOADI32_EAX &debug_list_string1 ; Using our second string
+ CALL32 %File_Print ; Print it
+ LOAD32_EAX_from_EBP_Immediate8 !0 ; Use address of pointer
+ CALL32 %numerate_number ; Convert it into string
+ CALL32 %File_Print ; Print it
+
+ ;; PREV
+ LOADI32_EAX &debug_list_string2 ; Using our third string
+ CALL32 %File_Print ; Print it
+ LOAD32_EAX_from_EBP_Immediate8 !4 ; Use address of pointer
+ CALL32 %numerate_number ; Convert it into string
+ CALL32 %File_Print ; Print it
+
+ ;; S
+ LOADI32_EAX &debug_list_string3 ; Using our fourth string
+ CALL32 %File_Print ; Print it
+ LOAD32_EAX_from_EBP_Immediate8 !8 ; Use address of pointer
+ CALL32 %numerate_number ; Convert it into string
+ CALL32 %File_Print ; Print it
+
+ ;; S Contents
+ LOADI32_EAX &debug_list_string4 ; Using our fifth string
+ CALL32 %File_Print ; Print it
+ LOAD32_EAX_from_EBP_Immediate8 !8 ; Use address of string
+ CMPI8_EAX !0 ; IF NULL Pointer
+ JNE32 %debug_list_null ; otherwise display
+ LOADI32_EAX &debug_list_string_null ; Give meaningful message instead
+:debug_list_null
+ CALL32 %File_Print ; Print it
+
+ ;; TYPE
+ LOADI32_EAX &debug_list_string5 ; Using our sixth string
+ CALL32 %File_Print ; Print it
+ LOAD32_EAX_from_EBP_Immediate8 !12 ; Use address of pointer
+ CALL32 %numerate_number ; Convert it into string
+ CALL32 %File_Print ; Print it
+
+ ;; ARGS/DEPTH
+ LOADI32_EAX &debug_list_string6 ; Using our third string
+ CALL32 %File_Print ; Print it
+ LOAD32_EAX_from_EBP_Immediate8 !16 ; Use address of pointer
+ CALL32 %numerate_number ; Convert it into string
+ CALL32 %File_Print ; Print it
+
+ LOADI32_EAX %10 ; Add "\n"
+ CALL32 %fputc ; print it
+ CALL32 %fputc ; print it
+
+ LOAD32_EBP_from_EBP ; TOKEN = TOKEN->NEXT
+ CMPI8_EBP !0 ; Check if NULL
+ JNE32 %debug_list_iter ; iterate otherwise
+
+ LOADI32_EBX %666 ; All is HELL
+ LOADI32_EAX %1 ; put the exit syscall number in eax
+ INT_80 ; Call it a bad day
+
+:debug_list_string0 "Token_list node at address: "
+:debug_list_string1 "
+NEXT address: "
+:debug_list_string2 "
+PREV address: "
+:debug_list_string3 "
+S address: "
+:debug_list_string4 "
+The contents of S are: "
+:debug_list_string5 "
+TYPE address: "
+:debug_list_string6 "
+ARGUMENTS address: "
+:debug_list_string_null ">::::<"
+
+
+:Address_of
+ NULL
+:C
+ NULL
+:Input_file
+ NULL
+:MALLOC
+ NULL
+:Output_file
+ NULL
+:Token
+ NULL
+:break_frame
+ NULL
+:break_target_func
+ NULL
+:break_target_head
+ NULL
+:break_target_num
+ NULL
+:current_count
+ NULL
+:current_target
+ NULL
+:function
+ NULL
+:global_constant_list
+ NULL
+:global_function_list
+ NULL
+:global_symbol_list
+ NULL
+:global_token
+ NULL
+:global_types
+ &prim_types
+:globals_list
+ NULL
+:output_list
+ NULL
+:string_index
+ NULL
+:strings_list
+ NULL
+
+:ELF_end
diff --git a/kaem.run b/kaem.run
deleted file mode 100644
index 7bae750..0000000
--- a/kaem.run
+++ /dev/null
@@ -1,40 +0,0 @@
-#! /usr/bin/env bash
-## Copyright (C) 2017 Jeremiah Orians
-## This file is part of M2-Planet.
-##
-## M2-Planet is free software: you can redistribute it and/or modify
-## it under the terms of the GNU General Public License as published by
-## the Free Software Foundation, either version 3 of the License, or
-## (at your option) any later version.
-##
-## M2-Planet is distributed in the hope that it will be useful,
-## but WITHOUT ANY WARRANTY; without even the implied warranty of
-## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-## GNU General Public License for more details.
-##
-## You should have received a copy of the GNU General Public License
-## along with M2-Planet. If not, see .
-
-# Make the required bin directry
-mkdir -p bin
-
-# Build debug footer
-blood-elf -f seed.M1 -o bin/seed-footer.M1
-
-# Macro assemble with libc written in M1-Macro
-M1 -f test/common_x86/x86_defs.M1 \
- -f functions/libc-core.M1 \
- -f seed.M1 \
- -f bin/seed-footer.M1 \
- --LittleEndian \
- --Architecture 1 \
- -o bin/seed.hex2
-
-# Resolve all linkages
-hex2 -f test/common_x86/ELF-i386-debug.hex2 \
- -f bin/seed.hex2 \
- --LittleEndian \
- --Architecture 1 \
- --BaseAddress 0x8048000 \
- -o bin/M2-Planet \
- --exec_enable
diff --git a/seed.M1 b/seed.M1
deleted file mode 100644
index cdd69f0..0000000
--- a/seed.M1
+++ /dev/null
@@ -1,15100 +0,0 @@
-# This file was generated by running:
-# ./bin/vm --rom roms/cc_x86 --memory 4M --tape_01 stage3/M2-Planet_x86.c --tape_02 ../M2-Planet/seed.M1
-# In stage0
-
-# Core program
-# Defining function fgetc
-:FUNCTION_fgetc
-LOAD_IMMEDIATE_eax %3
-LOAD_EFFECTIVE_ADDRESS_ebx %4
-LOAD_INTEGER_ebx
-PUSH_ebx
-COPY_esp_to_ecx
-LOAD_IMMEDIATE_edx %1
-INT_80
-TEST
-POP_eax
-JUMP_NE8 !FUNCTION_fgetc_Done
-LOAD_IMMEDIATE_eax %-1
-:FUNCTION_fgetc_Done
-RETURN
-# Defining function fputc
-:FUNCTION_fputc
-LOAD_IMMEDIATE_eax %4
-LOAD_EFFECTIVE_ADDRESS_ebx %4
-LOAD_INTEGER_ebx
-LOAD_EFFECTIVE_ADDRESS_ecx %8
-LOAD_IMMEDIATE_edx %1
-INT_80
-RETURN
-# Defining function open
-:FUNCTION_open
-LOAD_EFFECTIVE_ADDRESS_ebx %12
-LOAD_INTEGER_ebx
-LOAD_EFFECTIVE_ADDRESS_ecx %8
-LOAD_INTEGER_ecx
-LOAD_EFFECTIVE_ADDRESS_edx %4
-LOAD_INTEGER_edx
-LOAD_IMMEDIATE_eax %5
-INT_80
-RETURN
-# Defining function fopen
-:FUNCTION_fopen
-# Defining local f
-PUSH_eax #f
-# IF_fopen_0
-LOAD_IMMEDIATE_eax %119
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %0
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-LOAD_BYTE
-POP_ebx # _common_recursion
-CMP
-SETE
-MOVEZBL
-TEST
-JUMP_EQ %ELSE_fopen_0
-LOAD_BASE_ADDRESS_eax %-16
-PUSH_eax #_common_recursion
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax %577
-PUSH_eax #_process_expression2
-LOAD_IMMEDIATE_eax %384
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_open
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-POP_ebx # _common_recursion
-STORE_INTEGER
-JUMP %_END_IF_fopen_0
-:ELSE_fopen_0
-LOAD_BASE_ADDRESS_eax %-16
-PUSH_eax #_common_recursion
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax %0
-PUSH_eax #_process_expression2
-LOAD_IMMEDIATE_eax %0
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_open
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-POP_ebx # _common_recursion
-STORE_INTEGER
-:_END_IF_fopen_0
-# IF_fopen_1
-LOAD_IMMEDIATE_eax %0
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-16
-LOAD_INTEGER
-POP_ebx # _common_recursion
-CMP
-SETG
-MOVEZBL
-TEST
-JUMP_EQ %ELSE_fopen_1
-LOAD_IMMEDIATE_eax %0
-POP_ebx # _return_result_locals
-RETURN
-JUMP %_END_IF_fopen_1
-:ELSE_fopen_1
-:_END_IF_fopen_1
-LOAD_BASE_ADDRESS_eax %-16
-LOAD_INTEGER
-POP_ebx # _return_result_locals
-RETURN
-# Defining function close
-:FUNCTION_close
-LOAD_EFFECTIVE_ADDRESS_ebx %4
-LOAD_IMMEDIATE_eax %6
-INT_80
-RETURN
-# Defining function fclose
-:FUNCTION_fclose
-# Defining local error
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_close
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_eax #error
-LOAD_BASE_ADDRESS_eax %-12
-LOAD_INTEGER
-POP_ebx # _return_result_locals
-RETURN
-# Defining function malloc
-:FUNCTION_malloc
-STORE_eax_into_ESP_IMMEDIATE8 !4
-PUSH_eax
-LOAD_IMMEDIATE_eax %45
-LOAD_IMMEDIATE_ebx %0
-INT_80
-POP_ebx
-ADD_eax_to_ebx
-PUSH_eax
-PUSH_ebx
-LOAD_IMMEDIATE_eax %45
-INT_80
-POP_ebx
-CMP
-POP_eax
-JUMP_EQ8 !FUNCTION_malloc_Done
-LOAD_IMMEDIATE_eax %-1
-:FUNCTION_malloc_Done
-RETURN
-# Defining function memset
-:FUNCTION_memset
-# Defining local s
-PUSH_eax #s
-# FOR_initialization_memset_0
-LOAD_BASE_ADDRESS_eax %-20
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-:FOR_memset_0
-LOAD_IMMEDIATE_eax %0
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-12
-LOAD_INTEGER
-POP_ebx # _common_recursion
-CMP
-SETL
-MOVEZBL
-TEST
-JUMP_EQ %FOR_END_memset_0
-JUMP %FOR_THEN_memset_0
-:FOR_ITER_memset_0
-LOAD_BASE_ADDRESS_eax %-12
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-12
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %1
-POP_ebx # _common_recursion
-SUBTRACT_eax_from_ebx_into_ebx
-MOVE_ebx_to_eax
-POP_ebx # _common_recursion
-STORE_INTEGER
-JUMP %FOR_memset_0
-:FOR_THEN_memset_0
-LOAD_BASE_ADDRESS_eax %-20
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %0
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_CHAR
-LOAD_BASE_ADDRESS_eax %-20
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-20
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %1
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-POP_ebx # _common_recursion
-STORE_INTEGER
-JUMP %FOR_ITER_memset_0
-:FOR_END_memset_0
-POP_ebx # _recursive_statement_locals
-RETURN
-# Defining function calloc
-:FUNCTION_calloc
-# Defining local ret
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-POP_ebx # _common_recursion
-MULTIPLY_eax_by_ebx_into_eax
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_malloc
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_eax #ret
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-16
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax %0
-PUSH_eax #_process_expression2
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-POP_ebx # _common_recursion
-MULTIPLY_eax_by_ebx_into_eax
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_memset
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-LOAD_BASE_ADDRESS_eax %-16
-LOAD_INTEGER
-POP_ebx # _return_result_locals
-RETURN
-# Defining function free
-:FUNCTION_free
-RETURN
-# Defining function exit
-:FUNCTION_exit
-POP_ebx
-POP_ebx
-LOAD_IMMEDIATE_eax %1
-INT_80
-RETURN
-# Defining function match
-:FUNCTION_match
-# Defining local i
-LOAD_IMMEDIATE_eax %0
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %1
-POP_ebx # _common_recursion
-SUBTRACT_eax_from_ebx_into_ebx
-MOVE_ebx_to_eax
-PUSH_eax #i
-:DO_match_0
-LOAD_BASE_ADDRESS_eax %-16
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-16
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %1
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-POP_ebx # _common_recursion
-STORE_INTEGER
-# IF_match_1
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-16
-LOAD_INTEGER
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-LOAD_BYTE
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-16
-LOAD_INTEGER
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-LOAD_BYTE
-POP_ebx # _common_recursion
-CMP
-SETNE
-MOVEZBL
-TEST
-JUMP_EQ %ELSE_match_1
-LOAD_IMMEDIATE_eax %0
-POP_ebx # _return_result_locals
-RETURN
-JUMP %_END_IF_match_1
-:ELSE_match_1
-:_END_IF_match_1
-LOAD_IMMEDIATE_eax %0
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-16
-LOAD_INTEGER
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-LOAD_BYTE
-POP_ebx # _common_recursion
-CMP
-SETNE
-MOVEZBL
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %0
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-16
-LOAD_INTEGER
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-LOAD_BYTE
-POP_ebx # _common_recursion
-CMP
-SETNE
-MOVEZBL
-POP_ebx # _common_recursion
-AND_eax_ebx
-TEST
-JUMP_NE %DO_match_0
-:DO_END_match_0
-LOAD_IMMEDIATE_eax %1
-POP_ebx # _return_result_locals
-RETURN
-# Defining function numerate_number
-:FUNCTION_numerate_number
-# Defining local result
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax %16
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax %1
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_calloc
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_eax #result
-# Defining local i
-LOAD_IMMEDIATE_eax %0
-PUSH_eax #i
-# IF_numerate_number_0
-LOAD_IMMEDIATE_eax %0
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-POP_ebx # _common_recursion
-CMP
-SETE
-MOVEZBL
-TEST
-JUMP_EQ %ELSE_numerate_number_0
-LOAD_BASE_ADDRESS_eax %-12
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %0
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %48
-POP_ebx # _common_recursion
-STORE_CHAR
-LOAD_BASE_ADDRESS_eax %-12
-LOAD_INTEGER
-POP_ebx # _return_result_locals
-POP_ebx # _return_result_locals
-RETURN
-JUMP %_END_IF_numerate_number_0
-:ELSE_numerate_number_0
-:_END_IF_numerate_number_0
-# IF_numerate_number_1
-LOAD_IMMEDIATE_eax %0
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-POP_ebx # _common_recursion
-CMP
-SETG
-MOVEZBL
-TEST
-JUMP_EQ %ELSE_numerate_number_1
-LOAD_BASE_ADDRESS_eax %-12
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %0
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %45
-POP_ebx # _common_recursion
-STORE_CHAR
-LOAD_BASE_ADDRESS_eax %-16
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %1
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_BASE_ADDRESS_eax %-4
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %0
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %1
-POP_ebx # _common_recursion
-SUBTRACT_eax_from_ebx_into_ebx
-MOVE_ebx_to_eax
-POP_ebx # _common_recursion
-MULTIPLY_eax_by_ebx_into_eax
-POP_ebx # _common_recursion
-STORE_INTEGER
-JUMP %_END_IF_numerate_number_1
-:ELSE_numerate_number_1
-:_END_IF_numerate_number_1
-# Defining local divisor
-LOAD_IMMEDIATE_eax %0x3B9ACA00
-PUSH_eax #divisor
-:WHILE_numerate_number_2
-LOAD_IMMEDIATE_eax %0
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-20
-LOAD_INTEGER
-POP_ebx # _common_recursion
-XCHG_eax_ebx
-LOAD_IMMEDIATE_edx %0
-DIVIDE_eax_by_ebx_into_eax
-POP_ebx # _common_recursion
-CMP
-SETE
-MOVEZBL
-TEST
-JUMP_EQ %END_WHILE_numerate_number_2
-# THEN_while_numerate_number_2
-LOAD_BASE_ADDRESS_eax %-20
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-20
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %10
-POP_ebx # _common_recursion
-XCHG_eax_ebx
-LOAD_IMMEDIATE_edx %0
-DIVIDE_eax_by_ebx_into_eax
-POP_ebx # _common_recursion
-STORE_INTEGER
-JUMP %WHILE_numerate_number_2
-:END_WHILE_numerate_number_2
-:WHILE_numerate_number_3
-LOAD_IMMEDIATE_eax %0
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-20
-LOAD_INTEGER
-POP_ebx # _common_recursion
-CMP
-SETL
-MOVEZBL
-TEST
-JUMP_EQ %END_WHILE_numerate_number_3
-# THEN_while_numerate_number_3
-LOAD_BASE_ADDRESS_eax %-12
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-16
-LOAD_INTEGER
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-20
-LOAD_INTEGER
-POP_ebx # _common_recursion
-XCHG_eax_ebx
-LOAD_IMMEDIATE_edx %0
-DIVIDE_eax_by_ebx_into_eax
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %48
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-POP_ebx # _common_recursion
-STORE_CHAR
-LOAD_BASE_ADDRESS_eax %-4
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-20
-LOAD_INTEGER
-POP_ebx # _common_recursion
-XCHG_eax_ebx
-LOAD_IMMEDIATE_edx %0
-MODULUS_eax_from_ebx_into_ebx
-MOVE_edx_to_eax
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_BASE_ADDRESS_eax %-20
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-20
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %10
-POP_ebx # _common_recursion
-XCHG_eax_ebx
-LOAD_IMMEDIATE_edx %0
-DIVIDE_eax_by_ebx_into_eax
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_BASE_ADDRESS_eax %-16
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-16
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %1
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-POP_ebx # _common_recursion
-STORE_INTEGER
-JUMP %WHILE_numerate_number_3
-:END_WHILE_numerate_number_3
-LOAD_BASE_ADDRESS_eax %-12
-LOAD_INTEGER
-POP_ebx # _return_result_locals
-POP_ebx # _return_result_locals
-POP_ebx # _return_result_locals
-RETURN
-# Defining function char2hex
-:FUNCTION_char2hex
-# IF_char2hex_0
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %48
-POP_ebx # _common_recursion
-CMP
-SETGE
-MOVEZBL
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %57
-POP_ebx # _common_recursion
-CMP
-SETLE
-MOVEZBL
-POP_ebx # _common_recursion
-AND_eax_ebx
-TEST
-JUMP_EQ %ELSE_char2hex_0
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %48
-POP_ebx # _common_recursion
-SUBTRACT_eax_from_ebx_into_ebx
-MOVE_ebx_to_eax
-RETURN
-JUMP %_END_IF_char2hex_0
-:ELSE_char2hex_0
-# IF_char2hex_1
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %97
-POP_ebx # _common_recursion
-CMP
-SETGE
-MOVEZBL
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %102
-POP_ebx # _common_recursion
-CMP
-SETLE
-MOVEZBL
-POP_ebx # _common_recursion
-AND_eax_ebx
-TEST
-JUMP_EQ %ELSE_char2hex_1
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %87
-POP_ebx # _common_recursion
-SUBTRACT_eax_from_ebx_into_ebx
-MOVE_ebx_to_eax
-RETURN
-JUMP %_END_IF_char2hex_1
-:ELSE_char2hex_1
-# IF_char2hex_2
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %65
-POP_ebx # _common_recursion
-CMP
-SETGE
-MOVEZBL
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %70
-POP_ebx # _common_recursion
-CMP
-SETLE
-MOVEZBL
-POP_ebx # _common_recursion
-AND_eax_ebx
-TEST
-JUMP_EQ %ELSE_char2hex_2
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %55
-POP_ebx # _common_recursion
-SUBTRACT_eax_from_ebx_into_ebx
-MOVE_ebx_to_eax
-RETURN
-JUMP %_END_IF_char2hex_2
-:ELSE_char2hex_2
-LOAD_IMMEDIATE_eax %0
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %1
-POP_ebx # _common_recursion
-SUBTRACT_eax_from_ebx_into_ebx
-MOVE_ebx_to_eax
-RETURN
-:_END_IF_char2hex_2
-:_END_IF_char2hex_1
-:_END_IF_char2hex_0
-RETURN
-# Defining function hex2char
-:FUNCTION_hex2char
-# IF_hex2char_0
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %0
-POP_ebx # _common_recursion
-CMP
-SETGE
-MOVEZBL
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %9
-POP_ebx # _common_recursion
-CMP
-SETLE
-MOVEZBL
-POP_ebx # _common_recursion
-AND_eax_ebx
-TEST
-JUMP_EQ %ELSE_hex2char_0
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %48
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-RETURN
-JUMP %_END_IF_hex2char_0
-:ELSE_hex2char_0
-# IF_hex2char_1
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %10
-POP_ebx # _common_recursion
-CMP
-SETGE
-MOVEZBL
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %15
-POP_ebx # _common_recursion
-CMP
-SETLE
-MOVEZBL
-POP_ebx # _common_recursion
-AND_eax_ebx
-TEST
-JUMP_EQ %ELSE_hex2char_1
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %55
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-RETURN
-JUMP %_END_IF_hex2char_1
-:ELSE_hex2char_1
-LOAD_IMMEDIATE_eax %0
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %1
-POP_ebx # _common_recursion
-SUBTRACT_eax_from_ebx_into_ebx
-MOVE_ebx_to_eax
-RETURN
-:_END_IF_hex2char_1
-:_END_IF_hex2char_0
-RETURN
-# Defining function char2dec
-:FUNCTION_char2dec
-# IF_char2dec_0
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %48
-POP_ebx # _common_recursion
-CMP
-SETGE
-MOVEZBL
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %57
-POP_ebx # _common_recursion
-CMP
-SETLE
-MOVEZBL
-POP_ebx # _common_recursion
-AND_eax_ebx
-TEST
-JUMP_EQ %ELSE_char2dec_0
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %48
-POP_ebx # _common_recursion
-SUBTRACT_eax_from_ebx_into_ebx
-MOVE_ebx_to_eax
-RETURN
-JUMP %_END_IF_char2dec_0
-:ELSE_char2dec_0
-LOAD_IMMEDIATE_eax %0
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %1
-POP_ebx # _common_recursion
-SUBTRACT_eax_from_ebx_into_ebx
-MOVE_ebx_to_eax
-RETURN
-:_END_IF_char2dec_0
-RETURN
-# Defining function dec2char
-:FUNCTION_dec2char
-# IF_dec2char_0
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %0
-POP_ebx # _common_recursion
-CMP
-SETGE
-MOVEZBL
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %9
-POP_ebx # _common_recursion
-CMP
-SETLE
-MOVEZBL
-POP_ebx # _common_recursion
-AND_eax_ebx
-TEST
-JUMP_EQ %ELSE_dec2char_0
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %48
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-RETURN
-JUMP %_END_IF_dec2char_0
-:ELSE_dec2char_0
-LOAD_IMMEDIATE_eax %0
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %1
-POP_ebx # _common_recursion
-SUBTRACT_eax_from_ebx_into_ebx
-MOVE_ebx_to_eax
-RETURN
-:_END_IF_dec2char_0
-RETURN
-# Defining function numerate_string
-:FUNCTION_numerate_string
-# Defining local count
-LOAD_IMMEDIATE_eax %0
-PUSH_eax #count
-# Defining local index
-PUSH_eax #index
-# Defining local negative
-PUSH_eax #negative
-# IF_numerate_string_0
-LOAD_IMMEDIATE_eax %0
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %0
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-LOAD_BYTE
-POP_ebx # _common_recursion
-CMP
-SETE
-MOVEZBL
-TEST
-JUMP_EQ %ELSE_numerate_string_0
-LOAD_IMMEDIATE_eax %0
-POP_ebx # _return_result_locals
-POP_ebx # _return_result_locals
-POP_ebx # _return_result_locals
-RETURN
-JUMP %_END_IF_numerate_string_0
-:ELSE_numerate_string_0
-# IF_numerate_string_1
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %0
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-LOAD_BYTE
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %48
-POP_ebx # _common_recursion
-CMP
-SETE
-MOVEZBL
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %1
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-LOAD_BYTE
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %120
-POP_ebx # _common_recursion
-CMP
-SETE
-MOVEZBL
-POP_ebx # _common_recursion
-AND_eax_ebx
-TEST
-JUMP_EQ %ELSE_numerate_string_1
-# IF_numerate_string_2
-LOAD_IMMEDIATE_eax %45
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %2
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-LOAD_BYTE
-POP_ebx # _common_recursion
-CMP
-SETE
-MOVEZBL
-TEST
-JUMP_EQ %ELSE_numerate_string_2
-LOAD_BASE_ADDRESS_eax %-20
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %1
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_BASE_ADDRESS_eax %-16
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %3
-POP_ebx # _common_recursion
-STORE_INTEGER
-JUMP %_END_IF_numerate_string_2
-:ELSE_numerate_string_2
-LOAD_BASE_ADDRESS_eax %-20
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %0
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_BASE_ADDRESS_eax %-16
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %2
-POP_ebx # _common_recursion
-STORE_INTEGER
-:_END_IF_numerate_string_2
-:WHILE_numerate_string_3
-LOAD_IMMEDIATE_eax %0
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-16
-LOAD_INTEGER
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-LOAD_BYTE
-POP_ebx # _common_recursion
-CMP
-SETNE
-MOVEZBL
-TEST
-JUMP_EQ %END_WHILE_numerate_string_3
-# THEN_while_numerate_string_3
-# IF_numerate_string_4
-LOAD_IMMEDIATE_eax %0
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %1
-POP_ebx # _common_recursion
-SUBTRACT_eax_from_ebx_into_ebx
-MOVE_ebx_to_eax
-PUSH_eax #_common_recursion
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-16
-LOAD_INTEGER
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-LOAD_BYTE
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_char2hex
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-POP_ebx # _common_recursion
-CMP
-SETE
-MOVEZBL
-TEST
-JUMP_EQ %ELSE_numerate_string_4
-LOAD_IMMEDIATE_eax %0
-POP_ebx # _return_result_locals
-POP_ebx # _return_result_locals
-POP_ebx # _return_result_locals
-RETURN
-JUMP %_END_IF_numerate_string_4
-:ELSE_numerate_string_4
-:_END_IF_numerate_string_4
-LOAD_BASE_ADDRESS_eax %-12
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %16
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-12
-LOAD_INTEGER
-POP_ebx # _common_recursion
-MULTIPLY_eax_by_ebx_into_eax
-PUSH_eax #_common_recursion
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-16
-LOAD_INTEGER
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-LOAD_BYTE
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_char2hex
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_BASE_ADDRESS_eax %-16
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-16
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %1
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-POP_ebx # _common_recursion
-STORE_INTEGER
-JUMP %WHILE_numerate_string_3
-:END_WHILE_numerate_string_3
-JUMP %_END_IF_numerate_string_1
-:ELSE_numerate_string_1
-# IF_numerate_string_5
-LOAD_IMMEDIATE_eax %45
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %0
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-LOAD_BYTE
-POP_ebx # _common_recursion
-CMP
-SETE
-MOVEZBL
-TEST
-JUMP_EQ %ELSE_numerate_string_5
-LOAD_BASE_ADDRESS_eax %-20
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %1
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_BASE_ADDRESS_eax %-16
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %1
-POP_ebx # _common_recursion
-STORE_INTEGER
-JUMP %_END_IF_numerate_string_5
-:ELSE_numerate_string_5
-LOAD_BASE_ADDRESS_eax %-20
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %0
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_BASE_ADDRESS_eax %-16
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %0
-POP_ebx # _common_recursion
-STORE_INTEGER
-:_END_IF_numerate_string_5
-:WHILE_numerate_string_6
-LOAD_IMMEDIATE_eax %0
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-16
-LOAD_INTEGER
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-LOAD_BYTE
-POP_ebx # _common_recursion
-CMP
-SETNE
-MOVEZBL
-TEST
-JUMP_EQ %END_WHILE_numerate_string_6
-# THEN_while_numerate_string_6
-# IF_numerate_string_7
-LOAD_IMMEDIATE_eax %0
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %1
-POP_ebx # _common_recursion
-SUBTRACT_eax_from_ebx_into_ebx
-MOVE_ebx_to_eax
-PUSH_eax #_common_recursion
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-16
-LOAD_INTEGER
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-LOAD_BYTE
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_char2dec
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-POP_ebx # _common_recursion
-CMP
-SETE
-MOVEZBL
-TEST
-JUMP_EQ %ELSE_numerate_string_7
-LOAD_IMMEDIATE_eax %0
-POP_ebx # _return_result_locals
-POP_ebx # _return_result_locals
-POP_ebx # _return_result_locals
-RETURN
-JUMP %_END_IF_numerate_string_7
-:ELSE_numerate_string_7
-:_END_IF_numerate_string_7
-LOAD_BASE_ADDRESS_eax %-12
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %10
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-12
-LOAD_INTEGER
-POP_ebx # _common_recursion
-MULTIPLY_eax_by_ebx_into_eax
-PUSH_eax #_common_recursion
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-16
-LOAD_INTEGER
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-LOAD_BYTE
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_char2dec
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_BASE_ADDRESS_eax %-16
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-16
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %1
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-POP_ebx # _common_recursion
-STORE_INTEGER
-JUMP %WHILE_numerate_string_6
-:END_WHILE_numerate_string_6
-:_END_IF_numerate_string_1
-:_END_IF_numerate_string_0
-# IF_numerate_string_8
-LOAD_BASE_ADDRESS_eax %-20
-LOAD_INTEGER
-TEST
-JUMP_EQ %ELSE_numerate_string_8
-LOAD_BASE_ADDRESS_eax %-12
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-12
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %0
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %1
-POP_ebx # _common_recursion
-SUBTRACT_eax_from_ebx_into_ebx
-MOVE_ebx_to_eax
-POP_ebx # _common_recursion
-MULTIPLY_eax_by_ebx_into_eax
-POP_ebx # _common_recursion
-STORE_INTEGER
-JUMP %_END_IF_numerate_string_8
-:ELSE_numerate_string_8
-:_END_IF_numerate_string_8
-LOAD_BASE_ADDRESS_eax %-12
-LOAD_INTEGER
-POP_ebx # _return_result_locals
-POP_ebx # _return_result_locals
-POP_ebx # _return_result_locals
-RETURN
-# Defining function file_print
-:FUNCTION_file_print
-:WHILE_file_print_0
-LOAD_IMMEDIATE_eax %0
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %0
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-LOAD_BYTE
-POP_ebx # _common_recursion
-CMP
-SETNE
-MOVEZBL
-TEST
-JUMP_EQ %END_WHILE_file_print_0
-# THEN_while_file_print_0
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %0
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-LOAD_BYTE
-PUSH_eax #_process_expression1
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_fputc
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-LOAD_BASE_ADDRESS_eax %-4
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %1
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-POP_ebx # _common_recursion
-STORE_INTEGER
-JUMP %WHILE_file_print_0
-:END_WHILE_file_print_0
-RETURN
-# Defining function copy_string
-:FUNCTION_copy_string
-:WHILE_copy_string_0
-LOAD_IMMEDIATE_eax %0
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %0
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-LOAD_BYTE
-POP_ebx # _common_recursion
-CMP
-SETNE
-MOVEZBL
-TEST
-JUMP_EQ %END_WHILE_copy_string_0
-# THEN_while_copy_string_0
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %0
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %0
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-LOAD_BYTE
-POP_ebx # _common_recursion
-STORE_CHAR
-LOAD_BASE_ADDRESS_eax %-4
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %1
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_BASE_ADDRESS_eax %-8
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %1
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-POP_ebx # _common_recursion
-STORE_INTEGER
-JUMP %WHILE_copy_string_0
-:END_WHILE_copy_string_0
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-RETURN
-# Defining function postpend_char
-:FUNCTION_postpend_char
-# Defining local ret
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax %4096
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax %1
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_calloc
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_eax #ret
-# Defining local hold
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-16
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_copy_string
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_eax #hold
-LOAD_BASE_ADDRESS_eax %-20
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %0
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_CHAR
-LOAD_BASE_ADDRESS_eax %-16
-LOAD_INTEGER
-POP_ebx # _return_result_locals
-POP_ebx # _return_result_locals
-RETURN
-# Defining function prepend_char
-:FUNCTION_prepend_char
-# Defining local ret
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax %4096
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax %1
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_calloc
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_eax #ret
-LOAD_BASE_ADDRESS_eax %-16
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %0
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_CHAR
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-16
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %1
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-PUSH_eax #_process_expression1
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_copy_string
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-LOAD_BASE_ADDRESS_eax %-16
-LOAD_INTEGER
-POP_ebx # _return_result_locals
-RETURN
-# Defining function prepend_string
-:FUNCTION_prepend_string
-# Defining local ret
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax %4096
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax %1
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_calloc
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_eax #ret
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-16
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_copy_string
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_eax #_process_expression1
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_copy_string
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-LOAD_BASE_ADDRESS_eax %-16
-LOAD_INTEGER
-POP_ebx # _return_result_locals
-RETURN
-# Defining function string_length
-:FUNCTION_string_length
-# Defining local i
-LOAD_IMMEDIATE_eax %0
-PUSH_eax #i
-:WHILE_string_length_0
-LOAD_IMMEDIATE_eax %0
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-12
-LOAD_INTEGER
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-LOAD_BYTE
-POP_ebx # _common_recursion
-CMP
-SETNE
-MOVEZBL
-TEST
-JUMP_EQ %END_WHILE_string_length_0
-# THEN_while_string_length_0
-LOAD_BASE_ADDRESS_eax %-12
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-12
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %1
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-POP_ebx # _common_recursion
-STORE_INTEGER
-JUMP %WHILE_string_length_0
-:END_WHILE_string_length_0
-LOAD_BASE_ADDRESS_eax %-12
-LOAD_INTEGER
-POP_ebx # _return_result_locals
-RETURN
-# Defining function clearWhiteSpace
-:FUNCTION_clearWhiteSpace
-# IF_clearWhiteSpace_0
-LOAD_IMMEDIATE_eax %32
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-POP_ebx # _common_recursion
-CMP
-SETE
-MOVEZBL
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %9
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-POP_ebx # _common_recursion
-CMP
-SETE
-MOVEZBL
-POP_ebx # _common_recursion
-OR_eax_ebx
-TEST
-JUMP_EQ %ELSE_clearWhiteSpace_0
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &GLOBAL_input
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_fgetc
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_clearWhiteSpace
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-RETURN
-JUMP %_END_IF_clearWhiteSpace_0
-:ELSE_clearWhiteSpace_0
-# IF_clearWhiteSpace_1
-LOAD_IMMEDIATE_eax %10
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-POP_ebx # _common_recursion
-CMP
-SETE
-MOVEZBL
-TEST
-JUMP_EQ %ELSE_clearWhiteSpace_1
-LOAD_IMMEDIATE_eax &GLOBAL_line
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_line
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %1
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-POP_ebx # _common_recursion
-STORE_INTEGER
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &GLOBAL_input
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_fgetc
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_clearWhiteSpace
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-RETURN
-JUMP %_END_IF_clearWhiteSpace_1
-:ELSE_clearWhiteSpace_1
-:_END_IF_clearWhiteSpace_1
-:_END_IF_clearWhiteSpace_0
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-RETURN
-# Defining function consume_byte
-:FUNCTION_consume_byte
-LOAD_IMMEDIATE_eax &GLOBAL_hold_string
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_string_index
-LOAD_INTEGER
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_CHAR
-LOAD_IMMEDIATE_eax &GLOBAL_string_index
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_string_index
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %1
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-POP_ebx # _common_recursion
-STORE_INTEGER
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &GLOBAL_input
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_fgetc
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-RETURN
-# Defining function consume_word
-:FUNCTION_consume_word
-# Defining local escape
-LOAD_IMMEDIATE_eax %0
-PUSH_eax #escape
-:DO_consume_word_0
-# IF_consume_word_1
-LOAD_IMMEDIATE_eax %1
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-16
-LOAD_INTEGER
-POP_ebx # _common_recursion
-XOR_ebx_eax_into_eax
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %92
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-POP_ebx # _common_recursion
-CMP
-SETE
-MOVEZBL
-POP_ebx # _common_recursion
-AND_eax_ebx
-TEST
-JUMP_EQ %ELSE_consume_word_1
-LOAD_BASE_ADDRESS_eax %-16
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %1
-POP_ebx # _common_recursion
-STORE_INTEGER
-JUMP %_END_IF_consume_word_1
-:ELSE_consume_word_1
-LOAD_BASE_ADDRESS_eax %-16
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %0
-POP_ebx # _common_recursion
-STORE_INTEGER
-:_END_IF_consume_word_1
-LOAD_BASE_ADDRESS_eax %-4
-PUSH_eax #_common_recursion
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_consume_byte
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_BASE_ADDRESS_eax %-16
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-POP_ebx # _common_recursion
-CMP
-SETNE
-MOVEZBL
-POP_ebx # _common_recursion
-OR_eax_ebx
-TEST
-JUMP_NE %DO_consume_word_0
-:DO_END_consume_word_0
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &GLOBAL_input
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_fgetc
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-POP_ebx # _return_result_locals
-RETURN
-# Defining function fixup_label
-:FUNCTION_fixup_label
-# Defining local hold
-LOAD_IMMEDIATE_eax %58
-PUSH_eax #hold
-# Defining local prev
-PUSH_eax #prev
-# Defining local i
-LOAD_IMMEDIATE_eax %0
-PUSH_eax #i
-:DO_fixup_label_0
-LOAD_BASE_ADDRESS_eax %-12
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_BASE_ADDRESS_eax %-8
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_hold_string
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-16
-LOAD_INTEGER
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-LOAD_BYTE
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_IMMEDIATE_eax &GLOBAL_hold_string
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-16
-LOAD_INTEGER
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-12
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_CHAR
-LOAD_BASE_ADDRESS_eax %-16
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-16
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %1
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_IMMEDIATE_eax %0
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-POP_ebx # _common_recursion
-CMP
-SETNE
-MOVEZBL
-TEST
-JUMP_NE %DO_fixup_label_0
-:DO_END_fixup_label_0
-POP_ebx # _recursive_statement_locals
-POP_ebx # _recursive_statement_locals
-POP_ebx # _recursive_statement_locals
-RETURN
-# Defining function in_set
-:FUNCTION_in_set
-:WHILE_in_set_0
-LOAD_IMMEDIATE_eax %0
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %0
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-LOAD_BYTE
-POP_ebx # _common_recursion
-CMP
-SETNE
-MOVEZBL
-TEST
-JUMP_EQ %END_WHILE_in_set_0
-# THEN_while_in_set_0
-# IF_in_set_1
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %0
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-LOAD_BYTE
-POP_ebx # _common_recursion
-CMP
-SETE
-MOVEZBL
-TEST
-JUMP_EQ %ELSE_in_set_1
-LOAD_IMMEDIATE_eax %1
-RETURN
-JUMP %_END_IF_in_set_1
-:ELSE_in_set_1
-:_END_IF_in_set_1
-LOAD_BASE_ADDRESS_eax %-8
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %1
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-POP_ebx # _common_recursion
-STORE_INTEGER
-JUMP %WHILE_in_set_0
-:END_WHILE_in_set_0
-LOAD_IMMEDIATE_eax %0
-RETURN
-# Defining function preserve_keyword
-:FUNCTION_preserve_keyword
-:WHILE_preserve_keyword_0
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &STRING_preserve_keyword_1
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_in_set
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-TEST
-JUMP_EQ %END_WHILE_preserve_keyword_0
-# THEN_while_preserve_keyword_0
-LOAD_BASE_ADDRESS_eax %-4
-PUSH_eax #_common_recursion
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_consume_byte
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-POP_ebx # _common_recursion
-STORE_INTEGER
-JUMP %WHILE_preserve_keyword_0
-:END_WHILE_preserve_keyword_0
-# IF_preserve_keyword_2
-LOAD_IMMEDIATE_eax %58
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-POP_ebx # _common_recursion
-CMP
-SETE
-MOVEZBL
-TEST
-JUMP_EQ %ELSE_preserve_keyword_2
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_fixup_label
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-LOAD_IMMEDIATE_eax %32
-RETURN
-JUMP %_END_IF_preserve_keyword_2
-:ELSE_preserve_keyword_2
-:_END_IF_preserve_keyword_2
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-RETURN
-# Defining function preserve_symbol
-:FUNCTION_preserve_symbol
-:WHILE_preserve_symbol_0
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &STRING_preserve_symbol_1
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_in_set
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-TEST
-JUMP_EQ %END_WHILE_preserve_symbol_0
-# THEN_while_preserve_symbol_0
-LOAD_BASE_ADDRESS_eax %-4
-PUSH_eax #_common_recursion
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_consume_byte
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-POP_ebx # _common_recursion
-STORE_INTEGER
-JUMP %WHILE_preserve_symbol_0
-:END_WHILE_preserve_symbol_0
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-RETURN
-# Defining function purge_macro
-:FUNCTION_purge_macro
-:WHILE_purge_macro_0
-LOAD_IMMEDIATE_eax %10
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-POP_ebx # _common_recursion
-CMP
-SETNE
-MOVEZBL
-TEST
-JUMP_EQ %END_WHILE_purge_macro_0
-# THEN_while_purge_macro_0
-LOAD_BASE_ADDRESS_eax %-4
-PUSH_eax #_common_recursion
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &GLOBAL_input
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_fgetc
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-POP_ebx # _common_recursion
-STORE_INTEGER
-JUMP %WHILE_purge_macro_0
-:END_WHILE_purge_macro_0
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-RETURN
-# Defining function reset_hold_string
-:FUNCTION_reset_hold_string
-# Defining local i
-LOAD_IMMEDIATE_eax &GLOBAL_string_index
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %2
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-PUSH_eax #i
-:WHILE_reset_hold_string_0
-LOAD_IMMEDIATE_eax %0
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-POP_ebx # _common_recursion
-CMP
-SETNE
-MOVEZBL
-TEST
-JUMP_EQ %END_WHILE_reset_hold_string_0
-# THEN_while_reset_hold_string_0
-LOAD_IMMEDIATE_eax &GLOBAL_hold_string
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %0
-POP_ebx # _common_recursion
-STORE_CHAR
-LOAD_BASE_ADDRESS_eax %-8
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %1
-POP_ebx # _common_recursion
-SUBTRACT_eax_from_ebx_into_ebx
-MOVE_ebx_to_eax
-POP_ebx # _common_recursion
-STORE_INTEGER
-JUMP %WHILE_reset_hold_string_0
-:END_WHILE_reset_hold_string_0
-POP_ebx # _recursive_statement_locals
-RETURN
-# Defining function get_token
-:FUNCTION_get_token
-# Defining local current
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax %1
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax %20
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_calloc
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_eax #current
-:reset #C goto label
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_reset_hold_string
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-LOAD_IMMEDIATE_eax &GLOBAL_string_index
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %0
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_BASE_ADDRESS_eax %-4
-PUSH_eax #_common_recursion
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_clearWhiteSpace
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-POP_ebx # _common_recursion
-STORE_INTEGER
-# IF_get_token_0
-LOAD_IMMEDIATE_eax %35
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-POP_ebx # _common_recursion
-CMP
-SETE
-MOVEZBL
-TEST
-JUMP_EQ %ELSE_get_token_0
-LOAD_BASE_ADDRESS_eax %-4
-PUSH_eax #_common_recursion
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_purge_macro
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-POP_ebx # _common_recursion
-STORE_INTEGER
-JUMP %reset
-JUMP %_END_IF_get_token_0
-:ELSE_get_token_0
-# IF_get_token_1
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &STRING_get_token_2
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_in_set
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-TEST
-JUMP_EQ %ELSE_get_token_1
-LOAD_BASE_ADDRESS_eax %-4
-PUSH_eax #_common_recursion
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_preserve_keyword
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-POP_ebx # _common_recursion
-STORE_INTEGER
-JUMP %_END_IF_get_token_1
-:ELSE_get_token_1
-# IF_get_token_3
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &STRING_get_token_4
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_in_set
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-TEST
-JUMP_EQ %ELSE_get_token_3
-LOAD_BASE_ADDRESS_eax %-4
-PUSH_eax #_common_recursion
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_preserve_symbol
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-POP_ebx # _common_recursion
-STORE_INTEGER
-JUMP %_END_IF_get_token_3
-:ELSE_get_token_3
-# IF_get_token_5
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %39
-POP_ebx # _common_recursion
-CMP
-SETE
-MOVEZBL
-TEST
-JUMP_EQ %ELSE_get_token_5
-LOAD_BASE_ADDRESS_eax %-4
-PUSH_eax #_common_recursion
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax %39
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_consume_word
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-POP_ebx # _common_recursion
-STORE_INTEGER
-JUMP %_END_IF_get_token_5
-:ELSE_get_token_5
-# IF_get_token_6
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %34
-POP_ebx # _common_recursion
-CMP
-SETE
-MOVEZBL
-TEST
-JUMP_EQ %ELSE_get_token_6
-LOAD_BASE_ADDRESS_eax %-4
-PUSH_eax #_common_recursion
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax %34
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_consume_word
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-POP_ebx # _common_recursion
-STORE_INTEGER
-JUMP %_END_IF_get_token_6
-:ELSE_get_token_6
-# IF_get_token_7
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %47
-POP_ebx # _common_recursion
-CMP
-SETE
-MOVEZBL
-TEST
-JUMP_EQ %ELSE_get_token_7
-LOAD_BASE_ADDRESS_eax %-4
-PUSH_eax #_common_recursion
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_consume_byte
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-POP_ebx # _common_recursion
-STORE_INTEGER
-# IF_get_token_8
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %42
-POP_ebx # _common_recursion
-CMP
-SETE
-MOVEZBL
-TEST
-JUMP_EQ %ELSE_get_token_8
-LOAD_BASE_ADDRESS_eax %-4
-PUSH_eax #_common_recursion
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &GLOBAL_input
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_fgetc
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-POP_ebx # _common_recursion
-STORE_INTEGER
-:WHILE_get_token_9
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %47
-POP_ebx # _common_recursion
-CMP
-SETNE
-MOVEZBL
-TEST
-JUMP_EQ %END_WHILE_get_token_9
-# THEN_while_get_token_9
-:WHILE_get_token_10
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %42
-POP_ebx # _common_recursion
-CMP
-SETNE
-MOVEZBL
-TEST
-JUMP_EQ %END_WHILE_get_token_10
-# THEN_while_get_token_10
-LOAD_BASE_ADDRESS_eax %-4
-PUSH_eax #_common_recursion
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &GLOBAL_input
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_fgetc
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-POP_ebx # _common_recursion
-STORE_INTEGER
-# IF_get_token_11
-LOAD_IMMEDIATE_eax %10
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-POP_ebx # _common_recursion
-CMP
-SETE
-MOVEZBL
-TEST
-JUMP_EQ %ELSE_get_token_11
-LOAD_IMMEDIATE_eax &GLOBAL_line
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_line
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %1
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-POP_ebx # _common_recursion
-STORE_INTEGER
-JUMP %_END_IF_get_token_11
-:ELSE_get_token_11
-:_END_IF_get_token_11
-JUMP %WHILE_get_token_10
-:END_WHILE_get_token_10
-LOAD_BASE_ADDRESS_eax %-4
-PUSH_eax #_common_recursion
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &GLOBAL_input
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_fgetc
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-POP_ebx # _common_recursion
-STORE_INTEGER
-# IF_get_token_12
-LOAD_IMMEDIATE_eax %10
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-POP_ebx # _common_recursion
-CMP
-SETE
-MOVEZBL
-TEST
-JUMP_EQ %ELSE_get_token_12
-LOAD_IMMEDIATE_eax &GLOBAL_line
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_line
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %1
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-POP_ebx # _common_recursion
-STORE_INTEGER
-JUMP %_END_IF_get_token_12
-:ELSE_get_token_12
-:_END_IF_get_token_12
-JUMP %WHILE_get_token_9
-:END_WHILE_get_token_9
-LOAD_BASE_ADDRESS_eax %-4
-PUSH_eax #_common_recursion
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &GLOBAL_input
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_fgetc
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-POP_ebx # _common_recursion
-STORE_INTEGER
-JUMP %reset
-JUMP %_END_IF_get_token_8
-:ELSE_get_token_8
-# IF_get_token_13
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %47
-POP_ebx # _common_recursion
-CMP
-SETE
-MOVEZBL
-TEST
-JUMP_EQ %ELSE_get_token_13
-LOAD_BASE_ADDRESS_eax %-4
-PUSH_eax #_common_recursion
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &GLOBAL_input
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_fgetc
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-POP_ebx # _common_recursion
-STORE_INTEGER
-JUMP %reset
-JUMP %_END_IF_get_token_13
-:ELSE_get_token_13
-:_END_IF_get_token_13
-:_END_IF_get_token_8
-JUMP %_END_IF_get_token_7
-:ELSE_get_token_7
-# IF_get_token_14
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %0xFFFFFFFF
-POP_ebx # _common_recursion
-CMP
-SETE
-MOVEZBL
-TEST
-JUMP_EQ %ELSE_get_token_14
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-12
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_free
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-POP_ebx # _return_result_locals
-RETURN
-JUMP %_END_IF_get_token_14
-:ELSE_get_token_14
-LOAD_BASE_ADDRESS_eax %-4
-PUSH_eax #_common_recursion
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_consume_byte
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-POP_ebx # _common_recursion
-STORE_INTEGER
-:_END_IF_get_token_14
-:_END_IF_get_token_7
-:_END_IF_get_token_6
-:_END_IF_get_token_5
-:_END_IF_get_token_3
-:_END_IF_get_token_1
-:_END_IF_get_token_0
-LOAD_BASE_ADDRESS_eax %-12
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-PUSH_eax #_common_recursion
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &GLOBAL_string_index
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %2
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax %1
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_calloc
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-POP_ebx # _common_recursion
-STORE_INTEGER
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-12
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &GLOBAL_hold_string
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_copy_string
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-LOAD_BASE_ADDRESS_eax %-12
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %4
-ADD_ebx_to_eax
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_token
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_BASE_ADDRESS_eax %-12
-LOAD_INTEGER
-# looking up offset
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_token
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_BASE_ADDRESS_eax %-12
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %16
-ADD_ebx_to_eax
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_line
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_BASE_ADDRESS_eax %-12
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %12
-ADD_ebx_to_eax
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_file
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_IMMEDIATE_eax &GLOBAL_token
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-12
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-POP_ebx # _return_result_locals
-RETURN
-# Defining function reverse_list
-:FUNCTION_reverse_list
-# Defining local root
-LOAD_IMMEDIATE_eax %0
-PUSH_eax #root
-:WHILE_reverse_list_0
-LOAD_IMMEDIATE_eax %0
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-POP_ebx # _common_recursion
-CMP
-SETNE
-MOVEZBL
-TEST
-JUMP_EQ %END_WHILE_reverse_list_0
-# THEN_while_reverse_list_0
-# Defining local next
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-# looking up offset
-LOAD_INTEGER
-PUSH_eax #next
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-# looking up offset
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-12
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_BASE_ADDRESS_eax %-12
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_BASE_ADDRESS_eax %-4
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-16
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-POP_ebx # _recursive_statement_locals
-JUMP %WHILE_reverse_list_0
-:END_WHILE_reverse_list_0
-LOAD_BASE_ADDRESS_eax %-12
-LOAD_INTEGER
-POP_ebx # _return_result_locals
-RETURN
-# Defining function read_all_tokens
-:FUNCTION_read_all_tokens
-LOAD_IMMEDIATE_eax &GLOBAL_input
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_IMMEDIATE_eax &GLOBAL_line
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %1
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_IMMEDIATE_eax &GLOBAL_file
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-12
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_IMMEDIATE_eax &GLOBAL_token
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-# Defining local ch
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &GLOBAL_input
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_fgetc
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_eax #ch
-:WHILE_read_all_tokens_0
-LOAD_IMMEDIATE_eax %0xFFFFFFFF
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-20
-LOAD_INTEGER
-POP_ebx # _common_recursion
-CMP
-SETNE
-MOVEZBL
-TEST
-JUMP_EQ %END_WHILE_read_all_tokens_0
-# THEN_while_read_all_tokens_0
-LOAD_BASE_ADDRESS_eax %-20
-PUSH_eax #_common_recursion
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-20
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_get_token
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-POP_ebx # _common_recursion
-STORE_INTEGER
-JUMP %WHILE_read_all_tokens_0
-:END_WHILE_read_all_tokens_0
-LOAD_IMMEDIATE_eax &GLOBAL_token
-LOAD_INTEGER
-POP_ebx # _return_result_locals
-RETURN
-# Defining function upcase
-:FUNCTION_upcase
-# IF_upcase_0
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &STRING_upcase_1
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_in_set
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-TEST
-JUMP_EQ %ELSE_upcase_0
-LOAD_BASE_ADDRESS_eax %-4
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %32
-POP_ebx # _common_recursion
-SUBTRACT_eax_from_ebx_into_ebx
-MOVE_ebx_to_eax
-POP_ebx # _common_recursion
-STORE_INTEGER
-JUMP %_END_IF_upcase_0
-:ELSE_upcase_0
-:_END_IF_upcase_0
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-RETURN
-# Defining function hexify
-:FUNCTION_hexify
-# Defining local i
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_char2hex
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_eax #i
-# IF_hexify_0
-LOAD_IMMEDIATE_eax %0
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-16
-LOAD_INTEGER
-POP_ebx # _common_recursion
-CMP
-SETG
-MOVEZBL
-TEST
-JUMP_EQ %ELSE_hexify_0
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_hexify_1
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax %2
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_file_print
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax %1
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_exit
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-JUMP %_END_IF_hexify_0
-:ELSE_hexify_0
-:_END_IF_hexify_0
-# IF_hexify_2
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-TEST
-JUMP_EQ %ELSE_hexify_2
-LOAD_BASE_ADDRESS_eax %-16
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-16
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %4
-POP_ebx # _common_recursion
-COPY_eax_to_ecx
-COPY_ebx_to_eax
-SAL_eax_cl
-POP_ebx # _common_recursion
-STORE_INTEGER
-JUMP %_END_IF_hexify_2
-:ELSE_hexify_2
-:_END_IF_hexify_2
-LOAD_BASE_ADDRESS_eax %-16
-LOAD_INTEGER
-POP_ebx # _return_result_locals
-RETURN
-# Defining function weird
-:FUNCTION_weird
-# Defining local c
-PUSH_eax #c
-LOAD_BASE_ADDRESS_eax %-4
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %1
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-POP_ebx # _common_recursion
-STORE_INTEGER
-:weird_reset #C goto label
-LOAD_BASE_ADDRESS_eax %-12
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %0
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-LOAD_BYTE
-POP_ebx # _common_recursion
-STORE_INTEGER
-# IF_weird_0
-LOAD_IMMEDIATE_eax %0
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-12
-LOAD_INTEGER
-POP_ebx # _common_recursion
-CMP
-SETE
-MOVEZBL
-TEST
-JUMP_EQ %ELSE_weird_0
-LOAD_IMMEDIATE_eax %0
-POP_ebx # _return_result_locals
-RETURN
-JUMP %_END_IF_weird_0
-:ELSE_weird_0
-:_END_IF_weird_0
-# IF_weird_1
-LOAD_IMMEDIATE_eax %92
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-12
-LOAD_INTEGER
-POP_ebx # _common_recursion
-CMP
-SETE
-MOVEZBL
-TEST
-JUMP_EQ %ELSE_weird_1
-LOAD_BASE_ADDRESS_eax %-12
-PUSH_eax #_common_recursion
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_escape_lookup
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-POP_ebx # _common_recursion
-STORE_INTEGER
-# IF_weird_2
-LOAD_IMMEDIATE_eax %120
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %1
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-LOAD_BYTE
-POP_ebx # _common_recursion
-CMP
-SETE
-MOVEZBL
-TEST
-JUMP_EQ %ELSE_weird_2
-LOAD_BASE_ADDRESS_eax %-4
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %2
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-POP_ebx # _common_recursion
-STORE_INTEGER
-JUMP %_END_IF_weird_2
-:ELSE_weird_2
-:_END_IF_weird_2
-LOAD_BASE_ADDRESS_eax %-4
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %1
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-POP_ebx # _common_recursion
-STORE_INTEGER
-JUMP %_END_IF_weird_1
-:ELSE_weird_1
-:_END_IF_weird_1
-# IF_weird_3
-LOAD_IMMEDIATE_eax %1
-PUSH_eax #_common_recursion
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-12
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &STRING_weird_4
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_in_set
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-POP_ebx # _common_recursion
-XOR_ebx_eax_into_eax
-TEST
-JUMP_EQ %ELSE_weird_3
-LOAD_IMMEDIATE_eax %1
-POP_ebx # _return_result_locals
-RETURN
-JUMP %_END_IF_weird_3
-:ELSE_weird_3
-:_END_IF_weird_3
-# IF_weird_5
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-12
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &STRING_weird_6
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_in_set
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %58
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %1
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-LOAD_BYTE
-POP_ebx # _common_recursion
-CMP
-SETE
-MOVEZBL
-POP_ebx # _common_recursion
-AND_eax_ebx
-TEST
-JUMP_EQ %ELSE_weird_5
-LOAD_IMMEDIATE_eax %1
-POP_ebx # _return_result_locals
-RETURN
-JUMP %_END_IF_weird_5
-:ELSE_weird_5
-:_END_IF_weird_5
-LOAD_BASE_ADDRESS_eax %-4
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %1
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-POP_ebx # _common_recursion
-STORE_INTEGER
-JUMP %weird_reset
-POP_ebx # _recursive_statement_locals
-RETURN
-# Defining function escape_lookup
-:FUNCTION_escape_lookup
-# IF_escape_lookup_0
-LOAD_IMMEDIATE_eax %92
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %0
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-LOAD_BYTE
-POP_ebx # _common_recursion
-CMP
-SETNE
-MOVEZBL
-TEST
-JUMP_EQ %ELSE_escape_lookup_0
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %0
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-LOAD_BYTE
-RETURN
-JUMP %_END_IF_escape_lookup_0
-:ELSE_escape_lookup_0
-:_END_IF_escape_lookup_0
-# IF_escape_lookup_1
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %1
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-LOAD_BYTE
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %120
-POP_ebx # _common_recursion
-CMP
-SETE
-MOVEZBL
-TEST
-JUMP_EQ %ELSE_escape_lookup_1
-# Defining local t1
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %2
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-LOAD_BYTE
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax %1
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_hexify
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_eax #t1
-# Defining local t2
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %3
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-LOAD_BYTE
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax %0
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_hexify
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_eax #t2
-LOAD_BASE_ADDRESS_eax %-12
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-16
-LOAD_INTEGER
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-POP_ebx # _return_result_locals
-POP_ebx # _return_result_locals
-RETURN
-JUMP %_END_IF_escape_lookup_1
-:ELSE_escape_lookup_1
-# IF_escape_lookup_2
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %1
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-LOAD_BYTE
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %116
-POP_ebx # _common_recursion
-CMP
-SETE
-MOVEZBL
-TEST
-JUMP_EQ %ELSE_escape_lookup_2
-LOAD_IMMEDIATE_eax %9
-RETURN
-JUMP %_END_IF_escape_lookup_2
-:ELSE_escape_lookup_2
-# IF_escape_lookup_3
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %1
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-LOAD_BYTE
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %110
-POP_ebx # _common_recursion
-CMP
-SETE
-MOVEZBL
-TEST
-JUMP_EQ %ELSE_escape_lookup_3
-LOAD_IMMEDIATE_eax %10
-RETURN
-JUMP %_END_IF_escape_lookup_3
-:ELSE_escape_lookup_3
-# IF_escape_lookup_4
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %1
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-LOAD_BYTE
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %118
-POP_ebx # _common_recursion
-CMP
-SETE
-MOVEZBL
-TEST
-JUMP_EQ %ELSE_escape_lookup_4
-LOAD_IMMEDIATE_eax %11
-RETURN
-JUMP %_END_IF_escape_lookup_4
-:ELSE_escape_lookup_4
-# IF_escape_lookup_5
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %1
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-LOAD_BYTE
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %102
-POP_ebx # _common_recursion
-CMP
-SETE
-MOVEZBL
-TEST
-JUMP_EQ %ELSE_escape_lookup_5
-LOAD_IMMEDIATE_eax %12
-RETURN
-JUMP %_END_IF_escape_lookup_5
-:ELSE_escape_lookup_5
-# IF_escape_lookup_6
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %1
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-LOAD_BYTE
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %114
-POP_ebx # _common_recursion
-CMP
-SETE
-MOVEZBL
-TEST
-JUMP_EQ %ELSE_escape_lookup_6
-LOAD_IMMEDIATE_eax %13
-RETURN
-JUMP %_END_IF_escape_lookup_6
-:ELSE_escape_lookup_6
-# IF_escape_lookup_7
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %1
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-LOAD_BYTE
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %101
-POP_ebx # _common_recursion
-CMP
-SETE
-MOVEZBL
-TEST
-JUMP_EQ %ELSE_escape_lookup_7
-LOAD_IMMEDIATE_eax %27
-RETURN
-JUMP %_END_IF_escape_lookup_7
-:ELSE_escape_lookup_7
-# IF_escape_lookup_8
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %1
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-LOAD_BYTE
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %34
-POP_ebx # _common_recursion
-CMP
-SETE
-MOVEZBL
-TEST
-JUMP_EQ %ELSE_escape_lookup_8
-LOAD_IMMEDIATE_eax %34
-RETURN
-JUMP %_END_IF_escape_lookup_8
-:ELSE_escape_lookup_8
-# IF_escape_lookup_9
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %1
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-LOAD_BYTE
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %39
-POP_ebx # _common_recursion
-CMP
-SETE
-MOVEZBL
-TEST
-JUMP_EQ %ELSE_escape_lookup_9
-LOAD_IMMEDIATE_eax %39
-RETURN
-JUMP %_END_IF_escape_lookup_9
-:ELSE_escape_lookup_9
-# IF_escape_lookup_10
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %1
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-LOAD_BYTE
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %92
-POP_ebx # _common_recursion
-CMP
-SETE
-MOVEZBL
-TEST
-JUMP_EQ %ELSE_escape_lookup_10
-LOAD_IMMEDIATE_eax %92
-RETURN
-JUMP %_END_IF_escape_lookup_10
-:ELSE_escape_lookup_10
-:_END_IF_escape_lookup_10
-:_END_IF_escape_lookup_9
-:_END_IF_escape_lookup_8
-:_END_IF_escape_lookup_7
-:_END_IF_escape_lookup_6
-:_END_IF_escape_lookup_5
-:_END_IF_escape_lookup_4
-:_END_IF_escape_lookup_3
-:_END_IF_escape_lookup_2
-:_END_IF_escape_lookup_1
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_escape_lookup_11
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax %2
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_file_print
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax %2
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_file_print
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_escape_lookup_12
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax %2
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_file_print
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax %1
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_exit
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-RETURN
-# Defining function collect_regular_string
-:FUNCTION_collect_regular_string
-LOAD_IMMEDIATE_eax &GLOBAL_string_index
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %0
-POP_ebx # _common_recursion
-STORE_INTEGER
-:collect_regular_string_reset #C goto label
-# IF_collect_regular_string_0
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %0
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-LOAD_BYTE
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %92
-POP_ebx # _common_recursion
-CMP
-SETE
-MOVEZBL
-TEST
-JUMP_EQ %ELSE_collect_regular_string_0
-LOAD_IMMEDIATE_eax &GLOBAL_hold_string
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_string_index
-LOAD_INTEGER
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-PUSH_eax #_common_recursion
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_escape_lookup
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-POP_ebx # _common_recursion
-STORE_CHAR
-# IF_collect_regular_string_1
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %1
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-LOAD_BYTE
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %120
-POP_ebx # _common_recursion
-CMP
-SETE
-MOVEZBL
-TEST
-JUMP_EQ %ELSE_collect_regular_string_1
-LOAD_BASE_ADDRESS_eax %-4
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %2
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-POP_ebx # _common_recursion
-STORE_INTEGER
-JUMP %_END_IF_collect_regular_string_1
-:ELSE_collect_regular_string_1
-:_END_IF_collect_regular_string_1
-LOAD_BASE_ADDRESS_eax %-4
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %2
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-POP_ebx # _common_recursion
-STORE_INTEGER
-JUMP %_END_IF_collect_regular_string_0
-:ELSE_collect_regular_string_0
-LOAD_IMMEDIATE_eax &GLOBAL_hold_string
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_string_index
-LOAD_INTEGER
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %0
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-LOAD_BYTE
-POP_ebx # _common_recursion
-STORE_CHAR
-LOAD_BASE_ADDRESS_eax %-4
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %1
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-POP_ebx # _common_recursion
-STORE_INTEGER
-:_END_IF_collect_regular_string_0
-LOAD_IMMEDIATE_eax &GLOBAL_string_index
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_string_index
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %1
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-POP_ebx # _common_recursion
-STORE_INTEGER
-# IF_collect_regular_string_2
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %0
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-LOAD_BYTE
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %0
-POP_ebx # _common_recursion
-CMP
-SETNE
-MOVEZBL
-TEST
-JUMP_EQ %ELSE_collect_regular_string_2
-JUMP %collect_regular_string_reset
-JUMP %_END_IF_collect_regular_string_2
-:ELSE_collect_regular_string_2
-:_END_IF_collect_regular_string_2
-LOAD_IMMEDIATE_eax &GLOBAL_hold_string
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_string_index
-LOAD_INTEGER
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %34
-POP_ebx # _common_recursion
-STORE_CHAR
-LOAD_IMMEDIATE_eax &GLOBAL_hold_string
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_string_index
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %1
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %10
-POP_ebx # _common_recursion
-STORE_CHAR
-# Defining local message
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &GLOBAL_string_index
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %3
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax %1
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_calloc
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_eax #message
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-12
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &GLOBAL_hold_string
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_copy_string
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_reset_hold_string
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-LOAD_BASE_ADDRESS_eax %-12
-LOAD_INTEGER
-POP_ebx # _return_result_locals
-RETURN
-# Defining function collect_weird_string
-:FUNCTION_collect_weird_string
-LOAD_IMMEDIATE_eax &GLOBAL_string_index
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %1
-POP_ebx # _common_recursion
-STORE_INTEGER
-# Defining local temp
-PUSH_eax #temp
-# Defining local table
-LOAD_IMMEDIATE_eax &STRING_collect_weird_string_0
-PUSH_eax #table
-LOAD_IMMEDIATE_eax &GLOBAL_hold_string
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %0
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %39
-POP_ebx # _common_recursion
-STORE_CHAR
-:collect_weird_string_reset #C goto label
-LOAD_BASE_ADDRESS_eax %-4
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %1
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_IMMEDIATE_eax &GLOBAL_hold_string
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_string_index
-LOAD_INTEGER
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %32
-POP_ebx # _common_recursion
-STORE_CHAR
-LOAD_BASE_ADDRESS_eax %-12
-PUSH_eax #_common_recursion
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_escape_lookup
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_IMMEDIATE_eax &GLOBAL_hold_string
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_string_index
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %1
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-16
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-12
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %4
-POP_ebx # _common_recursion
-COPY_eax_to_ecx
-COPY_ebx_to_eax
-SAR_eax_cl
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-LOAD_BYTE
-POP_ebx # _common_recursion
-STORE_CHAR
-LOAD_IMMEDIATE_eax &GLOBAL_hold_string
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_string_index
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %2
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-16
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-12
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %15
-POP_ebx # _common_recursion
-AND_eax_ebx
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-LOAD_BYTE
-POP_ebx # _common_recursion
-STORE_CHAR
-# IF_collect_weird_string_1
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %0
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-LOAD_BYTE
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %92
-POP_ebx # _common_recursion
-CMP
-SETE
-MOVEZBL
-TEST
-JUMP_EQ %ELSE_collect_weird_string_1
-# IF_collect_weird_string_2
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %1
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-LOAD_BYTE
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %120
-POP_ebx # _common_recursion
-CMP
-SETE
-MOVEZBL
-TEST
-JUMP_EQ %ELSE_collect_weird_string_2
-LOAD_BASE_ADDRESS_eax %-4
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %2
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-POP_ebx # _common_recursion
-STORE_INTEGER
-JUMP %_END_IF_collect_weird_string_2
-:ELSE_collect_weird_string_2
-:_END_IF_collect_weird_string_2
-LOAD_BASE_ADDRESS_eax %-4
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %1
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-POP_ebx # _common_recursion
-STORE_INTEGER
-JUMP %_END_IF_collect_weird_string_1
-:ELSE_collect_weird_string_1
-:_END_IF_collect_weird_string_1
-LOAD_IMMEDIATE_eax &GLOBAL_string_index
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_string_index
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %3
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-POP_ebx # _common_recursion
-STORE_INTEGER
-# IF_collect_weird_string_3
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %1
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-LOAD_BYTE
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %0
-POP_ebx # _common_recursion
-CMP
-SETNE
-MOVEZBL
-TEST
-JUMP_EQ %ELSE_collect_weird_string_3
-JUMP %collect_weird_string_reset
-JUMP %_END_IF_collect_weird_string_3
-:ELSE_collect_weird_string_3
-:_END_IF_collect_weird_string_3
-LOAD_IMMEDIATE_eax &GLOBAL_hold_string
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_string_index
-LOAD_INTEGER
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %32
-POP_ebx # _common_recursion
-STORE_CHAR
-LOAD_IMMEDIATE_eax &GLOBAL_hold_string
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_string_index
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %1
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %48
-POP_ebx # _common_recursion
-STORE_CHAR
-LOAD_IMMEDIATE_eax &GLOBAL_hold_string
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_string_index
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %2
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %48
-POP_ebx # _common_recursion
-STORE_CHAR
-LOAD_IMMEDIATE_eax &GLOBAL_hold_string
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_string_index
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %3
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %39
-POP_ebx # _common_recursion
-STORE_CHAR
-LOAD_IMMEDIATE_eax &GLOBAL_hold_string
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_string_index
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %4
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %10
-POP_ebx # _common_recursion
-STORE_CHAR
-# Defining local hold
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &GLOBAL_string_index
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %6
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax %1
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_calloc
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_eax #hold
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-20
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &GLOBAL_hold_string
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_copy_string
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_reset_hold_string
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-LOAD_BASE_ADDRESS_eax %-20
-LOAD_INTEGER
-POP_ebx # _return_result_locals
-POP_ebx # _return_result_locals
-POP_ebx # _return_result_locals
-RETURN
-# Defining function parse_string
-:FUNCTION_parse_string
-# IF_parse_string_0
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_weird
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-TEST
-JUMP_EQ %ELSE_parse_string_0
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_collect_weird_string
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-RETURN
-JUMP %_END_IF_parse_string_0
-:ELSE_parse_string_0
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_collect_regular_string
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-RETURN
-:_END_IF_parse_string_0
-RETURN
-# Defining function initialize_types
-:FUNCTION_initialize_types
-LOAD_IMMEDIATE_eax &GLOBAL_global_types
-PUSH_eax #_common_recursion
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax %1
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax %28
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_calloc
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_IMMEDIATE_eax &GLOBAL_global_types
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %24
-ADD_ebx_to_eax
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &STRING_initialize_types_0
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_IMMEDIATE_eax &GLOBAL_global_types
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %4
-ADD_ebx_to_eax
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %4
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_IMMEDIATE_eax &GLOBAL_global_types
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %20
-ADD_ebx_to_eax
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_global_types
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_IMMEDIATE_eax &GLOBAL_global_types
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %12
-ADD_ebx_to_eax
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_global_types
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-# Defining local a
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax %1
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax %28
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_calloc
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_eax #a
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %24
-ADD_ebx_to_eax
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &STRING_initialize_types_1
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %4
-ADD_ebx_to_eax
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %4
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %12
-ADD_ebx_to_eax
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %20
-ADD_ebx_to_eax
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-# Defining local b
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax %1
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax %28
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_calloc
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_eax #b
-LOAD_BASE_ADDRESS_eax %-12
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %24
-ADD_ebx_to_eax
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &STRING_initialize_types_2
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_BASE_ADDRESS_eax %-12
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %4
-ADD_ebx_to_eax
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %4
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_BASE_ADDRESS_eax %-12
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %20
-ADD_ebx_to_eax
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-12
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-# Defining local c
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax %1
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax %28
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_calloc
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_eax #c
-LOAD_BASE_ADDRESS_eax %-16
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %24
-ADD_ebx_to_eax
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &STRING_initialize_types_3
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_BASE_ADDRESS_eax %-16
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %4
-ADD_ebx_to_eax
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %1
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_BASE_ADDRESS_eax %-16
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %20
-ADD_ebx_to_eax
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-16
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-# Defining local d
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax %1
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax %28
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_calloc
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_eax #d
-LOAD_BASE_ADDRESS_eax %-20
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %24
-ADD_ebx_to_eax
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &STRING_initialize_types_4
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_BASE_ADDRESS_eax %-20
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %4
-ADD_ebx_to_eax
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %4
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_BASE_ADDRESS_eax %-20
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %20
-ADD_ebx_to_eax
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-12
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_BASE_ADDRESS_eax %-20
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %12
-ADD_ebx_to_eax
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-20
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_BASE_ADDRESS_eax %-16
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %12
-ADD_ebx_to_eax
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-12
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_BASE_ADDRESS_eax %-12
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %12
-ADD_ebx_to_eax
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-20
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-# Defining local e
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax %1
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax %28
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_calloc
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_eax #e
-LOAD_BASE_ADDRESS_eax %-24
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %24
-ADD_ebx_to_eax
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &STRING_initialize_types_5
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_BASE_ADDRESS_eax %-24
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %4
-ADD_ebx_to_eax
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %4
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_BASE_ADDRESS_eax %-24
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %20
-ADD_ebx_to_eax
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-24
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_BASE_ADDRESS_eax %-24
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %12
-ADD_ebx_to_eax
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-24
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-# Defining local f
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax %1
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax %28
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_calloc
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_eax #f
-LOAD_BASE_ADDRESS_eax %-28
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %24
-ADD_ebx_to_eax
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &STRING_initialize_types_6
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_BASE_ADDRESS_eax %-28
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %4
-ADD_ebx_to_eax
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %4
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_BASE_ADDRESS_eax %-28
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %20
-ADD_ebx_to_eax
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-28
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_BASE_ADDRESS_eax %-28
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %12
-ADD_ebx_to_eax
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-28
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-# Defining local g
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax %1
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax %28
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_calloc
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_eax #g
-LOAD_BASE_ADDRESS_eax %-32
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %24
-ADD_ebx_to_eax
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &STRING_initialize_types_7
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_BASE_ADDRESS_eax %-32
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %4
-ADD_ebx_to_eax
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %4
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_BASE_ADDRESS_eax %-32
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %20
-ADD_ebx_to_eax
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-32
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_BASE_ADDRESS_eax %-32
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %12
-ADD_ebx_to_eax
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-32
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_BASE_ADDRESS_eax %-28
-LOAD_INTEGER
-# looking up offset
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-32
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_BASE_ADDRESS_eax %-24
-LOAD_INTEGER
-# looking up offset
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-28
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_BASE_ADDRESS_eax %-20
-LOAD_INTEGER
-# looking up offset
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-24
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_BASE_ADDRESS_eax %-16
-LOAD_INTEGER
-# looking up offset
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-24
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-# looking up offset
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-16
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_IMMEDIATE_eax &GLOBAL_global_types
-LOAD_INTEGER
-# looking up offset
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_IMMEDIATE_eax &GLOBAL_prim_types
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_global_types
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-POP_ebx # _recursive_statement_locals
-POP_ebx # _recursive_statement_locals
-POP_ebx # _recursive_statement_locals
-POP_ebx # _recursive_statement_locals
-POP_ebx # _recursive_statement_locals
-POP_ebx # _recursive_statement_locals
-POP_ebx # _recursive_statement_locals
-RETURN
-# Defining function lookup_type
-:FUNCTION_lookup_type
-# Defining local i
-PUSH_eax #i
-# FOR_initialization_lookup_type_0
-LOAD_BASE_ADDRESS_eax %-16
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-:FOR_lookup_type_0
-LOAD_IMMEDIATE_eax %0
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-16
-LOAD_INTEGER
-POP_ebx # _common_recursion
-CMP
-SETNE
-MOVEZBL
-TEST
-JUMP_EQ %FOR_END_lookup_type_0
-JUMP %FOR_THEN_lookup_type_0
-:FOR_ITER_lookup_type_0
-LOAD_BASE_ADDRESS_eax %-16
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-16
-LOAD_INTEGER
-# looking up offset
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-JUMP %FOR_lookup_type_0
-:FOR_THEN_lookup_type_0
-# IF_lookup_type_1
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-16
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %24
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_match
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-TEST
-JUMP_EQ %ELSE_lookup_type_1
-LOAD_BASE_ADDRESS_eax %-16
-LOAD_INTEGER
-POP_ebx # _return_result_locals
-RETURN
-JUMP %_END_IF_lookup_type_1
-:ELSE_lookup_type_1
-:_END_IF_lookup_type_1
-JUMP %FOR_ITER_lookup_type_0
-:FOR_END_lookup_type_0
-LOAD_IMMEDIATE_eax %0
-POP_ebx # _return_result_locals
-RETURN
-# Defining function lookup_member
-:FUNCTION_lookup_member
-# Defining local i
-PUSH_eax #i
-# FOR_initialization_lookup_member_0
-LOAD_BASE_ADDRESS_eax %-16
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %16
-ADD_ebx_to_eax
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-:FOR_lookup_member_0
-LOAD_IMMEDIATE_eax %0
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-16
-LOAD_INTEGER
-POP_ebx # _common_recursion
-CMP
-SETNE
-MOVEZBL
-TEST
-JUMP_EQ %FOR_END_lookup_member_0
-JUMP %FOR_THEN_lookup_member_0
-:FOR_ITER_lookup_member_0
-LOAD_BASE_ADDRESS_eax %-16
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-16
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %16
-ADD_ebx_to_eax
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-JUMP %FOR_lookup_member_0
-:FOR_THEN_lookup_member_0
-# IF_lookup_member_1
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-16
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %24
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_match
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-TEST
-JUMP_EQ %ELSE_lookup_member_1
-LOAD_BASE_ADDRESS_eax %-16
-LOAD_INTEGER
-POP_ebx # _return_result_locals
-RETURN
-JUMP %_END_IF_lookup_member_1
-:ELSE_lookup_member_1
-:_END_IF_lookup_member_1
-JUMP %FOR_ITER_lookup_member_0
-:FOR_END_lookup_member_0
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_lookup_member_2
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax %2
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_file_print
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %24
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax %2
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_file_print
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_lookup_member_3
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax %2
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_file_print
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax %2
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_file_print
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_lookup_member_4
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax %2
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_file_print
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_line_error
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_lookup_member_5
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax %2
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_file_print
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax %1
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_exit
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-POP_ebx # _recursive_statement_locals
-RETURN
-# Defining function build_member
-:FUNCTION_build_member
-# Defining local member_type
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_type_name
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_eax #member_type
-# Defining local i
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax %1
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax %28
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_calloc
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_eax #i
-LOAD_BASE_ADDRESS_eax %-20
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %24
-ADD_ebx_to_eax
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_BASE_ADDRESS_eax %-20
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %16
-ADD_ebx_to_eax
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-# IF_build_member_0
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_build_member_1
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_match
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-TEST
-JUMP_EQ %ELSE_build_member_0
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_BASE_ADDRESS_eax %-20
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %4
-ADD_ebx_to_eax
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-16
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %20
-ADD_ebx_to_eax
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %4
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_numerate_string
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-POP_ebx # _common_recursion
-MULTIPLY_eax_by_ebx_into_eax
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_build_member_2
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &STRING_build_member_3
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_require_match
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-JUMP %_END_IF_build_member_0
-:ELSE_build_member_0
-LOAD_BASE_ADDRESS_eax %-20
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %4
-ADD_ebx_to_eax
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-16
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %4
-ADD_ebx_to_eax
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-:_END_IF_build_member_0
-LOAD_IMMEDIATE_eax &GLOBAL_member_size
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-20
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %4
-ADD_ebx_to_eax
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_BASE_ADDRESS_eax %-20
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %20
-ADD_ebx_to_eax
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-16
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_BASE_ADDRESS_eax %-20
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_BASE_ADDRESS_eax %-20
-LOAD_INTEGER
-POP_ebx # _return_result_locals
-POP_ebx # _return_result_locals
-RETURN
-# Defining function build_union
-:FUNCTION_build_union
-# Defining local size
-LOAD_IMMEDIATE_eax %0
-PUSH_eax #size
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_build_union_0
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &STRING_build_union_1
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_require_match
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-:WHILE_build_union_2
-LOAD_IMMEDIATE_eax %125
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %0
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-LOAD_BYTE
-POP_ebx # _common_recursion
-CMP
-SETNE
-MOVEZBL
-TEST
-JUMP_EQ %END_WHILE_build_union_2
-# THEN_while_build_union_2
-LOAD_BASE_ADDRESS_eax %-4
-PUSH_eax #_common_recursion
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_build_member
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-POP_ebx # _common_recursion
-STORE_INTEGER
-# IF_build_union_3
-LOAD_IMMEDIATE_eax &GLOBAL_member_size
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-16
-LOAD_INTEGER
-POP_ebx # _common_recursion
-CMP
-SETG
-MOVEZBL
-TEST
-JUMP_EQ %ELSE_build_union_3
-LOAD_BASE_ADDRESS_eax %-16
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_member_size
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-JUMP %_END_IF_build_union_3
-:ELSE_build_union_3
-:_END_IF_build_union_3
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_build_union_4
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &STRING_build_union_5
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_require_match
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-JUMP %WHILE_build_union_2
-:END_WHILE_build_union_2
-LOAD_IMMEDIATE_eax &GLOBAL_member_size
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-16
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-POP_ebx # _return_result_locals
-RETURN
-# Defining function create_struct
-:FUNCTION_create_struct
-# Defining local offset
-LOAD_IMMEDIATE_eax %0
-PUSH_eax #offset
-LOAD_IMMEDIATE_eax &GLOBAL_member_size
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %0
-POP_ebx # _common_recursion
-STORE_INTEGER
-# Defining local head
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax %1
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax %28
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_calloc
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_eax #head
-# Defining local i
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax %1
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax %28
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_calloc
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_eax #i
-LOAD_BASE_ADDRESS_eax %-12
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %24
-ADD_ebx_to_eax
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_BASE_ADDRESS_eax %-16
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %24
-ADD_ebx_to_eax
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_BASE_ADDRESS_eax %-12
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %12
-ADD_ebx_to_eax
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-16
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_BASE_ADDRESS_eax %-16
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %12
-ADD_ebx_to_eax
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-12
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_BASE_ADDRESS_eax %-12
-LOAD_INTEGER
-# looking up offset
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_global_types
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_IMMEDIATE_eax &GLOBAL_global_types
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-12
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_BASE_ADDRESS_eax %-16
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %4
-ADD_ebx_to_eax
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %4
-POP_ebx # _common_recursion
-STORE_INTEGER
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_create_struct_0
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &STRING_create_struct_1
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_require_match
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-# Defining local last
-LOAD_IMMEDIATE_eax %0
-PUSH_eax #last
-:WHILE_create_struct_2
-LOAD_IMMEDIATE_eax %125
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %0
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-LOAD_BYTE
-POP_ebx # _common_recursion
-CMP
-SETNE
-MOVEZBL
-TEST
-JUMP_EQ %END_WHILE_create_struct_2
-# THEN_while_create_struct_2
-# IF_create_struct_3
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &STRING_create_struct_4
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_match
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-TEST
-JUMP_EQ %ELSE_create_struct_3
-LOAD_BASE_ADDRESS_eax %-20
-PUSH_eax #_common_recursion
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-20
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_build_union
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-POP_ebx # _common_recursion
-STORE_INTEGER
-JUMP %_END_IF_create_struct_3
-:ELSE_create_struct_3
-LOAD_BASE_ADDRESS_eax %-20
-PUSH_eax #_common_recursion
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-20
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_build_member
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-POP_ebx # _common_recursion
-STORE_INTEGER
-:_END_IF_create_struct_3
-LOAD_BASE_ADDRESS_eax %-8
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_member_size
-LOAD_INTEGER
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-POP_ebx # _common_recursion
-STORE_INTEGER
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_create_struct_5
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &STRING_create_struct_6
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_require_match
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-JUMP %WHILE_create_struct_2
-:END_WHILE_create_struct_2
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_create_struct_7
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &STRING_create_struct_8
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_require_match
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-LOAD_BASE_ADDRESS_eax %-12
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %4
-ADD_ebx_to_eax
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_BASE_ADDRESS_eax %-12
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %16
-ADD_ebx_to_eax
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-20
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_BASE_ADDRESS_eax %-16
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %16
-ADD_ebx_to_eax
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-20
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-POP_ebx # _recursive_statement_locals
-POP_ebx # _recursive_statement_locals
-POP_ebx # _recursive_statement_locals
-POP_ebx # _recursive_statement_locals
-RETURN
-# Defining function type_name
-:FUNCTION_type_name
-# Defining local structure
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_type_name_0
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_match
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_eax #structure
-# IF_type_name_1
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-TEST
-JUMP_EQ %ELSE_type_name_1
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-JUMP %_END_IF_type_name_1
-:ELSE_type_name_1
-:_END_IF_type_name_1
-# Defining local ret
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &GLOBAL_global_types
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_lookup_type
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_eax #ret
-# IF_type_name_2
-LOAD_IMMEDIATE_eax %0
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-12
-LOAD_INTEGER
-POP_ebx # _common_recursion
-CMP
-SETE
-MOVEZBL
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %1
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-POP_ebx # _common_recursion
-XOR_ebx_eax_into_eax
-POP_ebx # _common_recursion
-AND_eax_ebx
-TEST
-JUMP_EQ %ELSE_type_name_2
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_type_name_3
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax %2
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_file_print
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax %2
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_file_print
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_type_name_4
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax %2
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_file_print
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_line_error
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax %1
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_exit
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-JUMP %_END_IF_type_name_2
-:ELSE_type_name_2
-# IF_type_name_5
-LOAD_IMMEDIATE_eax %0
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-12
-LOAD_INTEGER
-POP_ebx # _common_recursion
-CMP
-SETE
-MOVEZBL
-TEST
-JUMP_EQ %ELSE_type_name_5
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_create_struct
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-LOAD_IMMEDIATE_eax %0
-POP_ebx # _return_result_locals
-POP_ebx # _return_result_locals
-RETURN
-JUMP %_END_IF_type_name_5
-:ELSE_type_name_5
-:_END_IF_type_name_5
-:_END_IF_type_name_2
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-:WHILE_type_name_6
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %0
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-LOAD_BYTE
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %42
-POP_ebx # _common_recursion
-CMP
-SETE
-MOVEZBL
-TEST
-JUMP_EQ %END_WHILE_type_name_6
-# THEN_while_type_name_6
-LOAD_BASE_ADDRESS_eax %-12
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-12
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %12
-ADD_ebx_to_eax
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-JUMP %WHILE_type_name_6
-:END_WHILE_type_name_6
-LOAD_BASE_ADDRESS_eax %-12
-LOAD_INTEGER
-POP_ebx # _return_result_locals
-POP_ebx # _return_result_locals
-RETURN
-# Defining function emit
-:FUNCTION_emit
-# Defining local t
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax %1
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax %20
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_calloc
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_eax #t
-LOAD_BASE_ADDRESS_eax %-16
-LOAD_INTEGER
-# looking up offset
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_BASE_ADDRESS_eax %-16
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_BASE_ADDRESS_eax %-16
-LOAD_INTEGER
-POP_ebx # _return_result_locals
-RETURN
-# Defining function emit_out
-:FUNCTION_emit_out
-LOAD_IMMEDIATE_eax &GLOBAL_out
-PUSH_eax #_common_recursion
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &GLOBAL_out
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-POP_ebx # _common_recursion
-STORE_INTEGER
-RETURN
-# Defining function uniqueID
-:FUNCTION_uniqueID
-LOAD_BASE_ADDRESS_eax %-8
-PUSH_eax #_common_recursion
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_BASE_ADDRESS_eax %-8
-PUSH_eax #_common_recursion
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_uniqueID_0
-PUSH_eax #_process_expression1
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_BASE_ADDRESS_eax %-8
-PUSH_eax #_common_recursion
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-12
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_BASE_ADDRESS_eax %-8
-PUSH_eax #_common_recursion
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_uniqueID_1
-PUSH_eax #_process_expression1
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-RETURN
-# Defining function uniqueID_out
-:FUNCTION_uniqueID_out
-LOAD_IMMEDIATE_eax &GLOBAL_out
-PUSH_eax #_common_recursion
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &GLOBAL_out
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_uniqueID
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-POP_ebx # _common_recursion
-STORE_INTEGER
-RETURN
-# Defining function sym_declare
-:FUNCTION_sym_declare
-# Defining local a
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax %1
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax %20
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_calloc
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_eax #a
-LOAD_BASE_ADDRESS_eax %-20
-LOAD_INTEGER
-# looking up offset
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-12
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_BASE_ADDRESS_eax %-20
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_BASE_ADDRESS_eax %-20
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %12
-ADD_ebx_to_eax
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_BASE_ADDRESS_eax %-20
-LOAD_INTEGER
-POP_ebx # _return_result_locals
-RETURN
-# Defining function sym_lookup
-:FUNCTION_sym_lookup
-# Defining local i
-PUSH_eax #i
-# FOR_initialization_sym_lookup_0
-LOAD_BASE_ADDRESS_eax %-16
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-:FOR_sym_lookup_0
-LOAD_IMMEDIATE_eax %0
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-16
-LOAD_INTEGER
-POP_ebx # _common_recursion
-CMP
-SETNE
-MOVEZBL
-TEST
-JUMP_EQ %FOR_END_sym_lookup_0
-JUMP %FOR_THEN_sym_lookup_0
-:FOR_ITER_sym_lookup_0
-LOAD_BASE_ADDRESS_eax %-16
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-16
-LOAD_INTEGER
-# looking up offset
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-JUMP %FOR_sym_lookup_0
-:FOR_THEN_sym_lookup_0
-# IF_sym_lookup_1
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-16
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_match
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-TEST
-JUMP_EQ %ELSE_sym_lookup_1
-LOAD_BASE_ADDRESS_eax %-16
-LOAD_INTEGER
-POP_ebx # _return_result_locals
-RETURN
-JUMP %_END_IF_sym_lookup_1
-:ELSE_sym_lookup_1
-:_END_IF_sym_lookup_1
-JUMP %FOR_ITER_sym_lookup_0
-:FOR_END_sym_lookup_0
-LOAD_IMMEDIATE_eax %0
-POP_ebx # _return_result_locals
-RETURN
-# Defining function line_error
-:FUNCTION_line_error
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %12
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax %2
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_file_print
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_line_error_0
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax %2
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_file_print
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %16
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_numerate_number
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax %2
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_file_print
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_line_error_1
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax %2
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_file_print
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-RETURN
-# Defining function require_match
-:FUNCTION_require_match
-# IF_require_match_0
-LOAD_IMMEDIATE_eax %1
-PUSH_eax #_common_recursion
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_match
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-POP_ebx # _common_recursion
-XOR_ebx_eax_into_eax
-TEST
-JUMP_EQ %ELSE_require_match_0
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_line_error
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax %2
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_file_print
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax %1
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_exit
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-JUMP %_END_IF_require_match_0
-:ELSE_require_match_0
-:_END_IF_require_match_0
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-RETURN
-# Defining function function_call
-:FUNCTION_function_call
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_function_call_0
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &STRING_function_call_1
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_require_match
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-# Defining local passed
-LOAD_IMMEDIATE_eax %0
-PUSH_eax #passed
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_function_call_2
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_function_call_3
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_function_call_4
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-# IF_function_call_5
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %0
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-LOAD_BYTE
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %41
-POP_ebx # _common_recursion
-CMP
-SETNE
-MOVEZBL
-TEST
-JUMP_EQ %ELSE_function_call_5
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_expression
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_function_call_6
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-LOAD_BASE_ADDRESS_eax %-16
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %1
-POP_ebx # _common_recursion
-STORE_INTEGER
-:WHILE_function_call_7
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %0
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-LOAD_BYTE
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %44
-POP_ebx # _common_recursion
-CMP
-SETE
-MOVEZBL
-TEST
-JUMP_EQ %END_WHILE_function_call_7
-# THEN_while_function_call_7
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_expression
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_function_call_8
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-LOAD_BASE_ADDRESS_eax %-16
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-16
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %1
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-POP_ebx # _common_recursion
-STORE_INTEGER
-JUMP %WHILE_function_call_7
-:END_WHILE_function_call_7
-JUMP %_END_IF_function_call_5
-:ELSE_function_call_5
-:_END_IF_function_call_5
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_function_call_9
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &STRING_function_call_10
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_require_match
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-# IF_function_call_11
-LOAD_IMMEDIATE_eax %1
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-POP_ebx # _common_recursion
-CMP
-SETE
-MOVEZBL
-TEST
-JUMP_EQ %ELSE_function_call_11
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_function_call_12
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_function_call_13
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_function_call_14
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_function_call_15
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-JUMP %_END_IF_function_call_11
-:ELSE_function_call_11
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_function_call_16
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_function_call_17
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_function_call_18
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-:_END_IF_function_call_11
-# FOR_initialization_function_call_19
-:FOR_function_call_19
-LOAD_BASE_ADDRESS_eax %-16
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %0
-POP_ebx # _common_recursion
-CMP
-SETG
-MOVEZBL
-TEST
-JUMP_EQ %FOR_END_function_call_19
-JUMP %FOR_THEN_function_call_19
-:FOR_ITER_function_call_19
-LOAD_BASE_ADDRESS_eax %-16
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-16
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %1
-POP_ebx # _common_recursion
-SUBTRACT_eax_from_ebx_into_ebx
-MOVE_ebx_to_eax
-POP_ebx # _common_recursion
-STORE_INTEGER
-JUMP %FOR_function_call_19
-:FOR_THEN_function_call_19
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_function_call_20
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-JUMP %FOR_ITER_function_call_19
-:FOR_END_function_call_19
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_function_call_21
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_function_call_22
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-POP_ebx # _recursive_statement_locals
-RETURN
-# Defining function constant_load
-:FUNCTION_constant_load
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_constant_load_0
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %16
-ADD_ebx_to_eax
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_constant_load_1
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-RETURN
-# Defining function variable_load
-:FUNCTION_variable_load
-# IF_variable_load_0
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_variable_load_1
-PUSH_eax #_process_expression1
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %12
-ADD_ebx_to_eax
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %24
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_match
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_eax #_common_recursion
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_variable_load_2
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_match
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-POP_ebx # _common_recursion
-AND_eax_ebx
-TEST
-JUMP_EQ %ELSE_variable_load_0
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %16
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_numerate_number
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax %1
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_function_call
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-RETURN
-JUMP %_END_IF_variable_load_0
-:ELSE_variable_load_0
-:_END_IF_variable_load_0
-LOAD_IMMEDIATE_eax &GLOBAL_current_target
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %12
-ADD_ebx_to_eax
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_variable_load_3
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %16
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_numerate_number
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_variable_load_4
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-# IF_variable_load_5
-LOAD_IMMEDIATE_eax %1
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_Address_of
-LOAD_INTEGER
-POP_ebx # _common_recursion
-CMP
-SETE
-MOVEZBL
-TEST
-JUMP_EQ %ELSE_variable_load_5
-RETURN
-JUMP %_END_IF_variable_load_5
-:ELSE_variable_load_5
-:_END_IF_variable_load_5
-# IF_variable_load_6
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_variable_load_7
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_match
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-TEST
-JUMP_EQ %ELSE_variable_load_6
-RETURN
-JUMP %_END_IF_variable_load_6
-:ELSE_variable_load_6
-:_END_IF_variable_load_6
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_variable_load_8
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-RETURN
-# Defining function function_load
-:FUNCTION_function_load
-# IF_function_load_0
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_function_load_1
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_match
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-TEST
-JUMP_EQ %ELSE_function_load_0
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax %0
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_function_call
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-RETURN
-JUMP %_END_IF_function_load_0
-:ELSE_function_load_0
-:_END_IF_function_load_0
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_function_load_2
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_function_load_3
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-RETURN
-# Defining function global_load
-:FUNCTION_global_load
-LOAD_IMMEDIATE_eax &GLOBAL_current_target
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %12
-ADD_ebx_to_eax
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_global_load_0
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_global_load_1
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-# IF_global_load_2
-LOAD_IMMEDIATE_eax %1
-PUSH_eax #_common_recursion
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_global_load_3
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_match
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-POP_ebx # _common_recursion
-XOR_ebx_eax_into_eax
-TEST
-JUMP_EQ %ELSE_global_load_2
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_global_load_4
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-JUMP %_END_IF_global_load_2
-:ELSE_global_load_2
-:_END_IF_global_load_2
-RETURN
-# Defining function primary_expr_failure
-:FUNCTION_primary_expr_failure
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_line_error
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_primary_expr_failure_0
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax %2
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_file_print
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax %2
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_file_print
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_primary_expr_failure_1
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax %2
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_file_print
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax %1
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_exit
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-RETURN
-# Defining function primary_expr_string
-:FUNCTION_primary_expr_string
-# Defining local number_string
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &GLOBAL_current_count
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_numerate_number
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_eax #number_string
-LOAD_IMMEDIATE_eax &GLOBAL_current_count
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_current_count
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %1
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-POP_ebx # _common_recursion
-STORE_INTEGER
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_primary_expr_string_0
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &GLOBAL_function
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_uniqueID_out
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-LOAD_IMMEDIATE_eax &GLOBAL_strings_list
-PUSH_eax #_common_recursion
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_primary_expr_string_1
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &GLOBAL_strings_list
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_IMMEDIATE_eax &GLOBAL_strings_list
-PUSH_eax #_common_recursion
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &GLOBAL_function
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &GLOBAL_strings_list
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_uniqueID
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_IMMEDIATE_eax &GLOBAL_strings_list
-PUSH_eax #_common_recursion
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_parse_string
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &GLOBAL_strings_list
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-POP_ebx # _recursive_statement_locals
-RETURN
-# Defining function primary_expr_char
-:FUNCTION_primary_expr_char
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_primary_expr_char_0
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %1
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_escape_lookup
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_numerate_number
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_primary_expr_char_1
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-RETURN
-# Defining function primary_expr_number
-:FUNCTION_primary_expr_number
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_primary_expr_number_0
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_primary_expr_number_1
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-RETURN
-# Defining function primary_expr_variable
-:FUNCTION_primary_expr_variable
-# Defining local s
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #s
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-# Defining local a
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &GLOBAL_global_constant_list
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_sym_lookup
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_eax #a
-# IF_primary_expr_variable_0
-LOAD_IMMEDIATE_eax %0
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-12
-LOAD_INTEGER
-POP_ebx # _common_recursion
-CMP
-SETNE
-MOVEZBL
-TEST
-JUMP_EQ %ELSE_primary_expr_variable_0
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-12
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_constant_load
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-POP_ebx # _return_result_locals
-POP_ebx # _return_result_locals
-RETURN
-JUMP %_END_IF_primary_expr_variable_0
-:ELSE_primary_expr_variable_0
-:_END_IF_primary_expr_variable_0
-LOAD_BASE_ADDRESS_eax %-12
-PUSH_eax #_common_recursion
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &GLOBAL_function
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %4
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_sym_lookup
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-POP_ebx # _common_recursion
-STORE_INTEGER
-# IF_primary_expr_variable_1
-LOAD_IMMEDIATE_eax %0
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-12
-LOAD_INTEGER
-POP_ebx # _common_recursion
-CMP
-SETNE
-MOVEZBL
-TEST
-JUMP_EQ %ELSE_primary_expr_variable_1
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-12
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_variable_load
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-POP_ebx # _return_result_locals
-POP_ebx # _return_result_locals
-RETURN
-JUMP %_END_IF_primary_expr_variable_1
-:ELSE_primary_expr_variable_1
-:_END_IF_primary_expr_variable_1
-LOAD_BASE_ADDRESS_eax %-12
-PUSH_eax #_common_recursion
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &GLOBAL_function
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %16
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_sym_lookup
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-POP_ebx # _common_recursion
-STORE_INTEGER
-# IF_primary_expr_variable_2
-LOAD_IMMEDIATE_eax %0
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-12
-LOAD_INTEGER
-POP_ebx # _common_recursion
-CMP
-SETNE
-MOVEZBL
-TEST
-JUMP_EQ %ELSE_primary_expr_variable_2
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-12
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_variable_load
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-POP_ebx # _return_result_locals
-POP_ebx # _return_result_locals
-RETURN
-JUMP %_END_IF_primary_expr_variable_2
-:ELSE_primary_expr_variable_2
-:_END_IF_primary_expr_variable_2
-LOAD_BASE_ADDRESS_eax %-12
-PUSH_eax #_common_recursion
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &GLOBAL_global_function_list
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_sym_lookup
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-POP_ebx # _common_recursion
-STORE_INTEGER
-# IF_primary_expr_variable_3
-LOAD_IMMEDIATE_eax %0
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-12
-LOAD_INTEGER
-POP_ebx # _common_recursion
-CMP
-SETNE
-MOVEZBL
-TEST
-JUMP_EQ %ELSE_primary_expr_variable_3
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-12
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_function_load
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-POP_ebx # _return_result_locals
-POP_ebx # _return_result_locals
-RETURN
-JUMP %_END_IF_primary_expr_variable_3
-:ELSE_primary_expr_variable_3
-:_END_IF_primary_expr_variable_3
-LOAD_BASE_ADDRESS_eax %-12
-PUSH_eax #_common_recursion
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &GLOBAL_global_symbol_list
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_sym_lookup
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-POP_ebx # _common_recursion
-STORE_INTEGER
-# IF_primary_expr_variable_4
-LOAD_IMMEDIATE_eax %0
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-12
-LOAD_INTEGER
-POP_ebx # _common_recursion
-CMP
-SETNE
-MOVEZBL
-TEST
-JUMP_EQ %ELSE_primary_expr_variable_4
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-12
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_global_load
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-POP_ebx # _return_result_locals
-POP_ebx # _return_result_locals
-RETURN
-JUMP %_END_IF_primary_expr_variable_4
-:ELSE_primary_expr_variable_4
-:_END_IF_primary_expr_variable_4
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_line_error
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax %2
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_file_print
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_primary_expr_variable_5
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax %2
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_file_print
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax %1
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_exit
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-POP_ebx # _recursive_statement_locals
-POP_ebx # _recursive_statement_locals
-RETURN
-# Defining function promote_type
-:FUNCTION_promote_type
-# IF_promote_type_0
-LOAD_IMMEDIATE_eax %0
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-POP_ebx # _common_recursion
-CMP
-SETE
-MOVEZBL
-TEST
-JUMP_EQ %ELSE_promote_type_0
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-RETURN
-JUMP %_END_IF_promote_type_0
-:ELSE_promote_type_0
-:_END_IF_promote_type_0
-# IF_promote_type_1
-LOAD_IMMEDIATE_eax %0
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-POP_ebx # _common_recursion
-CMP
-SETE
-MOVEZBL
-TEST
-JUMP_EQ %ELSE_promote_type_1
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-RETURN
-JUMP %_END_IF_promote_type_1
-:ELSE_promote_type_1
-:_END_IF_promote_type_1
-# Defining local i
-PUSH_eax #i
-# FOR_initialization_promote_type_2
-LOAD_BASE_ADDRESS_eax %-16
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_global_types
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-:FOR_promote_type_2
-LOAD_IMMEDIATE_eax %0
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-16
-LOAD_INTEGER
-POP_ebx # _common_recursion
-CMP
-SETNE
-MOVEZBL
-TEST
-JUMP_EQ %FOR_END_promote_type_2
-JUMP %FOR_THEN_promote_type_2
-:FOR_ITER_promote_type_2
-LOAD_BASE_ADDRESS_eax %-16
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-16
-LOAD_INTEGER
-# looking up offset
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-JUMP %FOR_promote_type_2
-:FOR_THEN_promote_type_2
-# IF_promote_type_3
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %24
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-16
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %24
-ADD_ebx_to_eax
-LOAD_INTEGER
-POP_ebx # _common_recursion
-CMP
-SETE
-MOVEZBL
-TEST
-JUMP_EQ %ELSE_promote_type_3
-JUMP %FOR_END_promote_type_2
-JUMP %_END_IF_promote_type_3
-:ELSE_promote_type_3
-:_END_IF_promote_type_3
-# IF_promote_type_4
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %24
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-16
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %24
-ADD_ebx_to_eax
-LOAD_INTEGER
-POP_ebx # _common_recursion
-CMP
-SETE
-MOVEZBL
-TEST
-JUMP_EQ %ELSE_promote_type_4
-JUMP %FOR_END_promote_type_2
-JUMP %_END_IF_promote_type_4
-:ELSE_promote_type_4
-:_END_IF_promote_type_4
-# IF_promote_type_5
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %24
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-16
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %12
-ADD_ebx_to_eax
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %24
-ADD_ebx_to_eax
-LOAD_INTEGER
-POP_ebx # _common_recursion
-CMP
-SETE
-MOVEZBL
-TEST
-JUMP_EQ %ELSE_promote_type_5
-JUMP %FOR_END_promote_type_2
-JUMP %_END_IF_promote_type_5
-:ELSE_promote_type_5
-:_END_IF_promote_type_5
-# IF_promote_type_6
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %24
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-16
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %12
-ADD_ebx_to_eax
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %24
-ADD_ebx_to_eax
-LOAD_INTEGER
-POP_ebx # _common_recursion
-CMP
-SETE
-MOVEZBL
-TEST
-JUMP_EQ %ELSE_promote_type_6
-JUMP %FOR_END_promote_type_2
-JUMP %_END_IF_promote_type_6
-:ELSE_promote_type_6
-:_END_IF_promote_type_6
-JUMP %FOR_ITER_promote_type_2
-:FOR_END_promote_type_2
-LOAD_BASE_ADDRESS_eax %-16
-LOAD_INTEGER
-POP_ebx # _return_result_locals
-RETURN
-# Defining function common_recursion
-:FUNCTION_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_last_type
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_current_target
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_common_recursion_0
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-COPY_edi_to_ebp
-CALL_eax
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-LOAD_IMMEDIATE_eax &GLOBAL_current_target
-PUSH_eax #_common_recursion
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &GLOBAL_current_target
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &GLOBAL_last_type
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_promote_type
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-POP_ebx # _common_recursion
-STORE_INTEGER
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_common_recursion_1
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-RETURN
-# Defining function general_recursion
-:FUNCTION_general_recursion
-# IF_general_recursion_0
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-12
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_match
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-TEST
-JUMP_EQ %ELSE_general_recursion_0
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_common_recursion
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-16
-LOAD_INTEGER
-COPY_edi_to_ebp
-CALL_eax
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-JUMP %_END_IF_general_recursion_0
-:ELSE_general_recursion_0
-:_END_IF_general_recursion_0
-RETURN
-# Defining function ceil_log2
-:FUNCTION_ceil_log2
-# Defining local result
-LOAD_IMMEDIATE_eax %0
-PUSH_eax #result
-# IF_ceil_log2_0
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %1
-POP_ebx # _common_recursion
-SUBTRACT_eax_from_ebx_into_ebx
-MOVE_ebx_to_eax
-POP_ebx # _common_recursion
-AND_eax_ebx
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %0
-POP_ebx # _common_recursion
-CMP
-SETE
-MOVEZBL
-TEST
-JUMP_EQ %ELSE_ceil_log2_0
-LOAD_BASE_ADDRESS_eax %-12
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %0
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %1
-POP_ebx # _common_recursion
-SUBTRACT_eax_from_ebx_into_ebx
-MOVE_ebx_to_eax
-POP_ebx # _common_recursion
-STORE_INTEGER
-JUMP %_END_IF_ceil_log2_0
-:ELSE_ceil_log2_0
-:_END_IF_ceil_log2_0
-:WHILE_ceil_log2_1
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %0
-POP_ebx # _common_recursion
-CMP
-SETG
-MOVEZBL
-TEST
-JUMP_EQ %END_WHILE_ceil_log2_1
-# THEN_while_ceil_log2_1
-LOAD_BASE_ADDRESS_eax %-12
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-12
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %1
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_BASE_ADDRESS_eax %-4
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %1
-POP_ebx # _common_recursion
-COPY_eax_to_ecx
-COPY_ebx_to_eax
-SAR_eax_cl
-POP_ebx # _common_recursion
-STORE_INTEGER
-JUMP %WHILE_ceil_log2_1
-:END_WHILE_ceil_log2_1
-LOAD_BASE_ADDRESS_eax %-12
-LOAD_INTEGER
-POP_ebx # _return_result_locals
-RETURN
-# Defining function postfix_expr_arrow
-:FUNCTION_postfix_expr_arrow
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_postfix_expr_arrow_0
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-# Defining local i
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &GLOBAL_current_target
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_lookup_member
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_eax #i
-LOAD_IMMEDIATE_eax &GLOBAL_current_target
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %20
-ADD_ebx_to_eax
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-# IF_postfix_expr_arrow_1
-LOAD_IMMEDIATE_eax %0
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-POP_ebx # _common_recursion
-CMP
-SETNE
-MOVEZBL
-TEST
-JUMP_EQ %ELSE_postfix_expr_arrow_1
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_postfix_expr_arrow_2
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_postfix_expr_arrow_3
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_numerate_number
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_postfix_expr_arrow_4
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-JUMP %_END_IF_postfix_expr_arrow_1
-:ELSE_postfix_expr_arrow_1
-:_END_IF_postfix_expr_arrow_1
-# IF_postfix_expr_arrow_5
-LOAD_IMMEDIATE_eax %1
-PUSH_eax #_common_recursion
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_postfix_expr_arrow_6
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_match
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-POP_ebx # _common_recursion
-XOR_ebx_eax_into_eax
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %4
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %4
-ADD_ebx_to_eax
-LOAD_INTEGER
-POP_ebx # _common_recursion
-CMP
-SETGE
-MOVEZBL
-POP_ebx # _common_recursion
-AND_eax_ebx
-TEST
-JUMP_EQ %ELSE_postfix_expr_arrow_5
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_postfix_expr_arrow_7
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-JUMP %_END_IF_postfix_expr_arrow_5
-:ELSE_postfix_expr_arrow_5
-:_END_IF_postfix_expr_arrow_5
-POP_ebx # _recursive_statement_locals
-RETURN
-# Defining function postfix_expr_array
-:FUNCTION_postfix_expr_array
-# Defining local array
-LOAD_IMMEDIATE_eax &GLOBAL_current_target
-LOAD_INTEGER
-PUSH_eax #array
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &FUNCTION_expression
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_common_recursion
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-LOAD_IMMEDIATE_eax &GLOBAL_current_target
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-# Defining local assign
-LOAD_IMMEDIATE_eax &STRING_postfix_expr_array_0
-PUSH_eax #assign
-# IF_postfix_expr_array_1
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_postfix_expr_array_2
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &GLOBAL_current_target
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %24
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_match
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-TEST
-JUMP_EQ %ELSE_postfix_expr_array_1
-LOAD_BASE_ADDRESS_eax %-12
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &STRING_postfix_expr_array_3
-POP_ebx # _common_recursion
-STORE_INTEGER
-JUMP %_END_IF_postfix_expr_array_1
-:ELSE_postfix_expr_array_1
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_postfix_expr_array_4
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &GLOBAL_current_target
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %12
-ADD_ebx_to_eax
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %4
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_ceil_log2
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_numerate_number
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_postfix_expr_array_5
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-:_END_IF_postfix_expr_array_1
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_postfix_expr_array_6
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_postfix_expr_array_7
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &STRING_postfix_expr_array_8
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_require_match
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-# IF_postfix_expr_array_9
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_postfix_expr_array_10
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_match
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-TEST
-JUMP_EQ %ELSE_postfix_expr_array_9
-LOAD_BASE_ADDRESS_eax %-12
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &STRING_postfix_expr_array_11
-POP_ebx # _common_recursion
-STORE_INTEGER
-JUMP %_END_IF_postfix_expr_array_9
-:ELSE_postfix_expr_array_9
-:_END_IF_postfix_expr_array_9
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-12
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-POP_ebx # _recursive_statement_locals
-POP_ebx # _recursive_statement_locals
-RETURN
-# Defining function unary_expr_sizeof
-:FUNCTION_unary_expr_sizeof
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_unary_expr_sizeof_0
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &STRING_unary_expr_sizeof_1
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_require_match
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-# Defining local a
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_type_name
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_eax #a
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_unary_expr_sizeof_2
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &STRING_unary_expr_sizeof_3
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_require_match
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_unary_expr_sizeof_4
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %4
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_numerate_number
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_unary_expr_sizeof_5
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-POP_ebx # _recursive_statement_locals
-RETURN
-# Defining function postfix_expr_stub
-:FUNCTION_postfix_expr_stub
-# IF_postfix_expr_stub_0
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_postfix_expr_stub_1
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_match
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-TEST
-JUMP_EQ %ELSE_postfix_expr_stub_0
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_postfix_expr_array
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_postfix_expr_stub
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-JUMP %_END_IF_postfix_expr_stub_0
-:ELSE_postfix_expr_stub_0
-:_END_IF_postfix_expr_stub_0
-# IF_postfix_expr_stub_2
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_postfix_expr_stub_3
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_match
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-TEST
-JUMP_EQ %ELSE_postfix_expr_stub_2
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_postfix_expr_arrow
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_postfix_expr_stub
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-JUMP %_END_IF_postfix_expr_stub_2
-:ELSE_postfix_expr_stub_2
-:_END_IF_postfix_expr_stub_2
-RETURN
-# Defining function postfix_expr
-:FUNCTION_postfix_expr
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_primary_expr
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_postfix_expr_stub
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-RETURN
-# Defining function additive_expr_stub
-:FUNCTION_additive_expr_stub
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &FUNCTION_postfix_expr
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &STRING_additive_expr_stub_0
-PUSH_eax #_process_expression2
-LOAD_IMMEDIATE_eax &STRING_additive_expr_stub_1
-PUSH_eax #_process_expression2
-LOAD_IMMEDIATE_eax &FUNCTION_additive_expr_stub
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_general_recursion
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &FUNCTION_postfix_expr
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &STRING_additive_expr_stub_2
-PUSH_eax #_process_expression2
-LOAD_IMMEDIATE_eax &STRING_additive_expr_stub_3
-PUSH_eax #_process_expression2
-LOAD_IMMEDIATE_eax &FUNCTION_additive_expr_stub
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_general_recursion
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &FUNCTION_postfix_expr
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &STRING_additive_expr_stub_4
-PUSH_eax #_process_expression2
-LOAD_IMMEDIATE_eax &STRING_additive_expr_stub_5
-PUSH_eax #_process_expression2
-LOAD_IMMEDIATE_eax &FUNCTION_additive_expr_stub
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_general_recursion
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &FUNCTION_postfix_expr
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &STRING_additive_expr_stub_6
-PUSH_eax #_process_expression2
-LOAD_IMMEDIATE_eax &STRING_additive_expr_stub_7
-PUSH_eax #_process_expression2
-LOAD_IMMEDIATE_eax &FUNCTION_additive_expr_stub
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_general_recursion
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &FUNCTION_postfix_expr
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &STRING_additive_expr_stub_8
-PUSH_eax #_process_expression2
-LOAD_IMMEDIATE_eax &STRING_additive_expr_stub_9
-PUSH_eax #_process_expression2
-LOAD_IMMEDIATE_eax &FUNCTION_additive_expr_stub
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_general_recursion
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &FUNCTION_postfix_expr
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &STRING_additive_expr_stub_10
-PUSH_eax #_process_expression2
-LOAD_IMMEDIATE_eax &STRING_additive_expr_stub_11
-PUSH_eax #_process_expression2
-LOAD_IMMEDIATE_eax &FUNCTION_additive_expr_stub
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_general_recursion
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &FUNCTION_postfix_expr
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &STRING_additive_expr_stub_12
-PUSH_eax #_process_expression2
-LOAD_IMMEDIATE_eax &STRING_additive_expr_stub_13
-PUSH_eax #_process_expression2
-LOAD_IMMEDIATE_eax &FUNCTION_additive_expr_stub
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_general_recursion
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-RETURN
-# Defining function additive_expr
-:FUNCTION_additive_expr
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_postfix_expr
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_additive_expr_stub
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-RETURN
-# Defining function relational_expr_stub
-:FUNCTION_relational_expr_stub
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &FUNCTION_additive_expr
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &STRING_relational_expr_stub_0
-PUSH_eax #_process_expression2
-LOAD_IMMEDIATE_eax &STRING_relational_expr_stub_1
-PUSH_eax #_process_expression2
-LOAD_IMMEDIATE_eax &FUNCTION_relational_expr_stub
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_general_recursion
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &FUNCTION_additive_expr
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &STRING_relational_expr_stub_2
-PUSH_eax #_process_expression2
-LOAD_IMMEDIATE_eax &STRING_relational_expr_stub_3
-PUSH_eax #_process_expression2
-LOAD_IMMEDIATE_eax &FUNCTION_relational_expr_stub
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_general_recursion
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &FUNCTION_additive_expr
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &STRING_relational_expr_stub_4
-PUSH_eax #_process_expression2
-LOAD_IMMEDIATE_eax &STRING_relational_expr_stub_5
-PUSH_eax #_process_expression2
-LOAD_IMMEDIATE_eax &FUNCTION_relational_expr_stub
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_general_recursion
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &FUNCTION_additive_expr
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &STRING_relational_expr_stub_6
-PUSH_eax #_process_expression2
-LOAD_IMMEDIATE_eax &STRING_relational_expr_stub_7
-PUSH_eax #_process_expression2
-LOAD_IMMEDIATE_eax &FUNCTION_relational_expr_stub
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_general_recursion
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &FUNCTION_additive_expr
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &STRING_relational_expr_stub_8
-PUSH_eax #_process_expression2
-LOAD_IMMEDIATE_eax &STRING_relational_expr_stub_9
-PUSH_eax #_process_expression2
-LOAD_IMMEDIATE_eax &FUNCTION_relational_expr_stub
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_general_recursion
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &FUNCTION_additive_expr
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &STRING_relational_expr_stub_10
-PUSH_eax #_process_expression2
-LOAD_IMMEDIATE_eax &STRING_relational_expr_stub_11
-PUSH_eax #_process_expression2
-LOAD_IMMEDIATE_eax &FUNCTION_relational_expr_stub
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_general_recursion
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-RETURN
-# Defining function relational_expr
-:FUNCTION_relational_expr
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_additive_expr
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_relational_expr_stub
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-RETURN
-# Defining function bitwise_expr_stub
-:FUNCTION_bitwise_expr_stub
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &FUNCTION_relational_expr
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &STRING_bitwise_expr_stub_0
-PUSH_eax #_process_expression2
-LOAD_IMMEDIATE_eax &STRING_bitwise_expr_stub_1
-PUSH_eax #_process_expression2
-LOAD_IMMEDIATE_eax &FUNCTION_bitwise_expr_stub
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_general_recursion
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &FUNCTION_relational_expr
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &STRING_bitwise_expr_stub_2
-PUSH_eax #_process_expression2
-LOAD_IMMEDIATE_eax &STRING_bitwise_expr_stub_3
-PUSH_eax #_process_expression2
-LOAD_IMMEDIATE_eax &FUNCTION_bitwise_expr_stub
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_general_recursion
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &FUNCTION_relational_expr
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &STRING_bitwise_expr_stub_4
-PUSH_eax #_process_expression2
-LOAD_IMMEDIATE_eax &STRING_bitwise_expr_stub_5
-PUSH_eax #_process_expression2
-LOAD_IMMEDIATE_eax &FUNCTION_bitwise_expr_stub
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_general_recursion
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &FUNCTION_relational_expr
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &STRING_bitwise_expr_stub_6
-PUSH_eax #_process_expression2
-LOAD_IMMEDIATE_eax &STRING_bitwise_expr_stub_7
-PUSH_eax #_process_expression2
-LOAD_IMMEDIATE_eax &FUNCTION_bitwise_expr_stub
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_general_recursion
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &FUNCTION_relational_expr
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &STRING_bitwise_expr_stub_8
-PUSH_eax #_process_expression2
-LOAD_IMMEDIATE_eax &STRING_bitwise_expr_stub_9
-PUSH_eax #_process_expression2
-LOAD_IMMEDIATE_eax &FUNCTION_bitwise_expr_stub
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_general_recursion
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-RETURN
-# Defining function bitwise_expr
-:FUNCTION_bitwise_expr
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_relational_expr
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_bitwise_expr_stub
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-RETURN
-# Defining function primary_expr
-:FUNCTION_primary_expr
-# IF_primary_expr_0
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_primary_expr_1
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_match
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-TEST
-JUMP_EQ %ELSE_primary_expr_0
-LOAD_IMMEDIATE_eax &GLOBAL_Address_of
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %1
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-JUMP %_END_IF_primary_expr_0
-:ELSE_primary_expr_0
-LOAD_IMMEDIATE_eax &GLOBAL_Address_of
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %0
-POP_ebx # _common_recursion
-STORE_INTEGER
-:_END_IF_primary_expr_0
-# IF_primary_expr_2
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_primary_expr_3
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_match
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-TEST
-JUMP_EQ %ELSE_primary_expr_2
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_unary_expr_sizeof
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-JUMP %_END_IF_primary_expr_2
-:ELSE_primary_expr_2
-# IF_primary_expr_4
-LOAD_IMMEDIATE_eax %45
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %0
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-LOAD_BYTE
-POP_ebx # _common_recursion
-CMP
-SETE
-MOVEZBL
-TEST
-JUMP_EQ %ELSE_primary_expr_4
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_primary_expr_5
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &FUNCTION_primary_expr
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_common_recursion
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_primary_expr_6
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-JUMP %_END_IF_primary_expr_4
-:ELSE_primary_expr_4
-# IF_primary_expr_7
-LOAD_IMMEDIATE_eax %33
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %0
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-LOAD_BYTE
-POP_ebx # _common_recursion
-CMP
-SETE
-MOVEZBL
-TEST
-JUMP_EQ %ELSE_primary_expr_7
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_primary_expr_8
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &FUNCTION_postfix_expr
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_common_recursion
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_primary_expr_9
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-JUMP %_END_IF_primary_expr_7
-:ELSE_primary_expr_7
-# IF_primary_expr_10
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %0
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-LOAD_BYTE
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %40
-POP_ebx # _common_recursion
-CMP
-SETE
-MOVEZBL
-TEST
-JUMP_EQ %ELSE_primary_expr_10
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_expression
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_primary_expr_11
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &STRING_primary_expr_12
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_require_match
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-JUMP %_END_IF_primary_expr_10
-:ELSE_primary_expr_10
-# IF_primary_expr_13
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %0
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-LOAD_BYTE
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %39
-POP_ebx # _common_recursion
-CMP
-SETE
-MOVEZBL
-TEST
-JUMP_EQ %ELSE_primary_expr_13
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_primary_expr_char
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-JUMP %_END_IF_primary_expr_13
-:ELSE_primary_expr_13
-# IF_primary_expr_14
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %0
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-LOAD_BYTE
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %34
-POP_ebx # _common_recursion
-CMP
-SETE
-MOVEZBL
-TEST
-JUMP_EQ %ELSE_primary_expr_14
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_primary_expr_string
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-JUMP %_END_IF_primary_expr_14
-:ELSE_primary_expr_14
-# IF_primary_expr_15
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %0
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-LOAD_BYTE
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &STRING_primary_expr_16
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_in_set
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-TEST
-JUMP_EQ %ELSE_primary_expr_15
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_primary_expr_variable
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-JUMP %_END_IF_primary_expr_15
-:ELSE_primary_expr_15
-# IF_primary_expr_17
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %0
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-LOAD_BYTE
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &STRING_primary_expr_18
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_in_set
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-TEST
-JUMP_EQ %ELSE_primary_expr_17
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_primary_expr_number
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-JUMP %_END_IF_primary_expr_17
-:ELSE_primary_expr_17
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_primary_expr_failure
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-:_END_IF_primary_expr_17
-:_END_IF_primary_expr_15
-:_END_IF_primary_expr_14
-:_END_IF_primary_expr_13
-:_END_IF_primary_expr_10
-:_END_IF_primary_expr_7
-:_END_IF_primary_expr_4
-:_END_IF_primary_expr_2
-RETURN
-# Defining function expression
-:FUNCTION_expression
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_bitwise_expr
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-# IF_expression_0
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_expression_1
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_match
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-TEST
-JUMP_EQ %ELSE_expression_0
-# Defining local store
-PUSH_eax #store
-# IF_expression_2
-LOAD_IMMEDIATE_eax %1
-PUSH_eax #_common_recursion
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_expression_3
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %4
-ADD_ebx_to_eax
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_match
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-POP_ebx # _common_recursion
-XOR_ebx_eax_into_eax
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %1
-PUSH_eax #_common_recursion
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_expression_4
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &GLOBAL_current_target
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %24
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_match
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-POP_ebx # _common_recursion
-XOR_ebx_eax_into_eax
-POP_ebx # _common_recursion
-OR_eax_ebx
-TEST
-JUMP_EQ %ELSE_expression_2
-LOAD_BASE_ADDRESS_eax %-8
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &STRING_expression_5
-POP_ebx # _common_recursion
-STORE_INTEGER
-JUMP %_END_IF_expression_2
-:ELSE_expression_2
-LOAD_BASE_ADDRESS_eax %-8
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &STRING_expression_6
-POP_ebx # _common_recursion
-STORE_INTEGER
-:_END_IF_expression_2
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &FUNCTION_expression
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_common_recursion
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-LOAD_IMMEDIATE_eax &GLOBAL_current_target
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %0
-POP_ebx # _common_recursion
-STORE_INTEGER
-POP_ebx # _recursive_statement_locals
-JUMP %_END_IF_expression_0
-:ELSE_expression_0
-:_END_IF_expression_0
-RETURN
-# Defining function collect_local
-:FUNCTION_collect_local
-# Defining local type_size
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_type_name
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_eax #type_size
-# Defining local a
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-LOAD_IMMEDIATE_eax &GLOBAL_function
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %4
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_sym_declare
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_eax #a
-# IF_collect_local_0
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_collect_local_1
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &GLOBAL_function
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_match
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %0
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_function
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %4
-ADD_ebx_to_eax
-LOAD_INTEGER
-POP_ebx # _common_recursion
-CMP
-SETE
-MOVEZBL
-POP_ebx # _common_recursion
-AND_eax_ebx
-TEST
-JUMP_EQ %ELSE_collect_local_0
-LOAD_BASE_ADDRESS_eax %-12
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %16
-ADD_ebx_to_eax
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %0
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %20
-POP_ebx # _common_recursion
-SUBTRACT_eax_from_ebx_into_ebx
-MOVE_ebx_to_eax
-POP_ebx # _common_recursion
-STORE_INTEGER
-JUMP %_END_IF_collect_local_0
-:ELSE_collect_local_0
-# IF_collect_local_2
-LOAD_IMMEDIATE_eax %0
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_function
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %16
-ADD_ebx_to_eax
-LOAD_INTEGER
-POP_ebx # _common_recursion
-CMP
-SETE
-MOVEZBL
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %0
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_function
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %4
-ADD_ebx_to_eax
-LOAD_INTEGER
-POP_ebx # _common_recursion
-CMP
-SETE
-MOVEZBL
-POP_ebx # _common_recursion
-AND_eax_ebx
-TEST
-JUMP_EQ %ELSE_collect_local_2
-LOAD_BASE_ADDRESS_eax %-12
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %16
-ADD_ebx_to_eax
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %0
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %8
-POP_ebx # _common_recursion
-SUBTRACT_eax_from_ebx_into_ebx
-MOVE_ebx_to_eax
-POP_ebx # _common_recursion
-STORE_INTEGER
-JUMP %_END_IF_collect_local_2
-:ELSE_collect_local_2
-# IF_collect_local_3
-LOAD_IMMEDIATE_eax %0
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_function
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %4
-ADD_ebx_to_eax
-LOAD_INTEGER
-POP_ebx # _common_recursion
-CMP
-SETE
-MOVEZBL
-TEST
-JUMP_EQ %ELSE_collect_local_3
-LOAD_BASE_ADDRESS_eax %-12
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %16
-ADD_ebx_to_eax
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_function
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %16
-ADD_ebx_to_eax
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %16
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %8
-POP_ebx # _common_recursion
-SUBTRACT_eax_from_ebx_into_ebx
-MOVE_ebx_to_eax
-POP_ebx # _common_recursion
-STORE_INTEGER
-JUMP %_END_IF_collect_local_3
-:ELSE_collect_local_3
-LOAD_BASE_ADDRESS_eax %-12
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %16
-ADD_ebx_to_eax
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_function
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %4
-ADD_ebx_to_eax
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %16
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %4
-POP_ebx # _common_recursion
-SUBTRACT_eax_from_ebx_into_ebx
-MOVE_ebx_to_eax
-POP_ebx # _common_recursion
-STORE_INTEGER
-:_END_IF_collect_local_3
-:_END_IF_collect_local_2
-:_END_IF_collect_local_0
-LOAD_IMMEDIATE_eax &GLOBAL_function
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %4
-ADD_ebx_to_eax
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-12
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_collect_local_4
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_collect_local_5
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-# IF_collect_local_6
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_collect_local_7
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_match
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-TEST
-JUMP_EQ %ELSE_collect_local_6
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_expression
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-JUMP %_END_IF_collect_local_6
-:ELSE_collect_local_6
-:_END_IF_collect_local_6
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_collect_local_8
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &STRING_collect_local_9
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_require_match
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_collect_local_10
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-12
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_collect_local_11
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-POP_ebx # _recursive_statement_locals
-POP_ebx # _recursive_statement_locals
-RETURN
-# Defining function process_if
-:FUNCTION_process_if
-# Defining local number_string
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &GLOBAL_current_count
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_numerate_number
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_eax #number_string
-LOAD_IMMEDIATE_eax &GLOBAL_current_count
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_current_count
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %1
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-POP_ebx # _common_recursion
-STORE_INTEGER
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_process_if_0
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &GLOBAL_function
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_uniqueID_out
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_process_if_1
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &STRING_process_if_2
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_require_match
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_expression
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_process_if_3
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &GLOBAL_function
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_uniqueID_out
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_process_if_4
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &STRING_process_if_5
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_require_match
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_statement
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_process_if_6
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &GLOBAL_function
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_uniqueID_out
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_process_if_7
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &GLOBAL_function
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_uniqueID_out
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-# IF_process_if_8
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_process_if_9
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_match
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-TEST
-JUMP_EQ %ELSE_process_if_8
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_statement
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-JUMP %_END_IF_process_if_8
-:ELSE_process_if_8
-:_END_IF_process_if_8
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_process_if_10
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &GLOBAL_function
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_uniqueID_out
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-POP_ebx # _recursive_statement_locals
-RETURN
-# Defining function process_for
-:FUNCTION_process_for
-# Defining local nested_locals
-LOAD_IMMEDIATE_eax &GLOBAL_break_frame
-LOAD_INTEGER
-PUSH_eax #nested_locals
-# Defining local nested_break_head
-LOAD_IMMEDIATE_eax &GLOBAL_break_target_head
-LOAD_INTEGER
-PUSH_eax #nested_break_head
-# Defining local nested_break_func
-LOAD_IMMEDIATE_eax &GLOBAL_break_target_func
-LOAD_INTEGER
-PUSH_eax #nested_break_func
-# Defining local nested_break_num
-LOAD_IMMEDIATE_eax &GLOBAL_break_target_num
-LOAD_INTEGER
-PUSH_eax #nested_break_num
-# Defining local number_string
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &GLOBAL_current_count
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_numerate_number
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_eax #number_string
-LOAD_IMMEDIATE_eax &GLOBAL_current_count
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_current_count
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %1
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_IMMEDIATE_eax &GLOBAL_break_target_head
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &STRING_process_for_0
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_IMMEDIATE_eax &GLOBAL_break_target_num
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-24
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_IMMEDIATE_eax &GLOBAL_break_frame
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_function
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %4
-ADD_ebx_to_eax
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_IMMEDIATE_eax &GLOBAL_break_target_func
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_function
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_process_for_1
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &GLOBAL_function
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-LOAD_BASE_ADDRESS_eax %-24
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_uniqueID_out
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_process_for_2
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &STRING_process_for_3
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_require_match
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-# IF_process_for_4
-LOAD_IMMEDIATE_eax %1
-PUSH_eax #_common_recursion
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_process_for_5
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_match
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-POP_ebx # _common_recursion
-XOR_ebx_eax_into_eax
-TEST
-JUMP_EQ %ELSE_process_for_4
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_expression
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-JUMP %_END_IF_process_for_4
-:ELSE_process_for_4
-:_END_IF_process_for_4
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_process_for_6
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &GLOBAL_function
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-LOAD_BASE_ADDRESS_eax %-24
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_uniqueID_out
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_process_for_7
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &STRING_process_for_8
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_require_match
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_expression
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_process_for_9
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &GLOBAL_function
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-LOAD_BASE_ADDRESS_eax %-24
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_uniqueID_out
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_process_for_10
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &GLOBAL_function
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-LOAD_BASE_ADDRESS_eax %-24
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_uniqueID_out
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_process_for_11
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &GLOBAL_function
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-LOAD_BASE_ADDRESS_eax %-24
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_uniqueID_out
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_process_for_12
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &STRING_process_for_13
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_require_match
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_expression
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_process_for_14
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &GLOBAL_function
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-LOAD_BASE_ADDRESS_eax %-24
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_uniqueID_out
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_process_for_15
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &GLOBAL_function
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-LOAD_BASE_ADDRESS_eax %-24
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_uniqueID_out
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_process_for_16
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &STRING_process_for_17
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_require_match
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_statement
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_process_for_18
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &GLOBAL_function
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-LOAD_BASE_ADDRESS_eax %-24
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_uniqueID_out
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_process_for_19
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &GLOBAL_function
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-LOAD_BASE_ADDRESS_eax %-24
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_uniqueID_out
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-LOAD_IMMEDIATE_eax &GLOBAL_break_target_head
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-12
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_IMMEDIATE_eax &GLOBAL_break_target_func
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-16
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_IMMEDIATE_eax &GLOBAL_break_target_num
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-20
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_IMMEDIATE_eax &GLOBAL_break_frame
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-POP_ebx # _recursive_statement_locals
-POP_ebx # _recursive_statement_locals
-POP_ebx # _recursive_statement_locals
-POP_ebx # _recursive_statement_locals
-POP_ebx # _recursive_statement_locals
-RETURN
-# Defining function process_asm
-:FUNCTION_process_asm
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_process_asm_0
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &STRING_process_asm_1
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_require_match
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-:WHILE_process_asm_2
-LOAD_IMMEDIATE_eax %34
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %0
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-LOAD_BYTE
-POP_ebx # _common_recursion
-CMP
-SETE
-MOVEZBL
-TEST
-JUMP_EQ %END_WHILE_process_asm_2
-# THEN_while_process_asm_2
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %1
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_process_asm_3
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-JUMP %WHILE_process_asm_2
-:END_WHILE_process_asm_2
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_process_asm_4
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &STRING_process_asm_5
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_require_match
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_process_asm_6
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &STRING_process_asm_7
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_require_match
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-RETURN
-# Defining function process_do
-:FUNCTION_process_do
-# Defining local nested_locals
-LOAD_IMMEDIATE_eax &GLOBAL_break_frame
-LOAD_INTEGER
-PUSH_eax #nested_locals
-# Defining local nested_break_head
-LOAD_IMMEDIATE_eax &GLOBAL_break_target_head
-LOAD_INTEGER
-PUSH_eax #nested_break_head
-# Defining local nested_break_func
-LOAD_IMMEDIATE_eax &GLOBAL_break_target_func
-LOAD_INTEGER
-PUSH_eax #nested_break_func
-# Defining local nested_break_num
-LOAD_IMMEDIATE_eax &GLOBAL_break_target_num
-LOAD_INTEGER
-PUSH_eax #nested_break_num
-# Defining local number_string
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &GLOBAL_current_count
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_numerate_number
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_eax #number_string
-LOAD_IMMEDIATE_eax &GLOBAL_current_count
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_current_count
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %1
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_IMMEDIATE_eax &GLOBAL_break_target_head
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &STRING_process_do_0
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_IMMEDIATE_eax &GLOBAL_break_target_num
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-24
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_IMMEDIATE_eax &GLOBAL_break_frame
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_function
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %4
-ADD_ebx_to_eax
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_IMMEDIATE_eax &GLOBAL_break_target_func
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_function
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_process_do_1
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &GLOBAL_function
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-LOAD_BASE_ADDRESS_eax %-24
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_uniqueID_out
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_statement
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_process_do_2
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &STRING_process_do_3
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_require_match
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_process_do_4
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &STRING_process_do_5
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_require_match
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_expression
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_process_do_6
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &STRING_process_do_7
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_require_match
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_process_do_8
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &STRING_process_do_9
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_require_match
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_process_do_10
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &GLOBAL_function
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-LOAD_BASE_ADDRESS_eax %-24
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_uniqueID_out
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_process_do_11
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &GLOBAL_function
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-LOAD_BASE_ADDRESS_eax %-24
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_uniqueID_out
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-LOAD_IMMEDIATE_eax &GLOBAL_break_frame
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_IMMEDIATE_eax &GLOBAL_break_target_head
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-12
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_IMMEDIATE_eax &GLOBAL_break_target_func
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-16
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_IMMEDIATE_eax &GLOBAL_break_target_num
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-20
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-POP_ebx # _recursive_statement_locals
-POP_ebx # _recursive_statement_locals
-POP_ebx # _recursive_statement_locals
-POP_ebx # _recursive_statement_locals
-POP_ebx # _recursive_statement_locals
-RETURN
-# Defining function process_while
-:FUNCTION_process_while
-# Defining local nested_locals
-LOAD_IMMEDIATE_eax &GLOBAL_break_frame
-LOAD_INTEGER
-PUSH_eax #nested_locals
-# Defining local nested_break_head
-LOAD_IMMEDIATE_eax &GLOBAL_break_target_head
-LOAD_INTEGER
-PUSH_eax #nested_break_head
-# Defining local nested_break_func
-LOAD_IMMEDIATE_eax &GLOBAL_break_target_func
-LOAD_INTEGER
-PUSH_eax #nested_break_func
-# Defining local nested_break_num
-LOAD_IMMEDIATE_eax &GLOBAL_break_target_num
-LOAD_INTEGER
-PUSH_eax #nested_break_num
-# Defining local number_string
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &GLOBAL_current_count
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_numerate_number
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_eax #number_string
-LOAD_IMMEDIATE_eax &GLOBAL_current_count
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_current_count
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %1
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_IMMEDIATE_eax &GLOBAL_break_target_head
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &STRING_process_while_0
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_IMMEDIATE_eax &GLOBAL_break_target_num
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-24
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_IMMEDIATE_eax &GLOBAL_break_frame
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_function
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %4
-ADD_ebx_to_eax
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_IMMEDIATE_eax &GLOBAL_break_target_func
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_function
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_process_while_1
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &GLOBAL_function
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-LOAD_BASE_ADDRESS_eax %-24
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_uniqueID_out
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_process_while_2
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &STRING_process_while_3
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_require_match
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_expression
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_process_while_4
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &GLOBAL_function
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-LOAD_BASE_ADDRESS_eax %-24
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_uniqueID_out
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_process_while_5
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &GLOBAL_function
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-LOAD_BASE_ADDRESS_eax %-24
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_uniqueID_out
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_process_while_6
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &STRING_process_while_7
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_require_match
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_statement
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_process_while_8
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &GLOBAL_function
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-LOAD_BASE_ADDRESS_eax %-24
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_uniqueID_out
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_process_while_9
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &GLOBAL_function
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-LOAD_BASE_ADDRESS_eax %-24
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_uniqueID_out
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-LOAD_IMMEDIATE_eax &GLOBAL_break_target_head
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-12
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_IMMEDIATE_eax &GLOBAL_break_target_func
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-16
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_IMMEDIATE_eax &GLOBAL_break_target_num
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-20
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_IMMEDIATE_eax &GLOBAL_break_frame
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-POP_ebx # _recursive_statement_locals
-POP_ebx # _recursive_statement_locals
-POP_ebx # _recursive_statement_locals
-POP_ebx # _recursive_statement_locals
-POP_ebx # _recursive_statement_locals
-RETURN
-# Defining function return_result
-:FUNCTION_return_result
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-# IF_return_result_0
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %0
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-LOAD_BYTE
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %59
-POP_ebx # _common_recursion
-CMP
-SETNE
-MOVEZBL
-TEST
-JUMP_EQ %ELSE_return_result_0
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_expression
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-JUMP %_END_IF_return_result_0
-:ELSE_return_result_0
-:_END_IF_return_result_0
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_return_result_1
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &STRING_return_result_2
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_require_match
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-# Defining local i
-PUSH_eax #i
-# FOR_initialization_return_result_3
-LOAD_BASE_ADDRESS_eax %-8
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_function
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %4
-ADD_ebx_to_eax
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-:FOR_return_result_3
-LOAD_IMMEDIATE_eax %0
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-POP_ebx # _common_recursion
-CMP
-SETNE
-MOVEZBL
-TEST
-JUMP_EQ %FOR_END_return_result_3
-JUMP %FOR_THEN_return_result_3
-:FOR_ITER_return_result_3
-LOAD_BASE_ADDRESS_eax %-8
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-# looking up offset
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-JUMP %FOR_return_result_3
-:FOR_THEN_return_result_3
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_return_result_4
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-JUMP %FOR_ITER_return_result_3
-:FOR_END_return_result_3
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_return_result_5
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-POP_ebx # _recursive_statement_locals
-RETURN
-# Defining function process_break
-:FUNCTION_process_break
-# IF_process_break_0
-LOAD_IMMEDIATE_eax %0
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_break_target_head
-LOAD_INTEGER
-POP_ebx # _common_recursion
-CMP
-SETE
-MOVEZBL
-TEST
-JUMP_EQ %ELSE_process_break_0
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_line_error
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_process_break_1
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax %2
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_file_print
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax %1
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_exit
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-JUMP %_END_IF_process_break_0
-:ELSE_process_break_0
-:_END_IF_process_break_0
-# Defining local i
-LOAD_IMMEDIATE_eax &GLOBAL_function
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %4
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #i
-:WHILE_process_break_2
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_break_frame
-LOAD_INTEGER
-POP_ebx # _common_recursion
-CMP
-SETNE
-MOVEZBL
-TEST
-JUMP_EQ %END_WHILE_process_break_2
-# THEN_while_process_break_2
-# IF_process_break_3
-LOAD_IMMEDIATE_eax %0
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-POP_ebx # _common_recursion
-CMP
-SETE
-MOVEZBL
-TEST
-JUMP_EQ %ELSE_process_break_3
-JUMP %END_WHILE_process_break_2
-JUMP %_END_IF_process_break_3
-:ELSE_process_break_3
-:_END_IF_process_break_3
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_process_break_4
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-LOAD_BASE_ADDRESS_eax %-8
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-# looking up offset
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-JUMP %WHILE_process_break_2
-:END_WHILE_process_break_2
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_process_break_5
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &GLOBAL_break_target_head
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &GLOBAL_break_target_func
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_process_break_6
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &GLOBAL_break_target_num
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_process_break_7
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_process_break_8
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &STRING_process_break_9
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_require_match
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-POP_ebx # _recursive_statement_locals
-RETURN
-# Defining function recursive_statement
-:FUNCTION_recursive_statement
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-# Defining local frame
-LOAD_IMMEDIATE_eax &GLOBAL_function
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %4
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #frame
-:WHILE_recursive_statement_0
-LOAD_IMMEDIATE_eax %1
-PUSH_eax #_common_recursion
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_recursive_statement_1
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_match
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-POP_ebx # _common_recursion
-XOR_ebx_eax_into_eax
-TEST
-JUMP_EQ %END_WHILE_recursive_statement_0
-# THEN_while_recursive_statement_0
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_statement
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-JUMP %WHILE_recursive_statement_0
-:END_WHILE_recursive_statement_0
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-# IF_recursive_statement_2
-LOAD_IMMEDIATE_eax %1
-PUSH_eax #_common_recursion
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_recursive_statement_3
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &GLOBAL_out
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_match
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-POP_ebx # _common_recursion
-XOR_ebx_eax_into_eax
-TEST
-JUMP_EQ %ELSE_recursive_statement_2
-# Defining local i
-PUSH_eax #i
-# FOR_initialization_recursive_statement_4
-LOAD_BASE_ADDRESS_eax %-12
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_function
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %4
-ADD_ebx_to_eax
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-:FOR_recursive_statement_4
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-12
-LOAD_INTEGER
-POP_ebx # _common_recursion
-CMP
-SETNE
-MOVEZBL
-TEST
-JUMP_EQ %FOR_END_recursive_statement_4
-JUMP %FOR_THEN_recursive_statement_4
-:FOR_ITER_recursive_statement_4
-LOAD_BASE_ADDRESS_eax %-12
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-12
-LOAD_INTEGER
-# looking up offset
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-JUMP %FOR_recursive_statement_4
-:FOR_THEN_recursive_statement_4
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_recursive_statement_5
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-JUMP %FOR_ITER_recursive_statement_4
-:FOR_END_recursive_statement_4
-POP_ebx # _recursive_statement_locals
-JUMP %_END_IF_recursive_statement_2
-:ELSE_recursive_statement_2
-:_END_IF_recursive_statement_2
-LOAD_IMMEDIATE_eax &GLOBAL_function
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %4
-ADD_ebx_to_eax
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-POP_ebx # _recursive_statement_locals
-RETURN
-# Defining function statement
-:FUNCTION_statement
-# IF_statement_0
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %0
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-LOAD_BYTE
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %123
-POP_ebx # _common_recursion
-CMP
-SETE
-MOVEZBL
-TEST
-JUMP_EQ %ELSE_statement_0
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_recursive_statement
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-JUMP %_END_IF_statement_0
-:ELSE_statement_0
-# IF_statement_1
-LOAD_IMMEDIATE_eax %58
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %0
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-LOAD_BYTE
-POP_ebx # _common_recursion
-CMP
-SETE
-MOVEZBL
-TEST
-JUMP_EQ %ELSE_statement_1
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_statement_2
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-JUMP %_END_IF_statement_1
-:ELSE_statement_1
-# IF_statement_3
-LOAD_IMMEDIATE_eax %0
-PUSH_eax #_common_recursion
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &GLOBAL_prim_types
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_lookup_type
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-POP_ebx # _common_recursion
-CMP
-SETNE
-MOVEZBL
-PUSH_eax #_common_recursion
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_statement_4
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_match
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-POP_ebx # _common_recursion
-OR_eax_ebx
-TEST
-JUMP_EQ %ELSE_statement_3
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_collect_local
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-JUMP %_END_IF_statement_3
-:ELSE_statement_3
-# IF_statement_5
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_statement_6
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_match
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-TEST
-JUMP_EQ %ELSE_statement_5
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_process_if
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-JUMP %_END_IF_statement_5
-:ELSE_statement_5
-# IF_statement_7
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_statement_8
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_match
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-TEST
-JUMP_EQ %ELSE_statement_7
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_process_do
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-JUMP %_END_IF_statement_7
-:ELSE_statement_7
-# IF_statement_9
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_statement_10
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_match
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-TEST
-JUMP_EQ %ELSE_statement_9
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_process_while
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-JUMP %_END_IF_statement_9
-:ELSE_statement_9
-# IF_statement_11
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_statement_12
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_match
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-TEST
-JUMP_EQ %ELSE_statement_11
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_process_for
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-JUMP %_END_IF_statement_11
-:ELSE_statement_11
-# IF_statement_13
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_statement_14
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_match
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-TEST
-JUMP_EQ %ELSE_statement_13
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_process_asm
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-JUMP %_END_IF_statement_13
-:ELSE_statement_13
-# IF_statement_15
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_statement_16
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_match
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-TEST
-JUMP_EQ %ELSE_statement_15
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_statement_17
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_statement_18
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_statement_19
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &STRING_statement_20
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_require_match
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-JUMP %_END_IF_statement_15
-:ELSE_statement_15
-# IF_statement_21
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_statement_22
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_match
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-TEST
-JUMP_EQ %ELSE_statement_21
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_return_result
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-JUMP %_END_IF_statement_21
-:ELSE_statement_21
-# IF_statement_23
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_statement_24
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_match
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-TEST
-JUMP_EQ %ELSE_statement_23
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_process_break
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-JUMP %_END_IF_statement_23
-:ELSE_statement_23
-# IF_statement_25
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_statement_26
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_match
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-TEST
-JUMP_EQ %ELSE_statement_25
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_statement_27
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_statement_28
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &STRING_statement_29
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_require_match
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-JUMP %_END_IF_statement_25
-:ELSE_statement_25
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_expression
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_statement_30
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &STRING_statement_31
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_require_match
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-:_END_IF_statement_25
-:_END_IF_statement_23
-:_END_IF_statement_21
-:_END_IF_statement_15
-:_END_IF_statement_13
-:_END_IF_statement_11
-:_END_IF_statement_9
-:_END_IF_statement_7
-:_END_IF_statement_5
-:_END_IF_statement_3
-:_END_IF_statement_1
-:_END_IF_statement_0
-RETURN
-# Defining function collect_arguments
-:FUNCTION_collect_arguments
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-:WHILE_collect_arguments_0
-LOAD_IMMEDIATE_eax %1
-PUSH_eax #_common_recursion
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_collect_arguments_1
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_match
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-POP_ebx # _common_recursion
-XOR_ebx_eax_into_eax
-TEST
-JUMP_EQ %END_WHILE_collect_arguments_0
-# THEN_while_collect_arguments_0
-# Defining local type_size
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_type_name
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_eax #type_size
-# IF_collect_arguments_2
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %0
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-LOAD_BYTE
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %41
-POP_ebx # _common_recursion
-CMP
-SETE
-MOVEZBL
-TEST
-JUMP_EQ %ELSE_collect_arguments_2
-
-#continue statement
-JUMP %_END_IF_collect_arguments_2
-:ELSE_collect_arguments_2
-# IF_collect_arguments_3
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %0
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-LOAD_BYTE
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %44
-POP_ebx # _common_recursion
-CMP
-SETNE
-MOVEZBL
-TEST
-JUMP_EQ %ELSE_collect_arguments_3
-# Defining local a
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-LOAD_IMMEDIATE_eax &GLOBAL_function
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %16
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_sym_declare
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_eax #a
-# IF_collect_arguments_4
-LOAD_IMMEDIATE_eax %0
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_function
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %16
-ADD_ebx_to_eax
-LOAD_INTEGER
-POP_ebx # _common_recursion
-CMP
-SETE
-MOVEZBL
-TEST
-JUMP_EQ %ELSE_collect_arguments_4
-LOAD_BASE_ADDRESS_eax %-12
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %16
-ADD_ebx_to_eax
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %0
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %4
-POP_ebx # _common_recursion
-SUBTRACT_eax_from_ebx_into_ebx
-MOVE_ebx_to_eax
-POP_ebx # _common_recursion
-STORE_INTEGER
-JUMP %_END_IF_collect_arguments_4
-:ELSE_collect_arguments_4
-LOAD_BASE_ADDRESS_eax %-12
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %16
-ADD_ebx_to_eax
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_function
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %16
-ADD_ebx_to_eax
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %16
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %4
-POP_ebx # _common_recursion
-SUBTRACT_eax_from_ebx_into_ebx
-MOVE_ebx_to_eax
-POP_ebx # _common_recursion
-STORE_INTEGER
-:_END_IF_collect_arguments_4
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_IMMEDIATE_eax &GLOBAL_function
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %16
-ADD_ebx_to_eax
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-12
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-POP_ebx # _recursive_statement_locals
-JUMP %_END_IF_collect_arguments_3
-:ELSE_collect_arguments_3
-:_END_IF_collect_arguments_3
-:_END_IF_collect_arguments_2
-# IF_collect_arguments_5
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %0
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-LOAD_BYTE
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %44
-POP_ebx # _common_recursion
-CMP
-SETE
-MOVEZBL
-TEST
-JUMP_EQ %ELSE_collect_arguments_5
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-JUMP %_END_IF_collect_arguments_5
-:ELSE_collect_arguments_5
-:_END_IF_collect_arguments_5
-POP_ebx # _recursive_statement_locals
-JUMP %WHILE_collect_arguments_0
-:END_WHILE_collect_arguments_0
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-RETURN
-# Defining function declare_function
-:FUNCTION_declare_function
-LOAD_IMMEDIATE_eax &GLOBAL_current_count
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %0
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_IMMEDIATE_eax &GLOBAL_function
-PUSH_eax #_common_recursion
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %4
-ADD_ebx_to_eax
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax %0
-PUSH_eax #_process_expression2
-LOAD_IMMEDIATE_eax &GLOBAL_global_function_list
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_sym_declare
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_IMMEDIATE_eax &GLOBAL_global_function_list
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_function
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_collect_arguments
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-# IF_declare_function_0
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %0
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-LOAD_BYTE
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %59
-POP_ebx # _common_recursion
-CMP
-SETE
-MOVEZBL
-TEST
-JUMP_EQ %ELSE_declare_function_0
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-JUMP %_END_IF_declare_function_0
-:ELSE_declare_function_0
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_declare_function_1
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &GLOBAL_function
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_declare_function_2
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_declare_function_3
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &GLOBAL_function
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_declare_function_4
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_statement
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-# IF_declare_function_5
-LOAD_IMMEDIATE_eax %1
-PUSH_eax #_common_recursion
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_declare_function_6
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &GLOBAL_out
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_match
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-POP_ebx # _common_recursion
-XOR_ebx_eax_into_eax
-TEST
-JUMP_EQ %ELSE_declare_function_5
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_declare_function_7
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit_out
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-JUMP %_END_IF_declare_function_5
-:ELSE_declare_function_5
-:_END_IF_declare_function_5
-:_END_IF_declare_function_0
-RETURN
-# Defining function program
-:FUNCTION_program
-LOAD_IMMEDIATE_eax &GLOBAL_out
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %0
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_IMMEDIATE_eax &GLOBAL_function
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %0
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_IMMEDIATE_eax &GLOBAL_Address_of
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %0
-POP_ebx # _common_recursion
-STORE_INTEGER
-# Defining local type_size
-PUSH_eax #type_size
-:new_type #C goto label
-# IF_program_0
-LOAD_IMMEDIATE_eax %0
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-POP_ebx # _common_recursion
-CMP
-SETE
-MOVEZBL
-TEST
-JUMP_EQ %ELSE_program_0
-LOAD_IMMEDIATE_eax &GLOBAL_out
-LOAD_INTEGER
-POP_ebx # _return_result_locals
-RETURN
-JUMP %_END_IF_program_0
-:ELSE_program_0
-:_END_IF_program_0
-# IF_program_1
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_program_2
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_match
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-TEST
-JUMP_EQ %ELSE_program_1
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_IMMEDIATE_eax &GLOBAL_global_constant_list
-PUSH_eax #_common_recursion
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax %0
-PUSH_eax #_process_expression2
-LOAD_IMMEDIATE_eax &GLOBAL_global_constant_list
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_sym_declare
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_IMMEDIATE_eax &GLOBAL_global_constant_list
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %16
-ADD_ebx_to_eax
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-LOAD_INTEGER
-# looking up offset
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-JUMP %_END_IF_program_1
-:ELSE_program_1
-LOAD_BASE_ADDRESS_eax %-8
-PUSH_eax #_common_recursion
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_type_name
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-POP_ebx # _common_recursion
-STORE_INTEGER
-# IF_program_3
-LOAD_IMMEDIATE_eax %0
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-POP_ebx # _common_recursion
-CMP
-SETE
-MOVEZBL
-TEST
-JUMP_EQ %ELSE_program_3
-JUMP %new_type
-JUMP %_END_IF_program_3
-:ELSE_program_3
-:_END_IF_program_3
-LOAD_IMMEDIATE_eax &GLOBAL_global_symbol_list
-PUSH_eax #_common_recursion
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-LOAD_IMMEDIATE_eax &GLOBAL_global_symbol_list
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_sym_declare
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-# IF_program_4
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_program_5
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_match
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-TEST
-JUMP_EQ %ELSE_program_4
-LOAD_IMMEDIATE_eax &GLOBAL_globals_list
-PUSH_eax #_common_recursion
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_program_6
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &GLOBAL_globals_list
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_IMMEDIATE_eax &GLOBAL_globals_list
-PUSH_eax #_common_recursion
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %4
-ADD_ebx_to_eax
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &GLOBAL_globals_list
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_IMMEDIATE_eax &GLOBAL_globals_list
-PUSH_eax #_common_recursion
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_program_7
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &GLOBAL_globals_list
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-JUMP %_END_IF_program_4
-:ELSE_program_4
-# IF_program_8
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_program_9
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_match
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-TEST
-JUMP_EQ %ELSE_program_8
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_declare_function
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-JUMP %_END_IF_program_8
-:ELSE_program_8
-# IF_program_10
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_program_11
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_match
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-TEST
-JUMP_EQ %ELSE_program_10
-LOAD_IMMEDIATE_eax &GLOBAL_globals_list
-PUSH_eax #_common_recursion
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_program_12
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &GLOBAL_globals_list
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_IMMEDIATE_eax &GLOBAL_globals_list
-PUSH_eax #_common_recursion
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %4
-ADD_ebx_to_eax
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &GLOBAL_globals_list
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_IMMEDIATE_eax &GLOBAL_globals_list
-PUSH_eax #_common_recursion
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_program_13
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &GLOBAL_globals_list
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-# IF_program_14
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %0
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-LOAD_BYTE
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &STRING_program_15
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_in_set
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-TEST
-JUMP_EQ %ELSE_program_14
-LOAD_IMMEDIATE_eax &GLOBAL_globals_list
-PUSH_eax #_common_recursion
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_program_16
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &GLOBAL_globals_list
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_IMMEDIATE_eax &GLOBAL_globals_list
-PUSH_eax #_common_recursion
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &GLOBAL_globals_list
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_IMMEDIATE_eax &GLOBAL_globals_list
-PUSH_eax #_common_recursion
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_program_17
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &GLOBAL_globals_list
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-POP_ebx # _common_recursion
-STORE_INTEGER
-JUMP %_END_IF_program_14
-:ELSE_program_14
-# IF_program_18
-LOAD_IMMEDIATE_eax %34
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %0
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-LOAD_BYTE
-POP_ebx # _common_recursion
-CMP
-SETE
-MOVEZBL
-TEST
-JUMP_EQ %ELSE_program_18
-LOAD_IMMEDIATE_eax &GLOBAL_globals_list
-PUSH_eax #_common_recursion
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_parse_string
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &GLOBAL_globals_list
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_emit
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-POP_ebx # _common_recursion
-STORE_INTEGER
-JUMP %_END_IF_program_18
-:ELSE_program_18
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_line_error
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_program_19
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax %2
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_file_print
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax %2
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_file_print
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_program_20
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax %2
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_file_print
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax %1
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_exit
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-:_END_IF_program_18
-:_END_IF_program_14
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-LOAD_INTEGER
-POP_ebx # _common_recursion
-STORE_INTEGER
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_program_21
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &STRING_program_22
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_require_match
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-JUMP %_END_IF_program_10
-:ELSE_program_10
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_line_error
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_program_23
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax %2
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_file_print
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax %2
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_file_print
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_program_24
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax %2
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_file_print
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax %1
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_exit
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-:_END_IF_program_10
-:_END_IF_program_8
-:_END_IF_program_4
-:_END_IF_program_1
-JUMP %new_type
-POP_ebx # _recursive_statement_locals
-RETURN
-# Defining function recursive_output
-:FUNCTION_recursive_output
-# IF_recursive_output_0
-LOAD_IMMEDIATE_eax %0
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-POP_ebx # _common_recursion
-CMP
-SETE
-MOVEZBL
-TEST
-JUMP_EQ %ELSE_recursive_output_0
-RETURN
-JUMP %_END_IF_recursive_output_0
-:ELSE_recursive_output_0
-:_END_IF_recursive_output_0
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-# looking up offset
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_recursive_output
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-# looking up offset
-# -> offset calculation
-LOAD_IMMEDIATE_ebx %8
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_file_print
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-RETURN
-# Defining function main
-:FUNCTION_main
-LOAD_IMMEDIATE_eax &GLOBAL_hold_string
-PUSH_eax #_common_recursion
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax %4096
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax %1
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_calloc
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-POP_ebx # _common_recursion
-STORE_INTEGER
-# Defining local DEBUG
-LOAD_IMMEDIATE_eax %0
-PUSH_eax #DEBUG
-# Defining local in
-LOAD_IMMEDIATE_eax %0
-PUSH_eax #in
-# Defining local destination_file
-LOAD_IMMEDIATE_eax %1
-PUSH_eax #destination_file
-# Defining local i
-LOAD_IMMEDIATE_eax %1
-PUSH_eax #i
-:WHILE_main_0
-LOAD_BASE_ADDRESS_eax %-32
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-4
-LOAD_INTEGER
-POP_ebx # _common_recursion
-CMP
-SETLE
-MOVEZBL
-TEST
-JUMP_EQ %END_WHILE_main_0
-# THEN_while_main_0
-# IF_main_1
-LOAD_IMMEDIATE_eax %0
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-32
-LOAD_INTEGER
-POP_ebx # _common_recursion
-SAL_eax_Immediate8 !2
-ADD_ebx_to_eax
-LOAD_INTEGER
-POP_ebx # _common_recursion
-CMP
-SETE
-MOVEZBL
-TEST
-JUMP_EQ %ELSE_main_1
-LOAD_BASE_ADDRESS_eax %-32
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-32
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %1
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-POP_ebx # _common_recursion
-STORE_INTEGER
-JUMP %_END_IF_main_1
-:ELSE_main_1
-# IF_main_2
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-32
-LOAD_INTEGER
-POP_ebx # _common_recursion
-SAL_eax_Immediate8 !2
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &STRING_main_3
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_match
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_eax #_common_recursion
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-32
-LOAD_INTEGER
-POP_ebx # _common_recursion
-SAL_eax_Immediate8 !2
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &STRING_main_4
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_match
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-POP_ebx # _common_recursion
-OR_eax_ebx
-TEST
-JUMP_EQ %ELSE_main_2
-# Defining local name
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-32
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %1
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-POP_ebx # _common_recursion
-SAL_eax_Immediate8 !2
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #name
-LOAD_BASE_ADDRESS_eax %-24
-PUSH_eax #_common_recursion
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-36
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &STRING_main_5
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_fopen
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-POP_ebx # _common_recursion
-STORE_INTEGER
-# IF_main_6
-LOAD_IMMEDIATE_eax %0
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-24
-LOAD_INTEGER
-POP_ebx # _common_recursion
-CMP
-SETE
-MOVEZBL
-TEST
-JUMP_EQ %ELSE_main_6
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_main_7
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax %2
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_file_print
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-36
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax %2
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_file_print
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_main_8
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax %2
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_file_print
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax %1
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_exit
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-JUMP %_END_IF_main_6
-:ELSE_main_6
-:_END_IF_main_6
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-PUSH_eax #_common_recursion
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-24
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-LOAD_BASE_ADDRESS_eax %-36
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_read_all_tokens
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_BASE_ADDRESS_eax %-32
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-32
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %2
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-POP_ebx # _common_recursion
-STORE_INTEGER
-POP_ebx # _recursive_statement_locals
-JUMP %_END_IF_main_2
-:ELSE_main_2
-# IF_main_9
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-32
-LOAD_INTEGER
-POP_ebx # _common_recursion
-SAL_eax_Immediate8 !2
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &STRING_main_10
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_match
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_eax #_common_recursion
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-32
-LOAD_INTEGER
-POP_ebx # _common_recursion
-SAL_eax_Immediate8 !2
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &STRING_main_11
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_match
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-POP_ebx # _common_recursion
-OR_eax_ebx
-TEST
-JUMP_EQ %ELSE_main_9
-LOAD_BASE_ADDRESS_eax %-28
-PUSH_eax #_common_recursion
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-32
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %1
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-POP_ebx # _common_recursion
-SAL_eax_Immediate8 !2
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &STRING_main_12
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_fopen
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-POP_ebx # _common_recursion
-STORE_INTEGER
-# IF_main_13
-LOAD_IMMEDIATE_eax %0
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-28
-LOAD_INTEGER
-POP_ebx # _common_recursion
-CMP
-SETE
-MOVEZBL
-TEST
-JUMP_EQ %ELSE_main_13
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_main_14
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax %2
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_file_print
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-32
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %1
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-POP_ebx # _common_recursion
-SAL_eax_Immediate8 !2
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax %2
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_file_print
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_main_15
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax %2
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_file_print
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax %1
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_exit
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-JUMP %_END_IF_main_13
-:ELSE_main_13
-:_END_IF_main_13
-LOAD_BASE_ADDRESS_eax %-32
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-32
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %2
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-POP_ebx # _common_recursion
-STORE_INTEGER
-JUMP %_END_IF_main_9
-:ELSE_main_9
-# IF_main_16
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-32
-LOAD_INTEGER
-POP_ebx # _common_recursion
-SAL_eax_Immediate8 !2
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &STRING_main_17
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_match
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_eax #_common_recursion
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-32
-LOAD_INTEGER
-POP_ebx # _common_recursion
-SAL_eax_Immediate8 !2
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &STRING_main_18
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_match
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-POP_ebx # _common_recursion
-OR_eax_ebx
-TEST
-JUMP_EQ %ELSE_main_16
-LOAD_BASE_ADDRESS_eax %-20
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %1
-POP_ebx # _common_recursion
-STORE_INTEGER
-LOAD_BASE_ADDRESS_eax %-32
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-32
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax %1
-POP_ebx # _common_recursion
-ADD_ebx_to_eax
-POP_ebx # _common_recursion
-STORE_INTEGER
-JUMP %_END_IF_main_16
-:ELSE_main_16
-# IF_main_19
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-32
-LOAD_INTEGER
-POP_ebx # _common_recursion
-SAL_eax_Immediate8 !2
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &STRING_main_20
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_match
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_eax #_common_recursion
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-32
-LOAD_INTEGER
-POP_ebx # _common_recursion
-SAL_eax_Immediate8 !2
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &STRING_main_21
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_match
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-POP_ebx # _common_recursion
-OR_eax_ebx
-TEST
-JUMP_EQ %ELSE_main_19
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_main_22
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax %1
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_file_print
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax %0
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_exit
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-JUMP %_END_IF_main_19
-:ELSE_main_19
-# IF_main_23
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-32
-LOAD_INTEGER
-POP_ebx # _common_recursion
-SAL_eax_Immediate8 !2
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &STRING_main_24
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_match
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_eax #_common_recursion
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-8
-LOAD_INTEGER
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-32
-LOAD_INTEGER
-POP_ebx # _common_recursion
-SAL_eax_Immediate8 !2
-ADD_ebx_to_eax
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &STRING_main_25
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_match
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-POP_ebx # _common_recursion
-OR_eax_ebx
-TEST
-JUMP_EQ %ELSE_main_23
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_main_26
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax %2
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_file_print
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax %0
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_exit
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-JUMP %_END_IF_main_23
-:ELSE_main_23
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_main_27
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax %1
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_file_print
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax %1
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_exit
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-:_END_IF_main_23
-:_END_IF_main_19
-:_END_IF_main_16
-:_END_IF_main_9
-:_END_IF_main_2
-:_END_IF_main_1
-JUMP %WHILE_main_0
-:END_WHILE_main_0
-# IF_main_28
-LOAD_IMMEDIATE_eax %0
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-24
-LOAD_INTEGER
-POP_ebx # _common_recursion
-CMP
-SETE
-MOVEZBL
-TEST
-JUMP_EQ %ELSE_main_28
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-PUSH_eax #_common_recursion
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-24
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-LOAD_IMMEDIATE_eax &STRING_main_29
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_read_all_tokens
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-POP_ebx # _common_recursion
-STORE_INTEGER
-JUMP %_END_IF_main_28
-:ELSE_main_28
-:_END_IF_main_28
-# IF_main_30
-LOAD_IMMEDIATE_eax %0
-PUSH_eax #_common_recursion
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-POP_ebx # _common_recursion
-CMP
-SETE
-MOVEZBL
-TEST
-JUMP_EQ %ELSE_main_30
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_main_31
-PUSH_eax #_process_expression1
-LOAD_IMMEDIATE_eax %2
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_file_print
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax %1
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_exit
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-JUMP %_END_IF_main_30
-:ELSE_main_30
-:_END_IF_main_30
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-PUSH_eax #_common_recursion
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &GLOBAL_global_token
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_reverse_list
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-POP_ebx # _common_recursion
-STORE_INTEGER
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_initialize_types
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_reset_hold_string
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-# Defining local output_list
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_program
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_eax #output_list
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_main_32
-PUSH_eax #_process_expression1
-LOAD_BASE_ADDRESS_eax %-28
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_file_print
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_BASE_ADDRESS_eax %-36
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-LOAD_BASE_ADDRESS_eax %-28
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_recursive_output
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-# IF_main_33
-LOAD_BASE_ADDRESS_eax %-20
-LOAD_INTEGER
-TEST
-JUMP_EQ %ELSE_main_33
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_main_34
-PUSH_eax #_process_expression1
-LOAD_BASE_ADDRESS_eax %-28
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_file_print
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-JUMP %_END_IF_main_33
-:ELSE_main_33
-:_END_IF_main_33
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_main_35
-PUSH_eax #_process_expression1
-LOAD_BASE_ADDRESS_eax %-28
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_file_print
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &GLOBAL_globals_list
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-LOAD_BASE_ADDRESS_eax %-28
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_recursive_output
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_main_36
-PUSH_eax #_process_expression1
-LOAD_BASE_ADDRESS_eax %-28
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_file_print
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &GLOBAL_strings_list
-LOAD_INTEGER
-PUSH_eax #_process_expression1
-LOAD_BASE_ADDRESS_eax %-28
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_recursive_output
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-# IF_main_37
-LOAD_IMMEDIATE_eax %1
-PUSH_eax #_common_recursion
-LOAD_BASE_ADDRESS_eax %-20
-LOAD_INTEGER
-POP_ebx # _common_recursion
-XOR_ebx_eax_into_eax
-TEST
-JUMP_EQ %ELSE_main_37
-PUSH_edi # Prevent overwriting in recursion
-PUSH_ebp # Protect the old base pointer
-COPY_esp_to_edi # Copy new base pointer
-LOAD_IMMEDIATE_eax &STRING_main_38
-PUSH_eax #_process_expression1
-LOAD_BASE_ADDRESS_eax %-28
-LOAD_INTEGER
-PUSH_eax #_process_expression2
-COPY_edi_to_ebp
-CALL_IMMEDIATE %FUNCTION_file_print
-POP_ebx # _process_expression_locals
-POP_ebx # _process_expression_locals
-POP_ebp # Restore old base pointer
-POP_edi # Prevent overwrite
-JUMP %_END_IF_main_37
-:ELSE_main_37
-:_END_IF_main_37
-LOAD_IMMEDIATE_eax %0
-POP_ebx # _return_result_locals
-POP_ebx # _return_result_locals
-POP_ebx # _return_result_locals
-POP_ebx # _return_result_locals
-POP_ebx # _return_result_locals
-RETURN
-
-:ELF_data
-
-# Program global variables
-:GLOBAL_global_types
-NOP
-:GLOBAL_prim_types
-NOP
-:GLOBAL_global_token
-NOP
-:GLOBAL_strings_list
-NOP
-:GLOBAL_globals_list
-NOP
-:GLOBAL_hold_string
-NOP
-:GLOBAL_string_index
-NOP
-:GLOBAL_input
-NOP
-:GLOBAL_token
-NOP
-:GLOBAL_line
-NOP
-:GLOBAL_file
-NOP
-:GLOBAL_member_size
-NOP
-:GLOBAL_global_symbol_list
-NOP
-:GLOBAL_global_function_list
-NOP
-:GLOBAL_global_constant_list
-NOP
-:GLOBAL_function
-NOP
-:GLOBAL_out
-NOP
-:GLOBAL_current_target
-NOP
-:GLOBAL_break_target_head
-NOP
-:GLOBAL_break_target_func
-NOP
-:GLOBAL_break_target_num
-NOP
-:GLOBAL_break_frame
-NOP
-:GLOBAL_current_count
-NOP
-:GLOBAL_last_type
-NOP
-:GLOBAL_Address_of
-NOP
-
-# Program strings
-:STRING_preserve_keyword_1
-"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_"
-:STRING_preserve_symbol_1
-"<=>|&!-"
-:STRING_get_token_2
-"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_"
-:STRING_get_token_4
-"<=>|&!-"
-:STRING_upcase_1
-"abcdefghijklmnopqrstuvwxyz"
-:STRING_hexify_1
-"Tried to print non-hex number
-"
-:STRING_weird_4
-"
- !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~"
-:STRING_weird_6
-' 20 09 0A 0D 00'
-:STRING_escape_lookup_11
-"Unknown escape recieved: "
-:STRING_escape_lookup_12
-" Unable to process
-"
-:STRING_collect_weird_string_0
-"0123456789ABCDEF"
-:STRING_initialize_types_0
-"void"
-:STRING_initialize_types_1
-"int"
-:STRING_initialize_types_2
-"char*"
-:STRING_initialize_types_3
-"char"
-:STRING_initialize_types_4
-"char**"
-:STRING_initialize_types_5
-"FILE"
-:STRING_initialize_types_6
-"FUNCTION"
-:STRING_initialize_types_7
-"unsigned"
-:STRING_lookup_member_2
-"ERROR in lookup_member "
-:STRING_lookup_member_3
-"->"
-:STRING_lookup_member_4
-" does not exist
-"
-:STRING_lookup_member_5
-"
-"
-:STRING_build_member_1
-"["
-:STRING_build_member_2
-"Struct only supports [num] form
-"
-:STRING_build_member_3
-"]"
-:STRING_build_union_0
-"ERROR in build_union
-Missing {
-"
-:STRING_build_union_1
-"{"
-:STRING_build_union_4
-"ERROR in build_union
-Missing ;
-"
-:STRING_build_union_5
-";"
-:STRING_create_struct_0
-"ERROR in create_struct
- Missing {
-"
-:STRING_create_struct_1
-"{"
-:STRING_create_struct_4
-"union"
-:STRING_create_struct_5
-"ERROR in create_struct
- Missing ;
-"
-:STRING_create_struct_6
-";"
-:STRING_create_struct_7
-"ERROR in create_struct
- Missing ;
-"
-:STRING_create_struct_8
-";"
-:STRING_type_name_0
-"struct"
-:STRING_type_name_3
-"Unknown type "
-:STRING_type_name_4
-"
-"
-:STRING_uniqueID_0
-"_"
-:STRING_uniqueID_1
-"
-"
-:STRING_line_error_0
-":"
-:STRING_line_error_1
-":"
-:STRING_function_call_0
-"ERROR in process_expression_list
-No ( was found
-"
-:STRING_function_call_1
-"("
-:STRING_function_call_2
-"PUSH_edi # Prevent overwriting in recursion
-"
-:STRING_function_call_3
-"PUSH_ebp # Protect the old base pointer
-"
-:STRING_function_call_4
-"COPY_esp_to_edi # Copy new base pointer
-"
-:STRING_function_call_6
-"PUSH_eax #_process_expression1
-"
-:STRING_function_call_8
-"PUSH_eax #_process_expression2
-"
-:STRING_function_call_9
-"ERROR in process_expression_list
-No ) was found
-"
-:STRING_function_call_10
-")"
-:STRING_function_call_12
-"LOAD_BASE_ADDRESS_eax %"
-:STRING_function_call_13
-"
-LOAD_INTEGER
-"
-:STRING_function_call_14
-"COPY_edi_to_ebp
-"
-:STRING_function_call_15
-"CALL_eax
-"
-:STRING_function_call_16
-"COPY_edi_to_ebp
-"
-:STRING_function_call_17
-"CALL_IMMEDIATE %FUNCTION_"
-:STRING_function_call_18
-"
-"
-:STRING_function_call_20
-"POP_ebx # _process_expression_locals
-"
-:STRING_function_call_21
-"POP_ebp # Restore old base pointer
-"
-:STRING_function_call_22
-"POP_edi # Prevent overwrite
-"
-:STRING_constant_load_0
-"LOAD_IMMEDIATE_eax %"
-:STRING_constant_load_1
-"
-"
-:STRING_variable_load_1
-"FUNCTION"
-:STRING_variable_load_2
-"("
-:STRING_variable_load_3
-"LOAD_BASE_ADDRESS_eax %"
-:STRING_variable_load_4
-"
-"
-:STRING_variable_load_7
-"="
-:STRING_variable_load_8
-"LOAD_INTEGER
-"
-:STRING_function_load_1
-"("
-:STRING_function_load_2
-"LOAD_IMMEDIATE_eax &FUNCTION_"
-:STRING_function_load_3
-"
-"
-:STRING_global_load_0
-"LOAD_IMMEDIATE_eax &GLOBAL_"
-:STRING_global_load_1
-"
-"
-:STRING_global_load_3
-"="
-:STRING_global_load_4
-"LOAD_INTEGER
-"
-:STRING_primary_expr_failure_0
-"Recieved "
-:STRING_primary_expr_failure_1
-" in primary_expr
-"
-:STRING_primary_expr_string_0
-"LOAD_IMMEDIATE_eax &STRING_"
-:STRING_primary_expr_string_1
-":STRING_"
-:STRING_primary_expr_char_0
-"LOAD_IMMEDIATE_eax %"
-:STRING_primary_expr_char_1
-"
-"
-:STRING_primary_expr_number_0
-"LOAD_IMMEDIATE_eax %"
-:STRING_primary_expr_number_1
-"
-"
-:STRING_primary_expr_variable_5
-" is not a defined symbol
-"
-:STRING_common_recursion_0
-"PUSH_eax #_common_recursion
-"
-:STRING_common_recursion_1
-"POP_ebx # _common_recursion
-"
-:STRING_postfix_expr_arrow_0
-"# looking up offset
-"
-:STRING_postfix_expr_arrow_2
-"# -> offset calculation
-"
-:STRING_postfix_expr_arrow_3
-"LOAD_IMMEDIATE_ebx %"
-:STRING_postfix_expr_arrow_4
-"
-ADD_ebx_to_eax
-"
-:STRING_postfix_expr_arrow_6
-"="
-:STRING_postfix_expr_arrow_7
-"LOAD_INTEGER
-"
-:STRING_postfix_expr_array_0
-"LOAD_INTEGER
-"
-:STRING_postfix_expr_array_2
-"char*"
-:STRING_postfix_expr_array_3
-"LOAD_BYTE
-"
-:STRING_postfix_expr_array_4
-"SAL_eax_Immediate8 !"
-:STRING_postfix_expr_array_5
-"
-"
-:STRING_postfix_expr_array_6
-"ADD_ebx_to_eax
-"
-:STRING_postfix_expr_array_7
-"ERROR in postfix_expr
-Missing ]
-"
-:STRING_postfix_expr_array_8
-"]"
-:STRING_postfix_expr_array_10
-"="
-:STRING_postfix_expr_array_11
-""
-:STRING_unary_expr_sizeof_0
-"ERROR in unary_expr
-Missing (
-"
-:STRING_unary_expr_sizeof_1
-"("
-:STRING_unary_expr_sizeof_2
-"ERROR in unary_expr
-Missing )
-"
-:STRING_unary_expr_sizeof_3
-")"
-:STRING_unary_expr_sizeof_4
-"LOAD_IMMEDIATE_eax %"
-:STRING_unary_expr_sizeof_5
-"
-"
-:STRING_postfix_expr_stub_1
-"["
-:STRING_postfix_expr_stub_3
-"->"
-:STRING_additive_expr_stub_0
-"ADD_ebx_to_eax
-"
-:STRING_additive_expr_stub_1
-"+"
-:STRING_additive_expr_stub_2
-"SUBTRACT_eax_from_ebx_into_ebx
-MOVE_ebx_to_eax
-"
-:STRING_additive_expr_stub_3
-"-"
-:STRING_additive_expr_stub_4
-"MULTIPLY_eax_by_ebx_into_eax
-"
-:STRING_additive_expr_stub_5
-"*"
-:STRING_additive_expr_stub_6
-"XCHG_eax_ebx
-LOAD_IMMEDIATE_edx %0
-DIVIDE_eax_by_ebx_into_eax
-"
-:STRING_additive_expr_stub_7
-"/"
-:STRING_additive_expr_stub_8
-"XCHG_eax_ebx
-LOAD_IMMEDIATE_edx %0
-MODULUS_eax_from_ebx_into_ebx
-MOVE_edx_to_eax
-"
-:STRING_additive_expr_stub_9
-"%"
-:STRING_additive_expr_stub_10
-"COPY_eax_to_ecx
-COPY_ebx_to_eax
-SAL_eax_cl
-"
-:STRING_additive_expr_stub_11
-"<<"
-:STRING_additive_expr_stub_12
-"COPY_eax_to_ecx
-COPY_ebx_to_eax
-SAR_eax_cl
-"
-:STRING_additive_expr_stub_13
-">>"
-:STRING_relational_expr_stub_0
-"CMP
-SETL
-MOVEZBL
-"
-:STRING_relational_expr_stub_1
-"<"
-:STRING_relational_expr_stub_2
-"CMP
-SETLE
-MOVEZBL
-"
-:STRING_relational_expr_stub_3
-"<="
-:STRING_relational_expr_stub_4
-"CMP
-SETGE
-MOVEZBL
-"
-:STRING_relational_expr_stub_5
-">="
-:STRING_relational_expr_stub_6
-"CMP
-SETG
-MOVEZBL
-"
-:STRING_relational_expr_stub_7
-">"
-:STRING_relational_expr_stub_8
-"CMP
-SETE
-MOVEZBL
-"
-:STRING_relational_expr_stub_9
-"=="
-:STRING_relational_expr_stub_10
-"CMP
-SETNE
-MOVEZBL
-"
-:STRING_relational_expr_stub_11
-"!="
-:STRING_bitwise_expr_stub_0
-"AND_eax_ebx
-"
-:STRING_bitwise_expr_stub_1
-"&"
-:STRING_bitwise_expr_stub_2
-"AND_eax_ebx
-"
-:STRING_bitwise_expr_stub_3
-"&&"
-:STRING_bitwise_expr_stub_4
-"OR_eax_ebx
-"
-:STRING_bitwise_expr_stub_5
-"|"
-:STRING_bitwise_expr_stub_6
-"OR_eax_ebx
-"
-:STRING_bitwise_expr_stub_7
-"||"
-:STRING_bitwise_expr_stub_8
-"XOR_ebx_eax_into_eax
-"
-:STRING_bitwise_expr_stub_9
-"^"
-:STRING_primary_expr_1
-"&"
-:STRING_primary_expr_3
-"sizeof"
-:STRING_primary_expr_5
-"LOAD_IMMEDIATE_eax %0
-"
-:STRING_primary_expr_6
-"SUBTRACT_eax_from_ebx_into_ebx
-MOVE_ebx_to_eax
-"
-:STRING_primary_expr_8
-"LOAD_IMMEDIATE_eax %1
-"
-:STRING_primary_expr_9
-"XOR_ebx_eax_into_eax
-"
-:STRING_primary_expr_11
-"Error in Primary expression
-Didn't get )
-"
-:STRING_primary_expr_12
-")"
-:STRING_primary_expr_16
-"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_"
-:STRING_primary_expr_18
-"0123456789"
-:STRING_expression_1
-"="
-:STRING_expression_3
-"]"
-:STRING_expression_4
-"char*"
-:STRING_expression_5
-"STORE_INTEGER
-"
-:STRING_expression_6
-"STORE_CHAR
-"
-:STRING_collect_local_1
-"main"
-:STRING_collect_local_4
-"# Defining local "
-:STRING_collect_local_5
-"
-"
-:STRING_collect_local_7
-"="
-:STRING_collect_local_8
-"ERROR in collect_local
-Missing ;
-"
-:STRING_collect_local_9
-";"
-:STRING_collect_local_10
-"PUSH_eax #"
-:STRING_collect_local_11
-"
-"
-:STRING_process_if_0
-"# IF_"
-:STRING_process_if_1
-"ERROR in process_if
-MISSING (
-"
-:STRING_process_if_2
-"("
-:STRING_process_if_3
-"TEST
-JUMP_EQ %ELSE_"
-:STRING_process_if_4
-"ERROR in process_if
-MISSING )
-"
-:STRING_process_if_5
-")"
-:STRING_process_if_6
-"JUMP %_END_IF_"
-:STRING_process_if_7
-":ELSE_"
-:STRING_process_if_9
-"else"
-:STRING_process_if_10
-":_END_IF_"
-:STRING_process_for_0
-"FOR_END_"
-:STRING_process_for_1
-"# FOR_initialization_"
-:STRING_process_for_2
-"ERROR in process_for
-MISSING (
-"
-:STRING_process_for_3
-"("
-:STRING_process_for_5
-";"
-:STRING_process_for_6
-":FOR_"
-:STRING_process_for_7
-"ERROR in process_for
-MISSING ;1
-"
-:STRING_process_for_8
-";"
-:STRING_process_for_9
-"TEST
-JUMP_EQ %FOR_END_"
-:STRING_process_for_10
-"JUMP %FOR_THEN_"
-:STRING_process_for_11
-":FOR_ITER_"
-:STRING_process_for_12
-"ERROR in process_for
-MISSING ;2
-"
-:STRING_process_for_13
-";"
-:STRING_process_for_14
-"JUMP %FOR_"
-:STRING_process_for_15
-":FOR_THEN_"
-:STRING_process_for_16
-"ERROR in process_for
-MISSING )
-"
-:STRING_process_for_17
-")"
-:STRING_process_for_18
-"JUMP %FOR_ITER_"
-:STRING_process_for_19
-":FOR_END_"
-:STRING_process_asm_0
-"ERROR in process_asm
-MISSING (
-"
-:STRING_process_asm_1
-"("
-:STRING_process_asm_3
-"
-"
-:STRING_process_asm_4
-"ERROR in process_asm
-MISSING )
-"
-:STRING_process_asm_5
-")"
-:STRING_process_asm_6
-"ERROR in process_asm
-MISSING ;
-"
-:STRING_process_asm_7
-";"
-:STRING_process_do_0
-"DO_END_"
-:STRING_process_do_1
-":DO_"
-:STRING_process_do_2
-"ERROR in process_do
-MISSING while
-"
-:STRING_process_do_3
-"while"
-:STRING_process_do_4
-"ERROR in process_do
-MISSING (
-"
-:STRING_process_do_5
-"("
-:STRING_process_do_6
-"ERROR in process_do
-MISSING )
-"
-:STRING_process_do_7
-")"
-:STRING_process_do_8
-"ERROR in process_do
-MISSING ;
-"
-:STRING_process_do_9
-";"
-:STRING_process_do_10
-"TEST
-JUMP_NE %DO_"
-:STRING_process_do_11
-":DO_END_"
-:STRING_process_while_0
-"END_WHILE_"
-:STRING_process_while_1
-":WHILE_"
-:STRING_process_while_2
-"ERROR in process_while
-MISSING (
-"
-:STRING_process_while_3
-"("
-:STRING_process_while_4
-"TEST
-JUMP_EQ %END_WHILE_"
-:STRING_process_while_5
-"# THEN_while_"
-:STRING_process_while_6
-"ERROR in process_while
-MISSING )
-"
-:STRING_process_while_7
-")"
-:STRING_process_while_8
-"JUMP %WHILE_"
-:STRING_process_while_9
-":END_WHILE_"
-:STRING_return_result_1
-"ERROR in return_result
-MISSING ;
-"
-:STRING_return_result_2
-";"
-:STRING_return_result_4
-"POP_ebx # _return_result_locals
-"
-:STRING_return_result_5
-"RETURN
-"
-:STRING_process_break_1
-"Not inside of a loop or case statement"
-:STRING_process_break_4
-"POP_ebx # break_cleanup_locals
-"
-:STRING_process_break_5
-"JUMP %"
-:STRING_process_break_6
-"_"
-:STRING_process_break_7
-"
-"
-:STRING_process_break_8
-"ERROR in break statement
-Missing ;
-"
-:STRING_process_break_9
-";"
-:STRING_recursive_statement_1
-"}"
-:STRING_recursive_statement_3
-"RETURN
-"
-:STRING_recursive_statement_5
-"POP_ebx # _recursive_statement_locals
-"
-:STRING_statement_2
-" #C goto label
-"
-:STRING_statement_4
-"struct"
-:STRING_statement_6
-"if"
-:STRING_statement_8
-"do"
-:STRING_statement_10
-"while"
-:STRING_statement_12
-"for"
-:STRING_statement_14
-"asm"
-:STRING_statement_16
-"goto"
-:STRING_statement_17
-"JUMP %"
-:STRING_statement_18
-"
-"
-:STRING_statement_19
-"ERROR in statement
-Missing ;
-"
-:STRING_statement_20
-";"
-:STRING_statement_22
-"return"
-:STRING_statement_24
-"break"
-:STRING_statement_26
-"continue"
-:STRING_statement_27
-"
-#continue statement
-"
-:STRING_statement_28
-"ERROR in statement
-Missing ;
-"
-:STRING_statement_29
-";"
-:STRING_statement_30
-"ERROR in statement
-MISSING ;
-"
-:STRING_statement_31
-";"
-:STRING_collect_arguments_1
-")"
-:STRING_declare_function_1
-"# Defining function "
-:STRING_declare_function_2
-"
-"
-:STRING_declare_function_3
-":FUNCTION_"
-:STRING_declare_function_4
-"
-"
-:STRING_declare_function_6
-"RETURN
-"
-:STRING_declare_function_7
-"RETURN
-"
-:STRING_program_2
-"CONSTANT"
-:STRING_program_5
-";"
-:STRING_program_6
-":GLOBAL_"
-:STRING_program_7
-"
-NOP
-"
-:STRING_program_9
-"("
-:STRING_program_11
-"="
-:STRING_program_12
-":GLOBAL_"
-:STRING_program_13
-"
-"
-:STRING_program_15
-"0123456789"
-:STRING_program_16
-"%"
-:STRING_program_17
-"
-"
-:STRING_program_19
-"Recieved "
-:STRING_program_20
-" in program
-"
-:STRING_program_21
-"ERROR in Program
-Missing ;
-"
-:STRING_program_22
-";"
-:STRING_program_23
-"Recieved "
-:STRING_program_24
-" in program
-"
-:STRING_main_3
-"-f"
-:STRING_main_4
-"--file"
-:STRING_main_5
-"r"
-:STRING_main_7
-"Unable to open for reading file: "
-:STRING_main_8
-"
- Aborting to avoid problems
-"
-:STRING_main_10
-"-o"
-:STRING_main_11
-"--output"
-:STRING_main_12
-"w"
-:STRING_main_14
-"Unable to open for writing file: "
-:STRING_main_15
-"
- Aborting to avoid problems
-"
-:STRING_main_17
-"-g"
-:STRING_main_18
-"--debug"
-:STRING_main_20
-"-h"
-:STRING_main_21
-"--help"
-:STRING_main_22
-" -f input file
- -o output file
- --help for this message
- --version for file version
-"
-:STRING_main_24
-"-V"
-:STRING_main_25
-"--version"
-:STRING_main_26
-"M2-Planet v1.0.0
-"
-:STRING_main_27
-"UNKNOWN ARGUMENT
-"
-:STRING_main_29
-"STDIN"
-:STRING_main_31
-"Either no input files were given or they were empty
-"
-:STRING_main_32
-"
-# Core program
-"
-:STRING_main_34
-' 0A 3A 45 4C 46 5F 64 61 74 61 0A 00'
-:STRING_main_35
-"
-# Program global variables
-"
-:STRING_main_36
-"
-# Program strings
-"
-:STRING_main_38
-' 0A 3A 45 4C 46 5F 65 6E 64 0A 00'