// File: /workspace/github_c_makefile_star2_O3/theovosse[P]llgen/llgen.c
// Function: GenerateRule
static void GenerateRule(Name ruleName, Node rule, Boolean emptyToEndOfRule, TREE follow, int indent, Boolean generateCode, Boolean guard, TREE firstNext, Boolean *usesLA) {
	NameType previous = string;
	TREE chainElt1Followers;
	TREE chainElt2Followers;
	TREE directFollowers;
	TREE overlap;
	Boolean empty1, empty2;

    if (generateCode && HasProperty("debugFF")) {
        doIndent(indent);
        fputs("/* follow: ", outputFile); PrintTree(outputFile, follow);
        fputs(", firstNext: ", outputFile); PrintTree(outputFile, firstNext);
		fprintf(outputFile, ", emptyToEndOfRule: %s", emptyToEndOfRule? "true": "false");
        fputs("*/", outputFile);
    }
	while (rule != NULL) {
		TREE firsts = NULL;
		TREE followers = NULL;
		TREE lFirstNext = NULL;
		TREE common = NULL;
        TREE sequenceFollowers = NULL;
		(void) collectFirst(&followers, follow, rule->next);
		empty2 = collectFirst(&lFirstNext, firstNext, rule->next);
		if (generateCode && HasProperty("debugFF")) {
			doIndent(indent);
			fputs("/* followers: ", outputFile); PrintTree(outputFile, followers);
			fputs(", lFirstNext: ", outputFile); PrintTree(outputFile, lFirstNext);
			fprintf(outputFile, ", empty2: %s", empty2? "true": "false");
			fputs("*/", outputFile);
		}
		switch (rule->nodeType) {
			case single:
				if (rule->element.name->nameType == identifier) {
					if (generateCode) {
						RuleResult res = rule->element.name->ruleResult;
						Name returnType = res == NULL? NULL: res->returnType;
						Name assignTo = rule->assignTo;
						Boolean assignToRuleOutput = assignTo != NULL && ruleName->ruleResult != NULL && ruleName->ruleResult->returnVariable != NULL && strcmp(assignTo->name, ruleName->ruleResult->returnVariable->name) == 0;
						doIndent(indent);
						int nrParameters = openFunctionCall(outputFile, rule->element.name->name, rule->arglist, assignToRuleOutput? NULL: returnType, rule->assignTo, ruleName);
						if (nrParameters != rule->element.name->nrParameters) {
							fprintf(stderr, "%s:%d: error: wrong number of parameters\n", inputFileName, rule->lineNr);
						}
                        targetLanguage->nextCallParameter(outputFile);
						if (empty2 && emptyToEndOfRule) {
							if (lFirstNext == NULL) {
								targetLanguage->nextCallParameterSymbol(outputFile, "follow");
							} else {
								fputs("uniteTokenSets(", outputFile);
                                if (targetLanguage->requiresLocalLTSetStorage) {
                                    targetLanguage->pointerToArray(outputFile, "ltSet", -1);
                                    fputs(", ", outputFile);
                                }
                                fputs("follow, ", outputFile);
                                TokenSetName2(lFirstNext);
                                fputs(")", outputFile);
							}
						} else {
							TokenSetName2(lFirstNext);
						}
						closeFunctionCall(outputFile);
						fputs(targetLanguage->terminateStatement, outputFile);
					} else {
						if (empty2 && emptyToEndOfRule && lFirstNext != NULL) {
							*usesLA = true;
						}
						CreateTokenSet2(outputFile, lFirstNext);
					}
				} else if (rule->element.name->nameType == token || rule->element.name->nameType == string) {
					if (generateCode) {
						doIndent(indent);
					    fputs(targetLanguage->owner, outputFile);
						targetLanguage->startFunctionCall(outputFile, "getToken", NULL, NULL);
						targetLanguage->nextCallParameter(outputFile);
                        targetLanguage->tokenEnum(outputFile, rule->element.name->index, rule->element.name->name);
						targetLanguage->nextCallParameter(outputFile);
                        TokenSetName2(lFirstNext);
						targetLanguage->nextCallParameter(outputFile);
						if (empty2 && emptyToEndOfRule) {
							if (lFirstNext == NULL) {
								targetLanguage->nextCallParameterSymbol(outputFile, "follow");
							} else {
								fputs("uniteTokenSets(", outputFile);
                                if (targetLanguage->requiresLocalLTSetStorage) {
                                    targetLanguage->pointerToArray(outputFile, "ltSet", -1);
                                    fputs(", ", outputFile);
                                }
                                fputs("follow, ", outputFile);
                                TokenSetName2(lFirstNext);
                                fputs(")", outputFile);
							}
						} else {
							TokenSetName2(lFirstNext);
						}
						targetLanguage->nextCallParameter(outputFile);
						targetLanguage->nextCallParameterSymbol(outputFile, empty2 && emptyToEndOfRule? "true": "false");
						targetLanguage->endFunctionCall(outputFile);
						fputs(targetLanguage->terminateStatement, outputFile);
						if (rule->assignTo != NULL) {
							Boolean noDecl = rule->assignTo != NULL && ruleName->ruleResult != NULL && ruleName->ruleResult->returnVariable != NULL && strcmp(rule->assignTo->name, ruleName->ruleResult->returnVariable->name) == 0;
							targetLanguage->assignLastSymbolTo(outputFile, indent, rule->assignTo, noDecl);
						}
					} else {
						if (empty2 && emptyToEndOfRule && lFirstNext != NULL) {
							*usesLA = true;
						}
						CreateTokenSet2(outputFile, lFirstNext);
					}
				} else if (rule->element.name->nameType == output || rule->element.name->nameType == code) {
					GenerateSingle(rule, previous, indent, generateCode);
				} else {
					fprintf(stderr, "GenerateRule: Unknown nameType: %d\n", rule->element.name->nameType);
				}
				previous = rule->element.name->nameType;
				break;
			case option:
				empty1 = collectFirst(&firsts, NULL, rule->element.sub);
				CreateGuard(guard, generateCode, true, indent, firsts, false, usesLA);
				// !!! if (empty1) Unite(&firsts, followers);
				common = NULL; // !!! Intersection(firsts, oneOf);
				if (generateCode) {
					doIndent(indent);
				}
				PrintFirstSymbols(firsts, ifCondition, indent, true, generateCode, NULL,
								  rule->lineNr, empty1, usesLA);
				if (generateCode) {
					startBlock(indent);
					overlap = Intersection2(firsts, followers);
					if (overlap != NULL) {
						if (!rule->element.sub->preferShift) {
							doIndent(indent + 1);
							fputs("/* Not an LL(1)-grammar (first/followers of option overlaps) */\n", outputFile);
							fprintf(stderr, "%s:%d: not an LL(1)-grammar (first/followers of option overlap): ", inputFileName, rule->lineNr);
							PrintTree(stderr, overlap);
							fputc('\n', stderr);
							notLLError = true;
						}
						KillTree(overlap, NULL);
					}
				}
				GenerateRule(ruleName, rule->element.sub, empty2 && emptyToEndOfRule, followers,
							 indent + 1, generateCode, false, lFirstNext, usesLA);
				if (generateCode) {
					terminateBlock(indent);
				}
				break;
			case sequence:
				empty1 = collectFirst(&firsts, NULL, rule->element.sub);
				Unite(&lFirstNext, firsts); /* a sequence can be followed by itself */
				CreateGuard(guard, generateCode, empty1, indent, firsts, false, usesLA);
				if (empty1) {
                    Unite(&firsts, followers);
                    sequenceFollowers = firsts;
                } else {
                    Unite(&sequenceFollowers, firsts);
                    Unite(&sequenceFollowers, followers);
                }
				Unite(&common, firsts);
				if (generateCode) {
					startDoWhileLoop(indent);
				}
				GenerateRule(ruleName, rule->element.sub, empty2 && emptyToEndOfRule, sequenceFollowers,
							 indent + 1, generateCode, false, lFirstNext, usesLA);
				CreateGuard(true, generateCode, empty2, indent + 1, lFirstNext, false, usesLA);
				if (generateCode) {
					overlap = Intersection2(firsts, followers);
					if (overlap != NULL) {
						if (!rule->preferShift) {
							doIndent(indent);
							fputs("/* Not an LL(1)-grammar (first/followers of sequence overlap) */\n", outputFile);
							fprintf(stderr, "%s:%d: not an LL(1)-grammar (first/followers of sequence overlap): ", inputFileName, rule->lineNr);
							PrintTree(stderr, overlap);
							fputc('\n', stderr);
							notLLError = true;
						}
						KillTree(overlap, NULL);
					}
				}
				PrintFirstSymbols(firsts, endDoWhileLoop, indent, true, generateCode, NULL,
								  rule->lineNr, false, usesLA);
                if (sequenceFollowers != firsts) {
                    KillTree(sequenceFollowers, NULL);
                }
				break;
			case chain:
				if (generateCode) {
					startUnconditionalLoop(indent);
				}
				chainElt1Followers = NULL;
				chainElt2Followers = NULL;
				Node chainElt1 = rule->element.sub->element.sub;
				Node chainElt2 = rule->element.sub->next->element.sub;
				Boolean emptyChain1 = collectFirst(&chainElt2Followers, followers, chainElt1);
				collectFirst(&chainElt1Followers, chainElt2Followers, chainElt2);
				(void) Unite(&chainElt1Followers, followers);
				directFollowers = NULL;
				if (collectFirst(&directFollowers, NULL, chainElt2)) {
					(void) collectFirst(&directFollowers, NULL, chainElt1);
				}
				(void) Unite(&directFollowers, lFirstNext);
				GenerateRule(ruleName, chainElt1, empty2 && emptyToEndOfRule, chainElt1Followers,
							 indent + 1, generateCode, true, directFollowers, usesLA);
				KillTree(directFollowers, NULL);
				KillTree(chainElt1Followers, NULL);
				KillTree(chainElt2Followers, NULL);
				chainElt1Followers = NULL;
				(void) collectFirst(&chainElt1Followers, followers, chainElt1);
				(void) collectFirst(&firsts, chainElt1Followers, chainElt2);
				KillTree(chainElt1Followers, NULL);
				if (generateCode) {
					overlap = Intersection2(firsts, followers);
					if (overlap != NULL) {
						if (!rule->preferShift) {
							doIndent(indent + 1);
							fputs("/* Not an LL(1)-grammar (first/followers of chain overlap) */\n", outputFile);
							fprintf(stderr, "%s:%d: not an LL(1)-grammar (first/followers of chain overlap): ", inputFileName, rule->lineNr);
							PrintTree(stderr, overlap);
							fputc('\n', stderr);
							notLLError = true;
						}
						KillTree(overlap, NULL);
					}
					doIndent(indent + 1);
				}
				PrintFirstSymbols(firsts, ifCondition, indent, false, generateCode, NULL, rule->lineNr, false, usesLA);
				if (generateCode) {
                    startBlock(indent + 1);
					breakStatement(indent + 2);
					terminateBlock(indent + 1);
				}
				chainElt1Followers = NULL;
				chainElt2Followers = NULL;
				collectFirst(&chainElt2Followers, NULL, chainElt2);
				(void) Unite(&chainElt2Followers, followers);
				(void) collectFirst(&chainElt1Followers, chainElt2Followers, chainElt1);
				directFollowers = NULL;
				if (collectFirst(&directFollowers, NULL, chainElt1)) {
					(void) collectFirst(&directFollowers, NULL, chainElt2);
					Unite(&directFollowers, lFirstNext);
				}
				GenerateRule(ruleName, chainElt2, emptyChain1 && empty2 && emptyToEndOfRule,
						     chainElt1Followers, indent + 1, generateCode, false, directFollowers, usesLA);
				KillTree(directFollowers, NULL);
				KillTree(chainElt1Followers, NULL);
				KillTree(chainElt2Followers, NULL);
				if (generateCode) {
                    endUnconditionalLoop(indent);
				}
				break;
			case alternative:
				PrintAlternatives(ruleName, rule->element.alternatives, emptyToEndOfRule, followers, indent,
								  targetLanguage->errorMsg, targetLanguage->errorArgs, generateCode, lFirstNext, usesLA, rule->lineNr);
				break;
			case breakToken:
				collectFirstOn(&firsts, rule);
				if (generateCode) {
					doIndent(indent);
				}
				PrintFirstSymbols(firsts, ifCondition, indent, true, generateCode,
								  NULL, rule->lineNr, false, usesLA);
				if (generateCode) {
					startBlock(indent);
					breakStatement(indent + 1);
					terminateBlock(indent);
				}
				break;
			case errorMessage:
				collectFirstOn(&firsts, rule);
				if (generateCode) {
					doIndent(indent);
				}
				PrintFirstSymbols(firsts, ifCondition, indent, true, generateCode,
								  NULL, rule->lineNr, false, usesLA);
				if (generateCode) {
					startBlock(indent);
					doIndent(indent + 1);
					targetLanguage->startFunctionCall(outputFile, "llerror", NULL, NULL);
					targetLanguage->nextCallParameter(outputFile);
					targetLanguage->nextCallParameterSymbol(outputFile, rule->element.sub->next->element.name->name);
					targetLanguage->endFunctionCall(outputFile);
					fputs(targetLanguage->terminateStatement, outputFile);
					terminateBlock(indent);
				}
				break;
		}
		rule = rule->next;
		KillTree(followers, NULL);
		KillTree(firsts, NULL);
		KillTree(common, NULL);
		KillTree(lFirstNext, NULL);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movl %r9d, %r13d
movq %r8, 0x18(%rsp)
movq %rcx, 0x80(%rsp)
movl %edx, 0x4(%rsp)
movq %rsi, %r12
movq %rdi, 0x48(%rsp)
testw %r13w, %r13w
je 0x8011
leaq 0x99df(%rip), %rdi      # 0x1194a
callq 0x628f
testw %ax, %ax
je 0x8011
movq 0x18(%rsp), %rdi
callq 0x420f
movq 0x11b5e(%rip), %rsi     # 0x19ae8
leaq 0x99c1(%rip), %rdi      # 0x11952
callq 0x3110
movq 0x11b4b(%rip), %rdi     # 0x19ae8
movq 0x80(%rsp), %rsi
callq 0x94e0
movq 0x11b37(%rip), %rsi     # 0x19ae8
leaq 0x99a6(%rip), %rdi      # 0x1195e
callq 0x3110
movq 0x11b24(%rip), %rdi     # 0x19ae8
movq 0xc8(%rsp), %rsi
callq 0x94e0
movq 0x11b10(%rip), %rdi     # 0x19ae8
cmpw $0x0, 0x4(%rsp)
leaq 0x99a3(%rip), %rax      # 0x11988
leaq 0x9997(%rip), %rdx      # 0x11983
cmoveq %rax, %rdx
leaq 0x9975(%rip), %rsi      # 0x1196c
xorl %eax, %eax
callq 0x3160
movq 0x11ae3(%rip), %rsi     # 0x19ae8
leaq 0xb855(%rip), %rdi      # 0x13861
callq 0x3110
testq %r12, %r12
je 0x92c3
movq 0x18(%rsp), %rax
leal 0x1(%rax), %ecx
movl %ecx, 0x14(%rsp)
addl $0x2, %eax
movl %eax, 0x7c(%rsp)
movl %r13d, 0x2c(%rsp)
xorl %eax, %eax
movq %rax, 0x8(%rsp)
movq %rax, 0x30(%rsp)
movq %rax, 0x20(%rsp)
movq %rax, 0x70(%rsp)
xorl %r14d, %r14d
movq %rax, 0x60(%rsp)
movq 0x28(%r12), %rdx
leaq 0x30(%rsp), %rdi
movq 0x80(%rsp), %rsi
callq 0x64b2
movq 0x28(%r12), %rdx
leaq 0x20(%rsp), %rdi
movq 0xc8(%rsp), %rsi
callq 0x64b2
movl %eax, %ebx
testw %r13w, %r13w
je 0x812e
leaq 0x98b9(%rip), %rdi      # 0x1194a
callq 0x628f
testw %ax, %ax
je 0x812e
movq 0x18(%rsp), %rdi
callq 0x420f
movq 0x11a38(%rip), %rsi     # 0x19ae8
leaq 0x98d7(%rip), %rdi      # 0x1198e
callq 0x3110
movq 0x11a25(%rip), %rdi     # 0x19ae8
movq 0x30(%rsp), %rsi
callq 0x94e0
movq 0x11a14(%rip), %rsi     # 0x19ae8
leaq 0x98c2(%rip), %rdi      # 0x1199d
callq 0x3110
movq 0x11a01(%rip), %rdi     # 0x19ae8
movq 0x20(%rsp), %rsi
callq 0x94e0
movq 0x119f0(%rip), %rdi     # 0x19ae8
testw %bx, %bx
leaq 0x9881(%rip), %rdx      # 0x11983
leaq 0x987f(%rip), %rax      # 0x11988
cmoveq %rax, %rdx
leaq 0x9898(%rip), %rsi      # 0x119ac
xorl %eax, %eax
callq 0x3160
movq 0x119c6(%rip), %rsi     # 0x19ae8
leaq 0xb738(%rip), %rdi      # 0x13861
callq 0x3110
movl 0x4(%r12), %eax
cmpq $0x6, %rax
ja 0x8c90
leaq 0x8f3c(%rip), %rcx      # 0x11080
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x18(%r12), %rax
movl 0x38(%rax), %edx
cmpq $0x4, %rdx
ja 0x928c
leaq 0x8f36(%rip), %rsi      # 0x1109c
movslq (%rsi,%rdx,4), %rcx
addq %rsi, %rcx
jmpq *%rcx
testw %r13w, %r13w
je 0x8cf4
movq 0x18(%rsp), %rdi
callq 0x420f
movq 0x10ff6(%rip), %rax     # 0x19180
movq 0x38(%rax), %rdi
movq 0x11953(%rip), %rsi     # 0x19ae8
callq 0x3110
movq 0x10fdf(%rip), %rax     # 0x19180
movq 0x11940(%rip), %rdi     # 0x19ae8
leaq 0x9853(%rip), %rsi      # 0x11a02
xorl %edx, %edx
xorl %ecx, %ecx
callq *0x130(%rax)
movq 0x10fc0(%rip), %rax     # 0x19180
movq 0x11921(%rip), %rdi     # 0x19ae8
callq *0x138(%rax)
movq 0x10fac(%rip), %rax     # 0x19180
movq 0x1190d(%rip), %rdi     # 0x19ae8
movq 0x18(%r12), %rcx
movq (%rcx), %rdx
movq 0x28(%rcx), %rsi
callq *0x108(%rax)
movq 0x10f8c(%rip), %rax     # 0x19180
movq 0x118ed(%rip), %rdi     # 0x19ae8
callq *0x138(%rax)
movq 0x20(%rsp), %rdi
callq 0x9556
movq 0x10f6e(%rip), %rax     # 0x19180
movq 0x118cf(%rip), %rdi     # 0x19ae8
callq *0x138(%rax)
movq 0x20(%rsp), %rdi
cmpw $0x0, 0x4(%rsp)
je 0x8d2d
testw %bx, %bx
je 0x8d2d
testq %rdi, %rdi
je 0x8f5f
movq 0x1189f(%rip), %rsi     # 0x19ae8
leaq 0x9793(%rip), %rdi      # 0x119e3
callq 0x3110
movq 0x10f24(%rip), %rax     # 0x19180
cmpw $0x0, 0x10(%rax)
je 0x8291
movq 0x1187e(%rip), %rdi     # 0x19ae8
leaq 0x9782(%rip), %rsi      # 0x119f3
movq $-0x1, %rdx
callq *0x100(%rax)
movq 0x11863(%rip), %rsi     # 0x19ae8
leaq 0x925b(%rip), %rdi      # 0x114e7
callq 0x3110
movq 0x11850(%rip), %rsi     # 0x19ae8
leaq 0x975a(%rip), %rdi      # 0x119f9
callq 0x3110
movq 0x20(%rsp), %rdi
callq 0x9556
movq 0x11833(%rip), %rsi     # 0x19ae8
leaq 0xabc3(%rip), %rdi      # 0x12e7f
callq 0x3110
jmp 0x8f7a
movq 0x18(%r12), %rsi
movq 0x30(%rsp), %rcx
movq 0x10ea9(%rip), %rax     # 0x19180
movq 0x28(%rax), %r9
movswl (%r12), %r10d
subq $0x8, %rsp
movswl %r13w, %r11d
movswl 0xc(%rsp), %edx
movq 0x50(%rsp), %rdi
movq 0x20(%rsp), %r8
pushq %r10
pushq 0xe0(%rsp)
pushq 0x38(%rsp)
pushq %r11
pushq 0x30(%rax)
callq 0x7a91
addq $0x30, %rsp
jmp 0x8c90
movl %r13d, %ebp
movl %ebx, %r13d
movq 0x18(%r12), %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x64b2
movl %eax, %ebx
movq 0x8(%rsp), %rsi
leaq 0x20(%rsp), %rdi
callq 0x6655
movq 0x8(%rsp), %r8
movswl %bx, %ebx
movswl 0xc0(%rsp), %edi
movswl %bp, %r14d
movl %r14d, %esi
movl %ebx, %edx
movq 0x18(%rsp), %rcx
movq 0xd0(%rsp), %rbp
movq %rbp, %r9
callq 0x966d
testw %bx, %bx
je 0x8975
movq 0x30(%rsp), %rsi
movq %r15, %rdi
callq 0x6655
movq 0x8(%rsp), %rsi
movq %rsi, 0x60(%rsp)
jmp 0x8999
movw %bx, 0x2a(%rsp)
testw %r13w, %r13w
je 0x83cd
movq 0x18(%rsp), %rbx
movl %ebx, %edi
callq 0x420f
movq 0x10dcd(%rip), %rax     # 0x19180
movq 0xa0(%rax), %rdi
movq 0x11727(%rip), %rsi     # 0x19ae8
callq 0x3110
movl %ebx, %edi
callq 0x424c
xorl %ebx, %ebx
movq %rbx, 0x40(%rsp)
movq %rbx, 0x58(%rsp)
movq 0x18(%r12), %rax
movq 0x18(%rax), %r13
movq 0x28(%rax), %rax
movq 0x18(%rax), %r15
movq 0x30(%rsp), %rsi
leaq 0x58(%rsp), %rdi
movq %r13, %rdx
callq 0x64b2
movw %ax, 0x3c(%rsp)
movq 0x58(%rsp), %rsi
leaq 0x40(%rsp), %r14
movq %r14, %rdi
movq %r15, %rdx
callq 0x64b2
movq 0x30(%rsp), %rsi
movq %r14, %rdi
callq 0x6655
movq %rbx, 0x50(%rsp)
leaq 0x50(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x64b2
testw %ax, %ax
movq 0xd0(%rsp), %rbp
je 0x8454
movq %r14, %rdi
xorl %esi, %esi
movq %r13, %rdx
callq 0x64b2
cmpw $0x0, 0x4(%rsp)
setne %bl
movq 0x20(%rsp), %rsi
movq %r14, %rdi
callq 0x6655
cmpw $0x0, 0x2a(%rsp)
setne %al
andb %bl, %al
movq 0x40(%rsp), %rcx
subq $0x8, %rsp
movzbl %al, %edx
movl 0x34(%rsp), %ebx
movswl %bx, %r9d
movq 0x50(%rsp), %rdi
movq %r13, %rsi
movl 0x1c(%rsp), %r8d
movl %r9d, 0x70(%rsp)
pushq %rbp
pushq 0x60(%rsp)
pushq $-0x1
callq 0x7f2d
addq $0x20, %rsp
movq 0x50(%rsp), %rdi
xorl %esi, %esi
callq 0xbd36
movq 0x40(%rsp), %rdi
xorl %esi, %esi
callq 0xbd36
movq 0x58(%rsp), %rdi
xorl %esi, %esi
callq 0xbd36
movq $0x0, 0x40(%rsp)
movq 0x30(%rsp), %rsi
leaq 0x40(%rsp), %rdi
movq %r13, %rdx
callq 0x64b2
movq 0x40(%rsp), %rsi
leaq 0x8(%rsp), %rdi
movq %r15, %rdx
callq 0x64b2
movq 0x40(%rsp), %rdi
xorl %esi, %esi
callq 0xbd36
movq 0x8(%rsp), %rax
testw %bx, %bx
je 0x8b19
movq 0x30(%rsp), %rsi
movq %rax, %rdi
callq 0x9849
testq %rax, %rax
je 0x8542
movq %rax, %rbx
cmpw $0x0, 0x20(%r12)
je 0x9264
movq %rbx, %rdi
xorl %esi, %esi
callq 0xbd36
movq %rbp, %r14
movl 0x14(%rsp), %ebx
movl %ebx, %edi
callq 0x420f
movq 0x8(%rsp), %rdi
movswl (%r12), %eax
subq $0x8, %rsp
leaq 0xf00(%rip), %rsi       # 0x9465
movq 0x20(%rsp), %rdx
xorl %ecx, %ecx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
xorl %r9d, %r9d
pushq %rax
callq 0x92d5
addq $0x10, %rsp
movl %ebx, %edi
callq 0x424c
movl 0x7c(%rsp), %edi
callq 0x420f
movq 0x11552(%rip), %rdi     # 0x19ae8
movq 0x10be3(%rip), %rax     # 0x19180
movq 0x80(%rax), %rcx
movq 0xa8(%rax), %rdx
leaq 0x9675(%rip), %rsi      # 0x11c27
xorl %eax, %eax
callq 0x3160
movl %ebx, %edi
callq 0x420f
movq 0x11521(%rip), %rsi     # 0x19ae8
leaq 0xabd6(%rip), %rdi      # 0x131a4
callq 0x3110
jmp 0x8b2b
movl %r13d, %r15d
movl %ebx, %r13d
movq 0x18(%r12), %rdx
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x64b2
movq 0x8(%rsp), %r8
movswl 0xc0(%rsp), %edi
movswl %r15w, %r14d
movl %r14d, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq 0x18(%rsp), %rbx
movl %ebx, %ecx
movq 0xd0(%rsp), %rbp
movq %rbp, %r9
callq 0x966d
movq $0x0, 0x70(%rsp)
testw %r15w, %r15w
je 0x8c3a
movl %ebx, %edi
callq 0x420f
movq 0x8(%rsp), %rdi
movswl (%r12), %eax
subq $0x8, %rsp
leaq 0xe17(%rip), %rsi       # 0x9465
movl %ebx, %edx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
xorl %r9d, %r9d
pushq %rax
callq 0x92d5
addq $0x10, %rsp
movl %ebx, %edi
callq 0x424c
movq 0x8(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x9849
testq %rax, %rax
je 0x86a0
movq %rax, %r15
movq 0x18(%r12), %rax
cmpw $0x0, 0x20(%rax)
je 0x9278
movq %r15, %rdi
xorl %esi, %esi
callq 0xbd36
cmpw $0x0, 0x4(%rsp)
setne %al
movq 0x18(%r12), %rsi
testw %r13w, %r13w
setne %dl
andb %al, %dl
movq 0x30(%rsp), %rcx
subq $0x8, %rsp
movzbl %dl, %edx
movq 0x50(%rsp), %rdi
movl 0x1c(%rsp), %r8d
movl %r14d, %r9d
pushq %rbp
pushq 0x30(%rsp)
pushq $0x0
callq 0x7f2d
addq $0x20, %rsp
movq 0x18(%rsp), %rdi
callq 0x420f
movq 0x113f7(%rip), %rsi     # 0x19ae8
leaq 0xaaac(%rip), %rdi      # 0x131a4
callq 0x3110
jmp 0x8c8b
leaq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x98aa
testw %r13w, %r13w
je 0x8881
movq 0x18(%rsp), %rbx
movl %ebx, %edi
callq 0x420f
movq 0x8(%rsp), %rdi
movswl (%r12), %eax
subq $0x8, %rsp
leaq 0xd2b(%rip), %rsi       # 0x9465
movl %ebx, %edx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
xorl %r9d, %r9d
pushq %rax
callq 0x92d5
addq $0x10, %rsp
movl %ebx, %edi
callq 0x424c
movl 0x14(%rsp), %edi
callq 0x420f
movq 0x1137d(%rip), %rdi     # 0x19ae8
movq 0x10a0e(%rip), %rax     # 0x19180
movq 0x80(%rax), %rcx
movq 0xa8(%rax), %rdx
leaq 0x94a0(%rip), %rsi      # 0x11c27
xorl %eax, %eax
callq 0x3160
jmp 0x887a
leaq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x98aa
testw %r13w, %r13w
je 0x8881
movq 0x18(%rsp), %rbx
movl %ebx, %edi
callq 0x420f
movq 0x8(%rsp), %rdi
movswl (%r12), %eax
subq $0x8, %rsp
leaq 0xc9a(%rip), %rsi       # 0x9465
movl %ebx, %edx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
xorl %r9d, %r9d
pushq %rax
callq 0x92d5
addq $0x10, %rsp
movl %ebx, %edi
callq 0x424c
movl 0x14(%rsp), %edi
callq 0x420f
movq 0x10984(%rip), %rax     # 0x19180
movq 0x112e5(%rip), %rdi     # 0x19ae8
leaq 0x93ae(%rip), %rsi      # 0x11bb8
xorl %edx, %edx
xorl %ecx, %ecx
callq *0x130(%rax)
movq 0x10965(%rip), %rax     # 0x19180
movq 0x112c6(%rip), %rdi     # 0x19ae8
callq *0x138(%rax)
movq 0x10951(%rip), %rax     # 0x19180
movq 0x112b2(%rip), %rdi     # 0x19ae8
movq 0x18(%r12), %rcx
movq 0x28(%rcx), %rcx
movq 0x18(%rcx), %rcx
movq (%rcx), %rsi
callq *0x140(%rax)
movq 0x1092d(%rip), %rax     # 0x19180
movq 0x1128e(%rip), %rdi     # 0x19ae8
callq *0x148(%rax)
movq 0x10919(%rip), %rax     # 0x19180
movq 0x80(%rax), %rdi
movq 0x11273(%rip), %rsi     # 0x19ae8
callq 0x3110
movl %ebx, %edi
jmp 0x8c20
movq 0x8(%rsp), %rsi
movq 0x1125b(%rip), %rdi     # 0x19ae8
callq 0x95ba
jmp 0x8c90
testw %r13w, %r13w
je 0x8c90
leaq 0x8b63(%rip), %rdi      # 0x1140b
callq 0x628f
testw %ax, %ax
je 0x88e6
movswl (%r12), %edx
cmpl %edx, 0x1126f(%rip)     # 0x19b2c
je 0x88e6
movq 0x11222(%rip), %rdi     # 0x19ae8
movq 0x108bb(%rip), %rcx     # 0x19188
leaq 0x8b3c(%rip), %rsi      # 0x11410
xorl %eax, %eax
callq 0x3160
movswl (%r12), %eax
movl %eax, 0x11246(%rip)     # 0x19b2c
movq 0x18(%r12), %rax
movl 0x38(%rax), %ecx
cmpl $0x3, %ecx
je 0x8d3e
cmpl $0x2, %ecx
jne 0x8c90
movq 0x18(%rsp), %rdi
callq 0x420f
movq 0x18(%r12), %rax
movq (%rax), %rdi
leaq 0xa80d(%rip), %rsi      # 0x13126
callq 0x3240
movq 0x111c3(%rip), %rsi     # 0x19ae8
testl %eax, %eax
je 0x91f0
leaq 0x92bf(%rip), %rdi      # 0x11bf3
callq 0x3110
movq 0x18(%r12), %rax
movq (%rax), %rdi
leaq 0x1(%rdi), %rbx
callq 0x30d0
leaq -0x2(%rax), %rdx
movq 0x11193(%rip), %rcx     # 0x19ae8
movl $0x1, %esi
movq %rbx, %rdi
callq 0x3210
movq 0x1117f(%rip), %rsi     # 0x19ae8
leaq 0x928c(%rip), %rdi      # 0x11bfc
jmp 0x8c33
movq 0x8(%rsp), %rsi
leaq 0x60(%rsp), %rbx
movq %rbx, %rdi
callq 0x6655
movq 0x30(%rsp), %rsi
movq %rbx, %rdi
callq 0x6655
movq 0x8(%rsp), %rsi
leaq 0x70(%rsp), %rdi
callq 0x6655
movswl %r13w, %r15d
cmpw $0x0, 0x2c(%rsp)
je 0x8a6e
cmpw $0x0, 0x4(%rsp)
setne %bl
movq 0x18(%rsp), %rbp
movl %ebp, %edi
callq 0x420f
movq 0x107b1(%rip), %rax     # 0x19180
movq 0x11112(%rip), %rdi     # 0x19ae8
movl %ebp, %esi
movq 0xd0(%rsp), %rbp
callq *0xb0(%rax)
movq 0x18(%r12), %rsi
testw %r13w, %r13w
setne %al
andb %bl, %al
movq 0x60(%rsp), %rcx
subq $0x8, %rsp
movzbl %al, %edx
movq 0x50(%rsp), %rdi
movl 0x1c(%rsp), %ebx
movl %ebx, %r8d
movl %r14d, %r9d
pushq %rbp
pushq 0x30(%rsp)
pushq $0x0
callq 0x7f2d
addq $0x20, %rsp
movq 0x20(%rsp), %r8
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movl %r14d, %esi
movl %r15d, %edx
movl %ebx, %ecx
movq %rbp, %r9
callq 0x966d
movq 0x8(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x9849
testq %rax, %rax
movl 0x2c(%rsp), %r13d
je 0x8ace
movq %rax, %r15
cmpw $0x0, 0x20(%r12)
je 0x924f
movq %r15, %rdi
xorl %esi, %esi
callq 0xbd36
jmp 0x8ace
cmpw $0x0, 0x4(%rsp)
setne %al
movq 0x18(%r12), %rsi
testw %r13w, %r13w
setne %dl
andb %al, %dl
movq 0x60(%rsp), %rcx
subq $0x8, %rsp
movzbl %dl, %edx
movq 0x50(%rsp), %rdi
movl 0x1c(%rsp), %ebx
movl %ebx, %r8d
xorl %r9d, %r9d
pushq %rbp
pushq 0x30(%rsp)
pushq $0x0
callq 0x7f2d
addq $0x20, %rsp
movq 0x20(%rsp), %r8
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
xorl %esi, %esi
movl %r15d, %edx
movl %ebx, %ecx
movq %rbp, %r9
callq 0x966d
movl 0x2c(%rsp), %r13d
movq 0x8(%rsp), %rdi
movswl (%r12), %eax
subq $0x8, %rsp
leaq 0xdac(%rip), %rsi       # 0x988f
movq 0x20(%rsp), %rdx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movl %r14d, %r8d
xorl %r9d, %r9d
pushq %rax
callq 0x92d5
addq $0x10, %rsp
movq 0x60(%rsp), %rdi
cmpq 0x8(%rsp), %rdi
je 0x8c90
xorl %esi, %esi
callq 0xbd36
jmp 0x8c90
movq %rbp, %r14
movq 0x10fc5(%rip), %rdi     # 0x19ae8
movq %rax, %rsi
callq 0x95ba
xorl %ebx, %ebx
movq %rbx, 0x40(%rsp)
movq %rbx, 0x58(%rsp)
leaq 0x58(%rsp), %rbp
movq %rbp, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x64b2
movq 0x30(%rsp), %rsi
movq %rbp, %rdi
callq 0x6655
movq 0x58(%rsp), %rsi
leaq 0x40(%rsp), %rdi
movq %r13, %rdx
callq 0x64b2
movq %rbx, 0x50(%rsp)
leaq 0x50(%rsp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
movq %r13, %rdx
callq 0x64b2
testw %ax, %ax
je 0x8b9e
movq %rbx, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x64b2
movq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x6655
cmpw $0x0, 0x2a(%rsp)
setne %al
cmpw $0x0, 0x4(%rsp)
setne %dl
cmpw $0x0, 0x3c(%rsp)
setne %cl
andb %al, %dl
andb %cl, %dl
movq 0x40(%rsp), %rcx
subq $0x8, %rsp
movzbl %dl, %edx
movq 0x50(%rsp), %rdi
movq %r15, %rsi
movl 0x1c(%rsp), %r8d
movl 0x70(%rsp), %r9d
pushq %r14
pushq 0x60(%rsp)
pushq $0x0
callq 0x7f2d
addq $0x20, %rsp
movq 0x50(%rsp), %rdi
xorl %esi, %esi
callq 0xbd36
movq 0x40(%rsp), %rdi
xorl %esi, %esi
callq 0xbd36
movq 0x58(%rsp), %rdi
xorl %esi, %esi
callq 0xbd36
movl 0x2c(%rsp), %r13d
testw %r13w, %r13w
je 0x8c90
movq 0x18(%rsp), %rdi
callq 0x420f
movq 0x10ebc(%rip), %rsi     # 0x19ae8
leaq 0xa571(%rip), %rdi      # 0x131a4
callq 0x3110
jmp 0x8c90
cmpw $0x0, 0x4(%rsp)
setne %bl
movq 0x8(%rsp), %rsi
movq 0x10e99(%rip), %rdi     # 0x19ae8
callq 0x95ba
movq 0x18(%r12), %rsi
testw %r13w, %r13w
setne %al
andb %bl, %al
movq 0x30(%rsp), %rcx
subq $0x8, %rsp
movzbl %al, %edx
movq 0x50(%rsp), %rdi
movl 0x1c(%rsp), %r8d
xorl %r9d, %r9d
pushq %rbp
pushq 0x30(%rsp)
pushq $0x0
callq 0x7f2d
addq $0x20, %rsp
movl 0x2c(%rsp), %r13d
movq 0x28(%r12), %r12
movq 0x30(%rsp), %rdi
xorl %esi, %esi
callq 0xbd36
movq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0xbd36
movq 0x70(%rsp), %rdi
xorl %esi, %esi
callq 0xbd36
movq 0x20(%rsp), %rdi
xorl %esi, %esi
callq 0xbd36
testq %r12, %r12
jne 0x8032
jmp 0x92c3
testw %r13w, %r13w
je 0x8cf4
movw %bx, 0x2a(%rsp)
movq 0x50(%rax), %rax
testq %rax, %rax
je 0x8e83
movq 0x8(%rax), %rbp
jmp 0x8e85
cmpw $0x0, 0x4(%rsp)
setne %al
testw %bx, %bx
setne %cl
movq 0x20(%rsp), %rsi
testq %rsi, %rsi
setne %dl
andb %al, %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x8886
movq 0xd0(%rsp), %rax
movw $0xffff, (%rax)         # imm = 0xFFFF
jmp 0x8886
callq 0x9556
leaq 0x8c4f(%rip), %rbx      # 0x11988
jmp 0x8f81
movq (%rax), %rbx
movq 0x18(%rsp), %rdi
callq 0x420f
movl 0x10ddb(%rip), %esi     # 0x19b2c
movzbl 0x10db8(%rip), %ecx     # 0x19b10
leal 0x4(,%rcx,4), %edi
orl $0x2, %ecx
leaq 0x1(%rbx), %r8
xorl %ebp, %ebp
movzbl -0x1(%r8), %eax
cmpl $0x9, %eax
je 0x8d8f
cmpl $0xa, %eax
je 0x8d80
cmpl $0x20, %eax
jne 0x8d9f
incl %ebp
jmp 0x8d9a
incl %esi
movl %esi, 0x10da4(%rip)     # 0x19b2c
xorl %ebp, %ebp
movq %r8, %rbx
jmp 0x8d9a
movl %ebp, %eax
cltd
idivl %edi
movl %eax, %ebp
incl %ebp
shll %cl, %ebp
incq %r8
jmp 0x8d68
movb (%rbx), %al
testb %al, %al
je 0x8c90
movl $0x1, %r15d
subl %ebp, %r15d
movq %rbx, %rdi
movzbl 0x10d54(%rip), %ecx     # 0x19b10
leal 0x4(,%rcx,4), %r8d
orl $0x2, %ecx
incq %rbx
xorl %r14d, %r14d
movzbl %al, %eax
cmpl $0x9, %eax
jg 0x8de9
jne 0x8dfc
movl %r14d, %eax
cltd
idivl %r8d
movl %eax, %r14d
incl %r14d
shll %cl, %r14d
jmp 0x8df1
cmpl $0x20, %eax
jne 0x8e06
incl %r14d
movb 0x1(%rdi), %al
incq %rdi
incq %rbx
jmp 0x8dcd
testl %eax, %eax
je 0x8c90
jmp 0x8e15
cmpl $0xa, %eax
jne 0x8e15
cmpb $0x0, 0x1(%rdi)
je 0x92b6
movq 0x18(%rsp), %rdi
callq 0x420f
cmpl %ebp, %r14d
jle 0x8e55
addl %r15d, %r14d
movq 0x10cba(%rip), %rsi     # 0x19ae8
movl $0x20, %edi
callq 0x3130
decl %r14d
cmpl $0x1, %r14d
ja 0x8e27
jmp 0x8e55
movsbl %al, %edi
movq 0x10c9b(%rip), %rsi     # 0x19ae8
callq 0x3130
incq %rbx
movzbl -0x1(%rbx), %eax
testl %eax, %eax
je 0x8c90
cmpl $0xa, %eax
jne 0x8e43
movl 0x10cc0(%rip), %esi     # 0x19b2c
incl %esi
movl %esi, 0x10cb8(%rip)     # 0x19b2c
movb (%rbx), %al
testb %al, %al
jne 0x8db2
jmp 0x8c90
xorl %ebp, %ebp
movq 0x18(%rsp), %rbx
movq 0x10(%r12), %rax
testq %rax, %rax
je 0x8ebb
movq 0x48(%rsp), %rcx
movq 0x50(%rcx), %rcx
testq %rcx, %rcx
je 0x8ebb
movq (%rcx), %rcx
testq %rcx, %rcx
je 0x8ebb
movq (%rax), %rdi
movq (%rcx), %rsi
callq 0x3240
testl %eax, %eax
cmoveq %r14, %rbp
movl %ebx, %edi
callq 0x420f
movq 0x10c1f(%rip), %r15     # 0x19ae8
movq 0x18(%r12), %rax
movq (%rax), %rax
movq %rax, 0x68(%rsp)
movq 0x8(%r12), %r13
movq 0x10(%r12), %r14
movl $0x0, 0x3c(%rsp)
testq %r13, %r13
setne 0x3b(%rsp)
testq %r14, %r14
je 0x8f1d
movq 0x48(%rsp), %rax
movq 0x50(%rax), %rax
testq %rax, %rax
je 0x8f1d
movq (%rax), %rax
testq %rax, %rax
je 0x8f1d
movq (%r14), %rdi
movq (%rax), %rsi
callq 0x3240
testl %eax, %eax
sete %bl
jmp 0x8f1f
xorl %ebx, %ebx
movq 0x1025a(%rip), %rax     # 0x19180
movq 0x38(%rax), %rdi
movq %r15, %rsi
callq 0x3110
movq 0x10247(%rip), %rax     # 0x19180
movq 0x130(%rax), %rax
testq %rbp, %rbp
je 0x9038
movl $0x0, %edx
testb %bl, %bl
jne 0x903a
movq (%rbp), %rdx
jmp 0x903a
movq 0x1021a(%rip), %rax     # 0x19180
movq 0x10b7b(%rip), %rdi     # 0x19ae8
leaq 0x8d84(%rip), %rsi      # 0x11cf8
callq *0x140(%rax)
leaq 0x8a02(%rip), %rbx      # 0x11983
movq 0x101f8(%rip), %rax     # 0x19180
movq 0x10b59(%rip), %rdi     # 0x19ae8
callq *0x138(%rax)
movq 0x101e4(%rip), %rax     # 0x19180
movq 0x10b45(%rip), %rdi     # 0x19ae8
movq %rbx, %rsi
callq *0x140(%rax)
movq 0x101cd(%rip), %rax     # 0x19180
movq 0x10b2e(%rip), %rdi     # 0x19ae8
callq *0x148(%rax)
movq 0x101b9(%rip), %rax     # 0x19180
movq 0x80(%rax), %rdi
movq 0x10b13(%rip), %rsi     # 0x19ae8
callq 0x3110
movq 0x10(%r12), %r14
testq %r14, %r14
je 0x8c90
movq 0x48(%rsp), %rax
movq 0x50(%rax), %rax
testq %rax, %rax
je 0x9012
movq (%rax), %rax
testq %rax, %rax
je 0x9012
movq (%r14), %rdi
movq (%rax), %rsi
callq 0x3240
xorl %ecx, %ecx
testl %eax, %eax
sete %cl
jmp 0x9014
xorl %ecx, %ecx
movq 0x10165(%rip), %rax     # 0x19180
movq 0x10ac6(%rip), %rdi     # 0x19ae8
movzwl %cx, %ecx
movq 0x18(%rsp), %rsi
movq %r14, %rdx
callq *0x160(%rax)
jmp 0x8c90
xorl %edx, %edx
testq %r14, %r14
je 0x9044
movq (%r14), %rcx
jmp 0x9046
xorl %ecx, %ecx
movl 0x3c(%rsp), %esi
movb 0x3b(%rsp), %dil
movb %dil, %sil
movl %esi, 0x3c(%rsp)
movq %r15, %rdi
movq 0x68(%rsp), %rsi
callq *%rax
testq %r13, %r13
je 0x9115
xorl %ebx, %ebx
movq 0x18(%r13), %r14
movswl (%r13), %ebp
testl %ebp, %ebp
je 0x9089
movl $0x20, %edi
movq %r15, %rsi
callq 0x3130
decl %ebp
jne 0x9078
cmpb $0x2c, (%r14)
jne 0x90b8
cmpb $0x0, 0x1(%r14)
sete %al
testl %ebx, %ebx
sete %cl
testb %cl, %al
je 0x90b8
movq 0x100d9(%rip), %rax     # 0x19180
movq %r15, %rdi
callq *0x138(%rax)
incl 0x3c(%rsp)
xorl %ebx, %ebx
jmp 0x9108
movq 0x100c1(%rip), %rax     # 0x19180
movq %r15, %rdi
movq %r14, %rsi
callq *0x140(%rax)
movzbl (%r14), %eax
cmpl $0x5c, %eax
jg 0x90e5
cmpl $0x28, %eax
je 0x90f4
cmpl $0x29, %eax
je 0x90ff
cmpl $0x5b, %eax
je 0x90f4
jmp 0x9108
cmpl $0x5d, %eax
je 0x90ff
cmpl $0x7d, %eax
je 0x90ff
cmpl $0x7b, %eax
jne 0x9108
cmpb $0x0, 0x1(%r14)
jne 0x9108
incl %ebx
jmp 0x9108
cmpb $0x0, 0x1(%r14)
jne 0x9108
decl %ebx
movq 0x28(%r13), %r13
testq %r13, %r13
jne 0x906b
movq 0x18(%r12), %rax
movl 0x3c(%rsp), %ecx
cmpl 0x48(%rax), %ecx
jne 0x92a9
movq 0x10052(%rip), %rax     # 0x19180
movq 0x109b3(%rip), %rdi     # 0x19ae8
callq *0x138(%rax)
movq 0x20(%rsp), %rdi
cmpw $0x0, 0x4(%rsp)
movl 0x2c(%rsp), %r13d
movzwl 0x2a(%rsp), %eax
je 0x91e9
testw %ax, %ax
je 0x91e9
testq %rdi, %rdi
je 0x9206
movq 0x10979(%rip), %rsi     # 0x19ae8
leaq 0x886d(%rip), %rdi      # 0x119e3
callq 0x3110
movq 0xfffe(%rip), %rax      # 0x19180
cmpw $0x0, 0x10(%rax)
je 0x91b7
movq 0x10958(%rip), %rdi     # 0x19ae8
leaq 0x885c(%rip), %rsi      # 0x119f3
movq $-0x1, %rdx
callq *0x100(%rax)
movq 0x1093d(%rip), %rsi     # 0x19ae8
leaq 0x8335(%rip), %rdi      # 0x114e7
callq 0x3110
movq 0x1092a(%rip), %rsi     # 0x19ae8
leaq 0x8834(%rip), %rdi      # 0x119f9
callq 0x3110
movq 0x20(%rsp), %rdi
callq 0x9556
movq 0x1090d(%rip), %rsi     # 0x19ae8
leaq 0x9c9d(%rip), %rdi      # 0x12e7f
callq 0x3110
jmp 0x9221
callq 0x9556
jmp 0x9221
movq %rsi, %rdi
leaq 0x89de(%rip), %rsi      # 0x11bd8
xorl %eax, %eax
callq 0x3160
jmp 0x8c90
movq 0xff73(%rip), %rax      # 0x19180
movq 0x108d4(%rip), %rdi     # 0x19ae8
leaq 0x8add(%rip), %rsi      # 0x11cf8
callq *0x140(%rax)
movq 0x108c0(%rip), %rdi     # 0x19ae8
movq 0xff51(%rip), %rax      # 0x19180
callq *0x148(%rax)
movq 0xff44(%rip), %rax      # 0x19180
movq 0x80(%rax), %rdi
movq 0x1089e(%rip), %rsi     # 0x19ae8
jmp 0x8c33
movq 0x18(%rsp), %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x35ba
jmp 0x8a62
movl 0x14(%rsp), %edi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x3558
jmp 0x8538
movl 0x14(%rsp), %edi
movq %r12, %rsi
movq %r15, %rdx
callq 0x361c
jmp 0x8696
movq 0xfd65(%rip), %rax      # 0x18ff8
movq (%rax), %rdi
leaq 0x876e(%rip), %rsi      # 0x11a0b
xorl %eax, %eax
callq 0x3160
jmp 0x8c90
movq %r12, %rdi
callq 0x367e
jmp 0x9127
incl %esi
movl %esi, 0x1086e(%rip)     # 0x19b2c
jmp 0x8c90
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq