// File: /workspace/github_c_makefile_star2_O1/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 $0xb8, %rsp
movl %r9d, %r13d
movq %r8, 0x28(%rsp)
movq %rcx, 0xa8(%rsp)
movl %edx, 0x38(%rsp)
movq %rsi, %r12
movq %rdi, 0x68(%rsp)
testw %r13w, %r13w
je 0x8172
leaq 0x9886(%rip), %rdi      # 0x11952
callq 0x63b8
testw %ax, %ax
je 0x8172
movq 0x28(%rsp), %rdi
callq 0x4284
movq 0x119fd(%rip), %rsi     # 0x19ae8
leaq 0x9868(%rip), %rdi      # 0x1195a
callq 0x3110
movq 0x119ea(%rip), %rdi     # 0x19ae8
movq 0xa8(%rsp), %rsi
callq 0x96b2
movq 0x119d6(%rip), %rsi     # 0x19ae8
leaq 0x984d(%rip), %rdi      # 0x11966
callq 0x3110
movq 0x119c3(%rip), %rdi     # 0x19ae8
movq 0xf8(%rsp), %rsi
callq 0x96b2
movq 0x119af(%rip), %rdi     # 0x19ae8
cmpw $0x0, 0x38(%rsp)
leaq 0x984a(%rip), %rax      # 0x11990
leaq 0x983e(%rip), %rdx      # 0x1198b
cmoveq %rax, %rdx
leaq 0x981c(%rip), %rsi      # 0x11974
xorl %eax, %eax
callq 0x3160
movq 0x11982(%rip), %rsi     # 0x19ae8
leaq 0xb6f4(%rip), %rdi      # 0x13861
callq 0x3110
testq %r12, %r12
je 0x94a4
movq 0x28(%rsp), %rax
leal 0x1(%rax), %ecx
movl %ecx, 0x3c(%rsp)
addl $0x2, %eax
movl %eax, 0xa4(%rsp)
movl %r13d, 0x88(%rsp)
xorl %eax, %eax
movq %rax, 0x30(%rsp)
movq %rax, 0x50(%rsp)
movq %rax, 0x40(%rsp)
movq %rax, 0x98(%rsp)
xorl %r14d, %r14d
movq %rax, 0x90(%rsp)
movq 0x28(%r12), %rdx
leaq 0x50(%rsp), %rdi
movq 0xa8(%rsp), %rsi
callq 0x65f6
movq 0x28(%r12), %rdx
leaq 0x40(%rsp), %rdi
movq 0xf8(%rsp), %rsi
callq 0x65f6
movl %eax, %ebp
testw %r13w, %r13w
je 0x829b
leaq 0x9754(%rip), %rdi      # 0x11952
callq 0x63b8
testw %ax, %ax
je 0x829b
movq 0x28(%rsp), %rdi
callq 0x4284
movq 0x118cb(%rip), %rsi     # 0x19ae8
leaq 0x9772(%rip), %rdi      # 0x11996
callq 0x3110
movq 0x118b8(%rip), %rdi     # 0x19ae8
movq 0x50(%rsp), %rsi
callq 0x96b2
movq 0x118a7(%rip), %rsi     # 0x19ae8
leaq 0x975d(%rip), %rdi      # 0x119a5
callq 0x3110
movq 0x11894(%rip), %rdi     # 0x19ae8
movq 0x40(%rsp), %rsi
callq 0x96b2
movq 0x11883(%rip), %rdi     # 0x19ae8
testw %bp, %bp
leaq 0x971c(%rip), %rdx      # 0x1198b
leaq 0x971a(%rip), %rax      # 0x11990
cmoveq %rax, %rdx
leaq 0x9733(%rip), %rsi      # 0x119b4
xorl %eax, %eax
callq 0x3160
movq 0x11859(%rip), %rsi     # 0x19ae8
leaq 0xb5cb(%rip), %rdi      # 0x13861
callq 0x3110
movl 0x4(%r12), %eax
cmpq $0x6, %rax
ja 0x8e1e
leaq 0x8dcf(%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 0x9467
leaq 0x8dc9(%rip), %rsi      # 0x1109c
movslq (%rsi,%rdx,4), %rcx
addq %rsi, %rcx
jmpq *%rcx
testw %r13w, %r13w
je 0x8e80
movq 0x28(%rsp), %rdi
callq 0x4284
movq 0x10e89(%rip), %rax     # 0x19180
movq 0x38(%rax), %rdi
movq 0x117e6(%rip), %rsi     # 0x19ae8
callq 0x3110
movq 0x10e72(%rip), %rax     # 0x19180
movq 0x117d3(%rip), %rdi     # 0x19ae8
leaq 0x96ee(%rip), %rsi      # 0x11a0a
xorl %edx, %edx
xorl %ecx, %ecx
callq *0x130(%rax)
movq 0x10e53(%rip), %rax     # 0x19180
movq 0x117b4(%rip), %rdi     # 0x19ae8
callq *0x138(%rax)
movq 0x10e3f(%rip), %rax     # 0x19180
movq 0x117a0(%rip), %rdi     # 0x19ae8
movq 0x18(%r12), %rcx
movq (%rcx), %rdx
movq 0x28(%rcx), %rsi
callq *0x108(%rax)
movq 0x10e1f(%rip), %rax     # 0x19180
movq 0x11780(%rip), %rdi     # 0x19ae8
callq *0x138(%rax)
movq 0x40(%rsp), %rdi
callq 0x9728
movq 0x10e01(%rip), %rax     # 0x19180
movq 0x11762(%rip), %rdi     # 0x19ae8
callq *0x138(%rax)
movq 0x40(%rsp), %rdi
cmpw $0x0, 0x38(%rsp)
je 0x8ec1
testw %bp, %bp
je 0x8ec1
testq %rdi, %rdi
je 0x90f1
movq 0x11732(%rip), %rsi     # 0x19ae8
leaq 0x962e(%rip), %rdi      # 0x119eb
callq 0x3110
movq 0x10db7(%rip), %rax     # 0x19180
cmpw $0x0, 0x10(%rax)
je 0x83fe
movq 0x11711(%rip), %rdi     # 0x19ae8
leaq 0x961d(%rip), %rsi      # 0x119fb
movq $-0x1, %rdx
callq *0x100(%rax)
movq 0x116f6(%rip), %rsi     # 0x19ae8
leaq 0x90f6(%rip), %rdi      # 0x114ef
callq 0x3110
movq 0x116e3(%rip), %rsi     # 0x19ae8
leaq 0x95f5(%rip), %rdi      # 0x11a01
callq 0x3110
movq 0x40(%rsp), %rdi
callq 0x9728
movq 0x116c6(%rip), %rsi     # 0x19ae8
leaq 0xaa56(%rip), %rdi      # 0x12e7f
callq 0x3110
jmp 0x910c
movq 0x18(%r12), %rsi
movq 0x50(%rsp), %rcx
movq 0x10d3c(%rip), %rax     # 0x19180
movq 0x28(%rax), %r9
movq 0x30(%rax), %rax
movq 0x40(%rsp), %rdx
movswl (%r12), %edi
movl %edi, 0x20(%rsp)
movq 0x100(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movswl %r13w, %edx
movl %edx, 0x8(%rsp)
movq %rax, (%rsp)
movswl 0x38(%rsp), %edx
movq 0x68(%rsp), %rdi
movq 0x28(%rsp), %r8
callq 0x7bfb
jmp 0x8e1e
movq 0x18(%r12), %rdx
leaq 0x30(%rsp), %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x65f6
movl %eax, %ebx
movq 0x30(%rsp), %rsi
leaq 0x40(%rsp), %rdi
callq 0x67a4
movq 0x30(%rsp), %r8
movswl %bx, %ebx
movswl 0xf0(%rsp), %edi
movswl %r13w, %r14d
movl %r14d, %esi
movl %ebx, %edx
movq 0x28(%rsp), %rcx
movq 0x100(%rsp), %r9
callq 0x983f
testw %bx, %bx
je 0x8a92
movq 0x50(%rsp), %rsi
movq %r15, %rdi
callq 0x67a4
movq 0x30(%rsp), %rax
movq %rax, 0x90(%rsp)
jmp 0x8ab4
testw %r13w, %r13w
je 0x853c
movq 0x28(%rsp), %rbx
movl %ebx, %edi
callq 0x4284
movq 0x10c5e(%rip), %rax     # 0x19180
movq 0xa0(%rax), %rdi
movq 0x115b8(%rip), %rsi     # 0x19ae8
callq 0x3110
movl %ebx, %edi
callq 0x42c1
xorl %ebx, %ebx
movq %rbx, 0x60(%rsp)
movq %rbx, 0x80(%rsp)
movq 0x18(%r12), %rax
movq 0x18(%rax), %r13
movq 0x28(%rax), %rax
movq 0x18(%rax), %r15
movq 0x50(%rsp), %rsi
leaq 0x80(%rsp), %rdi
movq %r13, %rdx
callq 0x65f6
movw %ax, 0x58(%rsp)
movq 0x80(%rsp), %rsi
leaq 0x60(%rsp), %r14
movq %r14, %rdi
movq %r15, %rdx
callq 0x65f6
movq 0x50(%rsp), %rsi
movq %r14, %rdi
callq 0x67a4
movq %rbx, 0x78(%rsp)
leaq 0x78(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x65f6
testw %ax, %ax
je 0x85c4
movq %r14, %rdi
xorl %esi, %esi
movq %r13, %rdx
callq 0x65f6
cmpw $0x0, 0x38(%rsp)
setne %bl
movq 0x40(%rsp), %rsi
movq %r14, %rdi
callq 0x67a4
testw %bp, %bp
setne %al
andb %bl, %al
movq 0x60(%rsp), %rcx
movq 0x78(%rsp), %rdx
movq 0x100(%rsp), %rsi
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movl $0xffffffff, (%rsp)     # imm = 0xFFFFFFFF
movzbl %al, %edx
movl 0x88(%rsp), %ebx
movswl %bx, %r14d
movq 0x68(%rsp), %rdi
movq %r13, %rsi
movl 0x3c(%rsp), %r8d
movl %r14d, %r9d
callq 0x808e
movq 0x78(%rsp), %rdi
xorl %esi, %esi
callq 0xc008
movq 0x60(%rsp), %rdi
xorl %esi, %esi
callq 0xc008
movq 0x80(%rsp), %rdi
xorl %esi, %esi
callq 0xc008
movq $0x0, 0x60(%rsp)
movq 0x50(%rsp), %rsi
leaq 0x60(%rsp), %rdi
movq %r13, %rdx
callq 0x65f6
movq 0x60(%rsp), %rsi
leaq 0x30(%rsp), %rdi
movq %r15, %rdx
callq 0x65f6
movq 0x60(%rsp), %rdi
xorl %esi, %esi
callq 0xc008
movq 0x30(%rsp), %rdi
testw %bx, %bx
movw %bp, 0x8e(%rsp)
je 0x8c5c
movq 0x50(%rsp), %rsi
callq 0x9a1b
testq %rax, %rax
je 0x86c7
movq %rax, %rbx
cmpw $0x0, 0x20(%r12)
je 0x943f
movq %rbx, %rdi
xorl %esi, %esi
callq 0xc008
movl 0x3c(%rsp), %ebx
movl %ebx, %edi
callq 0x4284
movq 0x30(%rsp), %rdi
movswl (%r12), %eax
movl %eax, (%rsp)
leaq 0xf51(%rip), %rsi       # 0x9637
movq 0x28(%rsp), %rdx
xorl %ecx, %ecx
movl %r14d, %r8d
xorl %r9d, %r9d
callq 0x94b6
movl %ebx, %edi
callq 0x42c1
movl 0xa4(%rsp), %edi
callq 0x4284
movq 0x113d6(%rip), %rdi     # 0x19ae8
movq 0x10a67(%rip), %rax     # 0x19180
movq 0x80(%rax), %rcx
movq 0xa8(%rax), %rdx
leaq 0x9501(%rip), %rsi      # 0x11c2f
xorl %eax, %eax
callq 0x3160
movl %ebx, %edi
callq 0x4284
movq 0x113a5(%rip), %rsi     # 0x19ae8
leaq 0xaa5a(%rip), %rdi      # 0x131a4
callq 0x3110
jmp 0x8c7d
movq 0x18(%r12), %rdx
leaq 0x30(%rsp), %rdi
xorl %esi, %esi
callq 0x65f6
movq 0x30(%rsp), %r8
movswl 0xf0(%rsp), %edi
movswl %r13w, %r14d
movl %r14d, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq 0x28(%rsp), %rbx
movl %ebx, %ecx
movq 0x100(%rsp), %r9
callq 0x983f
movq $0x0, 0x98(%rsp)
testw %r13w, %r13w
je 0x8d87
movl %ebx, %edi
callq 0x4284
movq 0x30(%rsp), %rdi
movswl (%r12), %eax
movl %eax, (%rsp)
leaq 0xe74(%rip), %rsi       # 0x9637
movl %ebx, %edx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movl %r14d, %r8d
xorl %r9d, %r9d
callq 0x94b6
movl %ebx, %edi
callq 0x42c1
movq 0x30(%rsp), %rdi
movq 0x50(%rsp), %rsi
callq 0x9a1b
testq %rax, %rax
je 0x8dad
movq %rax, %r15
movq 0x18(%r12), %rax
cmpw $0x0, 0x20(%rax)
je 0x9453
movq %r15, %rdi
xorl %esi, %esi
callq 0xc008
jmp 0x8dad
leaq 0x30(%rsp), %rdi
movq %r12, %rsi
callq 0x9a7c
testw %r13w, %r13w
je 0x8985
movq 0x28(%rsp), %rbx
movl %ebx, %edi
callq 0x4284
movq 0x30(%rsp), %rdi
movswl (%r12), %eax
movl %eax, (%rsp)
movswl %r13w, %r8d
leaq 0xde6(%rip), %rsi       # 0x9637
movl %ebx, %edx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
xorl %r9d, %r9d
callq 0x94b6
movl %ebx, %edi
callq 0x42c1
movl 0x3c(%rsp), %edi
callq 0x4284
movq 0x11271(%rip), %rdi     # 0x19ae8
movq 0x10902(%rip), %rax     # 0x19180
movq 0x80(%rax), %rcx
movq 0xa8(%rax), %rdx
leaq 0x939c(%rip), %rsi      # 0x11c2f
xorl %eax, %eax
callq 0x3160
jmp 0x897e
leaq 0x30(%rsp), %rdi
movq %r12, %rsi
callq 0x9a7c
testw %r13w, %r13w
je 0x8985
movq 0x28(%rsp), %rbx
movl %ebx, %edi
callq 0x4284
movq 0x30(%rsp), %rdi
movswl (%r12), %eax
movl %eax, (%rsp)
movswl %r13w, %r8d
leaq 0xd5d(%rip), %rsi       # 0x9637
movl %ebx, %edx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
xorl %r9d, %r9d
callq 0x94b6
movl %ebx, %edi
callq 0x42c1
movl 0x3c(%rsp), %edi
callq 0x4284
movq 0x10880(%rip), %rax     # 0x19180
movq 0x111e1(%rip), %rdi     # 0x19ae8
leaq 0x92b2(%rip), %rsi      # 0x11bc0
xorl %edx, %edx
xorl %ecx, %ecx
callq *0x130(%rax)
movq 0x10861(%rip), %rax     # 0x19180
movq 0x111c2(%rip), %rdi     # 0x19ae8
callq *0x138(%rax)
movq 0x1084d(%rip), %rax     # 0x19180
movq 0x111ae(%rip), %rdi     # 0x19ae8
movq 0x18(%r12), %rcx
movq 0x28(%rcx), %rcx
movq 0x18(%rcx), %rcx
movq (%rcx), %rsi
callq *0x140(%rax)
movq 0x10829(%rip), %rax     # 0x19180
movq 0x1118a(%rip), %rdi     # 0x19ae8
callq *0x148(%rax)
movq 0x10815(%rip), %rax     # 0x19180
movq 0x80(%rax), %rdi
movq 0x1116f(%rip), %rsi     # 0x19ae8
callq 0x3110
movl %ebx, %edi
jmp 0x8e06
movq 0x30(%rsp), %rdi
movswl (%r12), %eax
movl %eax, (%rsp)
movswl %r13w, %r8d
leaq 0xc9a(%rip), %rsi       # 0x9637
movq 0x28(%rsp), %rdx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
xorl %r9d, %r9d
callq 0x94b6
jmp 0x8e1e
testw %r13w, %r13w
je 0x8e1e
leaq 0x8a4e(%rip), %rdi      # 0x11413
callq 0x63b8
testw %ax, %ax
je 0x8a03
movswl (%r12), %edx
cmpl %edx, 0x11152(%rip)     # 0x19b2c
je 0x8a03
movq 0x11105(%rip), %rdi     # 0x19ae8
movq 0x1079e(%rip), %rcx     # 0x19188
leaq 0x8a27(%rip), %rsi      # 0x11418
xorl %eax, %eax
callq 0x3160
movswl (%r12), %eax
movl %eax, 0x11129(%rip)     # 0x19b2c
movq 0x18(%r12), %rax
movl 0x38(%rax), %ecx
cmpl $0x3, %ecx
je 0x8ed2
cmpl $0x2, %ecx
jne 0x8e1e
movq 0x28(%rsp), %rdi
callq 0x4284
movq 0x18(%r12), %rax
movq (%rax), %rdi
leaq 0xa6f0(%rip), %rsi      # 0x13126
callq 0x3240
movq 0x110a6(%rip), %rsi     # 0x19ae8
testl %eax, %eax
je 0x93cb
leaq 0x91aa(%rip), %rdi      # 0x11bfb
callq 0x3110
movq 0x18(%r12), %rax
movq (%rax), %rdi
leaq 0x1(%rdi), %rbx
callq 0x30d0
leaq -0x2(%rax), %rdx
movq 0x11076(%rip), %rcx     # 0x19ae8
movl $0x1, %esi
movq %rbx, %rdi
callq 0x3210
movq 0x11062(%rip), %rsi     # 0x19ae8
leaq 0x9177(%rip), %rdi      # 0x11c04
jmp 0x8e19
movq 0x30(%rsp), %rsi
leaq 0x90(%rsp), %rbx
movq %rbx, %rdi
callq 0x67a4
movq 0x50(%rsp), %rsi
movq %rbx, %rdi
callq 0x67a4
movq 0x30(%rsp), %rsi
leaq 0x98(%rsp), %rdi
callq 0x67a4
movswl %bp, %r15d
testw %r13w, %r13w
je 0x8ba7
cmpw $0x0, 0x38(%rsp)
setne %bl
movl %r15d, 0x58(%rsp)
movl %r13d, %r15d
movl %ebp, %r13d
movq 0x28(%rsp), %rbp
movl %ebp, %edi
callq 0x4284
movq 0x10685(%rip), %rax     # 0x19180
movq 0x10fe6(%rip), %rdi     # 0x19ae8
movl %ebp, %esi
callq *0xb0(%rax)
movq 0x18(%r12), %rsi
testw %r13w, %r13w
movl %r15d, %r13d
setne %al
andb %bl, %al
movq 0x90(%rsp), %rcx
movq 0x40(%rsp), %rdx
movq 0x100(%rsp), %rbx
movq %rbx, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movl $0x0, (%rsp)
movzbl %al, %edx
movq 0x68(%rsp), %rdi
movl 0x3c(%rsp), %ebp
movl %ebp, %r8d
movl %r14d, %r9d
callq 0x808e
movq 0x40(%rsp), %r8
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movl %r14d, %esi
movl 0x58(%rsp), %edx
movl %ebp, %ecx
movq %rbx, %r9
callq 0x983f
movq 0x30(%rsp), %rdi
movq 0x50(%rsp), %rsi
callq 0x9a1b
testq %rax, %rax
je 0x8c14
movq %rax, %r15
cmpw $0x0, 0x20(%r12)
je 0x942a
movq %r15, %rdi
xorl %esi, %esi
callq 0xc008
jmp 0x8c14
cmpw $0x0, 0x38(%rsp)
setne %al
movq 0x18(%r12), %rsi
testw %bp, %bp
setne %dl
andb %al, %dl
movq 0x90(%rsp), %rcx
movq 0x40(%rsp), %rax
movq 0x100(%rsp), %rbx
movq %rbx, 0x10(%rsp)
movq %rax, 0x8(%rsp)
movl $0x0, (%rsp)
movzbl %dl, %edx
movq 0x68(%rsp), %rdi
movl 0x3c(%rsp), %ebp
movl %ebp, %r8d
movl %r14d, %r9d
callq 0x808e
movq 0x40(%rsp), %r8
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movl %r14d, %esi
movl %r15d, %edx
movl %ebp, %ecx
movq %rbx, %r9
callq 0x983f
movq 0x30(%rsp), %rdi
movswl (%r12), %eax
movl %eax, (%rsp)
leaq 0xe39(%rip), %rsi       # 0x9a61
movq 0x28(%rsp), %rdx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movl %r14d, %r8d
xorl %r9d, %r9d
callq 0x94b6
movq 0x90(%rsp), %rdi
cmpq 0x30(%rsp), %rdi
je 0x8e1e
xorl %esi, %esi
callq 0xc008
jmp 0x8e1e
movswl (%r12), %eax
movl %eax, (%rsp)
leaq 0x9cc(%rip), %rsi       # 0x9637
movq 0x28(%rsp), %rdx
xorl %ecx, %ecx
movl %r14d, %r8d
xorl %r9d, %r9d
callq 0x94b6
xorl %ebx, %ebx
movq %rbx, 0x60(%rsp)
movq %rbx, 0x80(%rsp)
leaq 0x80(%rsp), %rbp
movq %rbp, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x65f6
movq 0x50(%rsp), %rsi
movq %rbp, %rdi
callq 0x67a4
movq 0x80(%rsp), %rsi
leaq 0x60(%rsp), %rdi
movq %r13, %rdx
callq 0x65f6
movq %rbx, 0x78(%rsp)
leaq 0x78(%rsp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
movq %r13, %rdx
callq 0x65f6
testw %ax, %ax
je 0x8cf9
movq %rbx, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x65f6
movq 0x40(%rsp), %rsi
movq %rbx, %rdi
callq 0x67a4
cmpw $0x0, 0x8e(%rsp)
setne %al
cmpw $0x0, 0x38(%rsp)
setne %dl
cmpw $0x0, 0x58(%rsp)
setne %cl
andb %al, %dl
andb %cl, %dl
movq 0x60(%rsp), %rcx
movq 0x78(%rsp), %rax
movq 0x100(%rsp), %rsi
movq %rsi, 0x10(%rsp)
movq %rax, 0x8(%rsp)
movl $0x0, (%rsp)
movzbl %dl, %edx
movq 0x68(%rsp), %rdi
movq %r15, %rsi
movl 0x3c(%rsp), %r8d
movl %r14d, %r9d
callq 0x808e
movq 0x78(%rsp), %rdi
xorl %esi, %esi
callq 0xc008
movq 0x60(%rsp), %rdi
xorl %esi, %esi
callq 0xc008
movq 0x80(%rsp), %rdi
xorl %esi, %esi
callq 0xc008
movl 0x88(%rsp), %r13d
jmp 0x8dfb
movq 0x30(%rsp), %rdi
movswl (%r12), %eax
movl %eax, (%rsp)
leaq 0x89c(%rip), %rsi       # 0x9637
movl %ebx, %edx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movl %r14d, %r8d
xorl %r9d, %r9d
callq 0x94b6
cmpw $0x0, 0x38(%rsp)
setne %al
movq 0x18(%r12), %rsi
testw %bp, %bp
setne %dl
andb %al, %dl
movq 0x50(%rsp), %rcx
movq 0x40(%rsp), %rax
movq 0x100(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movq %rax, 0x8(%rsp)
movl $0x0, (%rsp)
movzbl %dl, %edx
movq 0x68(%rsp), %rdi
movl 0x3c(%rsp), %r8d
movl %r14d, %r9d
callq 0x808e
testw %r13w, %r13w
je 0x8e1e
movq 0x28(%rsp), %rdi
callq 0x4284
movq 0x10cd6(%rip), %rsi     # 0x19ae8
leaq 0xa38b(%rip), %rdi      # 0x131a4
callq 0x3110
movq 0x28(%r12), %r12
movq 0x50(%rsp), %rdi
xorl %esi, %esi
callq 0xc008
movq 0x30(%rsp), %rdi
xorl %esi, %esi
callq 0xc008
movq 0x98(%rsp), %rdi
xorl %esi, %esi
callq 0xc008
movq 0x40(%rsp), %rdi
xorl %esi, %esi
callq 0xc008
testq %r12, %r12
jne 0x8199
jmp 0x94a4
testw %r13w, %r13w
je 0x8e80
movq 0x50(%rax), %rax
testq %rax, %rax
je 0x8fff
movq 0x8(%rax), %rax
jmp 0x9001
cmpw $0x0, 0x38(%rsp)
setne %al
testw %bp, %bp
setne %cl
movq 0x40(%rsp), %rsi
testq %rsi, %rsi
setne %dl
andb %al, %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x8eb0
movq 0x100(%rsp), %rax
movw $0xffff, (%rax)         # imm = 0xFFFF
movq 0x10c31(%rip), %rdi     # 0x19ae8
callq 0x978c
jmp 0x8e1e
callq 0x9728
leaq 0x8ac3(%rip), %rbx      # 0x11990
jmp 0x9113
movq (%rax), %rbx
movq 0x28(%rsp), %rdi
callq 0x4284
movl 0x10c47(%rip), %esi     # 0x19b2c
movzbl 0x10c24(%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 0x8f23
cmpl $0xa, %eax
je 0x8f14
cmpl $0x20, %eax
jne 0x8f33
incl %ebp
jmp 0x8f2e
incl %esi
movl %esi, 0x10c10(%rip)     # 0x19b2c
xorl %ebp, %ebp
movq %r8, %rbx
jmp 0x8f2e
movl %ebp, %eax
cltd
idivl %edi
movl %eax, %ebp
incl %ebp
shll %cl, %ebp
incq %r8
jmp 0x8efc
cmpb $0x0, (%rbx)
je 0x8e1e
movl $0x1, %r15d
subl %ebp, %r15d
movzbl 0x10bc4(%rip), %ecx     # 0x19b10
leal 0x4(,%rcx,4), %esi
orl $0x2, %ecx
xorl %r14d, %r14d
movb (%rbx), %al
movzbl %al, %edx
cmpl $0x9, %edx
jg 0x8f76
jne 0x8f83
movl %r14d, %eax
cltd
idivl %esi
movl %eax, %r14d
incl %r14d
shll %cl, %r14d
jmp 0x8f7e
cmpl $0x20, %edx
jne 0x8f8d
incl %r14d
incq %rbx
jmp 0x8f59
testl %edx, %edx
je 0x8e1e
jmp 0x8f9c
cmpl $0xa, %edx
jne 0x8f9c
cmpb $0x0, 0x1(%rbx)
je 0x9491
movq 0x28(%rsp), %rdi
callq 0x4284
cmpl %ebp, %r14d
jle 0x8fdc
addl %r15d, %r14d
movq 0x10b33(%rip), %rsi     # 0x19ae8
movl $0x20, %edi
callq 0x3130
decl %r14d
cmpl $0x1, %r14d
jg 0x8fae
jmp 0x8fdc
movsbl %al, %edi
incq %rbx
movq 0x10b11(%rip), %rsi     # 0x19ae8
callq 0x3130
movzbl (%rbx), %eax
testl %eax, %eax
je 0x8ff1
cmpl $0xa, %eax
jne 0x8fca
incq %rbx
incl 0x10b3b(%rip)           # 0x19b2c
cmpb $0x0, (%rbx)
jne 0x8f45
jmp 0x8e1e
xorl %eax, %eax
movq 0x28(%rsp), %rbx
movq %rax, 0x58(%rsp)
movq 0x10(%r12), %rax
testq %rax, %rax
je 0x9046
movq 0x68(%rsp), %rcx
movq 0x50(%rcx), %rcx
testq %rcx, %rcx
je 0x9046
movq (%rcx), %rcx
testq %rcx, %rcx
je 0x9046
movq (%rax), %rdi
movq (%rcx), %rsi
callq 0x3240
testl %eax, %eax
movq 0x58(%rsp), %rax
cmoveq %r14, %rax
movq %rax, 0x58(%rsp)
movl %ebx, %edi
callq 0x4284
movq 0x10a94(%rip), %r15     # 0x19ae8
movq 0x18(%r12), %rax
movq (%rax), %rax
movq %rax, 0xb0(%rsp)
movq 0x8(%r12), %r13
movq 0x10(%r12), %r14
movl $0x0, 0x74(%rsp)
testq %r13, %r13
setne 0x4f(%rsp)
testq %r14, %r14
je 0x90ab
movq 0x68(%rsp), %rax
movq 0x50(%rax), %rax
testq %rax, %rax
je 0x90ab
movq (%rax), %rax
testq %rax, %rax
je 0x90ab
movq (%r14), %rdi
movq (%rax), %rsi
callq 0x3240
testl %eax, %eax
sete %bl
jmp 0x90ad
xorl %ebx, %ebx
movq 0x100cc(%rip), %rax     # 0x19180
movq 0x38(%rax), %rdi
movq %r15, %rsi
callq 0x3110
movq 0x100b9(%rip), %rax     # 0x19180
movq 0x130(%rax), %rax
movq 0x58(%rsp), %rcx
testq %rcx, %rcx
je 0x91ca
movl $0x0, %edx
testb %bl, %bl
jne 0x91cc
movq (%rcx), %rdx
jmp 0x91cc
movq 0x10088(%rip), %rax     # 0x19180
movq 0x109e9(%rip), %rdi     # 0x19ae8
leaq 0x8bfa(%rip), %rsi      # 0x11d00
callq *0x140(%rax)
leaq 0x8878(%rip), %rbx      # 0x1198b
movq 0x10066(%rip), %rax     # 0x19180
movq 0x109c7(%rip), %rdi     # 0x19ae8
callq *0x138(%rax)
movq 0x10052(%rip), %rax     # 0x19180
movq 0x109b3(%rip), %rdi     # 0x19ae8
movq %rbx, %rsi
callq *0x140(%rax)
movq 0x1003b(%rip), %rax     # 0x19180
movq 0x1099c(%rip), %rdi     # 0x19ae8
callq *0x148(%rax)
movq 0x10027(%rip), %rax     # 0x19180
movq 0x80(%rax), %rdi
movq 0x10981(%rip), %rsi     # 0x19ae8
callq 0x3110
movq 0x10(%r12), %r14
testq %r14, %r14
je 0x8e1e
movq 0x68(%rsp), %rax
movq 0x50(%rax), %rax
testq %rax, %rax
je 0x91a4
movq (%rax), %rax
testq %rax, %rax
je 0x91a4
movq (%r14), %rdi
movq (%rax), %rsi
callq 0x3240
xorl %ecx, %ecx
testl %eax, %eax
sete %cl
jmp 0x91a6
xorl %ecx, %ecx
movq 0xffd3(%rip), %rax      # 0x19180
movq 0x10934(%rip), %rdi     # 0x19ae8
movzwl %cx, %ecx
movq 0x28(%rsp), %rsi
movq %r14, %rdx
callq *0x160(%rax)
jmp 0x8e1e
xorl %edx, %edx
testq %r14, %r14
je 0x91d6
movq (%r14), %rcx
jmp 0x91d8
xorl %ecx, %ecx
movl 0x74(%rsp), %esi
movb 0x4f(%rsp), %dil
movb %dil, %sil
movl %esi, 0x74(%rsp)
movq %r15, %rdi
movq 0xb0(%rsp), %rsi
callq *%rax
testq %r13, %r13
je 0x92f2
movl $0x0, 0x58(%rsp)
movl %ebp, %ebx
movq 0x18(%r13), %r14
movswl (%r13), %ebp
testl %ebp, %ebp
je 0x9226
movl $0x20, %edi
movq %r15, %rsi
callq 0x3130
decl %ebp
jne 0x9215
movq %r14, %rdi
leaq 0xa417(%rip), %rsi      # 0x13647
callq 0x3240
orl 0x58(%rsp), %eax
movq 0xff40(%rip), %rax      # 0x19180
movq %r15, %rdi
jne 0x925e
callq *0x138(%rax)
incl 0x74(%rsp)
movl $0x0, 0x58(%rsp)
movl %ebx, %ebp
jmp 0x92e5
movq %r14, %rsi
callq *0x140(%rax)
movq %r14, %rdi
leaq 0x9f89(%rip), %rsi      # 0x131fa
callq 0x3240
testl %eax, %eax
movl %ebx, %ebp
je 0x92e1
movq %r14, %rdi
leaq 0x7f57(%rip), %rsi      # 0x111dd
callq 0x3240
testl %eax, %eax
je 0x92e1
movq %r14, %rdi
leaq 0xa4a0(%rip), %rsi      # 0x13739
callq 0x3240
testl %eax, %eax
je 0x92e1
movq %r14, %rdi
leaq 0x9ef8(%rip), %rsi      # 0x131a4
callq 0x3240
testl %eax, %eax
je 0x92db
movq %r14, %rdi
leaq 0x9bc0(%rip), %rsi      # 0x12e7f
callq 0x3240
testl %eax, %eax
je 0x92db
movq %r14, %rdi
leaq 0x9dff(%rip), %rsi      # 0x130d1
callq 0x3240
testl %eax, %eax
jne 0x92e5
decl 0x58(%rsp)
jmp 0x92e5
incl 0x58(%rsp)
movq 0x28(%r13), %r13
testq %r13, %r13
jne 0x9206
movq 0x18(%r12), %rax
movl 0x74(%rsp), %ecx
cmpl 0x48(%rax), %ecx
jne 0x9484
movq 0xfe75(%rip), %rax      # 0x19180
movq 0x107d6(%rip), %rdi     # 0x19ae8
callq *0x138(%rax)
movq 0x40(%rsp), %rdi
cmpw $0x0, 0x38(%rsp)
movl 0x88(%rsp), %r13d
je 0x93c4
testw %bp, %bp
je 0x93c4
testq %rdi, %rdi
je 0x93e1
movq 0x1079e(%rip), %rsi     # 0x19ae8
leaq 0x869a(%rip), %rdi      # 0x119eb
callq 0x3110
movq 0xfe23(%rip), %rax      # 0x19180
cmpw $0x0, 0x10(%rax)
je 0x9392
movq 0x1077d(%rip), %rdi     # 0x19ae8
leaq 0x8689(%rip), %rsi      # 0x119fb
movq $-0x1, %rdx
callq *0x100(%rax)
movq 0x10762(%rip), %rsi     # 0x19ae8
leaq 0x8162(%rip), %rdi      # 0x114ef
callq 0x3110
movq 0x1074f(%rip), %rsi     # 0x19ae8
leaq 0x8661(%rip), %rdi      # 0x11a01
callq 0x3110
movq 0x40(%rsp), %rdi
callq 0x9728
movq 0x10732(%rip), %rsi     # 0x19ae8
leaq 0x9ac2(%rip), %rdi      # 0x12e7f
callq 0x3110
jmp 0x93fc
callq 0x9728
jmp 0x93fc
movq %rsi, %rdi
leaq 0x880b(%rip), %rsi      # 0x11be0
xorl %eax, %eax
callq 0x3160
jmp 0x8e1e
movq 0xfd98(%rip), %rax      # 0x19180
movq 0x106f9(%rip), %rdi     # 0x19ae8
leaq 0x890a(%rip), %rsi      # 0x11d00
callq *0x140(%rax)
movq 0x106e5(%rip), %rdi     # 0x19ae8
movq 0xfd76(%rip), %rax      # 0x19180
callq *0x148(%rax)
movq 0xfd69(%rip), %rax      # 0x19180
movq 0x80(%rax), %rdi
movq 0x106c3(%rip), %rsi     # 0x19ae8
jmp 0x8e19
movq 0x28(%rsp), %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x35cd
jmp 0x8b9b
movl 0x3c(%rsp), %edi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x356b
jmp 0x86bd
movl 0x3c(%rsp), %edi
movq %r12, %rsi
movq %r15, %rdx
callq 0x362f
jmp 0x8807
movq 0xfb8a(%rip), %rax      # 0x18ff8
movq (%rax), %rdi
leaq 0x859b(%rip), %rsi      # 0x11a13
xorl %eax, %eax
callq 0x3160
jmp 0x8e1e
movq %r12, %rdi
callq 0x3691
jmp 0x9304
cmpb $0xa, %al
jne 0x8e1e
incl 0x1068d(%rip)           # 0x19b2c
jmp 0x8e1e
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq