LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: chenhn123[P]wdt_util_src/wdt_ct/wif2_handler.cpp
// Function: get_wif2(char*, WifFile2*)
int get_wif2(char *path, WIF_FILE2 *out_pcur_wif)
{
	FILE *pfile = NULL;
	int ret = 1;

	pfile = fopen(path, "rb");
	if (!pfile){
		printf("Failed to read file: %s\n", path);
		return 0;
	}

	/* set file ptr to the end */
	fseek(pfile, 0, SEEK_END);
	out_pcur_wif->data_len = ftell(pfile);

	/* set the file ptr the beginning */
	rewind(pfile);
	UINT32 pdataSize = out_pcur_wif->data_len;

	out_pcur_wif->pdata = (BYTE *)malloc(pdataSize);

	if (!out_pcur_wif->pdata) {
		ret = 0;
		goto finish;
	}

	if (fread(out_pcur_wif->pdata, 1, out_pcur_wif->data_len, pfile) == out_pcur_wif->data_len) {
		ret = process_wif2(out_pcur_wif);
		if (ret == 1) {
			ret = 1;
			goto finish;
		} else {
			ret = 0;
			goto finish;
		}
	} else {
		ret = 0;
		goto finish;
	}

finish:

	fclose(pfile);

	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movl $0x1, -0x24(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x31ca(%rip), %rsi      # 0x10764
callq 0x21d0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xd5c8
movq -0x10(%rbp), %rsi
leaq 0x368b(%rip), %rdi      # 0x10c40
movb $0x0, %al
callq 0x2050
movl $0x0, -0x4(%rbp)
jmp 0xd68a
movq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x21c0
movq -0x20(%rbp), %rdi
callq 0x2030
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x20(%rbp), %rdi
callq 0x2070
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
movl %eax, %edi
callq 0x21f0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xd626
movl $0x0, -0x24(%rbp)
jmp 0xd67b
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, %edx
movq -0x20(%rbp), %rcx
movl $0x1, %esi
callq 0x2230
movq -0x18(%rbp), %rcx
movl 0x8(%rcx), %ecx
cmpq %rcx, %rax
jne 0xd674
movq -0x18(%rbp), %rdi
callq 0xd4c0
movl %eax, -0x24(%rbp)
cmpl $0x1, -0x24(%rbp)
jne 0xd66b
movl $0x1, -0x24(%rbp)
jmp 0xd67b
movl $0x0, -0x24(%rbp)
jmp 0xd67b
movl $0x0, -0x24(%rbp)
movq -0x20(%rbp), %rdi
callq 0x21a0
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chenhn123[P]wdt_util_src/wdt_ct/wif2_handler.cpp
// Function: do_wif2_chunk_info(WifFile2*, unsigned int)
int do_wif2_chunk_info(WIF_FILE2 *pcur_wif, UINT32 chunk_four_cc)
{
	if (!pcur_wif)
		return 0;

	if (!chunk_four_cc)
		return 0;
	WIF2_Info_Chunk *pchunk_info_ex;
	pchunk_info_ex = (WIF2_Info_Chunk *)malloc(sizeof(WIF2_Info_Chunk));
	if (!pchunk_info_ex)
		return 0;
	int ret = 1;
	UINT32 chunk_start_pos = 0 + sizeof(ChunkHeader);
	WIF2_Chunk_Header *pchunk_data = NULL;

	while (chunk_start_pos < pcur_wif->data_len) {
		pchunk_data = (WIF2_Chunk_Header *)&pcur_wif->pdata[chunk_start_pos];

		/* we got it */
		if (pchunk_data->FourCC == chunk_four_cc) {
			pchunk_info_ex->Header.FourCC = pchunk_data->FourCC;
			pchunk_info_ex->Header.Size = pchunk_data->Size;

			pchunk_info_ex->BinaryData = (BYTE *)malloc(pchunk_data->Size);
			if (!pchunk_info_ex->BinaryData) {
				ret = 0;
				goto finish;
			}

			chunk_start_pos = chunk_start_pos + pchunk_data->Size + 8;
			if (pchunk_info_ex->BinaryData)
				free(pchunk_info_ex->BinaryData);

		} else {
			/* 8 is the header size */
			chunk_start_pos = chunk_start_pos + pchunk_data->Size + 8;
		}
	}
finish:
	if (pchunk_info_ex)
		free(pchunk_info_ex);

	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xd6c2
movl $0x0, -0x4(%rbp)
jmp 0xd7d5
cmpl $0x0, -0x14(%rbp)
jne 0xd6d4
movl $0x0, -0x4(%rbp)
jmp 0xd7d5
movl $0x10, %edi
callq 0x21f0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xd6f5
movl $0x0, -0x4(%rbp)
jmp 0xd7d5
movl $0x1, -0x24(%rbp)
movl $0xc, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movl -0x28(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jae 0xd7bd
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl -0x28(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl (%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0xd7a8
movq -0x30(%rbp), %rax
movl (%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x30(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x30(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, %edi
callq 0x21f0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0xd77e
movl $0x0, -0x24(%rbp)
jmp 0xd7bf
movl -0x28(%rbp), %eax
movq -0x30(%rbp), %rcx
addl 0x4(%rcx), %eax
addl $0x8, %eax
movl %eax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xd7a6
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x21e0
jmp 0xd7b8
movl -0x28(%rbp), %eax
movq -0x30(%rbp), %rcx
addl 0x4(%rcx), %eax
addl $0x8, %eax
movl %eax, -0x28(%rbp)
jmp 0xd70b
jmp 0xd7bf
cmpq $0x0, -0x20(%rbp)
je 0xd7cf
movq -0x20(%rbp), %rdi
callq 0x21e0
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: chenhn123[P]wdt_util_src/wdt_ct/wif2_handler.cpp
// Function: append_WIF2_flash_node(WIF2FlashNode**, WIF2FlashSpace)
int append_WIF2_flash_node(struct WIF2FlashNode **head_ref, WIF2_Flash_Space new_data)
{
	/* 1. allocate node */
	struct WIF2FlashNode *new_node = (struct WIF2FlashNode *)malloc(sizeof(struct WIF2FlashNode));
	if (!new_node)
		return 0;

	struct WIF2FlashNode *last = *head_ref; /* used in step 5*/

	/* 2. put in the data  */
	new_node->Space = new_data;

	/* 3. This new node is going to be the last node, so make next of
	it as NULL*/
	new_node->Next = NULL;

	/* 4. If the Linked List is empty, then make the new node as head */
	if (*head_ref == NULL) {
		*head_ref = new_node;
		return 0;
	}

	/* 5. Else traverse till the last node */
	while (last->Next != NULL)
		last = last->Next;

	/* 6. Change the next of last node */
	last->Next = new_node;
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0xc(%rbp)
movq %rdi, -0x18(%rbp)
movl $0x10, %edi
callq 0x21f0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xdb9e
movl $0x0, -0x4(%rbp)
jmp 0xdc0c
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq -0xc(%rbp), %rcx
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xdbde
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0xdc0c
jmp 0xdbe0
movq -0x28(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xdbf9
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0xdbe0
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chenhn123[P]wdt_util_src/wdt_ct/wif2_handler.cpp
// Function: free_WIF2_flash_node(WIF2FlashNode*)
void free_WIF2_flash_node(WIF2FlashNode *pHead)
{
	WIF2FlashNode *pNode = pHead, *pNext;

	while (NULL != pNode) {
		pNext = pNode->Next;
		free(pNode);
		pNode = pNext;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
je 0xdc5b
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x21e0
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0xdc34
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chenhn123[P]wdt_util_src/wdt_ct/wif2_handler.cpp
// Function: do_update_fw_by_wif2_flow(WdtDevice*, WifFile2*)
int do_update_fw_by_wif2_flow(WDT_DEV *pdev, WIF_FILE2 *pcur_wif)
{
	if (!do_update_fw_by_wif2_chunk_fera(pdev, pcur_wif, FOURCC_ID_FERA))
		return 0;

	if (!do_update_fw_by_wif2_chunk_fbin(pdev, pcur_wif, FOURCC_ID_FBIN))
		return 0;

	pdev->funcs_device_private.p_wh_send_commands(pdev, WH_CMD_RESET, 0);
	printf("Reset device ... \n");
	wh_sleep(2000);

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x41524546, %edx       # imm = 0x41524546
callq 0xdf70
cmpl $0x0, %eax
jne 0xe160
movl $0x0, -0x4(%rbp)
jmp 0xe1b7
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x4e494246, %edx       # imm = 0x4E494246
callq 0xd7e0
cmpl $0x0, %eax
jne 0xe180
movl $0x0, -0x4(%rbp)
jmp 0xe1b7
movq -0x10(%rbp), %rax
movq 0x2d8(%rax), %rax
movq -0x10(%rbp), %rdi
movl $0x1, %esi
xorl %edx, %edx
callq *%rax
leaq 0x20c6(%rip), %rdi      # 0x10265
movb $0x0, %al
callq 0x2050
movl $0x7d0, %edi            # imm = 0x7D0
callq 0x2590
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: chenhn123[P]wdt_util_src/wdt_ct/wif2_handler.cpp
// Function: show_wif2_info(char*)
int show_wif2_info(char *path)
{
	WIF_FILE2 wif2;
	int ret;
	ret = get_wif2(path, &wif2);
	if (ret == 0)
		goto finish;
	ret = do_show_wif2_info_chunk(&wif2);

finish:
	free_wif2(&wif2);
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0xd570
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0xe3d4
jmp 0xe3e0
leaq -0x18(%rbp), %rdi
callq 0xe200
movl %eax, -0x1c(%rbp)
leaq -0x18(%rbp), %rdi
callq 0xd530
movl -0x1c(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chenhn123[P]wdt_util_src/wdt_ct/wif2_handler.cpp
// Function: update_fw_by_wif2(WdtDevice*, char*)
int update_fw_by_wif2(WDT_DEV *pdev, char *path)
{
	WIF_FILE2 wif2;
	int ret;
	ret = get_wif2(path, &wif2);
	if (ret == 0) {
		goto finish;
	}
	ret = do_update_fw_by_wif2_flow(pdev, &wif2);

finish:
	free_wif2(&wif2);
	printf("Operation done!\n");

	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0xd570
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jne 0xe428
jmp 0xe438
movq -0x8(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0xe130
movl %eax, -0x24(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xd530
leaq 0x287c(%rip), %rdi      # 0x10cc4
movb $0x0, %al
callq 0x2050
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: chenhn123[P]wdt_util_src/wdt_ct/wif2_handler.cpp
// Function: check_fw_by_wif2(WdtDevice*, char*)
int check_fw_by_wif2(WDT_DEV *pdev, char *path)
{
	WIF_FILE2 wif2;
	int ret;
	ret = get_wif2(path, &wif2);
	if (ret == 0) {
		goto finish;
	}
	ret = do_check_fw_by_wif2_flow(pdev, &wif2);

finish:
	free_wif2(&wif2);

	pdev->funcs_device.p_wh_close_device(pdev);
	printf("Operation done!\n");

	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0xd570
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jne 0xe488
jmp 0xe498
movq -0x8(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0xe1c0
movl %eax, -0x24(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xd530
movq -0x8(%rbp), %rax
movq 0x2a0(%rax), %rax
movq -0x8(%rbp), %rdi
callq *%rax
leaq 0x280b(%rip), %rdi      # 0x10cc4
movb $0x0, %al
callq 0x2050
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: wwdatabase[P]database/./smmana/sm.h
// Function: SM_Manager::drop_db(char const*)
RC SM_Manager::drop_db(const char* dbname)// still need to revise the system file
{
	for(vector<DB>::iterator i = databases.begin();i != databases.end();i++)
	{
		if(strcmp(dbname,i->dbname) == 0)
		{
			char command[255] = "rm -r ";
			strcat(command,dbname);
			system(command);
			printf("Deletion finished!\n");
			databases.erase(i);
			return 0;
		}
	}
	printf("database does not exists!\n");
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x160, %rsp            # imm = 0x160
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x150(%rbp)
callq 0x6a70
movq %rax, -0x20(%rbp)
movq -0x150(%rbp), %rdi
callq 0x6ae0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x6aa0
testb $0x1, %al
jne 0x404d
jmp 0x412c
movq -0x18(%rbp), %rax
movq %rax, -0x158(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x6b10
movq -0x158(%rbp), %rdi
movq %rax, %rsi
callq 0x2300
cmpl $0x0, %eax
jne 0x4113
leaq -0x130(%rbp), %rdi
xorl %esi, %esi
movl $0xff, %edx
callq 0x2110
movb $0x72, -0x130(%rbp)
movb $0x6d, -0x12f(%rbp)
movb $0x20, -0x12e(%rbp)
movb $0x2d, -0x12d(%rbp)
movb $0x72, -0x12c(%rbp)
movb $0x20, -0x12b(%rbp)
leaq -0x130(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x23e0
leaq -0x130(%rbp), %rdi
callq 0x21c0
leaq 0xb14b(%rip), %rdi      # 0xf224
movb $0x0, %al
callq 0x2040
leaq -0x138(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x6ba0
movq -0x150(%rbp), %rdi
movq -0x138(%rbp), %rsi
callq 0x6b30
movq %rax, -0x140(%rbp)
movl $0x0, -0x4(%rbp)
jmp 0x4141
jmp 0x4115
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x6be0
movq %rax, -0x148(%rbp)
jmp 0x4027
leaq 0xb105(%rip), %rdi      # 0xf238
movb $0x0, %al
callq 0x2040
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x160, %rsp            # imm = 0x160
popq %rbp
retq
nopl (%rax)
// File: wwdatabase[P]database/./smmana/sm.h
// Function: SM_Manager::use_db(char const*)
RC SM_Manager::use_db(const char* dbname)
{
	int i;
	for(i = 0;i < databases.size();i++)
	{
		if(strcmp(dbname,databases[i].dbname) == 0)
		{
			current_db_index = i;
			printf("Current in database %s\n",databases[i].dbname);
			break;
		}
	}
	if(i == databases.size())
	{
		printf("Database %s does not exists!\n",dbname);
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rdi
movslq -0x14(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x6c20
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x41e5
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movslq -0x14(%rbp), %rsi
callq 0x6c50
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x2300
cmpl $0x0, %eax
jne 0x41d8
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, 0x18(%rdi)
movslq -0x14(%rbp), %rsi
callq 0x6c50
movq %rax, %rsi
leaq 0xb084(%rip), %rdi      # 0xf253
movb $0x0, %al
callq 0x2040
jmp 0x41e5
jmp 0x41da
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x416f
movq -0x20(%rbp), %rdi
movslq -0x14(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0x6c20
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jne 0x4214
movq -0x10(%rbp), %rsi
leaq 0xb05e(%rip), %rdi      # 0xf26b
movb $0x0, %al
callq 0x2040
xorl %eax, %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: statgen[P]statgen/lib/tclap-1.2.0/examples/test2.cpp
// Function: main
int main(int argc, char** argv)
{

	parseOptions(argc,argv);

	cout << "for float we got : " << _floatTest << endl
		 << "for int we got : " << _intTest<< endl
		 << "for string we got : " << _stringTest<< endl
		 << "for ulabeled we got : " << _utest << endl
		 << "for bool A we got : " << _boolTestA << endl
		 << "for bool B we got : " << _boolTestB << endl
		 << "for bool C we got : " << _boolTestC << endl;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x5840
movq 0x1c8de(%rip), %rdi     # 0x21fd0
leaq 0x12945(%rip), %rsi     # 0x1803e
callq 0x5280
movq %rax, %rdi
movss 0x1cbcf(%rip), %xmm0    # 0x222d8
callq 0x5200
movq %rax, %rdi
movq 0x1c898(%rip), %rsi     # 0x21fb0
callq 0x52c0
movq %rax, %rdi
leaq 0x1292b(%rip), %rsi     # 0x18052
callq 0x5280
movq %rax, %rdi
movl 0x1cb9f(%rip), %esi     # 0x222d4
callq 0x5460
movq %rax, %rdi
movq 0x1c86c(%rip), %rsi     # 0x21fb0
callq 0x52c0
movq %rax, %rdi
leaq 0x12911(%rip), %rsi     # 0x18064
callq 0x5280
movq %rax, %rdi
leaq 0x1cb7e(%rip), %rsi     # 0x222e0
callq 0x5260
movq %rax, %rdi
movq 0x1c83f(%rip), %rsi     # 0x21fb0
callq 0x52c0
movq %rax, %rdi
leaq 0x128f9(%rip), %rsi     # 0x18079
callq 0x5280
movq %rax, %rdi
leaq 0x1cb71(%rip), %rsi     # 0x22300
callq 0x5260
movq %rax, %rdi
movq 0x1c812(%rip), %rsi     # 0x21fb0
callq 0x52c0
movq %rax, %rdi
leaq 0x128e3(%rip), %rsi     # 0x18090
callq 0x5280
movq %rax, %rdi
movb 0x1cb21(%rip), %al      # 0x222dc
andb $0x1, %al
movzbl %al, %esi
callq 0x5490
movq %rax, %rdi
movq 0x1c7e1(%rip), %rsi     # 0x21fb0
callq 0x52c0
movq %rax, %rdi
leaq 0x128c7(%rip), %rsi     # 0x180a5
callq 0x5280
movq %rax, %rdi
movb 0x1caf1(%rip), %al      # 0x222dd
andb $0x1, %al
movzbl %al, %esi
callq 0x5490
movq %rax, %rdi
movq 0x1c7b0(%rip), %rsi     # 0x21fb0
callq 0x52c0
movq %rax, %rdi
leaq 0x128ab(%rip), %rsi     # 0x180ba
callq 0x5280
movq %rax, %rdi
movb 0x1cac1(%rip), %al      # 0x222de
andb $0x1, %al
movzbl %al, %esi
callq 0x5490
movq %rax, %rdi
movq 0x1c77f(%rip), %rsi     # 0x21fb0
callq 0x52c0
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: Blaze2305[P]Compiler-Design-2021-Assignment/src/Models/Structs.cpp
// Function: operator<<(std::ostream&, SymTabRow const&)
std::ostream& operator<< (std::ostream& out, const SymTabRow& obj){
	out<<"\n------------------------------------------------------------------------------\n";
	out<<"Symbol Name --> "<<obj.symbolName<<std::endl;
	out<<"Type --> "<<obj.type<<std::endl;
	out<<"Value --> "<<obj.attribute<<std::endl;
	out<<"Line Number --> "<<obj.lineNumber<<std::endl;
	out<<"\n------------------------------------------------------------------------------\n";
	return out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xbeb5(%rip), %rsi      # 0x19160
callq 0x3290
movq -0x8(%rbp), %rdi
leaq 0xbef6(%rip), %rsi      # 0x191b1
callq 0x3290
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x3260
movq %rax, %rdi
movq 0x14cca(%rip), %rsi     # 0x21fa0
callq 0x32e0
movq -0x8(%rbp), %rdi
leaq 0xbef3(%rip), %rsi      # 0x191d9
callq 0x3290
movq %rax, %rdi
movq -0x10(%rbp), %rsi
addq $0x20, %rsi
callq 0x3260
movq %rax, %rdi
movq 0x14c9b(%rip), %rsi     # 0x21fa0
callq 0x32e0
movq -0x8(%rbp), %rdi
leaq 0xbed5(%rip), %rsi      # 0x191ea
callq 0x3290
movq %rax, %rdi
movq -0x10(%rbp), %rsi
addq $0x40, %rsi
callq 0x3260
movq %rax, %rdi
movq 0x14c6c(%rip), %rsi     # 0x21fa0
callq 0x32e0
movq -0x8(%rbp), %rdi
leaq 0xbe7e(%rip), %rsi      # 0x191c2
callq 0x3290
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl 0x60(%rax), %esi
callq 0x34e0
movq %rax, %rdi
movq 0x14c3e(%rip), %rsi     # 0x21fa0
callq 0x32e0
movq -0x8(%rbp), %rdi
leaq 0xbdee(%rip), %rsi      # 0x19160
callq 0x3290
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Blaze2305[P]Compiler-Design-2021-Assignment/src/Models/Structs.cpp
// Function: operator<<(std::ostream&, TokenRecord const&)
std::ostream& operator<< (std::ostream& out, const TokenRecord& obj){
	out<<"\n------------------------------------------------------------------------------\n";
	out<<"Token Type --> "<<TOKEN_ENUM_TYPE_NAMES[obj.tokenType]<<std::endl;
	out<<"String Value --> "<<obj.Value<<std::endl;
	out<<"Line Number --> "<<obj.lineNumber<<std::endl;
	out<<"\n------------------------------------------------------------------------------\n";
	return out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xbdb5(%rip), %rsi      # 0x19160
callq 0x3290
movq -0x8(%rbp), %rdi
leaq 0xbe18(%rip), %rsi      # 0x191d3
callq 0x3290
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, %esi
leaq 0x1563d(%rip), %rdi     # 0x22a10
callq 0xd470
movq -0x18(%rbp), %rdi
movq %rax, %rsi
callq 0x3260
movq %rax, %rdi
movq 0x14bb2(%rip), %rsi     # 0x21fa0
callq 0x32e0
movq -0x8(%rbp), %rdi
leaq 0xbde5(%rip), %rsi      # 0x191e3
callq 0x3290
movq %rax, %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
callq 0x3260
movq %rax, %rdi
movq 0x14b83(%rip), %rsi     # 0x21fa0
callq 0x32e0
movq -0x8(%rbp), %rdi
leaq 0xbd95(%rip), %rsi      # 0x191c2
callq 0x3290
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl 0x28(%rax), %esi
callq 0x34e0
movq %rax, %rdi
movq 0x14b55(%rip), %rsi     # 0x21fa0
callq 0x32e0
movq -0x8(%rbp), %rdi
leaq 0xbd05(%rip), %rsi      # 0x19160
callq 0x3290
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Blaze2305[P]Compiler-Design-2021-Assignment/src/Parser/Parser.cpp
// Function: Parser::parse()
void Parser::parse(){
	currentToken = scanner->getToken();
	parseProgram();
	if(currentToken.tokenType != EOT){
		std::ostringstream out ;
		out << "Syntax error on line ";
		out << currentToken.lineNumber;
		out << " Redundant chars at the end";
		throw  std::runtime_error(out.str());
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x200, %rsp            # imm = 0x200
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1f0(%rbp)
movq 0x30(%rax), %rsi
leaq -0x38(%rbp), %rdi
callq 0x121a0
movq -0x1f0(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x10610
leaq -0x38(%rbp), %rdi
callq 0x105f0
movq -0x1f0(%rbp), %rdi
callq 0xdce0
movq -0x1f0(%rbp), %rax
cmpl $0x8, (%rax)
je 0xdcc6
leaq -0x1b0(%rbp), %rdi
movq %rdi, -0x1f8(%rbp)
callq 0x33e0
movq -0x1f8(%rbp), %rdi
leaq 0xb638(%rip), %rsi      # 0x191f5
callq 0x3290
jmp 0xdbc4
movq -0x1f0(%rbp), %rax
movl 0x28(%rax), %esi
leaq -0x1b0(%rbp), %rdi
callq 0x34e0
jmp 0xdbdc
leaq 0xb683(%rip), %rsi      # 0x19266
leaq -0x1b0(%rbp), %rdi
callq 0x3290
jmp 0xdbf1
movb $0x1, -0x1e1(%rbp)
movl $0x10, %edi
callq 0x3150
movq %rax, -0x200(%rbp)
leaq -0x1e0(%rbp), %rdi
leaq -0x1b0(%rbp), %rsi
callq 0x32c0
jmp 0xdc1e
movq -0x200(%rbp), %rdi
leaq -0x1e0(%rbp), %rsi
callq 0x3470
jmp 0xdc33
movq -0x200(%rbp), %rdi
movb $0x0, -0x1e1(%rbp)
movq 0x143a8(%rip), %rsi     # 0x21ff0
movq 0x14371(%rip), %rdx     # 0x21fc0
callq 0x34d0
jmp 0xdcdb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b8(%rbp)
movl %eax, -0x1bc(%rbp)
jmp 0xdcb8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b8(%rbp)
movl %eax, -0x1bc(%rbp)
jmp 0xdc9f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b8(%rbp)
movl %eax, -0x1bc(%rbp)
leaq -0x1e0(%rbp), %rdi
callq 0x3558
testb $0x1, -0x1e1(%rbp)
jne 0xdcaa
jmp 0xdcb6
movq -0x200(%rbp), %rdi
callq 0x3200
jmp 0xdcb8
leaq -0x1b0(%rbp), %rdi
callq 0x30c0
jmp 0xdccf
addq $0x200, %rsp            # imm = 0x200
popq %rbp
retq
movq -0x1b8(%rbp), %rdi
callq 0x3500
nopl (%rax,%rax)
// File: Blaze2305[P]Compiler-Design-2021-Assignment/src/Parser/Parser.cpp
// Function: Parser::parseProgram()
void Parser::parseProgram(){
	tabNum+=1;
	printParseEnters(tabNum,tabChar,"parseProgram");
	accept(Global);
	if(checkToken(Def)){
		parseDeclList();
	}
	identifierCheckFlag = true;
	parseStmtList();
	accept(End);
	tabNum-=1;
	printParseExits(tabNum,tabChar,"parseProgram");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
movl 0x145cf(%rip), %eax     # 0x222cc
incl %eax
movl %eax, 0x145c7(%rip)     # 0x222cc
movl 0x145c1(%rip), %eax     # 0x222cc
movl %eax, -0x78(%rbp)
movb 0x145b4(%rip), %al      # 0x222c8
movb %al, -0x71(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x3510
movq -0x70(%rbp), %rdx
leaq 0xb553(%rip), %rsi      # 0x19282
leaq -0x28(%rbp), %rdi
callq 0xb640
jmp 0xdd3a
movl -0x78(%rbp), %edi
movb -0x71(%rbp), %al
movsbl %al, %esi
leaq -0x28(%rbp), %rdx
callq 0x15530
jmp 0xdd4e
leaq -0x28(%rbp), %rdi
callq 0x3558
leaq -0x29(%rbp), %rdi
callq 0x3300
movq -0x80(%rbp), %rdi
movl $0xa, %esi
callq 0xd670
movq -0x80(%rbp), %rdi
movl $0xc, %esi
callq 0xdb20
testb $0x1, %al
jne 0xdd82
jmp 0xddbe
movq -0x80(%rbp), %rdi
callq 0xdea0
jmp 0xddbe
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0xddb0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3558
leaq -0x29(%rbp), %rdi
callq 0x3300
jmp 0xde89
movq -0x80(%rbp), %rdi
movb $0x1, 0x6c(%rdi)
callq 0xe040
movq -0x80(%rbp), %rdi
movl $0xb, %esi
callq 0xd670
movl 0x144ed(%rip), %eax     # 0x222cc
decl %eax
movl %eax, 0x144e5(%rip)     # 0x222cc
movl 0x144df(%rip), %eax     # 0x222cc
movl %eax, -0x90(%rbp)
movb 0x144cf(%rip), %al      # 0x222c8
movb %al, -0x89(%rbp)
leaq -0x61(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x3510
movq -0x88(%rbp), %rdx
leaq 0xb465(%rip), %rsi      # 0x19282
leaq -0x60(%rbp), %rdi
callq 0xb640
jmp 0xde28
movl -0x90(%rbp), %edi
movb -0x89(%rbp), %al
movsbl %al, %esi
leaq -0x60(%rbp), %rdx
callq 0x15550
jmp 0xde42
leaq -0x60(%rbp), %rdi
callq 0x3558
leaq -0x61(%rbp), %rdi
callq 0x3300
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0xde80
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x3558
leaq -0x61(%rbp), %rdi
callq 0x3300
movq -0x38(%rbp), %rdi
callq 0x3500
nopw %cs:(%rax,%rax)
// File: Blaze2305[P]Compiler-Design-2021-Assignment/src/Parser/Parser.cpp
// Function: Parser::parseDeclList()
void Parser::parseDeclList(){
	tabNum+=1;
	printParseEnters(tabNum,tabChar,"parseDeclList");
	parseDecl();
	while(checkToken(Def)){
		parseDeclList();
	}
	tabNum-=1;
	printParseExits(tabNum,tabChar,"parseDeclList");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
movl 0x1440f(%rip), %eax     # 0x222cc
incl %eax
movl %eax, 0x14407(%rip)     # 0x222cc
movl 0x14401(%rip), %eax     # 0x222cc
movl %eax, -0x78(%rbp)
movb 0x143f4(%rip), %al      # 0x222c8
movb %al, -0x71(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x3510
movq -0x70(%rbp), %rdx
leaq 0xb3a0(%rip), %rsi      # 0x1928f
leaq -0x28(%rbp), %rdi
callq 0xb640
jmp 0xdefa
movl -0x78(%rbp), %edi
movb -0x71(%rbp), %al
movsbl %al, %esi
leaq -0x28(%rbp), %rdx
callq 0x15530
jmp 0xdf0e
leaq -0x28(%rbp), %rdi
callq 0x3558
leaq -0x29(%rbp), %rdi
callq 0x3300
movq -0x80(%rbp), %rdi
callq 0xe1d0
movq -0x80(%rbp), %rdi
movl $0xc, %esi
callq 0xdb20
testb $0x1, %al
jne 0xdf3d
jmp 0xdf79
movq -0x80(%rbp), %rdi
callq 0xdea0
jmp 0xdf29
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0xdf6b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3558
leaq -0x29(%rbp), %rdi
callq 0x3300
jmp 0xe029
movl 0x1434d(%rip), %eax     # 0x222cc
decl %eax
movl %eax, 0x14345(%rip)     # 0x222cc
movl 0x1433f(%rip), %eax     # 0x222cc
movl %eax, -0x90(%rbp)
movb 0x1432f(%rip), %al      # 0x222c8
movb %al, -0x89(%rbp)
leaq -0x61(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x3510
movq -0x88(%rbp), %rdx
leaq 0xb2d2(%rip), %rsi      # 0x1928f
leaq -0x60(%rbp), %rdi
callq 0xb640
jmp 0xdfc8
movl -0x90(%rbp), %edi
movb -0x89(%rbp), %al
movsbl %al, %esi
leaq -0x60(%rbp), %rdx
callq 0x15550
jmp 0xdfe2
leaq -0x60(%rbp), %rdi
callq 0x3558
leaq -0x61(%rbp), %rdi
callq 0x3300
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0xe020
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x3558
leaq -0x61(%rbp), %rdi
callq 0x3300
movq -0x38(%rbp), %rdi
callq 0x3500
nopw %cs:(%rax,%rax)
// File: Blaze2305[P]Compiler-Design-2021-Assignment/src/Parser/Parser.cpp
// Function: Parser::parseStmtList()
void Parser::parseStmtList(){
	tabNum+=1;
	printParseEnters(tabNum,tabChar,"parseStmtList");
	parseStmt();
	accept(SemiColon);
	parseStmtListA();
	tabNum-=1;
	printParseExits(tabNum,tabChar,"parseStmtList");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
movl 0x1426f(%rip), %eax     # 0x222cc
incl %eax
movl %eax, 0x14267(%rip)     # 0x222cc
movl 0x14261(%rip), %eax     # 0x222cc
movl %eax, -0x78(%rbp)
movb 0x14254(%rip), %al      # 0x222c8
movb %al, -0x71(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x3510
movq -0x70(%rbp), %rdx
leaq 0xb255(%rip), %rsi      # 0x192e4
leaq -0x28(%rbp), %rdi
callq 0xb640
jmp 0xe09a
movl -0x78(%rbp), %edi
movb -0x71(%rbp), %al
movsbl %al, %esi
leaq -0x28(%rbp), %rdx
callq 0x15530
jmp 0xe0ae
leaq -0x28(%rbp), %rdi
callq 0x3558
leaq -0x29(%rbp), %rdi
callq 0x3300
movq -0x80(%rbp), %rdi
callq 0xed50
movq -0x80(%rbp), %rdi
movl $0xf, %esi
callq 0xd670
movq -0x80(%rbp), %rdi
callq 0xf0c0
movl 0x141e6(%rip), %eax     # 0x222cc
decl %eax
movl %eax, 0x141de(%rip)     # 0x222cc
movl 0x141d8(%rip), %eax     # 0x222cc
movl %eax, -0x90(%rbp)
movb 0x141c8(%rip), %al      # 0x222c8
movb %al, -0x89(%rbp)
leaq -0x61(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x3510
movq -0x88(%rbp), %rdx
leaq 0xb1c0(%rip), %rsi      # 0x192e4
leaq -0x60(%rbp), %rdi
callq 0xb640
jmp 0xe12f
movl -0x90(%rbp), %edi
movb -0x89(%rbp), %al
movsbl %al, %esi
leaq -0x60(%rbp), %rdx
callq 0x15550
jmp 0xe149
leaq -0x60(%rbp), %rdi
callq 0x3558
leaq -0x61(%rbp), %rdi
callq 0x3300
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0xe187
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3558
leaq -0x29(%rbp), %rdi
callq 0x3300
jmp 0xe1be
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0xe1b5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x3558
leaq -0x61(%rbp), %rdi
callq 0x3300
movq -0x38(%rbp), %rdi
callq 0x3500
nopw (%rax,%rax)
// File: Blaze2305[P]Compiler-Design-2021-Assignment/src/Parser/Parser.cpp
// Function: Parser::parseDecl()
void Parser::parseDecl(){
	tabNum+=1;
	printParseEnters(tabNum,tabChar,"parseDecl");
	accept(Def);
	parseTypeList();
	accept(End);
	tabNum-=1;
	printParseExits(tabNum,tabChar,"parseDecl");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
movl 0x140df(%rip), %eax     # 0x222cc
incl %eax
movl %eax, 0x140d7(%rip)     # 0x222cc
movl 0x140d1(%rip), %eax     # 0x222cc
movl %eax, -0x78(%rbp)
movb 0x140c4(%rip), %al      # 0x222c8
movb %al, -0x71(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x3510
movq -0x70(%rbp), %rdx
leaq 0xb07e(%rip), %rsi      # 0x1929d
leaq -0x28(%rbp), %rdi
callq 0xb640
jmp 0xe22a
movl -0x78(%rbp), %edi
movb -0x71(%rbp), %al
movsbl %al, %esi
leaq -0x28(%rbp), %rdx
callq 0x15530
jmp 0xe23e
leaq -0x28(%rbp), %rdi
callq 0x3558
leaq -0x29(%rbp), %rdi
callq 0x3300
movq -0x80(%rbp), %rdi
movl $0xc, %esi
callq 0xd670
movq -0x80(%rbp), %rdi
callq 0xe360
movq -0x80(%rbp), %rdi
movl $0xb, %esi
callq 0xd670
movl 0x14051(%rip), %eax     # 0x222cc
decl %eax
movl %eax, 0x14049(%rip)     # 0x222cc
movl 0x14043(%rip), %eax     # 0x222cc
movl %eax, -0x90(%rbp)
movb 0x14033(%rip), %al      # 0x222c8
movb %al, -0x89(%rbp)
leaq -0x61(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x3510
movq -0x88(%rbp), %rdx
leaq 0xafe4(%rip), %rsi      # 0x1929d
leaq -0x60(%rbp), %rdi
callq 0xb640
jmp 0xe2c4
movl -0x90(%rbp), %edi
movb -0x89(%rbp), %al
movsbl %al, %esi
leaq -0x60(%rbp), %rdx
callq 0x15550
jmp 0xe2de
leaq -0x60(%rbp), %rdi
callq 0x3558
leaq -0x61(%rbp), %rdi
callq 0x3300
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0xe31c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3558
leaq -0x29(%rbp), %rdi
callq 0x3300
jmp 0xe353
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0xe34a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x3558
leaq -0x61(%rbp), %rdi
callq 0x3300
movq -0x38(%rbp), %rdi
callq 0x3500
nopl (%rax)
// File: Blaze2305[P]Compiler-Design-2021-Assignment/src/Parser/Parser.cpp
// Function: Parser::parseTypeList()
void Parser::parseTypeList(){
	tabNum+=1;
	printParseEnters(tabNum,tabChar,"parseTypeList");
	parseVarList();
	accept(Colon);
	parseType();
	accept(SemiColon);
	parseTypeListA();
	tabNum-=1;
	printParseExits(tabNum,tabChar,"parseTypeList");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
movl 0x13f4f(%rip), %eax     # 0x222cc
incl %eax
movl %eax, 0x13f47(%rip)     # 0x222cc
movl 0x13f41(%rip), %eax     # 0x222cc
movl %eax, -0x78(%rbp)
movb 0x13f34(%rip), %al      # 0x222c8
movb %al, -0x71(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x3510
movq -0x70(%rbp), %rdx
leaq 0xaef8(%rip), %rsi      # 0x192a7
leaq -0x28(%rbp), %rdi
callq 0xb640
jmp 0xe3ba
movl -0x78(%rbp), %edi
movb -0x71(%rbp), %al
movsbl %al, %esi
leaq -0x28(%rbp), %rdx
callq 0x15530
jmp 0xe3ce
leaq -0x28(%rbp), %rdi
callq 0x3558
leaq -0x29(%rbp), %rdi
callq 0x3300
movq -0x80(%rbp), %rdi
callq 0xe500
movq -0x80(%rbp), %rdi
movl $0xe, %esi
callq 0xd670
movq -0x80(%rbp), %rdi
callq 0xe6c0
movq -0x80(%rbp), %rdi
movl $0xf, %esi
callq 0xd670
movq -0x80(%rbp), %rdi
callq 0xea00
movl 0x13eaf(%rip), %eax     # 0x222cc
decl %eax
movl %eax, 0x13ea7(%rip)     # 0x222cc
movl 0x13ea1(%rip), %eax     # 0x222cc
movl %eax, -0x90(%rbp)
movb 0x13e91(%rip), %al      # 0x222c8
movb %al, -0x89(%rbp)
leaq -0x61(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x3510
movq -0x88(%rbp), %rdx
leaq 0xae4c(%rip), %rsi      # 0x192a7
leaq -0x60(%rbp), %rdi
callq 0xb640
jmp 0xe466
movl -0x90(%rbp), %edi
movb -0x89(%rbp), %al
movsbl %al, %esi
leaq -0x60(%rbp), %rdx
callq 0x15550
jmp 0xe480
leaq -0x60(%rbp), %rdi
callq 0x3558
leaq -0x61(%rbp), %rdi
callq 0x3300
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0xe4be
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3558
leaq -0x29(%rbp), %rdi
callq 0x3300
jmp 0xe4f5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0xe4ec
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x3558
leaq -0x61(%rbp), %rdi
callq 0x3300
movq -0x38(%rbp), %rdi
callq 0x3500
nop
// File: Blaze2305[P]Compiler-Design-2021-Assignment/src/Parser/Parser.cpp
// Function: Parser::parseVarList()
void Parser::parseVarList(){
	tabNum+=1;
	printParseEnters(tabNum,tabChar,"parseVarList");
	if(checkToken(Identifier)){
		parseVar();
		if(checkToken(Comma)){
			accept(Comma);
			parseVarList();
		}
	}
	tabNum-=1;
	printParseExits(tabNum,tabChar,"parseVarList");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
movl 0x13daf(%rip), %eax     # 0x222cc
incl %eax
movl %eax, 0x13da7(%rip)     # 0x222cc
movl 0x13da1(%rip), %eax     # 0x222cc
movl %eax, -0x78(%rbp)
movb 0x13d94(%rip), %al      # 0x222c8
movb %al, -0x71(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x3510
movq -0x70(%rbp), %rdx
leaq 0xad7f(%rip), %rsi      # 0x192ce
leaq -0x28(%rbp), %rdi
callq 0xb640
jmp 0xe55a
movl -0x78(%rbp), %edi
movb -0x71(%rbp), %al
movsbl %al, %esi
leaq -0x28(%rbp), %rdx
callq 0x15530
jmp 0xe56e
leaq -0x28(%rbp), %rdi
callq 0x3558
leaq -0x29(%rbp), %rdi
callq 0x3300
movq -0x80(%rbp), %rdi
xorl %esi, %esi
callq 0xdb20
testb $0x1, %al
jne 0xe591
jmp 0xe5fa
movq -0x80(%rbp), %rdi
callq 0xebc0
movq -0x80(%rbp), %rdi
movl $0x15, %esi
callq 0xdb20
testb $0x1, %al
jne 0xe5ae
jmp 0xe5f8
movq -0x80(%rbp), %rdi
movl $0x15, %esi
callq 0xd670
movq -0x80(%rbp), %rdi
callq 0xe500
jmp 0xe5f8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0xe5ea
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3558
leaq -0x29(%rbp), %rdi
callq 0x3300
jmp 0xe6aa
jmp 0xe5fa
movl 0x13ccc(%rip), %eax     # 0x222cc
decl %eax
movl %eax, 0x13cc4(%rip)     # 0x222cc
movl 0x13cbe(%rip), %eax     # 0x222cc
movl %eax, -0x90(%rbp)
movb 0x13cae(%rip), %al      # 0x222c8
movb %al, -0x89(%rbp)
leaq -0x61(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x3510
movq -0x88(%rbp), %rdx
leaq 0xac90(%rip), %rsi      # 0x192ce
leaq -0x60(%rbp), %rdi
callq 0xb640
jmp 0xe649
movl -0x90(%rbp), %edi
movb -0x89(%rbp), %al
movsbl %al, %esi
leaq -0x60(%rbp), %rdx
callq 0x15550
jmp 0xe663
leaq -0x60(%rbp), %rdi
callq 0x3558
leaq -0x61(%rbp), %rdi
callq 0x3300
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0xe6a1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x3558
leaq -0x61(%rbp), %rdi
callq 0x3300
movq -0x38(%rbp), %rdi
callq 0x3500
nopw %cs:(%rax,%rax)
// File: Blaze2305[P]Compiler-Design-2021-Assignment/src/Parser/Parser.cpp
// Function: Parser::parseTypeListA()
void Parser::parseTypeListA(){
	tabNum+=1;
	printParseEnters(tabNum,tabChar,"parseTypeListA");
	if(checkToken(Identifier)){
		parseVarList();
		accept(Colon);
		parseType();
		accept(SemiColon);
		parseTypeListA();
	}
	tabNum-=1;
	printParseExits(tabNum,tabChar,"parseTypeListA");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
movl 0x138af(%rip), %eax     # 0x222cc
incl %eax
movl %eax, 0x138a7(%rip)     # 0x222cc
movl 0x138a1(%rip), %eax     # 0x222cc
movl %eax, -0x78(%rbp)
movb 0x13894(%rip), %al      # 0x222c8
movb %al, -0x71(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x3510
movq -0x70(%rbp), %rdx
leaq 0xa866(%rip), %rsi      # 0x192b5
leaq -0x28(%rbp), %rdi
callq 0xb640
jmp 0xea5a
movl -0x78(%rbp), %edi
movb -0x71(%rbp), %al
movsbl %al, %esi
leaq -0x28(%rbp), %rdx
callq 0x15530
jmp 0xea6e
leaq -0x28(%rbp), %rdi
callq 0x3558
leaq -0x29(%rbp), %rdi
callq 0x3300
movq -0x80(%rbp), %rdi
xorl %esi, %esi
callq 0xdb20
testb $0x1, %al
jne 0xea91
jmp 0xeafb
movq -0x80(%rbp), %rdi
callq 0xe500
movq -0x80(%rbp), %rdi
movl $0xe, %esi
callq 0xd670
movq -0x80(%rbp), %rdi
callq 0xe6c0
movq -0x80(%rbp), %rdi
movl $0xf, %esi
callq 0xd670
movq -0x80(%rbp), %rdi
callq 0xea00
jmp 0xeafb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0xeaed
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3558
leaq -0x29(%rbp), %rdi
callq 0x3300
jmp 0xebab
movl 0x137cb(%rip), %eax     # 0x222cc
decl %eax
movl %eax, 0x137c3(%rip)     # 0x222cc
movl 0x137bd(%rip), %eax     # 0x222cc
movl %eax, -0x90(%rbp)
movb 0x137ad(%rip), %al      # 0x222c8
movb %al, -0x89(%rbp)
leaq -0x61(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x3510
movq -0x88(%rbp), %rdx
leaq 0xa776(%rip), %rsi      # 0x192b5
leaq -0x60(%rbp), %rdi
callq 0xb640
jmp 0xeb4a
movl -0x90(%rbp), %edi
movb -0x89(%rbp), %al
movsbl %al, %esi
leaq -0x60(%rbp), %rdx
callq 0x15550
jmp 0xeb64
leaq -0x60(%rbp), %rdi
callq 0x3558
leaq -0x61(%rbp), %rdi
callq 0x3300
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0xeba2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x3558
leaq -0x61(%rbp), %rdi
callq 0x3300
movq -0x38(%rbp), %rdi
callq 0x3500
nopw %cs:(%rax,%rax)
// File: Blaze2305[P]Compiler-Design-2021-Assignment/src/Parser/Parser.cpp
// Function: Parser::parseVar()
void Parser::parseVar(){
	tabNum+=1;
	printParseEnters(tabNum,tabChar,"parseVar");
	this->symbolNamesList.push_back(this->currentToken.Value);
	accept(Identifier);
	tabNum-=1;
	printParseExits(tabNum,tabChar,"parseVar");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
movl 0x136ef(%rip), %eax     # 0x222cc
incl %eax
movl %eax, 0x136e7(%rip)     # 0x222cc
movl 0x136e1(%rip), %eax     # 0x222cc
movl %eax, -0x78(%rbp)
movb 0x136d4(%rip), %al      # 0x222c8
movb %al, -0x71(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x3510
movq -0x70(%rbp), %rdx
leaq 0xa6cc(%rip), %rsi      # 0x192db
leaq -0x28(%rbp), %rdi
callq 0xb640
jmp 0xec1a
movl -0x78(%rbp), %edi
movb -0x71(%rbp), %al
movsbl %al, %esi
leaq -0x28(%rbp), %rdx
callq 0x15530
jmp 0xec2e
leaq -0x28(%rbp), %rdi
callq 0x3558
leaq -0x29(%rbp), %rdi
callq 0x3300
movq -0x80(%rbp), %rsi
movq %rsi, %rdi
addq $0x70, %rdi
addq $0x8, %rsi
callq 0x10760
movq -0x80(%rbp), %rdi
xorl %esi, %esi
callq 0xd670
movl 0x13667(%rip), %eax     # 0x222cc
decl %eax
movl %eax, 0x1365f(%rip)     # 0x222cc
movl 0x13659(%rip), %eax     # 0x222cc
movl %eax, -0x90(%rbp)
movb 0x13649(%rip), %al      # 0x222c8
movb %al, -0x89(%rbp)
leaq -0x61(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x3510
movq -0x88(%rbp), %rdx
leaq 0xa638(%rip), %rsi      # 0x192db
leaq -0x60(%rbp), %rdi
callq 0xb640
jmp 0xecae
movl -0x90(%rbp), %edi
movb -0x89(%rbp), %al
movsbl %al, %esi
leaq -0x60(%rbp), %rdx
callq 0x15550
jmp 0xecc8
leaq -0x60(%rbp), %rdi
callq 0x3558
leaq -0x61(%rbp), %rdi
callq 0x3300
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0xed06
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3558
leaq -0x29(%rbp), %rdi
callq 0x3300
jmp 0xed3d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0xed34
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x3558
leaq -0x61(%rbp), %rdi
callq 0x3300
movq -0x38(%rbp), %rdi
callq 0x3500
nopw %cs:(%rax,%rax)
// File: Blaze2305[P]Compiler-Design-2021-Assignment/src/Parser/Parser.cpp
// Function: Parser::parseStmtListA()
void Parser::parseStmtListA(){
	tabNum+=1;
	printParseEnters(tabNum,tabChar,"parseStmtListA");
	if(checkToken(Identifier) || checkToken(Read) || checkToken(Print) || checkToken(If) || checkToken(While)){
		parseStmt();
		accept(SemiColon);
		parseStmtListA();
	}
	tabNum-=1;
	printParseExits(tabNum,tabChar,"parseStmtListA");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
movl 0x131ef(%rip), %eax     # 0x222cc
incl %eax
movl %eax, 0x131e7(%rip)     # 0x222cc
movl 0x131e1(%rip), %eax     # 0x222cc
movl %eax, -0x78(%rbp)
movb 0x131d4(%rip), %al      # 0x222c8
movb %al, -0x71(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x3510
movq -0x70(%rbp), %rdx
leaq 0xa1e3(%rip), %rsi      # 0x192f2
leaq -0x28(%rbp), %rdi
callq 0xb640
jmp 0xf11a
movl -0x78(%rbp), %edi
movb -0x71(%rbp), %al
movsbl %al, %esi
leaq -0x28(%rbp), %rdx
callq 0x15530
jmp 0xf12e
leaq -0x28(%rbp), %rdi
callq 0x3558
leaq -0x29(%rbp), %rdi
callq 0x3300
movq -0x80(%rbp), %rdi
xorl %esi, %esi
callq 0xdb20
testb $0x1, %al
jne 0xf199
movq -0x80(%rbp), %rdi
movl $0x13, %esi
callq 0xdb20
testb $0x1, %al
jne 0xf199
movq -0x80(%rbp), %rdi
movl $0x14, %esi
callq 0xdb20
testb $0x1, %al
jne 0xf199
movq -0x80(%rbp), %rdi
movl $0x10, %esi
callq 0xdb20
testb $0x1, %al
jne 0xf199
movq -0x80(%rbp), %rdi
movl $0x12, %esi
callq 0xdb20
testb $0x1, %al
jne 0xf199
jmp 0xf1ec
movq -0x80(%rbp), %rdi
callq 0xed50
movq -0x80(%rbp), %rdi
movl $0xf, %esi
callq 0xd670
movq -0x80(%rbp), %rdi
callq 0xf0c0
jmp 0xf1ec
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0xf1de
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3558
leaq -0x29(%rbp), %rdi
callq 0x3300
jmp 0xf29c
movl 0x130da(%rip), %eax     # 0x222cc
decl %eax
movl %eax, 0x130d2(%rip)     # 0x222cc
movl 0x130cc(%rip), %eax     # 0x222cc
movl %eax, -0x90(%rbp)
movb 0x130bc(%rip), %al      # 0x222c8
movb %al, -0x89(%rbp)
leaq -0x61(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x3510
movq -0x88(%rbp), %rdx
leaq 0xa0c2(%rip), %rsi      # 0x192f2
leaq -0x60(%rbp), %rdi
callq 0xb640
jmp 0xf23b
movl -0x90(%rbp), %edi
movb -0x89(%rbp), %al
movsbl %al, %esi
leaq -0x60(%rbp), %rdx
callq 0x15550
jmp 0xf255
leaq -0x60(%rbp), %rdi
callq 0x3558
leaq -0x61(%rbp), %rdi
callq 0x3300
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0xf293
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x3558
leaq -0x61(%rbp), %rdi
callq 0x3300
movq -0x38(%rbp), %rdi
callq 0x3500
nopw %cs:(%rax,%rax)
// File: Blaze2305[P]Compiler-Design-2021-Assignment/src/Parser/Parser.cpp
// Function: Parser::parseAssignementStmt()
void Parser::parseAssignementStmt(){
	tabNum+=1;
	printParseEnters(tabNum,tabChar,"parseAssignementStmt");
	accept(Identifier);
	accept(Assignment);
	parseExp();
	tabNum-=1;
	printParseExits(tabNum,tabChar,"parseAssignementStmt");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
movl 0x12fff(%rip), %eax     # 0x222cc
incl %eax
movl %eax, 0x12ff7(%rip)     # 0x222cc
movl 0x12ff1(%rip), %eax     # 0x222cc
movl %eax, -0x78(%rbp)
movb 0x12fe4(%rip), %al      # 0x222c8
movb %al, -0x71(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x3510
movq -0x70(%rbp), %rdx
leaq 0xa00c(%rip), %rsi      # 0x1930b
leaq -0x28(%rbp), %rdi
callq 0xb640
jmp 0xf30a
movl -0x78(%rbp), %edi
movb -0x71(%rbp), %al
movsbl %al, %esi
leaq -0x28(%rbp), %rdx
callq 0x15530
jmp 0xf31e
leaq -0x28(%rbp), %rdi
callq 0x3558
leaq -0x29(%rbp), %rdi
callq 0x3300
movq -0x80(%rbp), %rdi
xorl %esi, %esi
callq 0xd670
movq -0x80(%rbp), %rdi
movl $0xd, %esi
callq 0xd670
movq -0x80(%rbp), %rdi
callq 0xfaa0
movl 0x12f74(%rip), %eax     # 0x222cc
decl %eax
movl %eax, 0x12f6c(%rip)     # 0x222cc
movl 0x12f66(%rip), %eax     # 0x222cc
movl %eax, -0x90(%rbp)
movb 0x12f56(%rip), %al      # 0x222c8
movb %al, -0x89(%rbp)
leaq -0x61(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x3510
movq -0x88(%rbp), %rdx
leaq 0x9f75(%rip), %rsi      # 0x1930b
leaq -0x60(%rbp), %rdi
callq 0xb640
jmp 0xf3a1
movl -0x90(%rbp), %edi
movb -0x89(%rbp), %al
movsbl %al, %esi
leaq -0x60(%rbp), %rdx
callq 0x15550
jmp 0xf3bb
leaq -0x60(%rbp), %rdi
callq 0x3558
leaq -0x61(%rbp), %rdi
callq 0x3300
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0xf3f9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3558
leaq -0x29(%rbp), %rdi
callq 0x3300
jmp 0xf430
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0xf427
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x3558
leaq -0x61(%rbp), %rdi
callq 0x3300
movq -0x38(%rbp), %rdi
callq 0x3500
nopl (%rax)