// File: /workspace/github_cpp_makefile_star2_O1/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 0x28(%rsp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
addq $0x30, %rdi
movq 0x38(%r14), %rdx
leaq 0x1a385(%rip), %rcx     # 0x248f1
movq $0x0, 0x8(%rsp)
movl $0x14, %r8d
xorl %esi, %esi
callq 0x3390
movq 0x30(%r14), %rsi
leaq 0x1a82e(%rip), %rdi     # 0x24dbb
xorl %eax, %eax
callq 0x3030
movb $0x1, 0x8d(%r14)
cmpl $0x4, 0x88(%r14)
movl $0x0, %ebp
movl $0x0, %r15d
movl $0x0, %r13d
jb 0xa5f7
movzbl 0x4(%rbx), %eax
movl %eax, %ebp
shll $0x1e, %ebp
sarl $0x1f, %ebp
movl $0xff, %r13d
andl %r13d, %ebp
movl %eax, %ecx
notl %ecx
movq $0x0, 0x8(%rsp)
testb $0x3, %cl
cmovel %r13d, %r15d
testb $0x8, %al
jne 0xa5e9
xorl %r13d, %r13d
jmp 0xa5f7
shll $0x1d, %eax
sarl $0x1f, %eax
movzbl %al, %eax
movq %rax, 0x8(%rsp)
movzbl 0xa(%rbx), %edx
cmpq $0x4, %rdx
ja 0xa793
leaq 0x17eb4(%rip), %rax     # 0x224c0
movslq (%rax,%rdx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
leaq 0x18(%rsp), %rdi
movq 0x8(%rdi), %rdx
leaq 0x1a37c(%rip), %rcx     # 0x249a1
movl $0x3, %r8d
xorl %esi, %esi
callq 0x3390
cmpl $0x4, 0x88(%r14)
jb 0xa656
cmpb $0x0, 0x90(%r14)
jne 0xa656
leaq 0x1a2b9(%rip), %rsi     # 0x24906
xorl %edi, %edi
xorl %eax, %eax
callq 0x37ec
movb $0x1, %al
movl %eax, 0x4(%rsp)
cmpl $0x4, 0x88(%r14)
jb 0xa9bd
xorl %r12d, %r12d
leaq 0x1a2ca(%rip), %rsi     # 0x2493e
movl $0x1, %edi
xorl %eax, %eax
callq 0x37ec
jmp 0xa9c0
leaq 0x18(%rsp), %rdi
movq 0x8(%rdi), %rdx
leaq 0x1a302(%rip), %rcx     # 0x24997
movl $0xd, %r8d
xorl %esi, %esi
callq 0x3390
cmpl $0x4, 0x88(%r14)
jb 0xa6c6
cmpb $0x0, 0x90(%r14)
jne 0xa6c6
leaq 0x1a249(%rip), %rsi     # 0x24906
xorl %edi, %edi
xorl %eax, %eax
callq 0x37ec
movb $0x1, %al
movl %eax, 0x4(%rsp)
cmpl $0x4, 0x88(%r14)
jb 0xa845
leaq 0x1a25d(%rip), %rsi     # 0x2493e
movl $0x1, %edi
xorl %eax, %eax
callq 0x37ec
movb $0x1, %r12b
jmp 0xa9c0
leaq 0x18(%rsp), %rdi
movq 0x8(%rdi), %rdx
leaq 0x1a261(%rip), %rcx     # 0x24966
movl $0xb, %r8d
xorl %esi, %esi
callq 0x3390
movb $0x1, %al
movl %eax, 0x4(%rsp)
cmpl $0x3, 0x88(%r14)
ja 0xa9bd
xorl %r12d, %r12d
movq 0x18(%rsp), %rdx
leaq 0x1a23d(%rip), %rsi     # 0x24972
xorl %edi, %edi
xorl %eax, %eax
callq 0x37ec
jmp 0xa9c0
leaq 0x18(%rsp), %rdi
movq 0x8(%rdi), %rdx
leaq 0x2663b(%rip), %rcx     # 0x30d8e
movl $0x3, %r8d
xorl %esi, %esi
callq 0x3390
cmpl $0x3, 0x88(%r14)
ja 0xa82e
movl $0x0, 0x4(%rsp)
movq 0x18(%rsp), %rdx
leaq 0x1a1f0(%rip), %rsi     # 0x24972
xorl %edi, %edi
xorl %eax, %eax
callq 0x37ec
xorl %r12d, %r12d
jmp 0xa9c0
leaq 0x1a243(%rip), %rsi     # 0x249dd
xorl %edi, %edi
xorl %eax, %eax
callq 0x37ec
leaq 0x68(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x1a248(%rip), %rsi     # 0x249fc
leaq 0x1a24a(%rip), %rdx     # 0x24a05
leaq 0x58(%rsp), %rdi
callq 0x8f6e
movzbl 0xa(%rbx), %esi
leaq 0x78(%rsp), %rdi
callq 0x59df
movq 0x58(%rsp), %rcx
movq 0x60(%rsp), %r8
movq 0x80(%rsp), %rdx
leaq (%rdx,%r8), %rax
movl $0xf, %esi
cmpq %r12, %rcx
je 0xa7f8
movq 0x68(%rsp), %rsi
cmpq %rsi, %rax
jbe 0xa81d
leaq 0x88(%rsp), %rdi
movl $0xf, %esi
cmpq %rdi, -0x10(%rdi)
je 0xa818
movq 0x88(%rsp), %rsi
cmpq %rsi, %rax
jbe 0xa86d
movq 0x78(%rsp), %rsi
leaq 0x58(%rsp), %rdi
callq 0x30b0
jmp 0xa87b
cmpb $0x0, 0x90(%r14)
je 0xa84d
movl $0x0, 0x4(%rsp)
jmp 0xa9bd
movb $0x1, %r12b
jmp 0xa9c0
movl $0x0, 0x4(%rsp)
leaq 0x1a149(%rip), %rsi     # 0x249a5
xorl %edi, %edi
xorl %eax, %eax
callq 0x37ec
xorl %r12d, %r12d
jmp 0xa9c0
leaq 0x78(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x3290
leaq 0x48(%rsp), %rdx
movq %rdx, -0x10(%rdx)
movq (%rax), %rsi
leaq 0x10(%rax), %rcx
cmpq %rcx, %rsi
je 0xa89f
movq %rsi, 0x38(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x48(%rsp)
jmp 0xa8a7
movupd (%rcx), %xmm0
movupd %xmm0, (%rdx)
movq %rax, %rdx
addq $0x8, %rdx
movq 0x8(%rax), %rsi
movq %rsi, 0x40(%rsp)
movq %rcx, (%rax)
movl %r13d, 0x14(%rsp)
movq $0x0, (%rdx)
movb $0x0, (%rcx)
leaq 0x21fb5(%rip), %rsi     # 0x2c885
leaq 0x38(%rsp), %rdi
callq 0x3420
leaq 0xa8(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0xa90a
movq %rdx, 0x98(%rsp)
movq (%rcx), %rdx
movq %rdx, 0xa8(%rsp)
jmp 0xa914
movupd (%rcx), %xmm0
movupd %xmm0, (%r13)
movq 0x8(%rax), %rdx
leaq 0x98(%rsp), %r12
movq %rdx, 0x8(%r12)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x18(%rsp), %rdi
movq %r12, %rsi
callq 0x32d0
movq (%r12), %rdi
cmpq %r13, %rdi
je 0xa95a
movq 0xa8(%rsp), %rsi
incq %rsi
callq 0x3260
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
leaq 0x68(%rsp), %r12
movl 0x14(%rsp), %r13d
je 0xa97f
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x3260
leaq 0x88(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa9a0
movq 0x88(%rsp), %rsi
incq %rsi
callq 0x3260
movq 0x58(%rsp), %rdi
cmpq %r12, %rdi
je 0xa9b7
movq 0x68(%rsp), %rsi
incq %rsi
callq 0x3260
movb $0x1, %al
movl %eax, 0x4(%rsp)
xorl %r12d, %r12d
movzbl 0x5(%rbx), %eax
addl %r15d, %eax
movzbl 0x6(%rbx), %ecx
addl %ebp, %ecx
cmpl %ecx, %eax
jbe 0xa9e1
leaq 0x1a02e(%rip), %rsi     # 0x24a06
xorl %edi, %edi
xorl %eax, %eax
callq 0x37ec
movzbl 0x5(%rbx), %eax
addl %r15d, %eax
movl %eax, 0x168(%r14)
movzbl 0x6(%rbx), %eax
addl %ebp, %eax
movl %eax, 0x16c(%r14)
movzbl 0x7(%rbx), %eax
addl 0x8(%rsp), %eax
movzbl 0x8(%rbx), %ecx
addl %r13d, %ecx
cmpl %ecx, %eax
jbe 0xaa1f
leaq 0x1a018(%rip), %rsi     # 0x24a2e
xorl %edi, %edi
xorl %eax, %eax
callq 0x37ec
movzbl 0x7(%rbx), %eax
movq 0x8(%rsp), %rcx
addl %ecx, %eax
imull $0x3e8, %eax, %eax      # imm = 0x3E8
movl %eax, 0x160(%r14)
movzbl 0x8(%rbx), %eax
addl %r13d, %eax
imull $0x3e8, %eax, %eax      # imm = 0x3E8
movl %eax, 0x164(%r14)
movq 0x18(%rsp), %rsi
movzbl 0x5(%rbx), %eax
addl %eax, %r15d
movzbl 0x6(%rbx), %eax
addl %eax, %ebp
movzbl 0x7(%rbx), %r8d
addl %ecx, %r8d
movzbl 0x8(%rbx), %r9d
addl %r13d, %r9d
leaq 0x19fe6(%rip), %rdi     # 0x24a5a
movl %r15d, %edx
movl %ebp, %ecx
xorl %eax, %eax
callq 0x3030
movl 0x88(%r14), %eax
cmpl $0x3, %eax
ja 0xaaab
cmpb $-0x1, 0x8(%rbx)
jne 0xaa99
shll 0x164(%r14)
cmpl $0x3, %eax
ja 0xaaab
cmpb $-0x1, 0x6(%rbx)
jne 0xaaab
shll 0x16c(%r14)
movzbl 0x9(%rbx), %ecx
testl %ecx, %ecx
je 0xaad9
imull $0x2710, %ecx, %eax     # imm = 0x2710
movl %eax, 0x170(%r14)
movzbl 0x9(%rbx), %eax
addl %eax, %eax
leal (%rax,%rax,4), %esi
leaq 0x19fbb(%rip), %rdi     # 0x24a8b
xorl %eax, %eax
callq 0x3030
jmp 0xaaf8
cmpl $0x4, %eax
jb 0xaaee
leaq 0x19fbd(%rip), %rsi     # 0x24aa2
xorl %edi, %edi
xorl %eax, %eax
callq 0x37ec
movl $0xa, %edi
callq 0x3310
movzbl 0xb(%rbx), %edx
testb %r12b, %r12b
je 0xab42
testl %edx, %edx
je 0xab15
leaq 0x19fc1(%rip), %rsi     # 0x24acd
xorl %edi, %edi
xorl %eax, %eax
callq 0x37ec
leaq 0xc(%rbx), %rdi
movl $0x6, %esi
xorl %edx, %edx
callq 0x5b92
testb %al, %al
je 0xacb4
leaq 0x19fbd(%rip), %rsi     # 0x24af1
xorl %edi, %edi
xorl %eax, %eax
callq 0x37ec
jmp 0xae55
cmpb $0x0, 0x4(%rsp)
je 0xab79
cmpl $0xa, %edx
je 0xab5e
leaq 0x1a216(%rip), %rsi     # 0x24d6b
xorl %edi, %edi
xorl %eax, %eax
callq 0x37ec
xorl %eax, %eax
cmpb $0x20, 0xc(%rbx,%rax)
jne 0xad3c
incq %rax
cmpq $0x6, %rax
jne 0xab60
jmp 0xae55
movl %edx, %esi
shrl $0x4, %esi
andl $0xf, %edx
leaq 0x19fe9(%rip), %rdi     # 0x24b71
xorl %eax, %eax
callq 0x3030
movb 0xc(%rbx), %bpl
cmpb $0x4, %bpl
jb 0xabe5
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 0x19b06(%rip), %xmm0    # 0x246c0
addsd %xmm1, %xmm0
leaq 0x19fc3(%rip), %rdi     # 0x24b88
movb $0x1, %al
callq 0x3030
cmpb $-0x60, %bpl
jb 0xabe5
leaq 0x19fd0(%rip), %rsi     # 0x24ba9
movl $0x1, %edi
xorl %eax, %eax
callq 0x37ec
movzbl 0xc(%rbx), %eax
andl $0x3, %eax
movzbl 0xd(%rbx), %esi
shll $0xb, %eax
shll $0x3, %esi
orl %eax, %esi
je 0xac08
leaq 0x19fdc(%rip), %rdi     # 0x24bdd
xorl %eax, %eax
callq 0x3030
movzbl 0xe(%rbx), %eax
testb %al, %al
leaq 0x16064(%rip), %rdi     # 0x20c79
leaq 0x1a00d(%rip), %rsi     # 0x24c29
cmovnsq %rdi, %rsi
testb $0x40, %al
leaq 0x1a005(%rip), %rdx     # 0x24c2e
cmoveq %rdi, %rdx
testb $0x20, %al
leaq 0x19ffe(%rip), %rcx     # 0x24c34
cmoveq %rdi, %rcx
testb $0x10, %al
leaq 0x19ff8(%rip), %r8      # 0x24c3b
cmoveq %rdi, %r8
testb $0x8, %al
leaq 0x19ff0(%rip), %r9      # 0x24c40
cmoveq %rdi, %r9
leaq 0x19fa6(%rip), %rdi     # 0x24c01
xorl %eax, %eax
callq 0x3030
testb $0x7, 0xe(%rbx)
je 0xac78
leaq 0x19fd7(%rip), %rsi     # 0x24c46
xorl %edi, %edi
xorl %eax, %eax
callq 0x37ec
leaq 0x19fef(%rip), %rdi     # 0x24c6e
xorl %eax, %eax
callq 0x3030
movzbl 0xf(%rbx), %eax
movl %eax, %esi
shrl $0x5, %esi
cmpl $0xa0, %eax
jae 0xad51
leaq 0x19a0b(%rip), %rax     # 0x246ac
movslq (%rax,%rsi,4), %rdi
addq %rax, %rdi
xorl %eax, %eax
callq 0x3030
jmp 0xad76
leaq 0x1b81a(%rip), %rdi     # 0x264d5
callq 0x3380
movzbl 0xc(%rbx), %esi
addl %esi, %esi
leaq 0x19e43(%rip), %rdi     # 0x24b10
xorl %eax, %eax
callq 0x3030
movzbl 0xd(%rbx), %eax
cvtsi2sd %eax, %xmm0
mulsd 0x15324(%rip), %xmm0    # 0x20008
leaq 0x19e44(%rip), %rdi     # 0x24b2f
movb $0x1, %al
callq 0x3030
movzwl 0xe(%rbx), %esi
leaq 0x19e43(%rip), %rdi     # 0x24b40
xorl %eax, %eax
callq 0x3030
movzbl 0x10(%rbx), %esi
leaq 0x19e44(%rip), %rdi     # 0x24b53
xorl %eax, %eax
callq 0x3030
movzbl 0x11(%rbx), %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
mulsd 0x152df(%rip), %xmm0    # 0x20008
leaq 0x19e30(%rip), %rdi     # 0x24b60
movb $0x1, %al
callq 0x3030
jmp 0xae55
leaq 0x1a04c(%rip), %rsi     # 0x24d8f
xorl %edi, %edi
xorl %eax, %eax
callq 0x37ec
jmp 0xae55
leaq 0x19f33(%rip), %rdi     # 0x24c8b
xorl %eax, %eax
callq 0x3030
movzbl 0xf(%rbx), %edx
shrl $0x5, %edx
leaq 0x19f2f(%rip), %rsi     # 0x24c9c
xorl %edi, %edi
xorl %eax, %eax
callq 0x37ec
movl $0xa, %edi
callq 0x3310
testb $0x8, 0xf(%rbx)
je 0xad92
leaq 0x1b686(%rip), %rdi     # 0x26413
callq 0x3380
testb $0x10, 0xf(%rbx)
je 0xada4
leaq 0x1b697(%rip), %rdi     # 0x26436
callq 0x3380
testb $0x7, 0xf(%rbx)
je 0xadba
leaq 0x19f13(%rip), %rsi     # 0x24cc4
xorl %edi, %edi
xorl %eax, %eax
callq 0x37ec
cmpb $0x10, 0x10(%rbx)
jb 0xae14
leaq 0x1b691(%rip), %rdi     # 0x26458
callq 0x3380
cmpb $0x0, 0x10(%rbx)
jns 0xadde
leaq 0x1b69e(%rip), %rdi     # 0x26477
callq 0x3380
testb $0x40, 0x10(%rbx)
je 0xadf0
leaq 0x1b6a4(%rip), %rdi     # 0x2648f
callq 0x3380
testb $0x20, 0x10(%rbx)
je 0xae02
leaq 0x1b6ab(%rip), %rdi     # 0x264a8
callq 0x3380
testb $0x10, 0x10(%rbx)
je 0xae14
leaq 0x1b6af(%rip), %rdi     # 0x264be
callq 0x3380
testb $0xf, 0x10(%rbx)
je 0xae2a
leaq 0x19ecb(%rip), %rsi     # 0x24cec
xorl %edi, %edi
xorl %eax, %eax
callq 0x37ec
movzbl 0x11(%rbx), %esi
testl %esi, %esi
je 0xae42
leaq 0x19edb(%rip), %rdi     # 0x24d14
xorl %eax, %eax
callq 0x3030
jmp 0xae55
leaq 0x19ef2(%rip), %rsi     # 0x24d3b
movl $0x1, %edi
xorl %eax, %eax
callq 0x37ec
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0xae71
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x3260
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xaeed
jmp 0xaeed
movq %rax, %rbx
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xaeaa
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x3260
jmp 0xaeaa
movq %rax, %rbx
leaq 0x88(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xaed0
movq 0x88(%rsp), %rsi
incq %rsi
callq 0x3260
jmp 0xaed0
movq %rax, %rbx
movq 0x58(%rsp), %rdi
cmpq %r12, %rdi
je 0xaef0
movq 0x68(%rsp), %rsi
incq %rsi
callq 0x3260
jmp 0xaef0
jmp 0xaeed
jmp 0xaeed
movq %rax, %rbx
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0xaf0c
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x3260
movq %rbx, %rdi
callq 0x3400