LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: eiskalteschatten[P]developersnotebook/src/components/Modal.cpp
// Function: Modal::show_error_modal()
void Modal::show_error_modal() {
    #ifdef __APPLE__
        mac_show_error_modal(message, sub_message);
    #else
        GtkWidget *image = gtk_image_new_from_icon_name("dialog-error", GTK_ICON_SIZE_DIALOG);
        gtk_grid_attach(GTK_GRID(main_grid), image, 0, 0, 1, 2);

        GtkDialogFlags flags = GTK_DIALOG_DESTROY_WITH_PARENT;
        GtkWidget *dialog    = gtk_dialog_new_with_buttons("",
                                                           GTK_WINDOW(parent_window),
                                                           flags,
                                                           "OK",
                                                           GTK_RESPONSE_OK,
                                                           NULL);

        gtk_container_set_border_width(GTK_CONTAINER(dialog), 10);

        GtkWidget *content_area = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
        gtk_box_pack_start(GTK_BOX(content_area), main_grid, TRUE, FALSE, 0);
        gtk_widget_show_all(dialog);

        gtk_dialog_run(GTK_DIALOG(dialog));
        gtk_widget_destroy(dialog);
    #endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq 0x258c(%rip), %rdi      # 0x54a47
movl $0x6, %esi
callq 0xac70
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, -0x10(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x60(%rbp)
callq 0xac20
movq -0x60(%rbp), %rdi
movq %rax, %rsi
callq 0xa190
movq %rax, %rdi
movq -0x10(%rbp), %rsi
xorl %ecx, %ecx
movl $0x1, %r8d
movl $0x2, %r9d
movl %ecx, %edx
callq 0xad40
movq -0x38(%rbp), %rax
movl $0x2, -0x14(%rbp)
movq (%rax), %rax
movq %rax, -0x58(%rbp)
callq 0xb270
movq -0x58(%rbp), %rdi
movq %rax, %rsi
callq 0xa190
movq %rax, %rsi
movl -0x14(%rbp), %edx
leaq 0x16f0(%rip), %rdi      # 0x53c25
leaq 0x2518(%rip), %rcx      # 0x54a54
movl $0xfffffffb, %r8d       # imm = 0xFFFFFFFB
xorl %eax, %eax
movl %eax, %r9d
movb $0x0, %al
callq 0xaa10
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
callq 0xac10
movq -0x50(%rbp), %rdi
movq %rax, %rsi
callq 0xa190
movq %rax, %rdi
movl $0xa, %esi
callq 0xb350
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
callq 0xaac0
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0xa190
movq %rax, %rdi
callq 0xa040
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
callq 0xab50
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0xa190
movq %rax, %rdi
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rsi
movl $0x1, %edx
xorl %r8d, %r8d
movl %r8d, %ecx
callq 0xa340
movq -0x20(%rbp), %rdi
callq 0xaf30
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0xaac0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0xa190
movq %rax, %rdi
callq 0xa480
movq -0x20(%rbp), %rdi
callq 0xa250
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: martinda3[P]Compiler/src/ASreturnState.cpp
// Function: toyc::ASreturnState::toString[abi:cxx11]()
std::string ASreturnState::toString()
	{
		if (hasop)
		{
			s = (spaces() + "returnStatement(\n");
			indent();
			s += (op->toString() + "\n");
			outdent();
			s += (spaces() +  ")\n");
			return s;
		}
		else
		{
			return (spaces() + "returnStatement()\n");
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp            # imm = 0x140
movq %rdi, -0x118(%rbp)
movq %rdi, %rax
movq %rax, -0x110(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x108(%rbp)
testb $0x1, 0x38(%rax)
je 0xcb6f
leaq -0x50(%rbp), %rdi
movq %rdi, -0x120(%rbp)
callq 0x1bce0
movq -0x120(%rbp), %rsi
leaq 0x2663d(%rip), %rdx     # 0x33004
leaq -0x30(%rbp), %rdi
callq 0xcc00
jmp 0xc9d2
movq -0x108(%rbp), %rdi
addq $0x18, %rdi
leaq -0x30(%rbp), %rsi
movq %rsi, -0x130(%rbp)
callq 0x9420
movq -0x130(%rbp), %rdi
callq 0x9658
leaq -0x50(%rbp), %rdi
callq 0x9658
callq 0x1bd10
movq -0x108(%rbp), %rax
movq 0x10(%rax), %rsi
movq (%rsi), %rax
movq (%rax), %rax
leaq -0xa0(%rbp), %rdi
movq %rdi, -0x128(%rbp)
callq *%rax
movq -0x128(%rbp), %rsi
leaq 0x275b4(%rip), %rdx     # 0x33fea
leaq -0x80(%rbp), %rdi
callq 0xcc00
jmp 0xca41
movq -0x108(%rbp), %rdi
addq $0x18, %rdi
leaq -0x80(%rbp), %rsi
callq 0x9450
jmp 0xca57
leaq -0x80(%rbp), %rdi
callq 0x9658
leaq -0xa0(%rbp), %rdi
callq 0x9658
callq 0x1bd30
leaq -0xe0(%rbp), %rdi
movq %rdi, -0x138(%rbp)
callq 0x1bce0
movq -0x138(%rbp), %rsi
leaq 0x26594(%rip), %rdx     # 0x33026
leaq -0xc0(%rbp), %rdi
callq 0xcc00
jmp 0xcaa0
movq -0x108(%rbp), %rdi
addq $0x18, %rdi
leaq -0xc0(%rbp), %rsi
callq 0x9450
jmp 0xcab9
leaq -0xc0(%rbp), %rdi
callq 0x9658
leaq -0xe0(%rbp), %rdi
callq 0x9658
movq -0x108(%rbp), %rsi
movq -0x118(%rbp), %rdi
addq $0x18, %rsi
callq 0x9170
jmp 0xcbc6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x9658
jmp 0xcbd6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0xcb2a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x9658
leaq -0xa0(%rbp), %rdi
callq 0x9658
jmp 0xcbd6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0xcb61
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0xc0(%rbp), %rdi
callq 0x9658
leaq -0xe0(%rbp), %rdi
callq 0x9658
jmp 0xcbd6
leaq -0x100(%rbp), %rdi
movq %rdi, -0x140(%rbp)
callq 0x1bce0
movq -0x118(%rbp), %rdi
movq -0x140(%rbp), %rsi
leaq 0x2647f(%rip), %rdx     # 0x33016
callq 0xcc00
jmp 0xcb9e
leaq -0x100(%rbp), %rdi
callq 0x9658
jmp 0xcbc6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x100(%rbp), %rdi
callq 0x9658
jmp 0xcbd6
movq -0x110(%rbp), %rax
addq $0x140, %rsp            # imm = 0x140
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x95b0
nop
// File: martinda3[P]Compiler/src/ASifState.cpp
// Function: toyc::ASifState::ASifState(toyc::ASexpression*, toyc::ASstatement*, toyc::ASstatement*)
ASifState::ASifState(ASexpression* oper1, ASstatement* oper2, ASstatement* oper3)
	{
		op1 = oper1;
		op2 = oper2;
		op3 = oper3;
		hasop = true;
		setType(IFstate);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x1ed40
movq -0x38(%rbp), %rdi
leaq 0x35db8(%rip), %rax     # 0x42a38
movq %rax, (%rdi)
addq $0x28, %rdi
movq %rdi, -0x40(%rbp)
callq 0x9480
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, 0x10(%rdi)
movq -0x18(%rbp), %rax
movq %rax, 0x18(%rdi)
movq -0x20(%rbp), %rax
movq %rax, 0x20(%rdi)
movb $0x1, 0x48(%rdi)
movl $0x3, %esi
callq 0x1ed80
jmp 0xccbc
addq $0x40, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x9658
movq -0x28(%rbp), %rdi
callq 0x95b0
// File: martinda3[P]Compiler/src/ASifState.cpp
// Function: toyc::ASifState::ASifState(toyc::ASexpression*, toyc::ASstatement*)
ASifState::ASifState(ASexpression* oper1, ASstatement* oper2)
	{
		op1 = oper1;
		op2 = oper2;
		hasop = false;
		setType(IFstate);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x1ed40
movq -0x30(%rbp), %rdi
leaq 0x35d2c(%rip), %rax     # 0x42a38
movq %rax, (%rdi)
addq $0x28, %rdi
movq %rdi, -0x38(%rbp)
callq 0x9480
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, 0x10(%rdi)
movq -0x18(%rbp), %rax
movq %rax, 0x18(%rdi)
movb $0x0, 0x48(%rdi)
movl $0x3, %esi
callq 0x1ed80
jmp 0xcd40
addq $0x40, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x9658
movq -0x20(%rbp), %rdi
callq 0x95b0
nopw %cs:(%rax,%rax)
// File: martinda3[P]Compiler/src/TCparser.cpp
// Function: toyc::TCparser::program()
ASprogram* TCparser::program()
	{
		enteringDEBUG("Program");   //  Need to call DefinitionList to recirsivly repeat
		ASdefinition* definitionList[MAX_STATEMENTS];
		symTable = new TCsymTable();
		int num = DefinitionList(definitionList, 0);
		exitingDEBUG("Program");
		return new ASprog(inputFileName, definitionList, num);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1060, %rsp           # imm = 0x1060
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1048(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x1040(%rbp)
callq 0x95c0
movq -0x1040(%rbp), %rdx
leaq 0x25bec(%rip), %rsi     # 0x33164
leaq -0x28(%rbp), %rdi
callq 0x13550
jmp 0xd583
leaq -0x28(%rbp), %rdi
callq 0xd790
jmp 0xd58e
leaq -0x28(%rbp), %rdi
callq 0x9658
leaq -0x29(%rbp), %rdi
callq 0x93b0
movl $0x328, %edi            # imm = 0x328
callq 0x9350
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x1050(%rbp)
callq 0x317a0
jmp 0xd5be
movq -0x1048(%rbp), %rdi
movq -0x1050(%rbp), %rcx
leaq 0x3808d(%rip), %rax     # 0x45660
movq %rcx, (%rax)
leaq -0xfe0(%rbp), %rsi
xorl %edx, %edx
callq 0xdbb0
movl %eax, -0xfe4(%rbp)
leaq -0x1009(%rbp), %rdi
movq %rdi, -0x1058(%rbp)
callq 0x95c0
movq -0x1058(%rbp), %rdx
leaq 0x25b59(%rip), %rsi     # 0x33164
leaq -0x1008(%rbp), %rdi
callq 0x13550
jmp 0xd619
leaq -0x1008(%rbp), %rdi
callq 0xda50
jmp 0xd627
leaq -0x1008(%rbp), %rdi
callq 0x9658
leaq -0x1009(%rbp), %rdi
callq 0x93b0
movl $0xfd8, %edi            # imm = 0xFD8
callq 0x9350
movq %rax, -0x1060(%rbp)
movb $0x1, -0x1031(%rbp)
leaq 0x37f82(%rip), %rsi     # 0x455e0
leaq -0x1030(%rbp), %rdi
callq 0x9170
jmp 0xd66c
movq -0x1060(%rbp), %rdi
movl -0xfe4(%rbp), %ecx
leaq -0x1030(%rbp), %rsi
leaq -0xfe0(%rbp), %rdx
callq 0x2e2b0
jmp 0xd68e
movb $0x0, -0x1031(%rbp)
leaq -0x1030(%rbp), %rdi
callq 0x9658
movq -0x1060(%rbp), %rax
addq $0x1060, %rsp           # imm = 0x1060
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0xd6d4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x9658
leaq -0x29(%rbp), %rdi
callq 0x93b0
jmp 0xd779
movq -0x1050(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
movl $0x328, %esi            # imm = 0x328
callq 0x9360
jmp 0xd779
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0xd727
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x1008(%rbp), %rdi
callq 0x9658
leaq -0x1009(%rbp), %rdi
callq 0x93b0
jmp 0xd779
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0xd75b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x1030(%rbp), %rdi
callq 0x9658
testb $0x1, -0x1031(%rbp)
jne 0xd766
jmp 0xd777
movq -0x1060(%rbp), %rdi
movl $0xfd8, %esi            # imm = 0xFD8
callq 0x9360
jmp 0xd779
movq -0x38(%rbp), %rdi
callq 0x95b0
nopw %cs:(%rax,%rax)
// File: martinda3[P]Compiler/src/TCparser.cpp
// Function: toyc::TCparser::DefinitionList(toyc::ASdefinition**, int)
int TCparser::DefinitionList(ASdefinition* l[], int n)
	{
		int num = 0;

		enteringDEBUG("Definition List");
		if (!(buff->getTokenType() == EOFILE))
		{
			l[n] = Definition();
			num = DefinitionList(l, n + 1);
		}
		else
		{
			num = n;
		}
		exitingDEBUG("Definition List");
		return num;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x88(%rbp)
movl $0x0, -0x18(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x95c0
movq -0x80(%rbp), %rdx
leaq 0x2557c(%rip), %rsi     # 0x3316c
leaq -0x38(%rbp), %rdi
callq 0x13550
jmp 0xdbfb
leaq -0x38(%rbp), %rdi
callq 0xd790
jmp 0xdc06
leaq -0x38(%rbp), %rdi
callq 0x9658
leaq -0x39(%rbp), %rdi
callq 0x93b0
movq -0x88(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1be60
cmpl $0x2d, %eax
je 0xdc94
movq -0x88(%rbp), %rdi
callq 0xdd30
movq -0x88(%rbp), %rdi
movq %rax, %rdx
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
addl $0x1, %edx
callq 0xdbb0
movl %eax, -0x18(%rbp)
jmp 0xdc9a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0xdc86
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x9658
leaq -0x39(%rbp), %rdi
callq 0x93b0
jmp 0xdd18
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
leaq -0x71(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x95c0
movq -0x90(%rbp), %rdx
leaq 0x254b4(%rip), %rsi     # 0x3316c
leaq -0x70(%rbp), %rdi
callq 0x13550
jmp 0xdcc3
leaq -0x70(%rbp), %rdi
callq 0xda50
jmp 0xdcce
leaq -0x70(%rbp), %rdi
callq 0x9658
leaq -0x71(%rbp), %rdi
callq 0x93b0
movl -0x18(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0xdd0f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x9658
leaq -0x71(%rbp), %rdi
callq 0x93b0
movq -0x48(%rbp), %rdi
callq 0x95b0
nopw %cs:(%rax,%rax)
// File: martinda3[P]Compiler/src/TCparser.cpp
// Function: toyc::TCparser::accept(int)
TCtoken* TCparser::accept(int t)
	{
		TCtoken *token; 
		std::string name;
		if (t == buff->getTokenType())
		{
			token = buff;
			name = token->getLexeme();
//			if (v_parser) {tokenDEBUG(name);}
			buff = scanner->getToken();
			return token;
		}
		else { throw t; }
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x9480
movq -0x78(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, -0x70(%rbp)
movq 0x8(%rax), %rdi
callq 0x1be60
movl %eax, -0x6c(%rbp)
jmp 0xe6ab
movl -0x70(%rbp), %eax
movl -0x6c(%rbp), %ecx
cmpl %ecx, %eax
jne 0xe74d
movq -0x78(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x1be70
jmp 0xe6d4
leaq -0x38(%rbp), %rdi
leaq -0x68(%rbp), %rsi
movq %rsi, -0x88(%rbp)
callq 0x9420
movq -0x88(%rbp), %rdi
callq 0x9658
movq -0x78(%rbp), %rax
movq (%rax), %rdi
callq 0x14a60
movq %rax, -0x80(%rbp)
jmp 0xe706
movq -0x78(%rbp), %rax
movq -0x80(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x9658
movq -0x90(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x9658
jmp 0xe771
movl $0x4, %edi
callq 0x91b0
movq %rax, %rdi
movl -0xc(%rbp), %eax
movl %eax, (%rdi)
movq 0x36832(%rip), %rsi     # 0x44f98
xorl %eax, %eax
movl %eax, %edx
callq 0x9580
jmp 0xe77a
movq -0x40(%rbp), %rdi
callq 0x95b0
nopw (%rax,%rax)
// File: martinda3[P]Compiler/src/TCparser.cpp
// Function: toyc::TCparser::FunctionDefinition(toyc::ASdefinition**, int*)
ASstatement* TCparser::FunctionDefinition(ASdefinition* list[], int* i) // DONE NEED TO TEST MORE
	{
		// FunctionDefinition  --> FunctionHeader FunctionBody
		enteringDEBUG("Function Definition");
		ASstatement* operand = NULL;
		*i = FunctionHeader(list);
		operand = FunctionBody();
		exitingDEBUG("Function Definition");
		return operand;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x95c0
movq -0x88(%rbp), %rdx
leaq 0x249eb(%rip), %rsi     # 0x331ab
leaq -0x38(%rbp), %rdi
callq 0x13550
jmp 0xe7cb
leaq -0x38(%rbp), %rdi
callq 0xd790
jmp 0xe7d6
leaq -0x38(%rbp), %rdi
callq 0x9658
leaq -0x39(%rbp), %rdi
callq 0x93b0
movq -0x90(%rbp), %rdi
movq $0x0, -0x58(%rbp)
movq -0x10(%rbp), %rsi
callq 0xe8d0
movq -0x90(%rbp), %rdi
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
callq 0xebd0
movq %rax, -0x58(%rbp)
leaq -0x79(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x95c0
movq -0x98(%rbp), %rdx
leaq 0x24975(%rip), %rsi     # 0x331ab
leaq -0x78(%rbp), %rdi
callq 0x13550
jmp 0xe841
leaq -0x78(%rbp), %rdi
callq 0xda50
jmp 0xe84c
leaq -0x78(%rbp), %rdi
callq 0x9658
leaq -0x79(%rbp), %rdi
callq 0x93b0
movq -0x58(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0xe88e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x9658
leaq -0x39(%rbp), %rdi
callq 0x93b0
jmp 0xe8c5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0xe8bc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x9658
leaq -0x79(%rbp), %rdi
callq 0x93b0
movq -0x48(%rbp), %rdi
callq 0x95b0
nop
// File: martinda3[P]Compiler/src/TCparser.cpp
// Function: toyc::TCparser::FunctionBody()
ASstatement* TCparser::FunctionBody()  // DONE NEED TO TEST MORE
	{
		// FunctionBody --> CompoundStatement
		enteringDEBUG("Function Body");
		ASstatement* operand = NULL;
		operand = CompoundStatement();
		//CompoundStatement();
		exitingDEBUG("Function Body");
		return operand;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x95c0
movq -0x78(%rbp), %rdx
leaq 0x245e5(%rip), %rsi     # 0x331e4
leaq -0x28(%rbp), %rdi
callq 0x13550
jmp 0xec0a
leaq -0x28(%rbp), %rdi
callq 0xd790
jmp 0xec15
leaq -0x28(%rbp), %rdi
callq 0x9658
leaq -0x29(%rbp), %rdi
callq 0x93b0
movq -0x80(%rbp), %rdi
movq $0x0, -0x48(%rbp)
callq 0xf5e0
movq %rax, -0x48(%rbp)
leaq -0x69(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x95c0
movq -0x88(%rbp), %rdx
leaq 0x2458a(%rip), %rsi     # 0x331e4
leaq -0x68(%rbp), %rdi
callq 0x13550
jmp 0xec65
leaq -0x68(%rbp), %rdi
callq 0xda50
jmp 0xec70
leaq -0x68(%rbp), %rdi
callq 0x9658
leaq -0x69(%rbp), %rdi
callq 0x93b0
movq -0x48(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0xecb2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x9658
leaq -0x29(%rbp), %rdi
callq 0x93b0
jmp 0xece9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0xece0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x9658
leaq -0x69(%rbp), %rdi
callq 0x93b0
movq -0x38(%rbp), %rdi
callq 0x95b0
nopw %cs:(%rax,%rax)
// File: martinda3[P]Compiler/src/TCparser.cpp
// Function: toyc::TCparser::ExpressionStatement()
ASstatement* TCparser::ExpressionStatement() // WIP
	{
		// ExpressionStatement --> Expression
		enteringDEBUG("Expression Statement");
		ASexpression* operand = NULL;
		operand = Expression();
		exitingDEBUG("Expression Statement");
		accept(SEMICOLON);
		return new ASexprState(operand);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x95c0
movq -0x78(%rbp), %rdx
leaq 0x23563(%rip), %rsi     # 0x33272
leaq -0x28(%rbp), %rdi
callq 0x13550
jmp 0xfd1a
leaq -0x28(%rbp), %rdi
callq 0xd790
jmp 0xfd25
leaq -0x28(%rbp), %rdi
callq 0x9658
leaq -0x29(%rbp), %rdi
callq 0x93b0
movq -0x80(%rbp), %rdi
movq $0x0, -0x48(%rbp)
callq 0xfe60
movq %rax, -0x48(%rbp)
leaq -0x69(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x95c0
movq -0x88(%rbp), %rdx
leaq 0x23508(%rip), %rsi     # 0x33272
leaq -0x68(%rbp), %rdi
callq 0x13550
jmp 0xfd75
leaq -0x68(%rbp), %rdi
callq 0xda50
jmp 0xfd80
leaq -0x68(%rbp), %rdi
callq 0x9658
leaq -0x69(%rbp), %rdi
callq 0x93b0
movq -0x80(%rbp), %rdi
movl $0x27, %esi
callq 0xe670
movl $0x38, %edi
callq 0x9350
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x90(%rbp)
movq -0x48(%rbp), %rsi
callq 0x1fa20
jmp 0xfdc2
movq -0x90(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0xfdf5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x9658
leaq -0x29(%rbp), %rdi
callq 0x93b0
jmp 0xfe4b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0xfe23
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x9658
leaq -0x69(%rbp), %rdi
callq 0x93b0
jmp 0xfe4b
movq -0x90(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
movl $0x38, %esi
callq 0x9360
movq -0x38(%rbp), %rdi
callq 0x95b0
nopw %cs:(%rax,%rax)
// File: martinda3[P]Compiler/src/TCparser.cpp
// Function: toyc::TCparser::Statement()
ASstatement* TCparser::Statement() // WIP
	{
		/* Statement --> ExpressionStatement
					   | BreakStatement
					   | CompoundStatement
					   | IfStatement
					   | NullStatement
					   | ReturnStatement
					   | WhileStatement
					   | ReadStatement
					   | WriteStatement
					   | NewLineStatement */
		ASstatement* operand = NULL;
		switch (buff->getTokenType())
		{
			case BREAK:
				operand = BreakStatement();
				break;

			case SEMICOLON:
				operand = NullStatement();
				break;

			case IF:
				operand = IfStatement();
				break;

			case RETURN:
				operand = ReturnStatement();
				break;

			case WHILE:
				operand = WhileStatement();
				break;

			case READ:
				operand = ReadStatement();
				break;

			case WRITE:
				operand = WriteStatement();
				break;

			case NEWLINE:
				operand = NewLineStatement();
				break;

			case LCURLY:
				operand = CompoundStatement();
				break;

			default:
				operand = ExpressionStatement();
				break;
		}
		return operand;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x10(%rbp)
movq 0x8(%rax), %rdi
callq 0x1be60
decl %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x26, %eax
ja 0x10344
movq -0x18(%rbp), %rax
leaq 0x22db3(%rip), %rcx     # 0x33064
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x20(%rbp), %rdi
callq 0x10780
movq %rax, -0x10(%rbp)
jmp 0x10351
movq -0x20(%rbp), %rdi
callq 0x108f0
movq %rax, -0x10(%rbp)
jmp 0x10351
movq -0x20(%rbp), %rdi
callq 0x10360
movq %rax, -0x10(%rbp)
jmp 0x10351
movq -0x20(%rbp), %rdi
callq 0x10a50
movq %rax, -0x10(%rbp)
jmp 0x10351
movq -0x20(%rbp), %rdi
callq 0x10d40
movq %rax, -0x10(%rbp)
jmp 0x10351
movq -0x20(%rbp), %rdi
callq 0x10f00
movq %rax, -0x10(%rbp)
jmp 0x10351
movq -0x20(%rbp), %rdi
callq 0x115c0
movq %rax, -0x10(%rbp)
jmp 0x10351
movq -0x20(%rbp), %rdi
callq 0x117c0
movq %rax, -0x10(%rbp)
jmp 0x10351
movq -0x20(%rbp), %rdi
callq 0xf5e0
movq %rax, -0x10(%rbp)
jmp 0x10351
movq -0x20(%rbp), %rdi
callq 0xfce0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: martinda3[P]Compiler/src/TCparser.cpp
// Function: toyc::TCparser::BreakStatement()
ASstatement* TCparser::BreakStatement() // DONE NEED TO TEST
	{
		// BreakStatement --> BREAK SEMICOLON
		enteringDEBUG("Break Statement");
		accept(BREAK);
		accept(SEMICOLON);
		exitingDEBUG("Break Statement");
		return new ASbreakState();
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x95c0
movq -0x70(%rbp), %rdx
leaq 0x22b35(%rip), %rsi     # 0x332e4
leaq -0x28(%rbp), %rdi
callq 0x13550
jmp 0x107ba
leaq -0x28(%rbp), %rdi
callq 0xd790
jmp 0x107c5
leaq -0x28(%rbp), %rdi
callq 0x9658
leaq -0x29(%rbp), %rdi
callq 0x93b0
movq -0x78(%rbp), %rdi
movl $0xb, %esi
callq 0xe670
movq -0x78(%rbp), %rdi
movl $0x27, %esi
callq 0xe670
leaq -0x61(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x95c0
movq -0x80(%rbp), %rdx
leaq 0x22ad9(%rip), %rsi     # 0x332e4
leaq -0x60(%rbp), %rdi
callq 0x13550
jmp 0x10816
leaq -0x60(%rbp), %rdi
callq 0xda50
jmp 0x10821
leaq -0x60(%rbp), %rdi
callq 0x9658
leaq -0x61(%rbp), %rdi
callq 0x93b0
movl $0x10, %edi
callq 0x9350
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x88(%rbp)
callq 0x1d0f0
jmp 0x10851
movq -0x88(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x10884
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x9658
leaq -0x29(%rbp), %rdi
callq 0x93b0
jmp 0x108da
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x108b2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x9658
leaq -0x61(%rbp), %rdi
callq 0x93b0
jmp 0x108da
movq -0x88(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
movl $0x10, %esi
callq 0x9360
movq -0x38(%rbp), %rdi
callq 0x95b0
nopw %cs:(%rax,%rax)
// File: martinda3[P]Compiler/src/TCparser.cpp
// Function: toyc::TCparser::NullStatement()
ASstatement* TCparser::NullStatement() // DONE NEED TO TEST
	{
		// SEMICOLON
		enteringDEBUG("Null Statement");
		exitingDEBUG("Null Statement");
		accept(SEMICOLON);
		return new ASnullState();
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x95c0
movq -0x70(%rbp), %rdx
leaq 0x229d5(%rip), %rsi     # 0x332f4
leaq -0x28(%rbp), %rdi
callq 0x13550
jmp 0x1092a
leaq -0x28(%rbp), %rdi
callq 0xd790
jmp 0x10935
leaq -0x28(%rbp), %rdi
callq 0x9658
leaq -0x29(%rbp), %rdi
callq 0x93b0
leaq -0x61(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x95c0
movq -0x80(%rbp), %rdx
leaq 0x22995(%rip), %rsi     # 0x332f4
leaq -0x60(%rbp), %rdi
callq 0x13550
jmp 0x1096a
leaq -0x60(%rbp), %rdi
callq 0xda50
jmp 0x10975
leaq -0x60(%rbp), %rdi
callq 0x9658
leaq -0x61(%rbp), %rdi
callq 0x93b0
movq -0x78(%rbp), %rdi
movl $0x27, %esi
callq 0xe670
movl $0x10, %edi
callq 0x9350
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x88(%rbp)
callq 0x1d1a0
jmp 0x109b3
movq -0x88(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x109e6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x9658
leaq -0x29(%rbp), %rdi
callq 0x93b0
jmp 0x10a3c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x10a14
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x9658
leaq -0x61(%rbp), %rdi
callq 0x93b0
jmp 0x10a3c
movq -0x88(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
movl $0x10, %esi
callq 0x9360
movq -0x38(%rbp), %rdi
callq 0x95b0
nopw %cs:(%rax,%rax)
// File: martinda3[P]Compiler/src/TCparser.cpp
// Function: toyc::TCparser::WhileStatement()
ASstatement* TCparser::WhileStatement() // Testing
	{
		// WHILE LPAREN Expression RPAREN Statement
		enteringDEBUG("While Statement");
		ASexpression* operand = NULL;
		ASstatement* operand2 = NULL;
		accept(WHILE);
		accept(LPAREN);
		operand = Expression();
		accept(RPAREN);
		operand2 = Statement();
		exitingDEBUG("While Statement");
		return new ASwhileState(operand, operand2);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x95c0
movq -0x80(%rbp), %rdx
leaq 0x225a2(%rip), %rsi     # 0x33314
leaq -0x28(%rbp), %rdi
callq 0x13550
jmp 0x10d7d
leaq -0x28(%rbp), %rdi
callq 0xd790
jmp 0x10d88
leaq -0x28(%rbp), %rdi
callq 0x9658
leaq -0x29(%rbp), %rdi
callq 0x93b0
movq -0x88(%rbp), %rdi
movq $0x0, -0x48(%rbp)
movq $0x0, -0x50(%rbp)
movl $0x8, %esi
callq 0xe670
movq -0x88(%rbp), %rdi
movl $0x1e, %esi
callq 0xe670
movq -0x88(%rbp), %rdi
callq 0xfe60
movq -0x88(%rbp), %rdi
movq %rax, -0x48(%rbp)
movl $0x1f, %esi
callq 0xe670
movq -0x88(%rbp), %rdi
callq 0x10270
movq %rax, -0x50(%rbp)
leaq -0x71(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x95c0
movq -0x90(%rbp), %rdx
leaq 0x224f9(%rip), %rsi     # 0x33314
leaq -0x70(%rbp), %rdi
callq 0x13550
jmp 0x10e26
leaq -0x70(%rbp), %rdi
callq 0xda50
jmp 0x10e31
leaq -0x70(%rbp), %rdi
callq 0x9658
leaq -0x71(%rbp), %rdi
callq 0x93b0
movl $0x20, %edi
callq 0x9350
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x98(%rbp)
movq -0x48(%rbp), %rsi
movq -0x50(%rbp), %rdx
callq 0x1db20
jmp 0x10e69
movq -0x98(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x10e9c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x9658
leaq -0x29(%rbp), %rdi
callq 0x93b0
jmp 0x10ef2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x10eca
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x9658
leaq -0x71(%rbp), %rdi
callq 0x93b0
jmp 0x10ef2
movq -0x98(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
movl $0x20, %esi
callq 0x9360
movq -0x38(%rbp), %rdi
callq 0x95b0
nopl (%rax,%rax)
// File: martinda3[P]Compiler/src/TCparser.cpp
// Function: toyc::TCparser::WriteStatement()
ASstatement* TCparser::WriteStatement() // WIP
	{
		// WriteStatement -> WRITE LPAREN ActualParameters RPAREN SEMICOLON
		enteringDEBUG("Write Statement");
		ASexpression* operand = NULL;
		ASexpression* operand2[MAX_STATEMENTS];
		accept(WRITE);
        enter_special_id(symTable,WRITE);
		accept(LPAREN);
		operand = ActualParameters();
		operand2[0] = operand;
		accept(RPAREN);
		exitingDEBUG("Write Statement");
		accept(SEMICOLON);
		return new ASwriteState(operand2, 1);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1040, %rsp           # imm = 0x1040
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1028(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x1020(%rbp)
callq 0x95c0
movq -0x1020(%rbp), %rdx
leaq 0x21d8f(%rip), %rsi     # 0x33387
leaq -0x28(%rbp), %rdi
callq 0x13550
jmp 0x11603
leaq -0x28(%rbp), %rdi
callq 0xd790
jmp 0x1160e
leaq -0x28(%rbp), %rdi
callq 0x9658
leaq -0x29(%rbp), %rdi
callq 0x93b0
movq -0x1028(%rbp), %rdi
movq $0x0, -0x48(%rbp)
movl $0xc, %esi
movl %esi, -0x1034(%rbp)
callq 0xe670
movl -0x1034(%rbp), %esi
leaq 0x34014(%rip), %rax     # 0x45660
movq (%rax), %rdi
callq 0x11930
movq -0x1028(%rbp), %rdi
movl $0x1e, %esi
callq 0xe670
movq -0x1028(%rbp), %rdi
callq 0x11a60
movq -0x1028(%rbp), %rdi
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0xff0(%rbp)
movl $0x1f, %esi
callq 0xe670
leaq -0x1011(%rbp), %rdi
movq %rdi, -0x1030(%rbp)
callq 0x95c0
movq -0x1030(%rbp), %rdx
leaq 0x21cd5(%rip), %rsi     # 0x33387
leaq -0x1010(%rbp), %rdi
callq 0x13550
jmp 0x116c0
leaq -0x1010(%rbp), %rdi
callq 0xda50
jmp 0x116ce
leaq -0x1010(%rbp), %rdi
callq 0x9658
leaq -0x1011(%rbp), %rdi
callq 0x93b0
movq -0x1028(%rbp), %rdi
movl $0x27, %esi
callq 0xe670
movl $0xfb8, %edi            # imm = 0xFB8
callq 0x9350
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x1040(%rbp)
leaq -0xff0(%rbp), %rsi
movl $0x1, %edx
callq 0x1e570
jmp 0x11721
movq -0x1040(%rbp), %rax
addq $0x1040, %rsp           # imm = 0x1040
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x11754
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x9658
leaq -0x29(%rbp), %rdi
callq 0x93b0
jmp 0x117b0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x11785
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x1010(%rbp), %rdi
callq 0x9658
leaq -0x1011(%rbp), %rdi
callq 0x93b0
jmp 0x117b0
movq -0x1040(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
movl $0xfb8, %esi            # imm = 0xFB8
callq 0x9360
movq -0x38(%rbp), %rdi
callq 0x95b0
nopl (%rax)
// File: martinda3[P]Compiler/src/TCparser.cpp
// Function: toyc::TCparser::NewLineStatement()
ASstatement* TCparser::NewLineStatement() // WIP
	{
		// NewLineStatement --> NEWLINE SEMICOLON
		enteringDEBUG("NewLine Statement");
		accept(NEWLINE);
		exitingDEBUG("NewLine Statement");
		accept(SEMICOLON);
		return new ASnewLineState();
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x95c0
movq -0x70(%rbp), %rdx
leaq 0x21ba8(%rip), %rsi     # 0x33397
leaq -0x28(%rbp), %rdi
callq 0x13550
jmp 0x117fa
leaq -0x28(%rbp), %rdi
callq 0xd790
jmp 0x11805
leaq -0x28(%rbp), %rdi
callq 0x9658
leaq -0x29(%rbp), %rdi
callq 0x93b0
movq -0x78(%rbp), %rdi
movl $0xf, %esi
callq 0xe670
leaq -0x61(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x95c0
movq -0x80(%rbp), %rdx
leaq 0x21b5a(%rip), %rsi     # 0x33397
leaq -0x60(%rbp), %rdi
callq 0x13550
jmp 0x11848
leaq -0x60(%rbp), %rdi
callq 0xda50
jmp 0x11853
leaq -0x60(%rbp), %rdi
callq 0x9658
leaq -0x61(%rbp), %rdi
callq 0x93b0
movq -0x78(%rbp), %rdi
movl $0x27, %esi
callq 0xe670
movl $0x10, %edi
callq 0x9350
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x88(%rbp)
callq 0x1fcd0
jmp 0x11891
movq -0x88(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x118c4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x9658
leaq -0x29(%rbp), %rdi
callq 0x93b0
jmp 0x1191a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x118f2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x9658
leaq -0x61(%rbp), %rdi
callq 0x93b0
jmp 0x1191a
movq -0x88(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
movl $0x10, %esi
callq 0x9360
movq -0x38(%rbp), %rdi
callq 0x95b0
nopw %cs:(%rax,%rax)
// File: martinda3[P]Compiler/src/TCparser.cpp
// Function: toyc::enter_special_id(toyc::TCsymTable*, toyc::tokens)
static void enter_special_id(TCsymTable *st,tokens type) {
	    int offffset;
        TCsymbol *sym = new TCsymbol();
        sym->setType(OFFSET);
        sym->setId((type==READ)?"System.in":"System.out");
        offffset = _nextOffset;
        sym->setOffset(offffset);
        sym->getNextOffset();
        st->add(sym);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x48, %edi
callq 0x9350
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x58(%rbp)
callq 0x1fd80
jmp 0x1195a
movq -0x58(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movl $0x2, %esi
callq 0x1ff10
movq -0x18(%rbp), %rax
movq %rax, -0x70(%rbp)
movl -0xc(%rbp), %eax
subl $0x7, %eax
leaq 0x21b56(%rip), %rcx     # 0x334db
leaq 0x21b59(%rip), %rax     # 0x334e5
cmoveq %rcx, %rax
movq %rax, -0x68(%rbp)
leaq -0x49(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x95c0
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rdx
leaq -0x48(%rbp), %rdi
callq 0x13550
jmp 0x119b4
movq -0x70(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x1fed0
jmp 0x119c3
leaq -0x48(%rbp), %rdi
callq 0x9658
leaq -0x49(%rbp), %rdi
callq 0x93b0
leaq 0x33970(%rip), %rax     # 0x4534c
movl (%rax), %eax
movl %eax, -0x10(%rbp)
movq -0x18(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0x1ffd0
movq -0x18(%rbp), %rdi
callq 0x1fff0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x317c0
addq $0x70, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x48, %esi
callq 0x9360
jmp 0x11a51
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x11a48
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x9658
leaq -0x49(%rbp), %rdi
callq 0x93b0
movq -0x20(%rbp), %rdi
callq 0x95b0
nopw (%rax,%rax)
// File: martinda3[P]Compiler/src/TCparser.cpp
// Function: toyc::TCparser::FunctionCall()
ASexpression* TCparser::FunctionCall() // WIP
	{
		// FunctionCall -- > LPAREN ActualParameters RPAREN
		enteringDEBUG("Function Call");
		ASexpression* operand = NULL;
		accept(LPAREN);
		try { operand = ActualParameters(); }
		catch (int t) { operand = new ASexpression(); }
		accept(RPAREN);
		exitingDEBUG("Function Call");
		return operand;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x95c0
movq -0x80(%rbp), %rdx
leaq 0x2010c(%rip), %rsi     # 0x3349e
leaq -0x28(%rbp), %rdi
callq 0x13550
jmp 0x1339d
leaq -0x28(%rbp), %rdi
callq 0xd790
jmp 0x133a8
leaq -0x28(%rbp), %rdi
callq 0x9658
leaq -0x29(%rbp), %rdi
callq 0x93b0
movq -0x88(%rbp), %rdi
movq $0x0, -0x48(%rbp)
movl $0x1e, %esi
callq 0xe670
movq -0x88(%rbp), %rdi
callq 0x11a60
movq %rax, -0x90(%rbp)
jmp 0x133e8
movq -0x90(%rbp), %rax
movq %rax, -0x48(%rbp)
jmp 0x13484
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x1341b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x9658
leaq -0x29(%rbp), %rdi
callq 0x93b0
jmp 0x13546
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x13546
movq -0x38(%rbp), %rdi
callq 0x9140
movl (%rax), %eax
movl %eax, -0x4c(%rbp)
movl $0x10, %edi
callq 0x9350
movq %rax, -0x98(%rbp)
jmp 0x13466
movq -0x98(%rbp), %rdi
callq 0x203f0
jmp 0x13474
movq -0x98(%rbp), %rax
movq %rax, -0x48(%rbp)
callq 0x9540
movq -0x88(%rbp), %rdi
movl $0x1f, %esi
callq 0xe670
leaq -0x71(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x95c0
movq -0xa0(%rbp), %rdx
leaq 0x1ffeb(%rip), %rsi     # 0x3349e
leaq -0x70(%rbp), %rdi
callq 0x13550
jmp 0x134be
leaq -0x70(%rbp), %rdi
callq 0xda50
jmp 0x134c9
leaq -0x70(%rbp), %rdi
callq 0x9658
leaq -0x71(%rbp), %rdi
callq 0x93b0
movq -0x48(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x13513
movq -0x98(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
movl $0x10, %esi
callq 0x9360
callq 0x9540
jmp 0x13546
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x1353d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x9658
leaq -0x71(%rbp), %rdi
callq 0x93b0
movq -0x38(%rbp), %rdi
callq 0x95b0
nop
// File: martinda3[P]Compiler/src/ASfuncDef.cpp
// Function: toyc::ASfuncDef::ASfuncDef(toyc::AStype*, toyc::ASdefinition**, int, toyc::ASstatement*)
ASfuncDef::ASfuncDef(AStype* id, ASdefinition* varDef[], int num, ASstatement* s)
	{
		identifier = id;
		for (int i = 0; i < num; i++)
		{
			varDefList[i] = varDef[i];
		}
		numVarDef = num;
		statement = s;
		setType(FUNCdef);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x143c0
movq -0x38(%rbp), %rax
leaq 0x2efe5(%rip), %rcx     # 0x42a58
addq $0x10, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x10(%rax)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x13ab5
movq -0x38(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq -0x2c(%rbp), %rdx
movq (%rcx,%rdx,8), %rdx
movslq -0x2c(%rbp), %rcx
movq %rdx, 0x18(%rax,%rcx,8)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x13a89
movq -0x38(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, 0xfb8(%rdi)
movq -0x28(%rbp), %rax
movq %rax, 0xfc0(%rdi)
xorl %esi, %esi
callq 0x2d600
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: martinda3[P]Compiler/src/TClexer.cpp
// Function: toyc::TClexer::TClexer(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
TClexer::TClexer(std::string fname) {
		inputFileName = fname;
		line = ""; pos = 0;
		infile.open(inputFileName);
		if (infile.fail()) {
			std::cerr << "ERROR: input file not found" << std::endl;
			exit(EXIT_FAILURE);
		}
		charBuff = getChar();
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x31159(%rip), %rdi     # 0x455e0
callq 0x9050
leaq 0x30ed5(%rip), %rdi     # 0x45368
leaq 0x2025a(%rip), %rsi     # 0x346f4
callq 0x9470
movl $0x0, 0x31107(%rip)     # 0x455b0
leaq 0x30ef8(%rip), %rdi     # 0x453a8
leaq 0x31129(%rip), %rsi     # 0x455e0
movl $0x8, %edx
callq 0x92c0
movq 0x30ee0(%rip), %rax     # 0x453a8
leaq 0x30ed9(%rip), %rdi     # 0x453a8
addq -0x18(%rax), %rdi
callq 0x9030
testb $0x1, %al
jne 0x144de
jmp 0x1450a
movq 0x30b0b(%rip), %rdi     # 0x44ff0
leaq 0x1f1f0(%rip), %rsi     # 0x336dc
callq 0x9340
movq %rax, %rdi
movq 0x30ab5(%rip), %rsi     # 0x44fb0
callq 0x9380
movl $0x1, %edi
callq 0x9410
callq 0x14520
movb %al, 0x3109f(%rip)      # 0x455b4
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: martinda3[P]Compiler/src/TClexer.cpp
// Function: toyc::isInAlphabet(char)
bool isInAlphabet(char ch)
	{
		return (isalpha(ch) || isdigit(ch) || (ch == '%') || (ch == '+') || (ch == '-') || (ch == '*') || (ch == '/') ||
		        (ch == '<') || (ch == '>') || (ch == '(') || (ch == ')') || (ch == '=') || (ch == ';') || (ch == ':') ||
		        (ch == '!') || (ch == '[') || (ch == ']') || (ch == '{') || (ch == '}') || (ch == ',') || (ch == '|') ||
		        (ch == '&') || (ch == '.') || (ch == '\\') || (ch == '\"') || (ch == '\''));
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
movsbl -0x1(%rbp), %edi
callq 0x9530
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x2(%rbp)
jne 0x1ab87
movsbl -0x1(%rbp), %edi
callq 0x9300
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x2(%rbp)
jne 0x1ab87
movsbl -0x1(%rbp), %ecx
movb $0x1, %al
cmpl $0x25, %ecx
movb %al, -0x2(%rbp)
je 0x1ab87
movsbl -0x1(%rbp), %ecx
movb $0x1, %al
cmpl $0x2b, %ecx
movb %al, -0x2(%rbp)
je 0x1ab87
movsbl -0x1(%rbp), %ecx
movb $0x1, %al
cmpl $0x2d, %ecx
movb %al, -0x2(%rbp)
je 0x1ab87
movsbl -0x1(%rbp), %ecx
movb $0x1, %al
cmpl $0x2a, %ecx
movb %al, -0x2(%rbp)
je 0x1ab87
movsbl -0x1(%rbp), %ecx
movb $0x1, %al
cmpl $0x2f, %ecx
movb %al, -0x2(%rbp)
je 0x1ab87
movsbl -0x1(%rbp), %ecx
movb $0x1, %al
cmpl $0x3c, %ecx
movb %al, -0x2(%rbp)
je 0x1ab87
movsbl -0x1(%rbp), %ecx
movb $0x1, %al
cmpl $0x3e, %ecx
movb %al, -0x2(%rbp)
je 0x1ab87
movsbl -0x1(%rbp), %ecx
movb $0x1, %al
cmpl $0x28, %ecx
movb %al, -0x2(%rbp)
je 0x1ab87
movsbl -0x1(%rbp), %ecx
movb $0x1, %al
cmpl $0x29, %ecx
movb %al, -0x2(%rbp)
je 0x1ab87
movsbl -0x1(%rbp), %ecx
movb $0x1, %al
cmpl $0x3d, %ecx
movb %al, -0x2(%rbp)
je 0x1ab87
movsbl -0x1(%rbp), %ecx
movb $0x1, %al
cmpl $0x3b, %ecx
movb %al, -0x2(%rbp)
je 0x1ab87
movsbl -0x1(%rbp), %ecx
movb $0x1, %al
cmpl $0x3a, %ecx
movb %al, -0x2(%rbp)
je 0x1ab87
movsbl -0x1(%rbp), %ecx
movb $0x1, %al
cmpl $0x21, %ecx
movb %al, -0x2(%rbp)
je 0x1ab87
movsbl -0x1(%rbp), %ecx
movb $0x1, %al
cmpl $0x5b, %ecx
movb %al, -0x2(%rbp)
je 0x1ab87
movsbl -0x1(%rbp), %ecx
movb $0x1, %al
cmpl $0x5d, %ecx
movb %al, -0x2(%rbp)
je 0x1ab87
movsbl -0x1(%rbp), %ecx
movb $0x1, %al
cmpl $0x7b, %ecx
movb %al, -0x2(%rbp)
je 0x1ab87
movsbl -0x1(%rbp), %ecx
movb $0x1, %al
cmpl $0x7d, %ecx
movb %al, -0x2(%rbp)
je 0x1ab87
movsbl -0x1(%rbp), %ecx
movb $0x1, %al
cmpl $0x2c, %ecx
movb %al, -0x2(%rbp)
je 0x1ab87
movsbl -0x1(%rbp), %ecx
movb $0x1, %al
cmpl $0x7c, %ecx
movb %al, -0x2(%rbp)
je 0x1ab87
movsbl -0x1(%rbp), %ecx
movb $0x1, %al
cmpl $0x26, %ecx
movb %al, -0x2(%rbp)
je 0x1ab87
movsbl -0x1(%rbp), %ecx
movb $0x1, %al
cmpl $0x2e, %ecx
movb %al, -0x2(%rbp)
je 0x1ab87
movsbl -0x1(%rbp), %ecx
movb $0x1, %al
cmpl $0x5c, %ecx
movb %al, -0x2(%rbp)
je 0x1ab87
movsbl -0x1(%rbp), %ecx
movb $0x1, %al
cmpl $0x22, %ecx
movb %al, -0x2(%rbp)
je 0x1ab87
movsbl -0x1(%rbp), %eax
cmpl $0x27, %eax
sete %al
movb %al, -0x2(%rbp)
movb -0x2(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: martinda3[P]Compiler/src/TCoutput.cpp
// Function: toyc::pad[abi:cxx11](int)
std::string pad(int n) {
        std::string s = "";
	    for (int i = 1; i <= n; i++) s += " ";
        // for (int i = 1; i <= n; i++) s += ".";   // For easy visiol debugging
        return s;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movb $0x0, -0xd(%rbp)
leaq -0xe(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x95c0
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rdx
leaq 0x1903a(%rip), %rsi     # 0x346f4
callq 0x13550
jmp 0x1b6c1
leaq -0xe(%rbp), %rdi
callq 0x93b0
movl $0x1, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0xc(%rbp), %eax
jg 0x1b726
movq -0x30(%rbp), %rdi
leaq 0x17a6f(%rip), %rsi     # 0x33153
callq 0x9330
jmp 0x1b6eb
jmp 0x1b6ed
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x1b6d1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0xe(%rbp), %rdi
callq 0x93b0
jmp 0x1b743
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x9658
jmp 0x1b743
movb $0x1, -0xd(%rbp)
testb $0x1, -0xd(%rbp)
jne 0x1b739
movq -0x30(%rbp), %rdi
callq 0x9658
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x95b0
nopl (%rax)
// File: martinda3[P]Compiler/src/ASreadState.cpp
// Function: toyc::ASreadState::ASreadState(toyc::ASexpression**, int)
ASreadState::ASreadState(ASexpression* identifiers[], int num)
	{
		for (int i = 0; i < num; i++)
		{
			identifierList[i] = identifiers[i];
		}
		numIdentifiers = num;
		setType(READstate);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x1ed40
movq -0x20(%rbp), %rax
leaq 0x258c5(%rip), %rcx     # 0x42b40
addq $0x10, %rcx
movq %rcx, (%rax)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x1d2b5
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq -0x18(%rbp), %rdx
movq (%rcx,%rdx,8), %rdx
movslq -0x18(%rbp), %rcx
movq %rdx, 0x10(%rax,%rcx,8)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1d289
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, 0xfb0(%rdi)
movl $0x7, %esi
callq 0x1ed80
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: martinda3[P]Compiler/src/ASwriteState.cpp
// Function: toyc::ASwriteState::ASwriteState(toyc::ASexpression**, int)
ASwriteState::ASwriteState(ASexpression* expressions[], int num)
	{
		for (int i = 0; i < num; i++)
		{
			expressionList[i] = expressions[i];

		}
		numExpressions = num;
		setType(WRITEstate);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x1ed40
movq -0x20(%rbp), %rax
leaq 0x24635(%rip), %rcx     # 0x42bd0
addq $0x10, %rcx
movq %rcx, (%rax)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x1e5d5
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq -0x18(%rbp), %rdx
movq (%rcx,%rdx,8), %rdx
movslq -0x18(%rbp), %rcx
movq %rdx, 0x10(%rax,%rcx,8)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1e5a9
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, 0xfb0(%rdi)
movl $0x8, %esi
callq 0x1ed80
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: martinda3[P]Compiler/src/ASprogram.cpp
// Function: toyc::ASprogram::toTypeString[abi:cxx11]()
std::string ASprogram::toTypeString()
	{
		std::string s;
		switch (type)
		{
			case PROGprog:
				s = "PROGprog";
				break;
			default:
				s = "error";
				break;
		}
		return s;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x9480
movq -0x30(%rbp), %rax
movl 0x8(%rax), %eax
testl %eax, %eax
jne 0x1eae4
jmp 0x1eab9
movq -0x40(%rbp), %rdi
leaq 0x152b4(%rip), %rsi     # 0x33d78
callq 0x9470
jmp 0x1eacb
jmp 0x1eaf8
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x9658
jmp 0x1eb15
movq -0x40(%rbp), %rdi
leaq 0x15cfc(%rip), %rsi     # 0x347eb
callq 0x9470
jmp 0x1eaf6
jmp 0x1eaf8
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x1eb0b
movq -0x40(%rbp), %rdi
callq 0x9658
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x95b0
nop