LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r12
leaq 0x28d8(%rip), %rsi      # 0xc55b
callq 0x21d0
testq %rax, %rax
je 0x9d16
movq %rax, %rbx
xorl %r14d, %r14d
movq %rax, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x21c0
movq %rbx, %rdi
callq 0x2030
movl %eax, 0x8(%r15)
movq %rbx, %rdi
callq 0x2070
movl 0x8(%r15), %r12d
movq %r12, %rdi
callq 0x21f0
movq %rax, (%r15)
testq %rax, %rax
je 0x9d0c
movl $0x1, %esi
movq %rax, %rdi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x2240
movl 0x8(%r15), %ecx
cmpq %rcx, %rax
jne 0x9d0c
movq (%r15), %rax
cmpl $0x46464952, (%rax)     # imm = 0x46464952
jne 0x9d09
cmpl $0x32464957, 0x8(%rax)  # imm = 0x32464957
jne 0x9d09
movl $0x1, %r14d
cmpl 0x4(%rax), %ecx
je 0x9d0c
xorl %r14d, %r14d
movq %rbx, %rdi
callq 0x21a0
jmp 0x9d2a
leaq 0x2e84(%rip), %rdi      # 0xcba1
xorl %r14d, %r14d
movq %r12, %rsi
xorl %eax, %eax
callq 0x2050
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl $0x10, %edi
callq 0x21f0
testq %rax, %rax
je 0x9f85
movq (%rbx), %rcx
movq %r14, (%rax)
movq $0x0, 0x8(%rax)
testq %rcx, %rcx
je 0x9f89
movq %rcx, %rbx
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
jne 0x9f6e
addq $0x8, %rbx
movl $0x1, %ecx
jmp 0x9f8b
xorl %ecx, %ecx
jmp 0x9f8e
xorl %ecx, %ecx
movq %rax, (%rbx)
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
testq %rdi, %rdi
je 0x9fb0
pushq %rbx
movq 0x8(%rdi), %rbx
callq 0x21e0
movq %rbx, %rdi
testq %rbx, %rbx
jne 0x9f9e
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
movl $0x41524546, %edx       # imm = 0x41524546
callq 0xa1eb
xorl %ebx, %ebx
testl %eax, %eax
je 0xa377
movq %r14, %rdi
movq %r15, %rsi
movl $0x4e494246, %edx       # imm = 0x4E494246
callq 0x9d4a
testl %eax, %eax
je 0xa377
movl $0x1, %ebx
movq %r14, %rdi
movl $0x1, %esi
xorl %edx, %edx
callq *0x2d8(%r14)
leaq 0x234a(%rip), %rdi      # 0xc6b2
callq 0x2270
movl $0x7d0, %edi            # imm = 0x7D0
callq 0x259c
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/chenhn123[P]wdt_util_src/wdt_ct/wif2_handler.cpp
// Function: do_show_wif2_info_chunk(WifFile2*)
int do_show_wif2_info_chunk(WIF_FILE2 *pcur_wif)
{
	if (!pcur_wif)
		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 == FOURCC_ID_INFO) {
			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;
			}

			memcpy((BYTE *)pchunk_info_ex->BinaryData, (BYTE *)&pcur_wif->pdata[chunk_start_pos],
			       pchunk_data->Size);
			for (size_t i = 0; i < pchunk_data->Size; i++)
				printf("%c", (unsigned char)(pchunk_info_ex->BinaryData[i]));
			printf("\n");

			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:
