LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/albinoloverats[P]hide/src/jpeg-load.c
// Function: ParseDQT
static int ParseDQT(stJpegData *jdata, const uint8_t *stream)
{
	int length = BYTE_TO_WORD(stream) - 2;
	stream += 2; // Skip length

	while (length > 0)
	{
		int qi = *stream++;

		int qprecision = qi >> 4; // upper 4 bits specify the precision
		int qindex = qi & 0xf; // index is lower 4 bits

		if (qprecision)
		{
			// precision in this case is either 0 or 1 and indicates the precision
			// of the quantized values;
			// 8-bit (baseline) for 0 and  up to 16-bit for 1
			fprintf(stderr, "Fail @ %s:%d\n", __FILE__, __LINE__);
			exit(-1);
		}
		if (qindex >= 4)
		{
			fprintf(stderr, "Fail @ %s:%d\n", __FILE__, __LINE__);
			exit(-1);
		}

		// The quantization table is the next 64 bytes
		// the quantization tables are stored in zigzag format, so we
		// use this functino to read them all in and de-zig zag them
		BuildQuantizationTable(jdata->m_Q_tables[qindex], stream);
		stream += 64;
		length -= 65;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
shll $0x8, %eax
movq -0x10(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
orl %ecx, %eax
subl $0x2, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x10(%rbp)
cmpl $0x0, -0x14(%rbp)
jle 0x233d
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movzbl (%rax), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
sarl $0x4, %eax
movl %eax, -0x1c(%rbp)
movl -0x18(%rbp), %eax
andl $0xf, %eax
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x227b
movq 0x6da4(%rip), %rax      # 0x8ff8
movq (%rax), %rdi
leaq 0x4e92(%rip), %rsi      # 0x70f0
leaq 0x4e99(%rip), %rdx      # 0x70fe
movl $0x166, %ecx            # imm = 0x166
movb $0x0, %al
callq 0x10e0
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x1150
cmpl $0x4, -0x20(%rbp)
jl 0x22af
movq 0x6d70(%rip), %rax      # 0x8ff8
movq (%rax), %rdi
leaq 0x4e5e(%rip), %rsi      # 0x70f0
leaq 0x4e65(%rip), %rdx      # 0x70fe
movl $0x16b, %ecx            # imm = 0x16B
movb $0x0, %al
callq 0x10e0
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x1150
jmp 0x22b1
movl $0x0, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
cmpl $0x8, -0x24(%rbp)
jge 0x2321
movl $0x0, -0x2c(%rbp)
cmpl $0x8, -0x2c(%rbp)
jge 0x2314
movq -0x10(%rbp), %rax
movslq -0x28(%rbp), %rcx
movzbl (%rax,%rcx), %eax
cvtsi2sd %eax, %xmm0
movq -0x8(%rbp), %rax
addq $0x2c0, %rax            # imm = 0x2C0
movslq -0x20(%rbp), %rcx
shlq $0x9, %rcx
addq %rcx, %rax
movslq -0x28(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x22cc
jmp 0x2316
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x22bf
jmp 0x2323
movq -0x10(%rbp), %rax
addq $0x40, %rax
movq %rax, -0x10(%rbp)
movl -0x14(%rbp), %eax
subl $0x41, %eax
movl %eax, -0x14(%rbp)
jmp 0x2216
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/albinoloverats[P]hide/src/jpeg-load.c
// Function: BuildHuffmanTable
static void BuildHuffmanTable(const uint8_t *bits, stHuffmanTable *HT)
{
	// Takes two array of bits, and build the huffman table for size, and code
	for (int j = 1; j <= 16; j++)
		HT->m_length[j] = bits[j];

	// Work out the total number of codes
	int numBlocks = 0;
	for (int i = 1; i <= 16; i++)
		numBlocks += HT->m_length[i];
	HT->m_numBlocks = numBlocks;

	// Fill in the data our our blocks, so we know how many bits each
	// one is
	for (int i = 1, c = 0; i <= 16; i++)
		for (int j = 0; j < HT->m_length[i]; j++, c++)
			HT->m_blocks[c].length = i;

	GenHuffCodes(HT->m_numBlocks, HT->m_blocks, HT->m_hufVal);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, -0x14(%rbp)
cmpl $0x10, -0x14(%rbp)
jg 0x278a
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2763
movl $0x0, -0x18(%rbp)
movl $0x1, -0x1c(%rbp)
cmpl $0x10, -0x1c(%rbp)
jg 0x27bb
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movzbl (%rax,%rcx), %eax
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x2798
movl -0x18(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x114(%rax)
movl $0x1, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
cmpl $0x10, -0x20(%rbp)
jg 0x2832
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
movq -0x10(%rbp), %rcx
movslq -0x20(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jge 0x2825
movl -0x20(%rbp), %ecx
movq -0x10(%rbp), %rax
addq $0x118, %rax            # imm = 0x118
movslq -0x24(%rbp), %rdx
imulq $0xc, %rdx, %rdx
addq %rdx, %rax
movl %ecx, 0x4(%rax)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x27e3
jmp 0x2827
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x27d6
jmp 0x2834
movl $0x0, -0x2c(%rbp)
movl $0x0, -0x30(%rbp)
movl $0x1, -0x34(%rbp)
movl -0x2c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x114(%rcx), %eax
jge 0x28e8
jmp 0x285e
movq -0x10(%rbp), %rax
addq $0x118, %rax            # imm = 0x118
movslq -0x2c(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
cmpl -0x34(%rbp), %eax
jle 0x288e
movl -0x30(%rbp), %eax
shll %eax
movl %eax, -0x30(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x285e
movl -0x30(%rbp), %eax
movw %ax, %cx
movq -0x10(%rbp), %rax
addq $0x118, %rax            # imm = 0x118
movslq -0x2c(%rbp), %rdx
imulq $0xc, %rdx, %rdx
addq %rdx, %rax
movw %cx, 0x8(%rax)
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movzbl 0x11(%rax,%rcx), %ecx
movq -0x10(%rbp), %rax
addq $0x118, %rax            # imm = 0x118
movslq -0x2c(%rbp), %rdx
imulq $0xc, %rdx, %rdx
addq %rdx, %rax
movl %ecx, (%rax)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x2849
jmp 0x28ea
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/albinoloverats[P]hide/src/jpeg-load.c
// Function: DecodeMCU
static void DecodeMCU(stJpegData *jdata, int w, int h)
{
	// Y
	for (int y = 0; y < h; y++)
		for (int x = 0; x < w; x++)
		{
			ProcessHuffmanDataUnit(jdata, cY);
			DecodeSingleBlock(&jdata->m_component_info[cY], &jdata->m_Y[(x << 3) + (y * w << 6)], w << 3);
		}

	// Cb
	ProcessHuffmanDataUnit(jdata, cCb);
	DecodeSingleBlock(&jdata->m_component_info[cCb], jdata->m_Cb, 8);

	// Cr
	ProcessHuffmanDataUnit(jdata, cCr);
	DecodeSingleBlock(&jdata->m_component_info[cCr], jdata->m_Cr, 8);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x2982
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x2975
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x2c10
movq -0x8(%rbp), %rdi
addq $0x20, %rdi
addq $0xa8, %rdi
movq -0x8(%rbp), %rsi
addq $0x19380, %rsi          # imm = 0x19380
movl -0x18(%rbp), %eax
shll $0x3, %eax
movl -0x14(%rbp), %ecx
imull -0xc(%rbp), %ecx
shll $0x6, %ecx
addl %ecx, %eax
cltq
addq %rax, %rsi
movl -0xc(%rbp), %edx
shll $0x3, %edx
callq 0x32c0
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x2918
jmp 0x2977
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2909
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x2c10
movq -0x8(%rbp), %rdi
addq $0x20, %rdi
addq $0x150, %rdi            # imm = 0x150
movq -0x8(%rbp), %rsi
addq $0x194c0, %rsi          # imm = 0x194C0
movl $0x8, %edx
callq 0x32c0
movq -0x8(%rbp), %rdi
movl $0x3, %esi
callq 0x2c10
movq -0x8(%rbp), %rdi
addq $0x20, %rdi
addq $0x1f8, %rdi            # imm = 0x1F8
movq -0x8(%rbp), %rsi
addq $0x19480, %rsi          # imm = 0x19480
movl $0x8, %edx
callq 0x32c0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/albinoloverats[P]hide/src/jpeg-load.c
// Function: IsInHuffmanCodes
static bool IsInHuffmanCodes(int code, int numCodeBits, int numBlocks, stBlock *blocks, int *outValue)
{
	for (int j = 0; j < numBlocks; j++)
		if (code == blocks[j].code && numCodeBits == blocks[j].length)
		{
			*outValue = blocks[j].value;
			return true; // We've got a match!
		}
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x3a6f
movl -0x8(%rbp), %eax
movq -0x18(%rbp), %rcx
movslq -0x24(%rbp), %rdx
imulq $0xc, %rdx, %rdx
addq %rdx, %rcx
movzwl 0x8(%rcx), %ecx
cmpl %ecx, %eax
jne 0x3a62
movl -0xc(%rbp), %eax
movq -0x18(%rbp), %rcx
movslq -0x24(%rbp), %rdx
imulq $0xc, %rdx, %rdx
addq %rdx, %rcx
cmpl 0x4(%rcx), %eax
jne 0x3a62
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl (%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x3a73
jmp 0x3a64
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x3a0c
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/albinoloverats[P]hide/src/jpeg-load.c
// Function: GetNBits
static inline int16_t GetNBits(const uint8_t **stream, int nbits_wanted)
{
	FillNBits(stream, nbits_wanted);
	int16_t result = g_reservoir >> (g_nbits_in_reservoir - nbits_wanted);
	shift_bits(nbits_wanted);
	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
jmp 0x3a8d
movl 0x5a91(%rip), %eax      # 0x9524
cmpl -0xc(%rbp), %eax
jae 0x3b06
movq -0x8(%rbp), %rcx
movq (%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, (%rcx)
movb (%rax), %al
movb %al, -0xd(%rbp)
movl 0x5a6c(%rip), %eax      # 0x9520
shll $0x8, %eax
movl %eax, 0x5a63(%rip)      # 0x9520
movzbl -0xd(%rbp), %eax
cmpl $0xff, %eax
jne 0x3ae5
movq -0x8(%rbp), %rax
movq (%rax), %rax
movzbl (%rax), %eax
cmpl $0x0, %eax
jne 0x3ae5
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movzbl -0xd(%rbp), %eax
orl 0x5a31(%rip), %eax      # 0x9520
movl %eax, 0x5a2b(%rip)      # 0x9520
movl 0x5a29(%rip), %eax      # 0x9524
addl $0x8, %eax
movl %eax, 0x5a20(%rip)      # 0x9524
jmp 0x3a8d
jmp 0x3b08
movl 0x5a12(%rip), %eax      # 0x9520
movl 0x5a10(%rip), %ecx      # 0x9524
subl -0xc(%rbp), %ecx
shrl %cl, %eax
movw %ax, -0x10(%rbp)
movl -0xc(%rbp), %ecx
movl 0x59fe(%rip), %eax      # 0x9524
subl %ecx, %eax
movl %eax, 0x59f6(%rip)      # 0x9524
movl 0x59f0(%rip), %ecx      # 0x9524
movl $0x1, %eax
shll %cl, %eax
subl $0x1, %eax
andl 0x59dc(%rip), %eax      # 0x9520
movl %eax, 0x59d6(%rip)      # 0x9520
movw -0x10(%rbp), %ax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/albinoloverats[P]hide/src/jpeg-load.c
// Function: innerIDCT
__attribute__((optimize("unroll-loops")))
#endif
static inline int innerIDCT(int x, int y, const int block[8][8])
{
	const double X = ((x << 1) + 1) * PI_BY_16;
	const double Y = ((y << 1) + 1) * PI_BY_16;

	double sum = 0.0;
	for (int u = 0; u < 8; u++)
	{
		const double cosxu = cos(X * u);
		for (int v = 0; v < 8; v++)
		{
			const double cosyv = cos(Y * v);
			sum += (u ? 1 : M_SQRT1_2) \
			     * (v ? 1 : M_SQRT1_2) \
			     *  block[u][v]        \
			     *  cosxu              \
			     *  cosyv;
		}
	}
	return (int)sum >> 2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movl -0x4(%rbp), %eax
shll %eax
addl $0x1, %eax
cvtsi2sd %eax, %xmm0
movsd 0x354a(%rip), %xmm1     # 0x70c0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movl -0x8(%rbp), %eax
shll %eax
addl $0x1, %eax
cvtsi2sd %eax, %xmm0
movsd 0x352d(%rip), %xmm1     # 0x70c0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
cmpl $0x8, -0x2c(%rbp)
jge 0x3cbc
movsd -0x18(%rbp), %xmm0
cvtsi2sdl -0x2c(%rbp), %xmm1
mulsd %xmm1, %xmm0
callq 0x10a0
movsd %xmm0, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
cmpl $0x8, -0x3c(%rbp)
jge 0x3cac
movsd -0x20(%rbp), %xmm0
cvtsi2sdl -0x3c(%rbp), %xmm1
mulsd %xmm1, %xmm0
callq 0x10a0
movsd %xmm0, -0x48(%rbp)
movl -0x2c(%rbp), %eax
movsd 0x34b7(%rip), %xmm0     # 0x70b8
movsd 0x34bf(%rip), %xmm1     # 0x70c8
movsd %xmm1, -0x58(%rbp)
cmpl $0x0, %eax
movsd %xmm0, -0x50(%rbp)
jne 0x3c22
movsd -0x58(%rbp), %xmm0
movsd %xmm0, -0x50(%rbp)
movsd -0x50(%rbp), %xmm0
movsd %xmm0, -0x70(%rbp)
movl -0x3c(%rbp), %eax
movsd 0x3481(%rip), %xmm0     # 0x70b8
movsd 0x3489(%rip), %xmm1     # 0x70c8
movsd %xmm1, -0x68(%rbp)
cmpl $0x0, %eax
movsd %xmm0, -0x60(%rbp)
jne 0x3c58
movsd -0x68(%rbp), %xmm0
movsd %xmm0, -0x60(%rbp)
movsd -0x70(%rbp), %xmm0
movsd -0x60(%rbp), %xmm1
mulsd %xmm1, %xmm0
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movslq -0x3c(%rbp), %rcx
cvtsi2sdl (%rax,%rcx,4), %xmm1
mulsd %xmm1, %xmm0
mulsd -0x38(%rbp), %xmm0
movsd -0x48(%rbp), %xmm2
movsd -0x28(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x3bd4
jmp 0x3cae
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x3bab
cvttsd2si -0x28(%rbp), %eax
sarl $0x2, %eax
addq $0x70, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/albinoloverats[P]hide/src/jpeg-save.c
// Function: init_all
static void init_all(void)
{
	set_DQTinfo();
	set_DHTinfo();
	init_Huffman_tables();
	set_numbers_category_and_bitcode();
	precalculate_YCbCr_tables();
	prepare_quant_tables();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x4b40
callq 0x4d10
callq 0x4f20
callq 0x5210
callq 0x5340
callq 0x54b0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/albinoloverats[P]hide/src/jpeg-save.c
// Function: write_APP0info
static void write_APP0info(void)
// Nothing to overwrite for APP0info
{
	writeword(APP0info.marker);
	writeword(APP0info.length);
	writetext(APP0info.JFIFsignature);
	writebyte(0); // extra nul necessary as JFIF should be \0 terminated
	writebyte(APP0info.versionhi);
	writebyte(APP0info.versionlo);
	writebyte(APP0info.xyunits);
	writeword(APP0info.xdensity);
	writeword(APP0info.ydensity);
	writebyte(APP0info.thumbnwidth);
	writebyte(APP0info.thumbnheight);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movzwl 0x5317(%rip), %eax      # 0x9482
movl $0x100, %ecx            # imm = 0x100
cltd
idivl %ecx
movl %eax, %edi
movq 0x53dc(%rip), %rsi      # 0x9558
callq 0x10b0
movzwl 0x52fa(%rip), %eax      # 0x9482
movl $0x100, %ecx            # imm = 0x100
cltd
idivl %ecx
movl %edx, %edi
movq 0x53bf(%rip), %rsi      # 0x9558
callq 0x10b0
movzwl 0x52df(%rip), %eax      # 0x9484
movl $0x100, %ecx            # imm = 0x100
cltd
idivl %ecx
movl %eax, %edi
movq 0x53a2(%rip), %rsi      # 0x9558
callq 0x10b0
movzwl 0x52c2(%rip), %eax      # 0x9484
movl $0x100, %ecx            # imm = 0x100
cltd
idivl %ecx
movl %edx, %edi
movq 0x5385(%rip), %rsi      # 0x9558
callq 0x10b0
movq 0x5379(%rip), %rsi      # 0x9558
leaq 0x529c(%rip), %rdi      # 0x9482
addq $0x4, %rdi
callq 0x1080
movq 0x5362(%rip), %rsi      # 0x9558
xorl %edi, %edi
callq 0x10b0
movzbl 0x5287(%rip), %edi      # 0x948b
movq 0x534d(%rip), %rsi      # 0x9558
callq 0x10b0
movzbl 0x5275(%rip), %edi      # 0x948c
movq 0x533a(%rip), %rsi      # 0x9558
callq 0x10b0
movzbl 0x5263(%rip), %edi      # 0x948d
movq 0x5327(%rip), %rsi      # 0x9558
callq 0x10b0
movzwl 0x5251(%rip), %eax      # 0x948e
movl $0x100, %ecx            # imm = 0x100
cltd
idivl %ecx
movl %eax, %edi
movq 0x530a(%rip), %rsi      # 0x9558
callq 0x10b0
movzwl 0x5234(%rip), %eax      # 0x948e
movl $0x100, %ecx            # imm = 0x100
cltd
idivl %ecx
movl %edx, %edi
movq 0x52ed(%rip), %rsi      # 0x9558
callq 0x10b0
movzwl 0x5219(%rip), %eax      # 0x9490
movl $0x100, %ecx            # imm = 0x100
cltd
idivl %ecx
movl %eax, %edi
movq 0x52d0(%rip), %rsi      # 0x9558
callq 0x10b0
movzwl 0x51fc(%rip), %eax      # 0x9490
movl $0x100, %ecx            # imm = 0x100
cltd
idivl %ecx
movl %edx, %edi
movq 0x52b3(%rip), %rsi      # 0x9558
callq 0x10b0
movzbl 0x51e1(%rip), %edi      # 0x9492
movq 0x52a0(%rip), %rsi      # 0x9558
callq 0x10b0
movzbl 0x51cf(%rip), %edi      # 0x9493
movq 0x528d(%rip), %rsi      # 0x9558
callq 0x10b0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/albinoloverats[P]hide/src/jpeg-save.c
// Function: write_DQTinfo
static void write_DQTinfo(void)
{
	writeword(DQTinfo.marker);
	writeword(DQTinfo.length);
	writebyte(DQTinfo.QTYinfo);
	for (int i = 0; i < 64; i++)
		writebyte(DQTinfo.Ytable[i]);
	writebyte(DQTinfo.QTCbinfo);
	for (int i = 0; i < 64; i++)
		writebyte(DQTinfo.Cbtable[i]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movzwl 0x5273(%rip), %eax      # 0x9562
movl $0x100, %ecx            # imm = 0x100
cltd
idivl %ecx
movl %eax, %edi
movq 0x5258(%rip), %rsi      # 0x9558
callq 0x10b0
movzwl 0x5256(%rip), %eax      # 0x9562
movl $0x100, %ecx            # imm = 0x100
cltd
idivl %ecx
movl %edx, %edi
movq 0x523b(%rip), %rsi      # 0x9558
callq 0x10b0
movzwl 0x523b(%rip), %eax      # 0x9564
movl $0x100, %ecx            # imm = 0x100
cltd
idivl %ecx
movl %eax, %edi
movq 0x521e(%rip), %rsi      # 0x9558
callq 0x10b0
movzwl 0x521e(%rip), %eax      # 0x9564
movl $0x100, %ecx            # imm = 0x100
cltd
idivl %ecx
movl %edx, %edi
movq 0x5201(%rip), %rsi      # 0x9558
callq 0x10b0
movzbl 0x5203(%rip), %edi      # 0x9566
movq 0x51ee(%rip), %rsi      # 0x9558
callq 0x10b0
movl $0x0, -0x4(%rbp)
cmpl $0x40, -0x4(%rbp)
jge 0x43a3
movslq -0x4(%rbp), %rcx
leaq 0x51db(%rip), %rax      # 0x9562
movzbl 0x5(%rax,%rcx), %edi
movq 0x51c5(%rip), %rsi      # 0x9558
callq 0x10b0
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x4376
movzbl 0x51fd(%rip), %edi      # 0x95a7
movq 0x51a7(%rip), %rsi      # 0x9558
callq 0x10b0
movl $0x0, -0x8(%rbp)
cmpl $0x40, -0x8(%rbp)
jge 0x43ea
movslq -0x8(%rbp), %rcx
leaq 0x5194(%rip), %rax      # 0x9562
movzbl 0x46(%rax,%rcx), %edi
movq 0x517e(%rip), %rsi      # 0x9558
callq 0x10b0
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x43bd
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/albinoloverats[P]hide/src/jpeg-save.c
// Function: write_SOF0info
static void write_SOF0info(void)
// We should overwrite width and height
{
	writeword(SOF0info.marker);
	writeword(SOF0info.length);
	writebyte(SOF0info.precision);
	writeword(SOF0info.height);
	writeword(SOF0info.width);
	writebyte(SOF0info.nrofcomponents);
	writebyte(SOF0info.IdY);
	writebyte(SOF0info.HVY);
	writebyte(SOF0info.QTY);
	writebyte(SOF0info.IdCb);
	writebyte(SOF0info.HVCb);
	writebyte(SOF0info.QTCb);
	writebyte(SOF0info.IdCr);
	writebyte(SOF0info.HVCr);
	writebyte(SOF0info.QTCr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movzwl 0x4dd5(%rip), %eax      # 0x91d0
movl $0x100, %ecx            # imm = 0x100
cltd
idivl %ecx
movl %eax, %edi
movq 0x514c(%rip), %rsi      # 0x9558
callq 0x10b0
movzwl 0x4db8(%rip), %eax      # 0x91d0
movl $0x100, %ecx            # imm = 0x100
cltd
idivl %ecx
movl %edx, %edi
movq 0x512f(%rip), %rsi      # 0x9558
callq 0x10b0
movzwl 0x4d9d(%rip), %eax      # 0x91d2
movl $0x100, %ecx            # imm = 0x100
cltd
idivl %ecx
movl %eax, %edi
movq 0x5112(%rip), %rsi      # 0x9558
callq 0x10b0
movzwl 0x4d80(%rip), %eax      # 0x91d2
movl $0x100, %ecx            # imm = 0x100
cltd
idivl %ecx
movl %edx, %edi
movq 0x50f5(%rip), %rsi      # 0x9558
callq 0x10b0
movzbl 0x4d65(%rip), %edi      # 0x91d4
movq 0x50e2(%rip), %rsi      # 0x9558
callq 0x10b0
movzwl 0x4d54(%rip), %eax      # 0x91d6
movl $0x100, %ecx            # imm = 0x100
cltd
idivl %ecx
movl %eax, %edi
movq 0x50c5(%rip), %rsi      # 0x9558
callq 0x10b0
movzwl 0x4d37(%rip), %eax      # 0x91d6
movl $0x100, %ecx            # imm = 0x100
cltd
idivl %ecx
movl %edx, %edi
movq 0x50a8(%rip), %rsi      # 0x9558
callq 0x10b0
movzwl 0x4d1c(%rip), %eax      # 0x91d8
movl $0x100, %ecx            # imm = 0x100
cltd
idivl %ecx
movl %eax, %edi
movq 0x508b(%rip), %rsi      # 0x9558
callq 0x10b0
movzwl 0x4cff(%rip), %eax      # 0x91d8
movl $0x100, %ecx            # imm = 0x100
cltd
idivl %ecx
movl %edx, %edi
movq 0x506e(%rip), %rsi      # 0x9558
callq 0x10b0
movzbl 0x4ce4(%rip), %edi      # 0x91da
movq 0x505b(%rip), %rsi      # 0x9558
callq 0x10b0
movzbl 0x4cd2(%rip), %edi      # 0x91db
movq 0x5048(%rip), %rsi      # 0x9558
callq 0x10b0
movzbl 0x4cc0(%rip), %edi      # 0x91dc
movq 0x5035(%rip), %rsi      # 0x9558
callq 0x10b0
movzbl 0x4cae(%rip), %edi      # 0x91dd
movq 0x5022(%rip), %rsi      # 0x9558
callq 0x10b0
movzbl 0x4c9c(%rip), %edi      # 0x91de
movq 0x500f(%rip), %rsi      # 0x9558
callq 0x10b0
movzbl 0x4c8a(%rip), %edi      # 0x91df
movq 0x4ffc(%rip), %rsi      # 0x9558
callq 0x10b0
movzbl 0x4c78(%rip), %edi      # 0x91e0
movq 0x4fe9(%rip), %rsi      # 0x9558
callq 0x10b0
movzbl 0x4c66(%rip), %edi      # 0x91e1
movq 0x4fd6(%rip), %rsi      # 0x9558
callq 0x10b0
movzbl 0x4c54(%rip), %edi      # 0x91e2
movq 0x4fc3(%rip), %rsi      # 0x9558
callq 0x10b0
movzbl 0x4c42(%rip), %edi      # 0x91e3
movq 0x4fb0(%rip), %rsi      # 0x9558
callq 0x10b0
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/albinoloverats[P]hide/src/jpeg-save.c
// Function: write_SOSinfo
static void write_SOSinfo(void)
// Nothing to overwrite for SOSinfo
{
	writeword(SOSinfo.marker);
	writeword(SOSinfo.length);
	writebyte(SOSinfo.nrofcomponents);
	writebyte(SOSinfo.IdY);
	writebyte(SOSinfo.HTY);
	writebyte(SOSinfo.IdCb);
	writebyte(SOSinfo.HTCb);
	writebyte(SOSinfo.IdCr);
	writebyte(SOSinfo.HTCr);
	writebyte(SOSinfo.Ss);
	writebyte(SOSinfo.Se);
	writebyte(SOSinfo.Bf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movzwl 0x4c59(%rip), %eax      # 0x9494
movl $0x100, %ecx            # imm = 0x100
cltd
idivl %ecx
movl %eax, %edi
movq 0x4d0c(%rip), %rsi      # 0x9558
callq 0x10b0
movzwl 0x4c3c(%rip), %eax      # 0x9494
movl $0x100, %ecx            # imm = 0x100
cltd
idivl %ecx
movl %edx, %edi
movq 0x4cef(%rip), %rsi      # 0x9558
callq 0x10b0
movzwl 0x4c21(%rip), %eax      # 0x9496
movl $0x100, %ecx            # imm = 0x100
cltd
idivl %ecx
movl %eax, %edi
movq 0x4cd2(%rip), %rsi      # 0x9558
callq 0x10b0
movzwl 0x4c04(%rip), %eax      # 0x9496
movl $0x100, %ecx            # imm = 0x100
cltd
idivl %ecx
movl %edx, %edi
movq 0x4cb5(%rip), %rsi      # 0x9558
callq 0x10b0
movzbl 0x4be9(%rip), %edi      # 0x9498
movq 0x4ca2(%rip), %rsi      # 0x9558
callq 0x10b0
movzbl 0x4bd7(%rip), %edi      # 0x9499
movq 0x4c8f(%rip), %rsi      # 0x9558
callq 0x10b0
movzbl 0x4bc5(%rip), %edi      # 0x949a
movq 0x4c7c(%rip), %rsi      # 0x9558
callq 0x10b0
movzbl 0x4bb3(%rip), %edi      # 0x949b
movq 0x4c69(%rip), %rsi      # 0x9558
callq 0x10b0
movzbl 0x4ba1(%rip), %edi      # 0x949c
movq 0x4c56(%rip), %rsi      # 0x9558
callq 0x10b0
movzbl 0x4b8f(%rip), %edi      # 0x949d
movq 0x4c43(%rip), %rsi      # 0x9558
callq 0x10b0
movzbl 0x4b7d(%rip), %edi      # 0x949e
movq 0x4c30(%rip), %rsi      # 0x9558
callq 0x10b0
movzbl 0x4b6b(%rip), %edi      # 0x949f
movq 0x4c1d(%rip), %rsi      # 0x9558
callq 0x10b0
movzbl 0x4b59(%rip), %edi      # 0x94a0
movq 0x4c0a(%rip), %rsi      # 0x9558
callq 0x10b0
movzbl 0x4b47(%rip), %edi      # 0x94a1
movq 0x4bf7(%rip), %rsi      # 0x9558
callq 0x10b0
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/albinoloverats[P]hide/src/jpeg-save.c
// Function: main_encoder
static void main_encoder(void)
{
	int16_t DCY = 0, DCCb = 0, DCCr = 0; // DC coefficients used for differential encoding
	for (uint32_t ypos = 0; ypos < Yimage; ypos += 8)
		for (uint32_t xpos = 0; xpos < Ximage; xpos += 8)
		{
			load_data_units_from_RGB_buffer(xpos, ypos);
			process_DU(YDU, fdtbl_Y, &DCY, YDC_HT, YAC_HT);
			process_DU(CbDU, fdtbl_Cb, &DCCb, CbDC_HT, CbAC_HT);
			process_DU(CrDU, fdtbl_Cb, &DCCr, CbDC_HT, CbAC_HT);
		}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movw $0x0, -0x2(%rbp)
movw $0x0, -0x4(%rbp)
movw $0x0, -0x6(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl 0x4bb2(%rip), %eax      # 0x954c
jae 0x4a4e
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl 0x4b98(%rip), %eax      # 0x9548
jae 0x4a3e
movl -0x10(%rbp), %edi
movl -0xc(%rbp), %esi
callq 0x55e0
leaq 0x57e48(%rip), %rdi     # 0x5c810
leaq 0x57a41(%rip), %rsi     # 0x5c410
leaq -0x2(%rbp), %rdx
leaq 0x4db6(%rip), %rcx      # 0x9790
leaq 0x4e0f(%rip), %r8       # 0x97f0
callq 0x5770
leaq 0x57e63(%rip), %rdi     # 0x5c850
leaq 0x57c1c(%rip), %rsi     # 0x5c610
leaq -0x4(%rbp), %rdx
leaq 0x4dc1(%rip), %rcx      # 0x97c0
leaq 0x51ea(%rip), %r8       # 0x9bf0
callq 0x5770
leaq 0x57e7e(%rip), %rdi     # 0x5c890
leaq 0x57bf7(%rip), %rsi     # 0x5c610
leaq -0x6(%rbp), %rdx
leaq 0x4d9c(%rip), %rcx      # 0x97c0
leaq 0x51c5(%rip), %r8       # 0x9bf0
callq 0x5770
movl -0x10(%rbp), %eax
addl $0x8, %eax
movl %eax, -0x10(%rbp)
jmp 0x49a7
jmp 0x4a40
movl -0xc(%rbp), %eax
addl $0x8, %eax
movl %eax, -0xc(%rbp)
jmp 0x4991
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/albinoloverats[P]hide/src/jpeg-save.c
// Function: writebits
static void writebits(bitstring bs)
{
	// bit position in the bitstring we read, should be<=15 and >=0
	for (int posval = bs.length - 1; posval >= 0; )
	{
		if (bs.value & mask[posval])
			bytenew |= mask[bytepos];
		posval--;
		bytepos--;
		if (bytepos < 0)
		{
			if (bytenew == 0xFF)
			{
				writebyte(0xFF);
				writebyte(0);
			}
			else
				writebyte(bytenew);
			bytepos = 7;
			bytenew = 0;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movzbl -0x4(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jl 0x4b33
movzwl -0x2(%rbp), %eax
movslq -0x8(%rbp), %rdx
leaq 0x4a22(%rip), %rcx      # 0x94b0
movzwl (%rcx,%rdx,2), %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0x4abb
movsbq 0x4743(%rip), %rcx      # 0x91e4
leaq 0x4a08(%rip), %rax      # 0x94b0
movzwl (%rax,%rcx,2), %ecx
movzbl 0x4aad(%rip), %eax      # 0x9560
orl %ecx, %eax
movb %al, 0x4aa5(%rip)       # 0x9560
movl -0x8(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x8(%rbp)
movb 0x471a(%rip), %al       # 0x91e4
addb $-0x1, %al
movb %al, 0x4712(%rip)       # 0x91e4
movsbl 0x470b(%rip), %eax      # 0x91e4
cmpl $0x0, %eax
jge 0x4b2e
movzbl 0x4a7b(%rip), %eax      # 0x9560
cmpl $0xff, %eax
jne 0x4b0d
movq 0x4a65(%rip), %rsi      # 0x9558
movl $0xff, %edi
callq 0x10b0
movq 0x4a54(%rip), %rsi      # 0x9558
xorl %edi, %edi
callq 0x10b0
jmp 0x4b20
movzbl 0x4a4c(%rip), %edi      # 0x9560
movq 0x4a3d(%rip), %rsi      # 0x9558
callq 0x10b0
movb $0x7, 0x46bd(%rip)      # 0x91e4
movb $0x0, 0x4a32(%rip)      # 0x9560
jmp 0x4a75
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/albinoloverats[P]hide/src/jpeg-save.c
// Function: set_DQTinfo
static void set_DQTinfo(void)
{
	// scalefactor controls the visual quality of the image
	// the smaller is, the better image we'll get, and the smaller
	// compression we'll achieve
	uint8_t scalefactor = 1; /* this could be a parameter */
	DQTinfo.marker = 0xFFDB;
	DQTinfo.length = 132;
	DQTinfo.QTYinfo = 0;
	DQTinfo.QTCbinfo = 1;
	set_quant_table(std_luminance_qt, scalefactor, DQTinfo.Ytable);
	set_quant_table(std_chrominance_qt, scalefactor, DQTinfo.Cbtable);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb $0x1, -0x1(%rbp)
movw $0xffdb, 0x4a11(%rip)   # imm = 0xFFDB
movw $0x84, 0x4a0a(%rip)     # 0x9564
movb $0x0, 0x4a05(%rip)      # 0x9566
movb $0x1, 0x4a3f(%rip)      # 0x95a7
movl $0x0, -0x8(%rbp)
cmpl $0x40, -0x8(%rbp)
jge 0x4c34
movslq -0x8(%rbp), %rcx
leaq 0x466c(%rip), %rax      # 0x91f0
movzbl (%rax,%rcx), %eax
movzbl -0x1(%rbp), %ecx
imull %ecx, %eax
addl $0x32, %eax
movl $0x64, %ecx
cltd
idivl %ecx
cmpl $0x1, %eax
jge 0x4ba9
movl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x4c05
movslq -0x8(%rbp), %rcx
leaq 0x463c(%rip), %rax      # 0x91f0
movzbl (%rax,%rcx), %eax
movzbl -0x1(%rbp), %ecx
imull %ecx, %eax
addl $0x32, %eax
movl $0x64, %ecx
cltd
idivl %ecx
cmpl $0xff, %eax
jle 0x4bdb
movl $0xff, %eax
movl %eax, -0x14(%rbp)
jmp 0x4bff
movslq -0x8(%rbp), %rcx
leaq 0x460a(%rip), %rax      # 0x91f0
movzbl (%rax,%rcx), %eax
movzbl -0x1(%rbp), %ecx
imull %ecx, %eax
addl $0x32, %eax
movl $0x64, %ecx
cltd
idivl %ecx
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
movb %al, %dl
movslq -0x8(%rbp), %rcx
leaq 0x461b(%rip), %rax      # 0x9230
movzbl (%rax,%rcx), %eax
movl %eax, %ecx
leaq 0x4940(%rip), %rax      # 0x9562
movb %dl, 0x5(%rax,%rcx)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x4b6f
movl $0x0, -0xc(%rbp)
cmpl $0x40, -0xc(%rbp)
jge 0x4d00
movslq -0xc(%rbp), %rcx
leaq 0x4620(%rip), %rax      # 0x9270
movzbl (%rax,%rcx), %eax
movzbl -0x1(%rbp), %ecx
imull %ecx, %eax
addl $0x32, %eax
movl $0x64, %ecx
cltd
idivl %ecx
cmpl $0x1, %eax
jge 0x4c75
movl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x4cd1
movslq -0xc(%rbp), %rcx
leaq 0x45f0(%rip), %rax      # 0x9270
movzbl (%rax,%rcx), %eax
movzbl -0x1(%rbp), %ecx
imull %ecx, %eax
addl $0x32, %eax
movl $0x64, %ecx
cltd
idivl %ecx
cmpl $0xff, %eax
jle 0x4ca7
movl $0xff, %eax
movl %eax, -0x1c(%rbp)
jmp 0x4ccb
movslq -0xc(%rbp), %rcx
leaq 0x45be(%rip), %rax      # 0x9270
movzbl (%rax,%rcx), %eax
movzbl -0x1(%rbp), %ecx
imull %ecx, %eax
addl $0x32, %eax
movl $0x64, %ecx
cltd
idivl %ecx
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movb %al, %dl
movslq -0xc(%rbp), %rcx
leaq 0x454f(%rip), %rax      # 0x9230
movzbl (%rax,%rcx), %eax
movl %eax, %ecx
leaq 0x4874(%rip), %rax      # 0x9562
movb %dl, 0x46(%rax,%rcx)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x4c3b
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/albinoloverats[P]hide/src/jpeg-save.c
// Function: set_numbers_category_and_bitcode
static void set_numbers_category_and_bitcode(void)
{
	int32_t nrlower = 1;
	int32_t nrupper = 2;

	category = category_alloc + 32767; // allow negative subscripts
	bitcode = bitcode_alloc + 32767;

	for (int cat = 1; cat <= 15; cat++)
	{
		// Positive numbers
		for (int nr = nrlower; nr < nrupper; nr++)
		{
			category[nr] = cat;
			bitcode[nr].length = cat;
			bitcode[nr].value = (uint16_t)nr;
		}
		// Negative numbers
		for (int nr = -(nrupper - 1); nr <= -nrlower; nr++)
		{
			category[nr] = cat;
			bitcode[nr].length = cat;
			bitcode[nr].value = (uint16_t)(nrupper - 1 + nr);
		}
		nrlower <<= 1;
		nrupper <<= 1;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x1, -0x4(%rbp)
movl $0x2, -0x8(%rbp)
leaq 0x4dc7(%rip), %rax      # 0x9ff0
addq $0x7fff, %rax           # imm = 0x7FFF
movq %rax, 0x14dba(%rip)     # 0x19ff0
leaq 0x14dc3(%rip), %rax     # 0x1a000
addq $0x1fffc, %rax          # imm = 0x1FFFC
movq %rax, 0x54db6(%rip)     # 0x5a000
movl $0x1, -0xc(%rbp)
cmpl $0xf, -0xc(%rbp)
jg 0x5334
movl -0x4(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x52b0
movl -0xc(%rbp), %eax
movb %al, %dl
movq 0x14d7b(%rip), %rax     # 0x19ff0
movslq -0x10(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0xc(%rbp), %eax
movb %al, %dl
movq 0x54d78(%rip), %rax     # 0x5a000
movslq -0x10(%rbp), %rcx
movb %dl, (%rax,%rcx,4)
movl -0x10(%rbp), %eax
movw %ax, %dx
movq 0x54d64(%rip), %rax     # 0x5a000
movslq -0x10(%rbp), %rcx
movw %dx, 0x2(%rax,%rcx,4)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x5261
movl -0x8(%rbp), %ecx
subl $0x1, %ecx
xorl %eax, %eax
subl %ecx, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
xorl %ecx, %ecx
subl -0x4(%rbp), %ecx
cmpl %ecx, %eax
jg 0x5316
movl -0xc(%rbp), %eax
movb %al, %dl
movq 0x14d1b(%rip), %rax     # 0x19ff0
movslq -0x14(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0xc(%rbp), %eax
movb %al, %dl
movq 0x54d18(%rip), %rax     # 0x5a000
movslq -0x14(%rbp), %rcx
movb %dl, (%rax,%rcx,4)
movl -0x8(%rbp), %eax
subl $0x1, %eax
addl -0x14(%rbp), %eax
movw %ax, %dx
movq 0x54cfe(%rip), %rax     # 0x5a000
movslq -0x14(%rbp), %rcx
movw %dx, 0x2(%rax,%rcx,4)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x52bd
movl -0x4(%rbp), %eax
shll %eax
movl %eax, -0x4(%rbp)
movl -0x8(%rbp), %eax
shll %eax
movl %eax, -0x8(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x5251
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/albinoloverats[P]hide/src/jpeg-save.c
// Function: precalculate_YCbCr_tables
static void precalculate_YCbCr_tables(void)
{
	for (int i = 0; i <= 255; i++)
	{
		// red values
		YRtab[i]  = (int32_t)(RED_Y    * i); // 65536 *  0.29900 + 0.5
		CbRtab[i] = (int32_t)(RED_Cb   * i); // 65536 * -0.16874 + 0.5
		CrRtab[i] = (int32_t)(RED_Cr   * i); // 32768
		// green values
		YGtab[i]  = (int32_t)(GREEN_Y  * i); // 65536 *  0.58700 + 0.5
		CbGtab[i] = (int32_t)(GREEN_Cb * i); // 65536 * -0.33126 + 0.5
		CrGtab[i] = (int32_t)(GREEN_Cr * i); // 65536 * -0.41869 + 0.5
		// blue values
		YBtab[i]  = (int32_t)(BLUE_Y   * i); // 65536 *  0.11400 + 0.5
		CbBtab[i] = (int32_t)(BLUE_Cb  * i); // 32768
		CrBtab[i] = (int32_t)(BLUE_Cr  * i); // 65536 * -0.08131 + 0.5
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x0, -0x4(%rbp)
cmpl $0xff, -0x4(%rbp)
jg 0x54a1
cvtsi2sdl -0x4(%rbp), %xmm1
movsd 0x1de3(%rip), %xmm0     # 0x7148
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %edx
movslq -0x4(%rbp), %rcx
leaq 0x54c98(%rip), %rax     # 0x5a010
movl %edx, (%rax,%rcx,4)
cvtsi2sdl -0x4(%rbp), %xmm1
movsd 0x1db8(%rip), %xmm0     # 0x7140
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %edx
movslq -0x4(%rbp), %rcx
leaq 0x55075(%rip), %rax     # 0x5a410
movl %edx, (%rax,%rcx,4)
cvtsi2sdl -0x4(%rbp), %xmm1
movsd 0x1d6d(%rip), %xmm0     # 0x7118
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %edx
movslq -0x4(%rbp), %rcx
leaq 0x55452(%rip), %rax     # 0x5a810
movl %edx, (%rax,%rcx,4)
cvtsi2sdl -0x4(%rbp), %xmm1
movsd 0x1d6a(%rip), %xmm0     # 0x7138
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %edx
movslq -0x4(%rbp), %rcx
leaq 0x5582f(%rip), %rax     # 0x5ac10
movl %edx, (%rax,%rcx,4)
cvtsi2sdl -0x4(%rbp), %xmm1
movsd 0x1d3f(%rip), %xmm0     # 0x7130
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %edx
movslq -0x4(%rbp), %rcx
leaq 0x55c0c(%rip), %rax     # 0x5b010
movl %edx, (%rax,%rcx,4)
cvtsi2sdl -0x4(%rbp), %xmm1
movsd 0x1d14(%rip), %xmm0     # 0x7128
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %edx
movslq -0x4(%rbp), %rcx
leaq 0x55fe9(%rip), %rax     # 0x5b410
movl %edx, (%rax,%rcx,4)
cvtsi2sdl -0x4(%rbp), %xmm1
movsd 0x1ce9(%rip), %xmm0     # 0x7120
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %edx
movslq -0x4(%rbp), %rcx
leaq 0x563c6(%rip), %rax     # 0x5b810
movl %edx, (%rax,%rcx,4)
cvtsi2sdl -0x4(%rbp), %xmm1
movsd 0x1cbe(%rip), %xmm0     # 0x7118
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %edx
movslq -0x4(%rbp), %rcx
leaq 0x567a3(%rip), %rax     # 0x5bc10
movl %edx, (%rax,%rcx,4)
cvtsi2sdl -0x4(%rbp), %xmm1
movsd 0x1c93(%rip), %xmm0     # 0x7110
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %edx
movslq -0x4(%rbp), %rcx
leaq 0x56b80(%rip), %rax     # 0x5c010
movl %edx, (%rax,%rcx,4)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x534b
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/albinoloverats[P]hide/src/jpeg-save.c
// Function: prepare_quant_tables
static void prepare_quant_tables(void)
{
	for (int i = 0, row = 0; row < 8; row++)
		for (int col = 0; col < 8; col++, i++)
		{
			fdtbl_Y[i] = 1.0 /                   \
				((DQTinfo.Ytable[zigzag[i]]  \
				* AAN_SCALE_FACTOR[row]      \
				* AAN_SCALE_FACTOR[col])     \
				* 8);
			fdtbl_Cb[i] = 1.0 /                  \
				((DQTinfo.Cbtable[zigzag[i]] \
				* AAN_SCALE_FACTOR[row]      \
				* AAN_SCALE_FACTOR[col])     \
				* 8);
		}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x0, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
cmpl $0x8, -0x8(%rbp)
jge 0x55d6
movl $0x0, -0xc(%rbp)
cmpl $0x8, -0xc(%rbp)
jge 0x55c6
movslq -0x4(%rbp), %rcx
leaq 0x3d48(%rip), %rax      # 0x9230
movzbl (%rax,%rcx), %eax
movl %eax, %ecx
leaq 0x406d(%rip), %rax      # 0x9562
movzbl 0x5(%rax,%rcx), %eax
cvtsi2sd %eax, %xmm1
movslq -0x8(%rbp), %rcx
leaq 0x1c77(%rip), %rax      # 0x7180
mulsd (%rax,%rcx,8), %xmm1
movslq -0xc(%rbp), %rcx
leaq 0x1c67(%rip), %rax      # 0x7180
mulsd (%rax,%rcx,8), %xmm1
movsd 0x1c2a(%rip), %xmm0     # 0x7150
mulsd %xmm0, %xmm1
movsd 0x1b86(%rip), %xmm0     # 0x70b8
divsd %xmm1, %xmm0
movslq -0x4(%rbp), %rcx
leaq 0x56ecf(%rip), %rax     # 0x5c410
movsd %xmm0, (%rax,%rcx,8)
movslq -0x4(%rbp), %rcx
leaq 0x3cdf(%rip), %rax      # 0x9230
movzbl (%rax,%rcx), %eax
movl %eax, %ecx
leaq 0x4004(%rip), %rax      # 0x9562
movzbl 0x46(%rax,%rcx), %eax
cvtsi2sd %eax, %xmm1
movslq -0x8(%rbp), %rcx
leaq 0x1c0e(%rip), %rax      # 0x7180
mulsd (%rax,%rcx,8), %xmm1
movslq -0xc(%rbp), %rcx
leaq 0x1bfe(%rip), %rax      # 0x7180
mulsd (%rax,%rcx,8), %xmm1
movsd 0x1bc1(%rip), %xmm0     # 0x7150
mulsd %xmm0, %xmm1
movsd 0x1b1d(%rip), %xmm0     # 0x70b8
divsd %xmm1, %xmm0
movslq -0x4(%rbp), %rcx
leaq 0x57066(%rip), %rax     # 0x5c610
movsd %xmm0, (%rax,%rcx,8)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x54d3
jmp 0x55c8
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x54c2
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/albinoloverats[P]hide/src/jpeg-save.c
// Function: load_data_units_from_RGB_buffer
static void load_data_units_from_RGB_buffer(int xpos, int ypos)
{
	uint8_t pos = 0;
	uint32_t location = ypos * Ximage + xpos;
	for (int y = 0; y < 8; y++)
	{
		for (int x = 0; x < 8; x++)
		{
			int R = RGB_buffer[location].R;
			int G = RGB_buffer[location].G;
			int B = RGB_buffer[location].B;
			YDU[pos] = Y(R, G, B);
			CbDU[pos] = Cb(R, G, B);
			CrDU[pos] = Cr(R, G, B);
			location++;
			pos++;
		}
		location += Ximage - 8;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movb $0x0, -0x9(%rbp)
movl -0x8(%rbp), %eax
imull 0x3f50(%rip), %eax      # 0x9548
addl -0x4(%rbp), %eax
movl %eax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x8, -0x14(%rbp)
jge 0x5768
movl $0x0, -0x18(%rbp)
cmpl $0x8, -0x18(%rbp)
jge 0x574b
movq 0x3f29(%rip), %rax      # 0x9550
movl -0x10(%rbp), %ecx
imulq $0x3, %rcx, %rcx
addq %rcx, %rax
movzbl (%rax), %eax
movl %eax, -0x1c(%rbp)
movq 0x3f12(%rip), %rax      # 0x9550
movl -0x10(%rbp), %ecx
imulq $0x3, %rcx, %rcx
addq %rcx, %rax
movzbl 0x1(%rax), %eax
movl %eax, -0x20(%rbp)
movq 0x3efa(%rip), %rax      # 0x9550
movl -0x10(%rbp), %ecx
imulq $0x3, %rcx, %rcx
addq %rcx, %rax
movzbl 0x2(%rax), %eax
movl %eax, -0x24(%rbp)
movslq -0x1c(%rbp), %rcx
leaq 0x5499e(%rip), %rax     # 0x5a010
movl (%rax,%rcx,4), %eax
movslq -0x20(%rbp), %rdx
leaq 0x55590(%rip), %rcx     # 0x5ac10
addl (%rcx,%rdx,4), %eax
movslq -0x24(%rbp), %rdx
leaq 0x56182(%rip), %rcx     # 0x5b810
addl (%rcx,%rdx,4), %eax
sarl $0x10, %eax
movzbl %al, %eax
subl $0x80, %eax
movb %al, %dl
movzbl -0x9(%rbp), %eax
movl %eax, %ecx
leaq 0x57165(%rip), %rax     # 0x5c810
movb %dl, (%rax,%rcx)
movslq -0x1c(%rbp), %rcx
leaq 0x54d57(%rip), %rax     # 0x5a410
movl (%rax,%rcx,4), %eax
movslq -0x20(%rbp), %rdx
leaq 0x55949(%rip), %rcx     # 0x5b010
addl (%rcx,%rdx,4), %eax
movslq -0x24(%rbp), %rdx
leaq 0x5653b(%rip), %rcx     # 0x5bc10
addl (%rcx,%rdx,4), %eax
sarl $0x10, %eax
movb %al, %dl
movzbl -0x9(%rbp), %eax
movl %eax, %ecx
leaq 0x57166(%rip), %rax     # 0x5c850
movb %dl, (%rax,%rcx)
movslq -0x1c(%rbp), %rcx
leaq 0x55118(%rip), %rax     # 0x5a810
movl (%rax,%rcx,4), %eax
movslq -0x20(%rbp), %rdx
leaq 0x55d0a(%rip), %rcx     # 0x5b410
addl (%rcx,%rdx,4), %eax
movslq -0x24(%rbp), %rdx
leaq 0x568fc(%rip), %rcx     # 0x5c010
addl (%rcx,%rdx,4), %eax
sarl $0x10, %eax
movb %al, %dl
movzbl -0x9(%rbp), %eax
movl %eax, %ecx
leaq 0x57167(%rip), %rax     # 0x5c890
movb %dl, (%rax,%rcx)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
movb -0x9(%rbp), %al
addb $0x1, %al
movb %al, -0x9(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x5616
movl 0x3df7(%rip), %eax      # 0x9548
subl $0x8, %eax
addl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x5605
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/thiagok00[P]INF1715-Compilers/ArvoreSintaticaAbstrata.c
// Function: getStringTipo
char* getStringTipo (Tipo *t) {

    Tipo *aux = t;
    char *strbase = strFormatoTipo(t->tipo_base);
    char *arrayde = "array de ";
    char *str;
    int arrayCounts = 0;

    if(t == NULL) {
      printf("TIPO NULL");
      return NULL;
    }
    while (aux->de != NULL) {
      arrayCounts++;
      aux = aux->de;
    }

    str = (char*)malloc((strlen(arrayde)*arrayCounts + strlen(strbase) + 1) * sizeof(char));
    if (str == NULL){printf("falta de memoria"); exit(1);}
    str[0] = '\0';
    while(arrayCounts) {
      strcat(str,arrayde);
      arrayCounts--;
    }
    strcat(str,strbase);
    return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %edi
callq 0x4bb0
movq %rax, -0x20(%rbp)
leaq 0x5709(%rip), %rax      # 0xa1c4
movq %rax, -0x28(%rbp)
movl $0x0, -0x34(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x4ae8
leaq 0x56fa(%rip), %rdi      # 0xa1ce
movb $0x0, %al
callq 0x10a0
movq $0x0, -0x8(%rbp)
jmp 0x4b9b
jmp 0x4aea
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x4b0c
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x4aea
movq -0x28(%rbp), %rdi
callq 0x1090
movslq -0x34(%rbp), %rcx
imulq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1090
movq -0x40(%rbp), %rdi
addq %rax, %rdi
addq $0x1, %rdi
shlq $0x0, %rdi
callq 0x1130
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x4b61
leaq 0x5688(%rip), %rdi      # 0xa1d8
movb $0x0, %al
callq 0x10a0
movl $0x1, %edi
callq 0x1190
movq -0x30(%rbp), %rax
movb $0x0, (%rax)
cmpl $0x0, -0x34(%rbp)
je 0x4b86
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x1170
movl -0x34(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x4b68
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1170
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/thiagok00[P]INF1715-Compilers/ArvoreSintaticaAbstrata.c
// Function: strFormatoTipo
static char* strFormatoTipo(Base_TAG x) {
    switch (x){
      case bInt: return "INT";
      case bFloat: return "FLOAT";
      case bChar: return "CHAR";
      case bVoid: return "VOID";
      default: return "TIPOERRADO";
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0x3, %rax
ja 0x4c0c
movq -0x18(%rbp), %rax
leaq 0x5565(%rip), %rcx      # 0xa134
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x5637(%rip), %rax      # 0xa216
movq %rax, -0x8(%rbp)
jmp 0x4c17
leaq 0x562e(%rip), %rax      # 0xa21a
movq %rax, -0x8(%rbp)
jmp 0x4c17
leaq 0x5627(%rip), %rax      # 0xa220
movq %rax, -0x8(%rbp)
jmp 0x4c17
leaq 0x561f(%rip), %rax      # 0xa225
movq %rax, -0x8(%rbp)
jmp 0x4c17
leaq 0x5617(%rip), %rax      # 0xa22a
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/thiagok00[P]INF1715-Compilers/ArvoreSintaticaAbstrata.c
// Function: print_tree
void print_tree (Programa *p) {
  int nivel = 0;
  if (p != NULL){
    printf("Nivel\t No\n");
    printf("%d\t [Programa]\n",nivel);
    print_defs(p->defs,nivel+1);
  }
  else
    printf("[Programa vazio]\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x4c6d
leaq 0x55a8(%rip), %rdi      # 0xa1e9
movb $0x0, %al
callq 0x10a0
movl -0xc(%rbp), %esi
leaq 0x55a2(%rip), %rdi      # 0xa1f4
movb $0x0, %al
callq 0x10a0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x1, %esi
callq 0x4c90
jmp 0x4c7b
leaq 0x5590(%rip), %rdi      # 0xa204
movb $0x0, %al
callq 0x10a0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/thiagok00[P]INF1715-Compilers/ArvoreSintaticaAbstrata.c
// Function: print_defs
static void print_defs(Definicao* d, int nivel) {
    Definicao *aux = d;
    while (aux != NULL) {
      printf("%d\t [Definicao]\n",nivel);
      if(aux->tag == DVar){
          print_defvar(aux->u.v,nivel+1);
      }
      else if (aux->tag == DFunc) {
        print_deffunc(aux->u.f,nivel+1);
      }
      nivel++;
      aux = aux->prox;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x4d12
movl -0xc(%rbp), %esi
leaq 0x557d(%rip), %rdi      # 0xa235
movb $0x0, %al
callq 0x10a0
movq -0x18(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x4cdd
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x1, %esi
callq 0x4d20
jmp 0x4cfb
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x4cf9
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x1, %esi
callq 0x4da0
jmp 0x4cfb
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x4ca7
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/thiagok00[P]INF1715-Compilers/ArvoreSintaticaAbstrata.c
// Function: print_defvar
static void print_defvar(DefVar * dvar,int nivel) {
    if (dvar == NULL) return;

    char *tipostr = getStringTipo(dvar->tipo);
    if(dvar->escopo == 0 ) //Global def
      printf("%d\t [Def Variavel Global] %s : %s\n",nivel,dvar->id,tipostr);
    else //EscopoLocal
      printf("%d\t [Def Variavel Local] %s : %s\n",nivel,dvar->id,tipostr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x4d38
jmp 0x4d8d
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x4a90
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x14(%rax)
jne 0x4d71
movl -0xc(%rbp), %esi
movq -0x8(%rbp), %rax
movq (%rax), %rdx
movq -0x18(%rbp), %rcx
leaq 0x54de(%rip), %rdi      # 0xa246
movb $0x0, %al
callq 0x10a0
jmp 0x4d8d
movl -0xc(%rbp), %esi
movq -0x8(%rbp), %rax
movq (%rax), %rdx
movq -0x18(%rbp), %rcx
leaq 0x54e3(%rip), %rdi      # 0xa269
movb $0x0, %al
callq 0x10a0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/thiagok00[P]INF1715-Compilers/ArvoreSintaticaAbstrata.c
// Function: print_deffunc
static void print_deffunc(DefFunc * dfunc,int nivel) {

    char *tiporetstr;
    ParametroL* aux = dfunc->params;
    int parametroCount = 0;
    if(dfunc == NULL) return;
    tiporetstr = getStringTipo(dfunc->tiporet);
    printf("%d\t [Def Funcao] %s : %s \n",nivel,dfunc->id,tiporetstr);
    while ( aux != NULL) {
      char *tipoparam = getStringTipo(aux->tipo);
      printf("%d\t [Parametro %d] %s : %s\n",nivel,parametroCount+1,aux->id,tipoparam);
      parametroCount++;
      aux = aux->prox;
    }
    print_bloco(dfunc->bloco,nivel+1  );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x4dce
jmp 0x4e5f
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x4a90
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %esi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x18(%rbp), %rcx
leaq 0x5497(%rip), %rdi      # 0xa28b
movb $0x0, %al
callq 0x10a0
cmpq $0x0, -0x20(%rbp)
je 0x4e4c
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x4a90
movq %rax, -0x30(%rbp)
movl -0xc(%rbp), %esi
movl -0x24(%rbp), %edx
addl $0x1, %edx
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x30(%rbp), %r8
leaq 0x5478(%rip), %rdi      # 0xa2a6
movb $0x0, %al
callq 0x10a0
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x4dfb
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x1, %esi
callq 0x4e70
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)