// File: /workspace/github_cpp_makefile_star2_O3/rpavlik[P]edid-decode/parse-base-block.cpp
// Function: edid_state::detailed_display_range_limits(unsigned char const*)
void edid_state::detailed_display_range_limits(const unsigned char *x)
{
	int h_max_offset = 0, h_min_offset = 0;
	int v_max_offset = 0, v_min_offset = 0;
	int is_cvt = 0;
	bool has_sec_gtf = false;
	std::string range_class;

	data_block = "Display Range Limits";
	printf("  %s:\n", data_block.c_str());
	base.has_display_range_descriptor = 1;

	if (base.edid_minor >= 4) {
		if (x[4] & 0x02) {
			v_max_offset = 255;
			if (x[4] & 0x01) {
				v_min_offset = 255;
			}
		}
		if (x[4] & 0x08) {
			h_max_offset = 255;
			if (x[4] & 0x04) {
				h_min_offset = 255;
			}
		}
	}

	/*
	 * despite the values, this is not a bitfield.
	 */
	switch (x[10]) {
	case 0x00: /* default gtf */
		range_class = "GTF";
		if (base.edid_minor >= 4 && !base.supports_continuous_freq)
			fail("GTF can't be combined with non-continuous frequencies.\n");
		if (base.edid_minor >= 4)
			warn("GTF support is deprecated in EDID 1.4.\n");
		break;
	case 0x01: /* range limits only */
		range_class = "Bare Limits";
		if (base.edid_minor < 4)
			fail("'%s' is not allowed for EDID < 1.4.\n", range_class.c_str());
		break;
	case 0x02: /* secondary gtf curve */
		range_class = "Secondary GTF";
		if (base.edid_minor >= 4 && !base.supports_continuous_freq)
			fail("GTF can't be combined with non-continuous frequencies.\n");
		if (base.edid_minor >= 4)
			warn("GTF support is deprecated in EDID 1.4.\n");
		has_sec_gtf = true;
		break;
	case 0x04: /* cvt */
		range_class = "CVT";
		is_cvt = 1;
		if (base.edid_minor < 4)
			fail("'%s' is not allowed for EDID < 1.4.\n", range_class.c_str());
		else if (!base.supports_continuous_freq)
			fail("CVT can't be combined with non-continuous frequencies.\n");
		break;
	default: /* invalid */
		fail("Unknown range class (0x%02x).\n", x[10]);
		range_class = std::string("Unknown (") + utohex(x[10]) + ")";
		break;
	}

	if (x[5] + v_min_offset > x[6] + v_max_offset)
		fail("Min vertical rate > max vertical rate.\n");
	base.min_display_vert_freq_hz = x[5] + v_min_offset;
	base.max_display_vert_freq_hz = x[6] + v_max_offset;
	if (x[7] + h_min_offset > x[8] + h_max_offset)
		fail("Min horizontal freq > max horizontal freq.\n");
	base.min_display_hor_freq_hz = (x[7] + h_min_offset) * 1000;
	base.max_display_hor_freq_hz = (x[8] + h_max_offset) * 1000;
	printf("    Monitor ranges (%s): %d-%d Hz V, %d-%d kHz H",
	       range_class.c_str(),
	       x[5] + v_min_offset, x[6] + v_max_offset,
	       x[7] + h_min_offset, x[8] + h_max_offset);

	// For EDID 1.3 the horizontal frequency maxes out at 255 kHz.
	// So to avoid false range-check warnings due to this limitation,
	// just double the max_display_hor_freq_hz in this case.
	if (base.edid_minor < 4 && x[8] == 0xff)
		base.max_display_hor_freq_hz *= 2;

	// For EDID 1.3 the vertical frequency maxes out at 255 Hz.
	// So to avoid false range-check warnings due to this limitation,
	// just double the max_display_vert_freq_hz in this case.
	if (base.edid_minor < 4 && x[6] == 0xff)
		base.max_display_vert_freq_hz *= 2;

	if (x[9]) {
		base.max_display_pixclk_khz = x[9] * 10000;
		printf(", max dotclock %d MHz\n", x[9] * 10);
	} else {
		if (base.edid_minor >= 4)
			fail("EDID 1.4 block does not set max dotclock.\n");
		printf("\n");
	}

	if (has_sec_gtf) {
		if (x[11])
			fail("Byte 11 is 0x%02x instead of 0x00.\n", x[11]);
		if (memchk(x + 12, 6)) {
			fail("Zeroed Secondary Curve Block.\n");
		} else {
			printf("    GTF Secondary Curve Block:\n");
			printf("      Start frequency: %u kHz\n", x[12] * 2);
			printf("      C: %.1f%%\n", x[13] / 2.0);
			printf("      M: %u%%/kHz\n", (x[15] << 8) | x[14]);
			printf("      K: %u\n", x[16]);
			printf("      J: %.1f%%\n", x[17] / 2.0);
		}
	} else if (is_cvt) {
		int max_h_pixels = 0;

		printf("    CVT version %d.%d\n", (x[11] & 0xf0) >> 4, x[11] & 0x0f);

		if (x[12] & 0xfc) {
			unsigned raw_offset = (x[12] & 0xfc) >> 2;

			printf("    Real max dotclock: %.2f MHz\n",
			       (x[9] * 10) - (raw_offset * 0.25));
			if (raw_offset >= 40)
				warn("CVT block corrects dotclock by more than 9.75 MHz.\n");
		}

		max_h_pixels = x[12] & 0x03;
		max_h_pixels <<= 8;
		max_h_pixels |= x[13];
		max_h_pixels *= 8;
		if (max_h_pixels)
			printf("    Max active pixels per line: %d\n", max_h_pixels);

		printf("    Supported aspect ratios:%s%s%s%s%s\n",
		       x[14] & 0x80 ? " 4:3" : "",
		       x[14] & 0x40 ? " 16:9" : "",
		       x[14] & 0x20 ? " 16:10" : "",
		       x[14] & 0x10 ? " 5:4" : "",
		       x[14] & 0x08 ? " 15:9" : "");
		if (x[14] & 0x07)
			fail("Reserved bits of byte 14 are non-zero.\n");

		printf("    Preferred aspect ratio: ");
		switch ((x[15] & 0xe0) >> 5) {
		case 0x00:
			printf("4:3");
			break;
		case 0x01:
			printf("16:9");
			break;
		case 0x02:
			printf("16:10");
			break;
		case 0x03:
			printf("5:4");
			break;
		case 0x04:
			printf("15:9");
			break;
		default:
			printf("Unknown (0x%02x)", (x[15] & 0xe0) >> 5);
			fail("Invalid preferred aspect ratio 0x%02x.\n",
			     (x[15] & 0xe0) >> 5);
			break;
		}
		printf("\n");

		if (x[15] & 0x08)
			printf("    Supports CVT standard blanking\n");
		if (x[15] & 0x10)
			printf("    Supports CVT reduced blanking\n");

		if (x[15] & 0x07)
			fail("Reserved bits of byte 15 are non-zero.\n");

		if (x[16] & 0xf0) {
			printf("    Supported display scaling:\n");
			if (x[16] & 0x80)
				printf("      Horizontal shrink\n");
			if (x[16] & 0x40)
				printf("      Horizontal stretch\n");
			if (x[16] & 0x20)
				printf("      Vertical shrink\n");
			if (x[16] & 0x10)
				printf("      Vertical stretch\n");
		}

		if (x[16] & 0x0f)
			fail("Reserved bits of byte 16 are non-zero.\n");

		if (x[17])
			printf("    Preferred vertical refresh: %d Hz\n", x[17]);
		else
			warn("CVT block does not set preferred refresh rate.\n");
	} else {
		if (x[11] != 0x0a)
			fail("Byte 11 is 0x%02x instead of 0x0a.\n", x[11]);
		for (unsigned i = 12; i <= 17; i++) {
			if (x[i] != 0x20) {
				fail("Bytes 12-17 must be 0x20.\n");
				break;
			}
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x20(%rsp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
addq $0x30, %rdi
movq 0x38(%r14), %rdx
leaq 0x1a619(%rip), %rcx     # 0x24941
xorl %r15d, %r15d
movl $0x14, %r8d
xorl %esi, %esi
callq 0x3390
movq 0x30(%r14), %rsi
leaq 0x1aac8(%rip), %rdi     # 0x24e0b
xorl %eax, %eax
callq 0x3030
movb $0x1, 0x8d(%r14)
cmpl $0x4, 0x88(%r14)
movl $0x0, %ebp
movl $0x0, %r12d
movl $0x0, 0xc(%rsp)
jb 0xa3b0
movzbl 0x4(%rbx), %eax
movl %eax, %ebp
shll $0x1e, %ebp
sarl $0x1f, %ebp
movl $0xff, %edx
andl %edx, %ebp
movl %eax, %ecx
notl %ecx
xorl %r15d, %r15d
testb $0x3, %cl
movl $0xff, 0xc(%rsp)
cmovel %edx, %r12d
testb $0x8, %al
jne 0xa3a6
movl $0x0, 0xc(%rsp)
jmp 0xa3b0
shll $0x1d, %eax
sarl $0x1f, %eax
movzbl %al, %r15d
movzbl 0xa(%rbx), %edx
cmpq $0x4, %rdx
ja 0xa554
leaq 0x1810b(%rip), %rax     # 0x224d0
movslq (%rax,%rdx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
leaq 0x10(%rsp), %rdi
movq 0x8(%rdi), %rdx
leaq 0x1a613(%rip), %rcx     # 0x249f1
movl $0x3, %r8d
xorl %esi, %esi
callq 0x3390
movb $0x1, %al
movl %eax, 0x8(%rsp)
cmpl $0x4, 0x88(%r14)
jb 0xa77d
cmpb $0x0, 0x90(%r14)
jne 0xa427
leaq 0x1a546(%rip), %rsi     # 0x24956
xorl %edi, %edi
xorl %eax, %eax
callq 0x37cc
cmpl $0x4, 0x88(%r14)
jb 0xa77d
xorl %r13d, %r13d
leaq 0x1a55d(%rip), %rsi     # 0x2498e
movl $0x1, %edi
xorl %eax, %eax
callq 0x37cc
jmp 0xa780
leaq 0x10(%rsp), %rdi
movq 0x8(%rdi), %rdx
leaq 0x1a595(%rip), %rcx     # 0x249e7
movl $0xd, %r8d
xorl %esi, %esi
callq 0x3390
movb $0x1, %al
movl %eax, 0x8(%rsp)
cmpl $0x4, 0x88(%r14)
jb 0xa5ea
cmpb $0x0, 0x90(%r14)
jne 0xa49b
leaq 0x1a4d2(%rip), %rsi     # 0x24956
xorl %edi, %edi
xorl %eax, %eax
callq 0x37cc
cmpl $0x4, 0x88(%r14)
jb 0xa5ea
leaq 0x1a4ec(%rip), %rsi     # 0x2498e
movl $0x1, %edi
xorl %eax, %eax
callq 0x37cc
movb $0x1, %r13b
jmp 0xa780
leaq 0x10(%rsp), %rdi
movq 0x8(%rdi), %rdx
leaq 0x1a4f0(%rip), %rcx     # 0x249b6
movl $0xb, %r8d
xorl %esi, %esi
callq 0x3390
movb $0x1, %al
movl %eax, 0x8(%rsp)
cmpl $0x3, 0x88(%r14)
ja 0xa77d
xorl %r13d, %r13d
movq 0x10(%rsp), %rdx
leaq 0x1a4cc(%rip), %rsi     # 0x249c2
xorl %edi, %edi
xorl %eax, %eax
callq 0x37cc
jmp 0xa780
leaq 0x10(%rsp), %rdi
movq 0x8(%rdi), %rdx
leaq 0x268ba(%rip), %rcx     # 0x30dce
movl $0x3, %r8d
xorl %esi, %esi
callq 0x3390
cmpl $0x3, 0x88(%r14)
ja 0xa5f2
movl $0x0, 0x8(%rsp)
movq 0x10(%rsp), %rdx
leaq 0x1a47f(%rip), %rsi     # 0x249c2
xorl %edi, %edi
xorl %eax, %eax
callq 0x37cc
xorl %r13d, %r13d
jmp 0xa780
leaq 0x1a4d2(%rip), %rsi     # 0x24a2d
xorl %edi, %edi
xorl %eax, %eax
callq 0x37cc
leaq 0x60(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x1a4d8(%rip), %rsi     # 0x24a4c
leaq 0x1a4da(%rip), %rdx     # 0x24a55
leaq 0x50(%rsp), %rdi
callq 0x8d58
movzbl 0xa(%rbx), %esi
leaq 0x70(%rsp), %rdi
callq 0x59f2
movq 0x50(%rsp), %rcx
movq 0x58(%rsp), %r8
movq 0x78(%rsp), %rdx
leaq (%rdx,%r8), %rax
movl $0xf, %edi
cmpq %r13, %rcx
je 0xa5b5
movq 0x60(%rsp), %rdi
movq 0x70(%rsp), %rsi
cmpq %rdi, %rax
jbe 0xa5de
leaq 0x80(%rsp), %r9
movl $0xf, %edi
cmpq %r9, %rsi
je 0xa5d9
movq 0x80(%rsp), %rdi
cmpq %rdi, %rax
jbe 0xa629
leaq 0x50(%rsp), %rdi
callq 0x30b0
jmp 0xa637
movb $0x1, %r13b
jmp 0xa780
cmpb $0x0, 0x90(%r14)
je 0xa609
movl $0x0, 0x8(%rsp)
jmp 0xa77d
movl $0x0, 0x8(%rsp)
leaq 0x1a3dd(%rip), %rsi     # 0x249f5
xorl %edi, %edi
xorl %eax, %eax
callq 0x37cc
xorl %r13d, %r13d
jmp 0xa780
leaq 0x70(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x3290
leaq 0x40(%rsp), %rdx
movq %rdx, -0x10(%rdx)
movq (%rax), %rsi
leaq 0x10(%rax), %rcx
cmpq %rcx, %rsi
je 0xa65b
movq %rsi, 0x30(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x40(%rsp)
jmp 0xa663
movupd (%rcx), %xmm0
movupd %xmm0, (%rdx)
movq %rax, %rdx
addq $0x8, %rdx
movq 0x8(%rax), %rsi
movq %rsi, 0x38(%rsp)
movq %rcx, (%rax)
movq %r15, 0x90(%rsp)
movq $0x0, (%rdx)
movb $0x0, (%rcx)
leaq 0x2221e(%rip), %rsi     # 0x2c8ad
leaq 0x30(%rsp), %rdi
callq 0x3420
leaq 0xa8(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0xa6c9
movq %rdx, 0x98(%rsp)
movq (%rcx), %rdx
movq %rdx, 0xa8(%rsp)
jmp 0xa6d2
movupd (%rcx), %xmm0
movupd %xmm0, (%r15)
movq 0x8(%rax), %rdx
leaq 0x98(%rsp), %r13
movq %rdx, 0x8(%r13)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x10(%rsp), %rdi
movq %r13, %rsi
callq 0x32d0
movq (%r13), %rdi
cmpq %r15, %rdi
je 0xa717
movq 0xa8(%rsp), %rsi
incq %rsi
callq 0x3260
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
leaq 0x60(%rsp), %r13
movq 0x90(%rsp), %r15
je 0xa73f
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x3260
leaq 0x80(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa760
movq 0x80(%rsp), %rsi
incq %rsi
callq 0x3260
movq 0x50(%rsp), %rdi
cmpq %r13, %rdi
je 0xa777
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x3260
movb $0x1, %al
movl %eax, 0x8(%rsp)
xorl %r13d, %r13d
movzbl 0x5(%rbx), %eax
addl %r12d, %eax
movzbl 0x6(%rbx), %ecx
addl %ebp, %ecx
cmpl %ecx, %eax
jbe 0xa7a8
leaq 0x1a2be(%rip), %rsi     # 0x24a56
xorl %edi, %edi
xorl %eax, %eax
callq 0x37cc
movzbl 0x5(%rbx), %eax
addl %r12d, %eax
movl %eax, 0x168(%r14)
movzbl 0x6(%rbx), %eax
addl %ebp, %eax
movl %eax, 0x16c(%r14)
movzbl 0x7(%rbx), %eax
addl %r15d, %eax
movzbl 0x8(%rbx), %ecx
addl 0xc(%rsp), %ecx
cmpl %ecx, %eax
jbe 0xa7e6
leaq 0x1a2a8(%rip), %rsi     # 0x24a7e
xorl %edi, %edi
xorl %eax, %eax
callq 0x37cc
movzbl 0x7(%rbx), %eax
addl %r15d, %eax
imull $0x3e8, %eax, %eax      # imm = 0x3E8
movl %eax, 0x160(%r14)
movzbl 0x8(%rbx), %eax
movl 0xc(%rsp), %ecx
addl %ecx, %eax
imull $0x3e8, %eax, %eax      # imm = 0x3E8
movl %eax, 0x164(%r14)
movq 0x10(%rsp), %rsi
movzbl 0x5(%rbx), %eax
addl %eax, %r12d
movzbl 0x6(%rbx), %eax
addl %eax, %ebp
movzbl 0x7(%rbx), %eax
addl %eax, %r15d
movzbl 0x8(%rbx), %r9d
addl %ecx, %r9d
leaq 0x1a278(%rip), %rdi     # 0x24aaa
movl %r12d, %edx
movl %ebp, %ecx
movl %r15d, %r8d
xorl %eax, %eax
callq 0x3030
movl 0x88(%r14), %eax
cmpl $0x3, %eax
ja 0xa867
cmpb $-0x1, 0x8(%rbx)
jne 0xa85a
shll 0x164(%r14)
cmpb $-0x1, 0x6(%rbx)
jne 0xa867
shll 0x16c(%r14)
movzbl 0x9(%rbx), %ecx
testl %ecx, %ecx
je 0xa895
imull $0x2710, %ecx, %eax     # imm = 0x2710
movl %eax, 0x170(%r14)
movzbl 0x9(%rbx), %eax
addl %eax, %eax
leal (%rax,%rax,4), %esi
leaq 0x1a24f(%rip), %rdi     # 0x24adb
xorl %eax, %eax
callq 0x3030
jmp 0xa8b4
cmpl $0x4, %eax
jb 0xa8aa
leaq 0x1a251(%rip), %rsi     # 0x24af2
xorl %edi, %edi
xorl %eax, %eax
callq 0x37cc
movl $0xa, %edi
callq 0x3310
movzbl 0xb(%rbx), %edx
testb %r13b, %r13b
je 0xa8fe
testl %edx, %edx
je 0xa8d1
leaq 0x1a255(%rip), %rsi     # 0x24b1d
xorl %edi, %edi
xorl %eax, %eax
callq 0x37cc
leaq 0xc(%rbx), %rdi
movl $0x6, %esi
xorl %edx, %edx
callq 0x5ba5
testb %al, %al
je 0xaa70
leaq 0x1a251(%rip), %rsi     # 0x24b41
xorl %edi, %edi
xorl %eax, %eax
callq 0x37cc
jmp 0xac1a
cmpb $0x0, 0x8(%rsp)
je 0xa935
cmpl $0xa, %edx
je 0xa91a
leaq 0x1a4aa(%rip), %rsi     # 0x24dbb
xorl %edi, %edi
xorl %eax, %eax
callq 0x37cc
xorl %eax, %eax
cmpb $0x20, 0xc(%rbx,%rax)
jne 0xaaf8
incq %rax
cmpq $0x6, %rax
jne 0xa91c
jmp 0xac1a
movl %edx, %esi
shrl $0x4, %esi
andl $0xf, %edx
leaq 0x1a27d(%rip), %rdi     # 0x24bc1
xorl %eax, %eax
callq 0x3030
movb 0xc(%rbx), %bpl
cmpb $0x4, %bpl
jb 0xa9a1
movl %ebp, %eax
movzbl 0x9(%rbx), %ecx
addl %ecx, %ecx
leal (%rcx,%rcx,4), %ecx
cvtsi2sd %ecx, %xmm1
shrb $0x2, %al
movzbl %al, %eax
cvtsi2sd %eax, %xmm0
mulsd 0x19d5a(%rip), %xmm0    # 0x246d0
addsd %xmm1, %xmm0
leaq 0x1a257(%rip), %rdi     # 0x24bd8
movb $0x1, %al
callq 0x3030
cmpb $-0x60, %bpl
jb 0xa9a1
leaq 0x1a264(%rip), %rsi     # 0x24bf9
movl $0x1, %edi
xorl %eax, %eax
callq 0x37cc
movzbl 0xc(%rbx), %eax
andl $0x3, %eax
movzbl 0xd(%rbx), %esi
shll $0xb, %eax
shll $0x3, %esi
orl %eax, %esi
je 0xa9c4
leaq 0x1a270(%rip), %rdi     # 0x24c2d
xorl %eax, %eax
callq 0x3030
movzbl 0xe(%rbx), %eax
testb %al, %al
leaq 0x162b8(%rip), %rdi     # 0x20c89
leaq 0x1a2a1(%rip), %rsi     # 0x24c79
cmovnsq %rdi, %rsi
testb $0x40, %al
leaq 0x1a299(%rip), %rdx     # 0x24c7e
cmoveq %rdi, %rdx
testb $0x20, %al
leaq 0x1a292(%rip), %rcx     # 0x24c84
cmoveq %rdi, %rcx
testb $0x10, %al
leaq 0x1a28c(%rip), %r8      # 0x24c8b
cmoveq %rdi, %r8
testb $0x8, %al
leaq 0x1a284(%rip), %r9      # 0x24c90
cmoveq %rdi, %r9
leaq 0x1a23a(%rip), %rdi     # 0x24c51
xorl %eax, %eax
callq 0x3030
testb $0x7, 0xe(%rbx)
je 0xaa34
leaq 0x1a26b(%rip), %rsi     # 0x24c96
xorl %edi, %edi
xorl %eax, %eax
callq 0x37cc
leaq 0x1a283(%rip), %rdi     # 0x24cbe
xorl %eax, %eax
callq 0x3030
movzbl 0xf(%rbx), %eax
movl %eax, %esi
shrl $0x5, %esi
cmpl $0xa0, %eax
jae 0xab0d
leaq 0x19c5f(%rip), %rax     # 0x246bc
movslq (%rax,%rsi,4), %rdi
addq %rax, %rdi
xorl %eax, %eax
callq 0x3030
jmp 0xab32
leaq 0x1baae(%rip), %rdi     # 0x26525
callq 0x3380
movzbl 0xc(%rbx), %esi
addl %esi, %esi
leaq 0x1a0d7(%rip), %rdi     # 0x24b60
xorl %eax, %eax
callq 0x3030
movzbl 0xd(%rbx), %eax
cvtsi2sd %eax, %xmm0
mulsd 0x15570(%rip), %xmm0    # 0x20010
leaq 0x1a0d8(%rip), %rdi     # 0x24b7f
movb $0x1, %al
callq 0x3030
movzwl 0xe(%rbx), %esi
leaq 0x1a0d7(%rip), %rdi     # 0x24b90
xorl %eax, %eax
callq 0x3030
movzbl 0x10(%rbx), %esi
leaq 0x1a0d8(%rip), %rdi     # 0x24ba3
xorl %eax, %eax
callq 0x3030
movzbl 0x11(%rbx), %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
mulsd 0x1552b(%rip), %xmm0    # 0x20010
leaq 0x1a0c4(%rip), %rdi     # 0x24bb0
movb $0x1, %al
callq 0x3030
jmp 0xac1a
leaq 0x1a2e0(%rip), %rsi     # 0x24ddf
xorl %edi, %edi
xorl %eax, %eax
callq 0x37cc
jmp 0xac1a
leaq 0x1a1c7(%rip), %rdi     # 0x24cdb
xorl %eax, %eax
callq 0x3030
movzbl 0xf(%rbx), %edx
shrl $0x5, %edx
leaq 0x1a1c3(%rip), %rsi     # 0x24cec
xorl %edi, %edi
xorl %eax, %eax
callq 0x37cc
movl $0xa, %edi
callq 0x3310
movb 0xf(%rbx), %al
testb $0x8, %al
je 0xab52
leaq 0x1b919(%rip), %rdi     # 0x26463
callq 0x3380
movb 0xf(%rbx), %al
testb $0x10, %al
je 0xab65
leaq 0x1b929(%rip), %rdi     # 0x26486
callq 0x3380
movb 0xf(%rbx), %al
testb $0x7, %al
je 0xab79
leaq 0x1a1a4(%rip), %rsi     # 0x24d14
xorl %edi, %edi
xorl %eax, %eax
callq 0x37cc
movb 0x10(%rbx), %al
cmpb $0x10, %al
jb 0xabdb
leaq 0x1b921(%rip), %rdi     # 0x264a8
callq 0x3380
movb 0x10(%rbx), %al
testb %al, %al
jns 0xaba2
leaq 0x1b92d(%rip), %rdi     # 0x264c7
callq 0x3380
movb 0x10(%rbx), %al
testb $0x40, %al
je 0xabb5
leaq 0x1b932(%rip), %rdi     # 0x264df
callq 0x3380
movb 0x10(%rbx), %al
testb $0x20, %al
je 0xabc8
leaq 0x1b938(%rip), %rdi     # 0x264f8
callq 0x3380
movb 0x10(%rbx), %al
testb $0x10, %al
je 0xabdb
leaq 0x1b93b(%rip), %rdi     # 0x2650e
callq 0x3380
movb 0x10(%rbx), %al
testb $0xf, %al
je 0xabef
leaq 0x1a156(%rip), %rsi     # 0x24d3c
xorl %edi, %edi
xorl %eax, %eax
callq 0x37cc
movzbl 0x11(%rbx), %esi
testl %esi, %esi
je 0xac07
leaq 0x1a166(%rip), %rdi     # 0x24d64
xorl %eax, %eax
callq 0x3030
jmp 0xac1a
leaq 0x1a17d(%rip), %rsi     # 0x24d8b
movl $0x1, %edi
xorl %eax, %eax
callq 0x37cc
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0xac36
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3260
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xacb2
jmp 0xacb2
movq %rax, %rbx
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xac6f
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x3260
jmp 0xac6f
movq %rax, %rbx
leaq 0x80(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xac95
movq 0x80(%rsp), %rsi
incq %rsi
callq 0x3260
jmp 0xac95
movq %rax, %rbx
movq 0x50(%rsp), %rdi
cmpq %r13, %rdi
je 0xacb5
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x3260
jmp 0xacb5
jmp 0xacb2
jmp 0xacb2
movq %rax, %rbx
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0xacd1
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3260
movq %rbx, %rdi
callq 0x3400
nop