testq %rdi, %rdi
je 0xa432
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x1, %eax
cmpl $0xd, 0x8(%rdi)
jb 0xa437
movl $0xc, %ebp
movq (%r14), %r15
movl %ebp, %ebx
movl 0x4(%r15,%rbx), %r13d
cmpl $0x4f464e49, (%r15,%rbx) # imm = 0x4F464E49
jne 0xa41f
movq %r13, %rdi
callq 0x21f0
testq %rax, %rax
je 0xa435
movq %rax, %r12
addq %rbx, %r15
movq %rax, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x2150
cmpl $0x0, 0x4(%r15)
je 0xa409
xorl %r13d, %r13d
movzbl (%r12,%r13), %edi
callq 0x2200
incq %r13
movl 0x4(%r15), %eax
cmpq %rax, %r13
jb 0xa3f3
movl $0xa, %edi
callq 0x2200
movl 0x4(%r15), %r13d
movq %r12, %rdi
callq 0x21e0
addl %r13d, %ebp
addl $0x8, %ebp
cmpl 0x8(%r14), %ebp
jb 0xa3b4
movl $0x1, %eax
jmp 0xa437
xorl %eax, %eax
retq
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
subq $0x10, %rsp
movq %rsp, %rsi
callq 0x9c6e
testl %eax, %eax
je 0xa463
movq %rsp, %rdi
callq 0xa389
movl %eax, %ebx
jmp 0xa465
xorl %ebx, %ebx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0xa473
callq 0x21e0
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
subq $0x10, %rsp
movq %rsi, %rax
movq %rdi, %rbx
movq %rsp, %rsi
movq %rax, %rdi
callq 0x9c6e
testl %eax, %eax
je 0xa4a4
movq %rsp, %rsi
movq %rbx, %rdi
callq 0xa31c
movl %eax, %ebx
jmp 0xa4a6
xorl %ebx, %ebx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0xa4b4
callq 0x21e0
leaq 0x2766(%rip), %rdi      # 0xcc21
callq 0x2270
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rax
movq %rdi, %rbx
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x9c6e
testl %eax, %eax
je 0xa4fb
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
movl $0x4d555346, %edx       # imm = 0x4D555346
callq 0x9fb1
movl %eax, %ebp
jmp 0xa4fd
xorl %ebp, %ebp
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xa50c
callq 0x21e0
movq %rbx, %rdi
callq *0x2a0(%rbx)
leaq 0x2705(%rip), %rdi      # 0xcc21
callq 0x2270
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/wwdatabase[P]database/./smmana/sm.h
// Function: SM_Manager::create_db(char const*)
RC SM_Manager::create_db(const char* dbname)
{
	char* name;
	DB new_db(dbname);
	databases.push_back(new_db);// revise the system file
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x120, %rsp            # imm = 0x120
movq %rsi, %r14
movq %rdi, %r15
leaq -0x38(%rbp), %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
leaq -0x138(%rbp), %r12
movq %r12, %rdi
callq 0x21a0
movq %r14, %rdi
movl $0x1c0, %esi            # imm = 0x1C0
callq 0x20d0
movq %r15, %rdi
movq %r12, %rsi
callq 0x5a90
movq %rbx, %rdi
callq 0x6bbe
xorl %eax, %eax
addq $0x120, %rsp            # imm = 0x120
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x6bbe
movq %r14, %rdi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq (%rdi), %r14
movq 0x8(%rdi), %r12
cmpq %r12, %r14
sete %r13b
je 0x3bde
movq %rsi, %r15
movq %rdi, %rbx
movq %r15, %rdi
movq %r14, %rsi
callq 0x2240
testl %eax, %eax
je 0x3b89
addq $0x118, %r14            # imm = 0x118
cmpq %r12, %r14
sete %r13b
jne 0x3b68
jmp 0x3bde
leaq -0x130(%rbp), %r12
movl $0xff, %edx
movq %r12, %rdi
xorl %esi, %esi
callq 0x2100
movl $0x2d206d72, (%r12)     # imm = 0x2D206D72
movw $0x2072, 0x4(%r12)      # imm = 0x2072
movq %r12, %rdi
movq %r15, %rsi
callq 0x2330
movq %r12, %rdi
callq 0x2180
leaq 0x58bd(%rip), %rdi      # 0x9486
callq 0x22c0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7eec
testb %r13b, %r13b
je 0x3bea
leaq 0x58b4(%rip), %rdi      # 0x9499
callq 0x22c0
xorl %eax, %eax
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %r15
movq 0x8(%rdi), %r12
movabsq $-0x5075075075075075, %rcx # imm = 0xAF8AF8AF8AF8AF8B
subq %r15, %r12
je 0x3c5e
sarq $0x3, %r12
imulq %rcx, %r12
cmpq $0x1, %r12
adcq $0x0, %r12
xorl %r13d, %r13d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2240
testl %eax, %eax
je 0x3c63
incq %r13
addq $0x118, %r15            # imm = 0x118
cmpq %r13, %r12
jne 0x3c3b
movq %r12, %r13
jmp 0x3c78
xorl %r13d, %r13d
jmp 0x3c82
movl %r13d, 0x18(%r14)
leaq 0x561b(%rip), %rdi      # 0x9289
movq %r15, %rsi
xorl %eax, %eax
callq 0x2050
movabsq $-0x5075075075075075, %rcx # imm = 0xAF8AF8AF8AF8AF8B
movq 0x8(%r14), %rax
subq (%r14), %rax
sarq $0x3, %rax
imulq %rcx, %rax
cmpq %r13, %rax
jne 0x3ca7
leaq 0x5604(%rip), %rdi      # 0x92a1
movq %rbx, %rsi
xorl %eax, %eax
callq 0x2050
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
callq 0x47f8
movq 0x11a17(%rip), %rbx     # 0x15fd0
leaq 0xba6e(%rip), %rsi      # 0x1002e
movl $0x13, %edx
movq %rbx, %rdi
callq 0x4210
cvtss2sd 0x11c33(%rip), %xmm0    # 0x16208
movq %rbx, %rdi
callq 0x42b0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x41b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x4030
movq %rax, %rdi
callq 0x4150
movq %rax, %rbx
leaq 0xba31(%rip), %rsi      # 0x10042
movl $0x11, %edx
movq %rax, %rdi
callq 0x4210
movl 0x11be0(%rip), %esi     # 0x16204
movq %rbx, %rdi
callq 0x4310
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x41b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x4030
movq %rax, %rdi
callq 0x4150
movq %rax, %rbx
leaq 0xb9f4(%rip), %rsi      # 0x10054
movl $0x14, %edx
movq %rax, %rdi
callq 0x4210
movq 0x11b9c(%rip), %rsi     # 0x16210
movq 0x11b9d(%rip), %rdx     # 0x16218
movq %rbx, %rdi
callq 0x4210
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x41b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x4030
movq %rax, %rdi
callq 0x4150
movq %rax, %rbx
leaq 0xb9b2(%rip), %rsi      # 0x10069
movl $0x16, %edx
movq %rax, %rdi
callq 0x4210
movq 0x11b65(%rip), %rsi     # 0x16230
movq 0x11b66(%rip), %rdx     # 0x16238
movq %rbx, %rdi
callq 0x4210
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x41b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x4030
movq %rax, %rdi
callq 0x4150
movq %rax, %rbx
leaq 0xb972(%rip), %rsi      # 0x10080
movl $0x14, %edx
movq %rax, %rdi
callq 0x4210
movzbl 0x11aea(%rip), %esi     # 0x1620c
movq %rbx, %rdi
callq 0x42e0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x41b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x4030
movq %rax, %rdi
callq 0x4150
movq %rax, %rbx
leaq 0xb937(%rip), %rsi      # 0x10095
movl $0x14, %edx
movq %rax, %rdi
callq 0x4210
movzbl 0x11a9b(%rip), %esi     # 0x1620d
movq %rbx, %rdi
callq 0x42e0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x41b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x4030
movq %rax, %rdi
callq 0x4150
movq %rax, %rbx
leaq 0xb8fc(%rip), %rsi      # 0x100aa
movl $0x14, %edx
movq %rax, %rdi
callq 0x4210
movzbl 0x11a4c(%rip), %esi     # 0x1620e
movq %rbx, %rdi
callq 0x42e0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x41b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x4030
movq %rax, %rdi
callq 0x4150
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/Blaze2305[P]Compiler-Design-2021-Assignment/main.cpp
// Function: main
int main(int argc, char *argv[]){
	// Check if the file is passed as an argument or not
	// if not then error out
 	if(argc != 2){
		std::cout<<"\nFile Missing , Invalid number of arguments\n";
		return 1;
	}
	std::cout<<"----------------------------------------------------------------------------\n";
	std::cout<<argv[1]<<std::endl;
	std::cout<<"----------------------------------------------------------------------------\n";
	

	// TESTING SCANNER 
	// Scanner scanner = Scanner(argv[1]);
	// while(true){
	// 	TokenRecord val = scanner.getToken();
	// 	std::cout<<val;
	// 	if(val.tokenType==EOT){
	// 		break;
	// 	}
	// }

	Parser parser = Parser(argv[1]);
	try{
		parser.parse();
	}catch(std::runtime_error err){
		std::cout<<"INVALID \n";
		std::cout<<err.what();
		exit(1);
	}
	std::cout<<"VALID CODE\n";
	parser.showSymbolTable();

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xb8, %rsp
cmpl $0x2, %edi
jne 0x6034
movq %rsi, %rbx
movq 0x9fd5(%rip), %r14      # 0xffd0
leaq 0x6108(%rip), %rsi      # 0xc10a
movl $0x4d, %edx
movq %r14, %rdi
callq 0x2210
movq 0x8(%rbx), %r15
testq %r15, %r15
je 0x6056
movq %r15, %rdi
callq 0x20e0
movq 0x9fa9(%rip), %rdi      # 0xffd0
movq %r15, %rsi
movq %rax, %rdx
callq 0x2210
jmp 0x606e
movq 0x9f95(%rip), %rdi      # 0xffd0
leaq 0x6058(%rip), %rsi      # 0xc09a
movl $0x2c, %edx
callq 0x2210
movl $0x1, %eax
jmp 0x6121
movq (%r14), %rax
movq -0x18(%rax), %rax
leaq (%r14,%rax), %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0x2360
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x21b0
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2130
leaq 0x606e(%rip), %rsi      # 0xc10a
movl $0x4d, %edx
movq %r14, %rdi
callq 0x2210
movq 0x8(%rbx), %rsi
leaq -0x48(%rbp), %rdi
leaq -0x28(%rbp), %rdx
callq 0x61e6
leaq -0xd0(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x6b98
leaq -0x38(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x60e3
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21e0
leaq -0xd0(%rbp), %rdi
callq 0x7100
movq 0x9eda(%rip), %rdi      # 0xffd0
leaq 0x5fd4(%rip), %rsi      # 0xc0d1
movl $0xb, %edx
callq 0x2210
leaq -0xd0(%rbp), %rdi
callq 0x6d0e
leaq -0xd0(%rbp), %rdi
callq 0x6cb2
xorl %eax, %eax
addq $0xb8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
cmpl $0x1, %edx
jne 0x61d2
movq %rbx, %rdi
callq 0x2270
leaq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x20d0
movq %rbx, %rdi
callq 0x20c0
movq 0x9e72(%rip), %rdi      # 0xffd0
leaq 0x5f62(%rip), %rsi      # 0xc0c7
movl $0x9, %edx
callq 0x2210
leaq -0x28(%rbp), %rdi
callq 0x22a0
movq 0x9e51(%rip), %rdi      # 0xffd0
movq %rax, %rsi
callq 0x21c0
movl $0x1, %edi
callq 0x2250
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
callq 0x23d8
callq 0x2330
jmp 0x61d2
movq %rax, %rdi
callq 0x63ac
movq %rax, %rbx
leaq -0x38(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x61de
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21e0
jmp 0x61de
movq %rax, %rbx
jmp 0x61de
movq %rax, %rbx
leaq -0xd0(%rbp), %rdi
callq 0x6cb2
movq %rbx, %rdi
callq 0x2390
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x5803(%rip), %r14      # 0xc107
movl $0x50, %edx
movq %r14, %rsi
callq 0x2210
leaq 0x5840(%rip), %rsi      # 0xc158
movl $0x10, %edx
movq %rbx, %rdi
callq 0x2210
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %rbx, %rdi
callq 0x2210
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x21b0
movsbl %al, %esi
movq %r12, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2130
leaq 0x581b(%rip), %rsi      # 0xc180
movl $0x9, %edx
movq %rbx, %rdi
callq 0x2210
movq 0x20(%r15), %rsi
movq 0x28(%r15), %rdx
movq %rbx, %rdi
callq 0x2210
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x21b0
movsbl %al, %esi
movq %r12, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2130
leaq 0x57de(%rip), %rsi      # 0xc191
movl $0xa, %edx
movq %rbx, %rdi
callq 0x2210
movq 0x40(%r15), %rsi
movq 0x48(%r15), %rdx
movq %rbx, %rdi
callq 0x2210
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x21b0
movsbl %al, %esi
movq %r12, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2130
leaq 0x5768(%rip), %rsi      # 0xc169
movl $0x10, %edx
movq %rbx, %rdi
callq 0x2210
movl 0x60(%r15), %esi
movq %rbx, %rdi
callq 0x2380
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x21b0
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2130
movl $0x50, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2210
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x568f(%rip), %r14      # 0xc107
movl $0x50, %edx
movq %r14, %rsi
callq 0x2210
leaq 0x56ee(%rip), %rsi      # 0xc17a
movl $0xf, %edx
movq %rbx, %rdi
callq 0x2210
movl (%r15), %eax
shlq $0x5, %rax
leaq 0x9ea9(%rip), %rcx      # 0x10950
movq (%rax,%rcx), %rsi
movq 0x8(%rax,%rcx), %rdx
movq %rbx, %rdi
callq 0x2210
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x21b0
movsbl %al, %esi
movq %r12, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2130
leaq 0x56a1(%rip), %rsi      # 0xc18a
movl $0x11, %edx
movq %rbx, %rdi
callq 0x2210
movq 0x8(%r15), %rsi
movq 0x10(%r15), %rdx
movq %rbx, %rdi
callq 0x2210
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x21b0
movsbl %al, %esi
movq %r12, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2130
leaq 0x5632(%rip), %rsi      # 0xc169
movl $0x10, %edx
movq %rbx, %rdi
callq 0x2210
movl 0x28(%r15), %esi
movq %rbx, %rdi
callq 0x2380
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x21b0
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2130
movl $0x50, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2210
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movq %rdi, %rbx
movq 0x30(%rdi), %rsi
leaq -0x1b0(%rbp), %r14
movq %r14, %rdi
callq 0x9a6e
movl (%r14), %eax
movl %eax, (%rbx)
leaq 0x8(%rbx), %rdi
leaq -0x1a8(%rbp), %r14
movq %r14, %rsi
callq 0x2260
movl 0x20(%r14), %eax
movl %eax, 0x28(%rbx)
movq (%r14), %rdi
leaq -0x198(%rbp), %rax
cmpq %rax, %rdi
je 0x7163
movq -0x198(%rbp), %rsi
incq %rsi
callq 0x21e0
movq %rbx, %rdi
callq 0x726a
cmpl $0x8, (%rbx)
jne 0x717e
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq -0x1b0(%rbp), %r14
movq %r14, %rdi
callq 0x2290
leaq 0x501c(%rip), %rsi      # 0xc1b0
movl $0x15, %edx
movq %r14, %rdi
callq 0x2210
movl 0x28(%rbx), %esi
leaq -0x1b0(%rbp), %rdi
callq 0x2380
leaq 0x506a(%rip), %rsi      # 0xc221
leaq -0x1b0(%rbp), %rdi
movl $0x1b, %edx
callq 0x2210
movl $0x10, %edi
callq 0x20f0
movq %rax, %rbx
leaq -0x1a8(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x2310
movb $0x1, %r15b
leaq -0x38(%rbp), %rsi
movq %rbx, %rdi
callq 0x2320
xorl %r15d, %r15d
movq 0x8df2(%rip), %rsi      # 0xfff0
movq 0x8dbb(%rip), %rdx      # 0xffc0
movq %rbx, %rdi
callq 0x2370
movq %rax, %r14
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7231
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x21e0
jmp 0x7231
movq %rax, %r14
movb $0x1, %r15b
testb %r15b, %r15b
je 0x7243
movq %rbx, %rdi
callq 0x2160
jmp 0x7243
movq %rax, %r14
movq 0x8d7e(%rip), %rsi      # 0xffc8
leaq -0x1b0(%rbp), %rdi
callq 0x2110
leaq -0x140(%rbp), %rdi
callq 0x20a0
movq %r14, %rdi
callq 0x2390
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movl 0x8f87(%rip), %r14d     # 0x1020c
incl %r14d
movl %r14d, 0x8f7d(%rip)     # 0x1020c
movsbl 0x8f71(%rip), %r15d     # 0x10208
leaq -0x58(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0x4f97(%rip), %rsi      # 0xc23d
leaq 0x4f9c(%rip), %rdx      # 0xc249
leaq -0x68(%rbp), %r12
movq %r12, %rdi
callq 0x644a
movl %r14d, %edi
movl %r15d, %esi
movq %r12, %rdx
callq 0xb315
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x72dc
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x21e0
movq %rbx, %rdi
movl $0xa, %esi
callq 0x6d1c
cmpl $0xc, (%rbx)
jne 0x72f6
movq %rbx, %rdi
callq 0x73a2
movb $0x1, 0x6c(%rbx)
movq %rbx, %rdi
callq 0x74be
movq %rbx, %rdi
movl $0xb, %esi
callq 0x6d1c
movl 0x8ef7(%rip), %ebx      # 0x1020c
decl %ebx
movl %ebx, 0x8eef(%rip)      # 0x1020c
movsbl 0x8ee3(%rip), %r14d     # 0x10208
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0x4f09(%rip), %rsi      # 0xc23d
leaq 0x4f0e(%rip), %rdx      # 0xc249
leaq -0x48(%rbp), %r15
movq %r15, %rdi
callq 0x644a
movl %ebx, %edi
movl %r14d, %esi
movq %r15, %rdx
callq 0xb31b
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x7369
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21e0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
jmp 0x7388
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x7399
movq (%r13), %rsi
incq %rsi
callq 0x21e0
movq %rbx, %rdi
callq 0x2390
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movl 0x8e4f(%rip), %r14d     # 0x1020c
incl %r14d
movl %r14d, 0x8e45(%rip)     # 0x1020c
movsbl 0x8e39(%rip), %r15d     # 0x10208
leaq -0x58(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0x4e6c(%rip), %rsi      # 0xc24a
leaq 0x4e72(%rip), %rdx      # 0xc257
leaq -0x68(%rbp), %r12
movq %r12, %rdi
callq 0x644a
movl %r14d, %edi
movl %r15d, %esi
movq %r12, %rdx
callq 0xb315
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x7414
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x21e0
movq %rbx, %rdi
callq 0x75e0
jmp 0x7426
movq %rbx, %rdi
callq 0x73a2
cmpl $0xc, (%rbx)
je 0x741e
movl 0x8ddb(%rip), %ebx      # 0x1020c
decl %ebx
movl %ebx, 0x8dd3(%rip)      # 0x1020c
movsbl 0x8dc7(%rip), %r14d     # 0x10208
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0x4dfa(%rip), %rsi      # 0xc24a
leaq 0x4e00(%rip), %rdx      # 0xc257
leaq -0x48(%rbp), %r15
movq %r15, %rdi
callq 0x644a
movl %ebx, %edi
movl %r14d, %esi
movq %r15, %rdx
callq 0xb31b
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x7485
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21e0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
jmp 0x74a4
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x74b5
movq (%r13), %rsi
incq %rsi
callq 0x21e0
movq %rbx, %rdi
callq 0x2390
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movl 0x8d33(%rip), %r14d     # 0x1020c
incl %r14d
movl %r14d, 0x8d29(%rip)     # 0x1020c
movsbl 0x8d1d(%rip), %r15d     # 0x10208
leaq -0x58(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0x4da5(%rip), %rsi      # 0xc29f
leaq 0x4dab(%rip), %rdx      # 0xc2ac
leaq -0x68(%rbp), %r12
movq %r12, %rdi
callq 0x644a
movl %r14d, %edi
movl %r15d, %esi
movq %r12, %rdx
callq 0xb315
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x7530
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x21e0
movq %rbx, %rdi
callq 0x7ee8
movq %rbx, %rdi
movl $0xf, %esi
callq 0x6d1c
movq %rbx, %rdi
callq 0x8122
movl 0x8cb9(%rip), %ebx      # 0x1020c
decl %ebx
movl %ebx, 0x8cb1(%rip)      # 0x1020c
movsbl 0x8ca5(%rip), %r14d     # 0x10208
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0x4d2d(%rip), %rsi      # 0xc29f
leaq 0x4d33(%rip), %rdx      # 0xc2ac
leaq -0x48(%rbp), %r15
movq %r15, %rdi
callq 0x644a
movl %ebx, %edi
movl %r14d, %esi
movq %r15, %rdx
callq 0xb31b
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x75a7
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21e0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
jmp 0x75c6
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x75d7
movq (%r13), %rsi
incq %rsi
callq 0x21e0
movq %rbx, %rdi
callq 0x2390
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movl 0x8c11(%rip), %r14d     # 0x1020c
incl %r14d
movl %r14d, 0x8c07(%rip)     # 0x1020c
movsbl 0x8bfb(%rip), %r15d     # 0x10208
leaq -0x58(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0x4c3c(%rip), %rsi      # 0xc258
leaq 0x4c3e(%rip), %rdx      # 0xc261
leaq -0x68(%rbp), %r12
movq %r12, %rdi
callq 0x644a
movl %r14d, %edi
movl %r15d, %esi
movq %r12, %rdx
callq 0xb315
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x7652
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x21e0
movq %rbx, %rdi
movl $0xc, %esi
callq 0x6d1c
movq %rbx, %rdi
callq 0x7706
movq %rbx, %rdi
movl $0xb, %esi
callq 0x6d1c
movl 0x8b92(%rip), %ebx      # 0x1020c
decl %ebx
movl %ebx, 0x8b8a(%rip)      # 0x1020c
movsbl 0x8b7e(%rip), %r14d     # 0x10208
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0x4bbf(%rip), %rsi      # 0xc258
leaq 0x4bc1(%rip), %rdx      # 0xc261
leaq -0x48(%rbp), %r15
movq %r15, %rdi
callq 0x644a
movl %ebx, %edi
movl %r14d, %esi
movq %r15, %rdx
callq 0xb31b
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x76ce
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21e0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
jmp 0x76ed
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x76fe
movq (%r13), %rsi
incq %rsi
callq 0x21e0
movq %rbx, %rdi
callq 0x2390
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movl 0x8aeb(%rip), %r14d     # 0x1020c
incl %r14d
movl %r14d, 0x8ae1(%rip)     # 0x1020c
movsbl 0x8ad5(%rip), %r15d     # 0x10208
leaq -0x58(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0x4b20(%rip), %rsi      # 0xc262
leaq 0x4b26(%rip), %rdx      # 0xc26f
leaq -0x68(%rbp), %r12
movq %r12, %rdi
callq 0x644a
movl %r14d, %edi
movl %r15d, %esi
movq %r12, %rdx
callq 0xb315
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x7778
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x21e0
movq %rbx, %rdi
callq 0x783c
movq %rbx, %rdi
movl $0xe, %esi
callq 0x6d1c
movq %rbx, %rdi
callq 0x7968
movq %rbx, %rdi
movl $0xf, %esi
callq 0x6d1c
movq %rbx, %rdi
callq 0x7c90
movl 0x8a5c(%rip), %ebx      # 0x1020c
decl %ebx
movl %ebx, 0x8a54(%rip)      # 0x1020c
movsbl 0x8a48(%rip), %r14d     # 0x10208
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0x4a93(%rip), %rsi      # 0xc262
leaq 0x4a99(%rip), %rdx      # 0xc26f
leaq -0x48(%rbp), %r15
movq %r15, %rdi
callq 0x644a
movl %ebx, %edi
movl %r14d, %esi
movq %r15, %rdx
callq 0xb31b
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x7804
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21e0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
jmp 0x7823
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x7834
movq (%r13), %rsi
incq %rsi
callq 0x21e0
movq %rbx, %rdi
callq 0x2390
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movl 0x89b5(%rip), %r14d     # 0x1020c
incl %r14d
movl %r14d, 0x89ab(%rip)     # 0x1020c
movsbl 0x899f(%rip), %r15d     # 0x10208
leaq -0x58(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0x4a11(%rip), %rsi      # 0xc289
leaq 0x4a16(%rip), %rdx      # 0xc295
leaq -0x68(%rbp), %r12
movq %r12, %rdi
callq 0x644a
movl %r14d, %edi
movl %r15d, %esi
movq %r12, %rdx
callq 0xb315
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x78ae
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x21e0
cmpl $0x0, (%rbx)
jne 0x78d5
movq %rbx, %rdi
callq 0x7dcc
cmpl $0x15, (%rbx)
jne 0x78d5
movq %rbx, %rdi
movl $0x15, %esi
callq 0x6d1c
movq %rbx, %rdi
callq 0x783c
movl 0x8931(%rip), %ebx      # 0x1020c
decl %ebx
movl %ebx, 0x8929(%rip)      # 0x1020c
movsbl 0x891d(%rip), %r14d     # 0x10208
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0x498f(%rip), %rsi      # 0xc289
leaq 0x4994(%rip), %rdx      # 0xc295
leaq -0x48(%rbp), %r15
movq %r15, %rdi
callq 0x644a
movl %ebx, %edi
movl %r14d, %esi
movq %r15, %rdx
callq 0xb31b
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x792f
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21e0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
jmp 0x794e
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x795f
movq (%r13), %rsi
incq %rsi
callq 0x21e0
movq %rbx, %rdi
callq 0x2390
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movl 0x8561(%rip), %r14d     # 0x1020c
incl %r14d
movl %r14d, 0x8557(%rip)     # 0x1020c
movsbl 0x854b(%rip), %r15d     # 0x10208
leaq -0x58(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0x45a4(%rip), %rsi      # 0xc270
leaq 0x45ab(%rip), %rdx      # 0xc27e
leaq -0x68(%rbp), %r12
movq %r12, %rdi
callq 0x644a
movl %r14d, %edi
movl %r15d, %esi
movq %r12, %rdx
callq 0xb315
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x7d02
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x21e0
cmpl $0x0, (%rbx)
jne 0x7d39
movq %rbx, %rdi
callq 0x783c
movq %rbx, %rdi
movl $0xe, %esi
callq 0x6d1c
movq %rbx, %rdi
callq 0x7968
movq %rbx, %rdi
movl $0xf, %esi
callq 0x6d1c
movq %rbx, %rdi
callq 0x7c90
movl 0x84cd(%rip), %ebx      # 0x1020c
decl %ebx
movl %ebx, 0x84c5(%rip)      # 0x1020c
movsbl 0x84b9(%rip), %r14d     # 0x10208
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0x4512(%rip), %rsi      # 0xc270
leaq 0x4519(%rip), %rdx      # 0xc27e
leaq -0x48(%rbp), %r15
movq %r15, %rdi
callq 0x644a
movl %ebx, %edi
movl %r14d, %esi
movq %r15, %rdx
callq 0xb31b
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x7d93
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21e0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
jmp 0x7db2
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x7dc3
movq (%r13), %rsi
incq %rsi
callq 0x21e0
movq %rbx, %rdi
callq 0x2390
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movl 0x8425(%rip), %r14d     # 0x1020c
incl %r14d
movl %r14d, 0x841b(%rip)     # 0x1020c
movsbl 0x840f(%rip), %r15d     # 0x10208
leaq -0x58(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0x448e(%rip), %rsi      # 0xc296
leaq 0x448f(%rip), %rdx      # 0xc29e
leaq -0x68(%rbp), %r12
movq %r12, %rdi
callq 0x644a
movl %r14d, %edi
movl %r15d, %esi
movq %r12, %rdx
callq 0xb315
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x7e3e
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x21e0
leaq 0x70(%rbx), %rdi
leaq 0x8(%rbx), %rsi
callq 0x8fd2
movq %rbx, %rdi
xorl %esi, %esi
callq 0x6d1c
movl 0x83b1(%rip), %ebx      # 0x1020c
decl %ebx
movl %ebx, 0x83a9(%rip)      # 0x1020c
movsbl 0x839d(%rip), %r14d     # 0x10208
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0x441c(%rip), %rsi      # 0xc296
leaq 0x441d(%rip), %rdx      # 0xc29e
leaq -0x48(%rbp), %r15
movq %r15, %rdi
callq 0x644a
movl %ebx, %edi
movl %r14d, %esi
movq %r15, %rdx
callq 0xb31b
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x7eaf
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21e0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
jmp 0x7ece
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x7edf
movq (%r13), %rsi
incq %rsi
callq 0x21e0
movq %rbx, %rdi
callq 0x2390
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movl 0x80cf(%rip), %r14d     # 0x1020c
incl %r14d
movl %r14d, 0x80c5(%rip)     # 0x1020c
movsbl 0x80b9(%rip), %r15d     # 0x10208
leaq -0x58(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0x414f(%rip), %rsi      # 0xc2ad
leaq 0x4156(%rip), %rdx      # 0xc2bb
leaq -0x68(%rbp), %r12
movq %r12, %rdi
callq 0x644a
movl %r14d, %edi
movl %r15d, %esi
movq %r12, %rdx
callq 0xb315
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x8194
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x21e0
movl (%rbx), %eax
cmpl $0x14, %eax
ja 0x81c2
movl $0x1d0001, %ecx         # imm = 0x1D0001
btl %eax, %ecx
jae 0x81c2
movq %rbx, %rdi
callq 0x7ee8
movq %rbx, %rdi
movl $0xf, %esi
callq 0x6d1c
movq %rbx, %rdi
callq 0x8122
movl 0x8044(%rip), %ebx      # 0x1020c
decl %ebx
movl %ebx, 0x803c(%rip)      # 0x1020c
movsbl 0x8030(%rip), %r14d     # 0x10208
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0x40c6(%rip), %rsi      # 0xc2ad
leaq 0x40cd(%rip), %rdx      # 0xc2bb
leaq -0x48(%rbp), %r15
movq %r15, %rdi
callq 0x644a
movl %ebx, %edi
movl %r14d, %esi
movq %r15, %rdx
callq 0xb31b
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x821c
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21e0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
jmp 0x823b
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x824c
movq (%r13), %rsi
incq %rsi
callq 0x21e0
movq %rbx, %rdi
callq 0x2390
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movl 0x7f9d(%rip), %r14d     # 0x1020c
incl %r14d
movl %r14d, 0x7f93(%rip)     # 0x1020c
movsbl 0x7f87(%rip), %r15d     # 0x10208
leaq -0x58(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0x4036(%rip), %rsi      # 0xc2c6
leaq 0x4043(%rip), %rdx      # 0xc2da
leaq -0x68(%rbp), %r12
movq %r12, %rdi
callq 0x644a
movl %r14d, %edi
movl %r15d, %esi
movq %r12, %rdx
callq 0xb315
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x82c6
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x21e0
movq %rbx, %rdi
xorl %esi, %esi
callq 0x6d1c
movq %rbx, %rdi
movl $0xd, %esi
callq 0x6d1c
movq %rbx, %rdi
callq 0x882e
movl 0x7f21(%rip), %ebx      # 0x1020c
decl %ebx
movl %ebx, 0x7f19(%rip)      # 0x1020c
movsbl 0x7f0d(%rip), %r14d     # 0x10208
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0x3fbc(%rip), %rsi      # 0xc2c6
leaq 0x3fc9(%rip), %rdx      # 0xc2da
leaq -0x48(%rbp), %r15
movq %r15, %rdi
callq 0x644a
movl %ebx, %edi
movl %r14d, %esi
movq %r15, %rdx
callq 0xb31b
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x833f
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21e0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
jmp 0x835e
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x836f
movq (%r13), %rsi
incq %rsi
callq 0x21e0
movq %rbx, %rdi
callq 0x2390
nop
// File: /workspace/github_cpp_makefile_star2_O1/Blaze2305[P]Compiler-Design-2021-Assignment/src/Parser/Parser.cpp
// Function: Parser::parseReadStmt()
void Parser::parseReadStmt(){
	tabNum+=1;
	printParseEnters(tabNum,tabChar,"parseReadStmt");
	accept(Read);
	accept(Identifier);
	tabNum-=1;
	printParseExits(tabNum,tabChar,"parseReadStmt");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movl 0x7e79(%rip), %r14d     # 0x1020c
incl %r14d
movl %r14d, 0x7e6f(%rip)     # 0x1020c
movsbl 0x7e63(%rip), %r15d     # 0x10208
leaq -0x58(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0x3f27(%rip), %rsi      # 0xc2db
leaq 0x3f2d(%rip), %rdx      # 0xc2e8
leaq -0x68(%rbp), %r12
movq %r12, %rdi
callq 0x644a
movl %r14d, %edi
movl %r15d, %esi
movq %r12, %rdx
callq 0xb315
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x83ea
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x21e0
movq %rbx, %rdi
movl $0x13, %esi
callq 0x6d1c
movq %rbx, %rdi
xorl %esi, %esi
callq 0x6d1c
movl 0x7e05(%rip), %ebx      # 0x1020c
decl %ebx
movl %ebx, 0x7dfd(%rip)      # 0x1020c
movsbl 0x7df1(%rip), %r14d     # 0x10208
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0x3eb5(%rip), %rsi      # 0xc2db
leaq 0x3ebb(%rip), %rdx      # 0xc2e8
leaq -0x48(%rbp), %r15
movq %r15, %rdi
callq 0x644a
movl %ebx, %edi
movl %r14d, %esi
movq %r15, %rdx
callq 0xb31b
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x845b
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21e0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
jmp 0x847a
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x848b
movq (%r13), %rsi
incq %rsi
callq 0x21e0
movq %rbx, %rdi
callq 0x2390
nop
// File: /workspace/github_cpp_makefile_star2_O1/Blaze2305[P]Compiler-Design-2021-Assignment/src/Parser/Parser.cpp
// Function: Parser::parsePrintStmt()
void Parser::parsePrintStmt(){
	tabNum+=1;
	printParseEnters(tabNum,tabChar,"parsePrintStmt");
	accept(Print);
	parseExp();
	tabNum-=1;
	printParseExits(tabNum,tabChar,"parsePrintStmt");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movl 0x7d5d(%rip), %r14d     # 0x1020c
incl %r14d
movl %r14d, 0x7d53(%rip)     # 0x1020c
movsbl 0x7d47(%rip), %r15d     # 0x10208
leaq -0x58(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0x3e19(%rip), %rsi      # 0xc2e9
leaq 0x3e20(%rip), %rdx      # 0xc2f7
leaq -0x68(%rbp), %r12
movq %r12, %rdi
callq 0x644a
movl %r14d, %edi
movl %r15d, %esi
movq %r12, %rdx
callq 0xb315
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x8506
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x21e0
movq %rbx, %rdi
movl $0x14, %esi
callq 0x6d1c
movq %rbx, %rdi
callq 0x882e
movl 0x7ceb(%rip), %ebx      # 0x1020c
decl %ebx
movl %ebx, 0x7ce3(%rip)      # 0x1020c
movsbl 0x7cd7(%rip), %r14d     # 0x10208
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0x3da9(%rip), %rsi      # 0xc2e9
leaq 0x3db0(%rip), %rdx      # 0xc2f7
leaq -0x48(%rbp), %r15
movq %r15, %rdi
callq 0x644a
movl %ebx, %edi
movl %r14d, %esi
movq %r15, %rdx
callq 0xb31b
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x8575
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21e0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
jmp 0x8594
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x85a5
movq (%r13), %rsi
incq %rsi
callq 0x21e0
movq %rbx, %rdi
callq 0x2390
nop