// File: /workspace/github_c_makefile_star2_O2/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 $0xc8, %rsp
movl %r9d, %r13d
movl %r8d, %ebx
movq %rcx, 0xb8(%rsp)
movl %edx, 0x44(%rsp)
movq %rsi, %r12
movq %rdi, 0x88(%rsp)
testw %r13w, %r13w
je 0x76c1
leaq 0x930c(%rip), %rdi      # 0x1092a
callq 0x6126
testw %ax, %ax
je 0x76c1
movl %ebx, %edi
callq 0x39c6
movq 0x114ae(%rip), %rsi     # 0x18ae8
leaq 0x92f1(%rip), %rdi      # 0x10932
callq 0x3110
movq 0x1149b(%rip), %rdi     # 0x18ae8
movq 0xb8(%rsp), %rsi
callq 0x8cca
movq 0x11487(%rip), %rsi     # 0x18ae8
leaq 0x92d6(%rip), %rdi      # 0x1093e
callq 0x3110
movq 0x11474(%rip), %rdi     # 0x18ae8
movq 0x108(%rsp), %rsi
callq 0x8cca
movq 0x11460(%rip), %rdi     # 0x18ae8
cmpw $0x0, 0x44(%rsp)
leaq 0x92d3(%rip), %rax      # 0x10968
leaq 0x92c7(%rip), %rdx      # 0x10963
cmoveq %rax, %rdx
leaq 0x92a5(%rip), %rsi      # 0x1094c
xorl %eax, %eax
callq 0x3150
movq 0x11433(%rip), %rsi     # 0x18ae8
leaq 0xb185(%rip), %rdi      # 0x12841
callq 0x3110
leal 0x1(%rbx), %eax
movl %eax, 0x54(%rsp)
movq %rbx, 0x48(%rsp)
leal 0x2(%rbx), %eax
movl %eax, 0xb4(%rsp)
pushq $0x20
popq %rbp
movl %r13d, 0x34(%rsp)
testq %r12, %r12
je 0x8a67
andq $0x0, 0x38(%rsp)
andq $0x0, 0x68(%rsp)
andq $0x0, 0x58(%rsp)
andq $0x0, 0xa8(%rsp)
andq $0x0, 0xa0(%rsp)
movq 0x28(%r12), %rdx
leaq 0x68(%rsp), %rdi
movq 0xb8(%rsp), %rsi
callq 0x6378
movq 0x28(%r12), %rdx
leaq 0x58(%rsp), %rdi
movq 0x108(%rsp), %rsi
callq 0x6378
movl %eax, %ebx
testw %r13w, %r13w
je 0x77ea
leaq 0x91dd(%rip), %rdi      # 0x1092a
callq 0x6126
testw %ax, %ax
je 0x77ea
movq 0x48(%rsp), %rdi
callq 0x39c6
movq 0x1137c(%rip), %rsi     # 0x18ae8
leaq 0x91fb(%rip), %rdi      # 0x1096e
callq 0x3110
movq 0x11369(%rip), %rdi     # 0x18ae8
movq 0x68(%rsp), %rsi
callq 0x8cca
movq 0x11358(%rip), %rsi     # 0x18ae8
leaq 0x91e6(%rip), %rdi      # 0x1097d
callq 0x3110
movq 0x11345(%rip), %rdi     # 0x18ae8
movq 0x58(%rsp), %rsi
callq 0x8cca
movq 0x11334(%rip), %rdi     # 0x18ae8
testw %bx, %bx
leaq 0x91a5(%rip), %rdx      # 0x10963
leaq 0x91a3(%rip), %rax      # 0x10968
cmoveq %rax, %rdx
leaq 0x91bc(%rip), %rsi      # 0x1098c
xorl %eax, %eax
callq 0x3150
movq 0x1130a(%rip), %rsi     # 0x18ae8
leaq 0xb05c(%rip), %rdi      # 0x12841
callq 0x3110
movl 0x4(%r12), %eax
cmpq $0x6, %rax
ja 0x8336
movw %bx, 0x32(%rsp)
leaq 0x887b(%rip), %rcx      # 0x10080
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
movl %r13d, %r14d
movswl %r14w, %r13d
movswl 0x100(%rsp), %ebx
jmpq *%rax
movq 0x18(%r12), %rax
movl 0x38(%rax), %edx
cmpq $0x4, %rdx
ja 0x8a21
leaq 0x8866(%rip), %rsi      # 0x1009c
movslq (%rsi,%rdx,4), %rcx
addq %rsi, %rcx
movl 0x34(%rsp), %r13d
jmpq *%rcx
testw %r13w, %r13w
je 0x838f
movq 0x48(%rsp), %rdi
callq 0x39c6
movq 0x10921(%rip), %rax     # 0x18180
movq 0x38(%rax), %rdi
movq 0x1127e(%rip), %rsi     # 0x18ae8
callq 0x3110
movq 0x1090a(%rip), %rax     # 0x18180
movq 0x1126b(%rip), %rdi     # 0x18ae8
leaq 0x915e(%rip), %rsi      # 0x109e2
xorl %edx, %edx
xorl %ecx, %ecx
callq *0x130(%rax)
movq 0x108eb(%rip), %rax     # 0x18180
movq 0x1124c(%rip), %rdi     # 0x18ae8
callq *0x138(%rax)
movq 0x108d7(%rip), %rax     # 0x18180
movq 0x11238(%rip), %rdi     # 0x18ae8
movq 0x18(%r12), %rcx
movq (%rcx), %rdx
movq 0x28(%rcx), %rsi
callq *0x108(%rax)
movq 0x108b7(%rip), %rax     # 0x18180
movq 0x11218(%rip), %rdi     # 0x18ae8
callq *0x138(%rax)
movq 0x58(%rsp), %rdi
callq 0x8d1f
movq 0x10899(%rip), %rax     # 0x18180
movq 0x111fa(%rip), %rdi     # 0x18ae8
callq *0x138(%rax)
movq 0x58(%rsp), %rdi
cmpw $0x0, 0x44(%rsp)
movzwl 0x32(%rsp), %eax
je 0x83d2
testw %ax, %ax
je 0x83d2
testq %rdi, %rdi
je 0x8605
movq 0x111c5(%rip), %rsi     # 0x18ae8
leaq 0x9099(%rip), %rdi      # 0x109c3
callq 0x3110
movq 0x1084a(%rip), %rax     # 0x18180
cmpw $0x0, 0x10(%rax)
je 0x7967
movq 0x111a4(%rip), %rdi     # 0x18ae8
leaq 0x9088(%rip), %rsi      # 0x109d3
pushq $-0x1
popq %rdx
callq *0x100(%rax)
movq 0x1118d(%rip), %rsi     # 0x18ae8
leaq 0x8b65(%rip), %rdi      # 0x104c7
callq 0x3110
movq 0x1117a(%rip), %rsi     # 0x18ae8
leaq 0x9064(%rip), %rdi      # 0x109d9
callq 0x3110
movq 0x58(%rsp), %rdi
callq 0x8d1f
movq 0x1115d(%rip), %rsi     # 0x18ae8
leaq 0xa4cd(%rip), %rdi      # 0x11e5f
callq 0x3110
jmp 0x8620
movq 0x18(%r12), %rsi
movq 0x68(%rsp), %rcx
movq 0x107d3(%rip), %rax     # 0x18180
movq 0x28(%rax), %r9
movq 0x30(%rax), %rax
movq 0x58(%rsp), %rdx
movswl (%r12), %edi
movl %edi, 0x20(%rsp)
movq 0x110(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movl %r13d, 0x8(%rsp)
movq %rax, (%rsp)
movswl 0x44(%rsp), %edx
movq 0x88(%rsp), %rdi
movq 0x48(%rsp), %r8
callq 0x715c
movl %r14d, %r13d
jmp 0x8336
movq 0x18(%r12), %rdx
leaq 0x38(%rsp), %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x6378
movl %eax, %r14d
movq 0x38(%rsp), %rsi
leaq 0x58(%rsp), %rdi
callq 0x651d
movq 0x38(%rsp), %r8
movswl %r14w, %r14d
movl %ebx, %edi
movl %r13d, %esi
movl %r14d, %edx
movq 0x48(%rsp), %rcx
movq 0x110(%rsp), %r9
callq 0x8e57
testw %r14w, %r14w
je 0x7f9b
movq 0x68(%rsp), %rsi
movq %r15, %rdi
callq 0x651d
movq 0x38(%rsp), %rsi
movq %rsi, 0xa0(%rsp)
jmp 0x7fc2
testw %r14w, %r14w
je 0x7aa2
movq 0x48(%rsp), %rbx
movl %ebx, %edi
callq 0x39c6
movq 0x106f8(%rip), %rax     # 0x18180
movq 0xa0(%rax), %rdi
movq 0x11052(%rip), %rsi     # 0x18ae8
callq 0x3110
movl %ebx, %edi
callq 0x3a00
andq $0x0, 0x80(%rsp)
andq $0x0, 0x98(%rsp)
movq 0x18(%r12), %rax
movq 0x18(%rax), %rbx
movq 0x28(%rax), %rax
movq 0x18(%rax), %r14
movq 0x68(%rsp), %rsi
leaq 0x98(%rsp), %rdi
movq %rbx, %rdx
callq 0x6378
movw %ax, 0x70(%rsp)
movq 0x98(%rsp), %rsi
leaq 0x80(%rsp), %r15
movq %r15, %rdi
movq %r14, %rdx
callq 0x6378
movq 0x68(%rsp), %rsi
movq %r15, %rdi
callq 0x651d
andq $0x0, 0x90(%rsp)
leaq 0x90(%rsp), %r15
movq %r15, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x6378
testw %ax, %ax
je 0x7b37
movq %r15, %rdi
xorl %esi, %esi
movq %rbx, %rdx
callq 0x6378
cmpw $0x0, 0x44(%rsp)
movq %r15, %rdi
setne %r15b
movq 0x58(%rsp), %rsi
callq 0x651d
cmpw $0x0, 0x32(%rsp)
setne %al
andb %r15b, %al
movq 0x80(%rsp), %rcx
movq 0x90(%rsp), %rdx
movq 0x110(%rsp), %rsi
movq %rsi, 0x10(%rsp)
orl $-0x1, (%rsp)
movq %rdx, 0x8(%rsp)
movzbl %al, %edx
movq 0x88(%rsp), %rdi
movq %rbx, %rsi
movl 0x54(%rsp), %r8d
movl %r13d, %r9d
callq 0x75df
movq 0x90(%rsp), %rdi
xorl %esi, %esi
callq 0xb397
movq 0x80(%rsp), %rdi
xorl %esi, %esi
callq 0xb397
movq 0x98(%rsp), %rdi
xorl %esi, %esi
callq 0xb397
andq $0x0, 0x80(%rsp)
movq 0x68(%rsp), %rsi
leaq 0x80(%rsp), %rdi
movq %rbx, %rdx
callq 0x6378
movq 0x80(%rsp), %rsi
leaq 0x38(%rsp), %rdi
movq %r14, %rdx
callq 0x6378
movq 0x80(%rsp), %rdi
xorl %esi, %esi
callq 0xb397
movq 0x38(%rsp), %rdi
cmpw $0x0, 0x34(%rsp)
je 0x8173
movq 0x68(%rsp), %rsi
callq 0x902e
testq %rax, %rax
je 0x7c44
movq %rax, %r15
cmpw $0x0, 0x20(%r12)
je 0x895d
movq %r15, %rdi
xorl %esi, %esi
callq 0xb397
movl 0x54(%rsp), %r15d
movl %r15d, %edi
callq 0x39c6
movq 0x38(%rsp), %rdi
movswl (%r12), %eax
movl %eax, (%rsp)
leaq 0xfec(%rip), %rsi       # 0x8c51
movq 0x48(%rsp), %rdx
xorl %ecx, %ecx
movl %r13d, %r8d
xorl %r9d, %r9d
callq 0x8a79
movl %r15d, %edi
callq 0x3a00
movl 0xb4(%rsp), %edi
callq 0x908f
movl %r15d, %edi
callq 0x3a30
jmp 0x8194
movq 0x18(%r12), %rdx
leaq 0x38(%rsp), %rdi
xorl %esi, %esi
callq 0x6378
movq 0x38(%rsp), %r8
movl %ebx, %edi
movl %r13d, %esi
pushq $-0x1
popq %r15
movl %r15d, %edx
movq 0x48(%rsp), %rbx
movl %ebx, %ecx
movq 0x110(%rsp), %r9
callq 0x8e57
andq $0x0, 0xa8(%rsp)
testw %r14w, %r14w
je 0x82ac
movl %ebx, %edi
callq 0x39c6
movq 0x38(%rsp), %rdi
movswl (%r12), %eax
movl %eax, (%rsp)
leaq 0xf55(%rip), %rsi       # 0x8c51
movl %ebx, %edx
movl %r15d, %ecx
movl %r13d, %r8d
xorl %r9d, %r9d
callq 0x8a79
movl %ebx, %edi
callq 0x3a00
movq 0x38(%rsp), %rdi
movq 0x68(%rsp), %rsi
callq 0x902e
testq %rax, %rax
je 0x82d0
movq %rax, %rbx
movq 0x18(%r12), %rax
cmpw $0x0, 0x20(%rax)
je 0x89c6
movq %rbx, %rdi
xorl %esi, %esi
callq 0xb397
jmp 0x82d0
leaq 0x38(%rsp), %rdi
movq %r12, %rsi
callq 0x90c1
testw %r14w, %r14w
je 0x7e8e
movq 0x48(%rsp), %rbx
movl %ebx, %edi
callq 0x39c6
movq 0x38(%rsp), %rdi
movswl (%r12), %eax
movl %eax, (%rsp)
leaq 0xecd(%rip), %rsi       # 0x8c51
movl %ebx, %edx
pushq $-0x1
popq %rcx
movl %r13d, %r8d
xorl %r9d, %r9d
callq 0x8a79
movl %ebx, %edi
callq 0x3a00
movl 0x54(%rsp), %edi
callq 0x908f
jmp 0x7e85
leaq 0x38(%rsp), %rdi
movq %r12, %rsi
callq 0x90c1
testw %r14w, %r14w
je 0x7e8e
movq 0x48(%rsp), %rbx
movl %ebx, %edi
callq 0x39c6
movq 0x38(%rsp), %rdi
movswl (%r12), %eax
movl %eax, (%rsp)
leaq 0xe71(%rip), %rsi       # 0x8c51
movl %ebx, %edx
pushq $-0x1
popq %rcx
movl %r13d, %r8d
xorl %r9d, %r9d
callq 0x8a79
movl %ebx, %edi
callq 0x3a00
movl 0x54(%rsp), %edi
callq 0x39c6
movq 0x10379(%rip), %rax     # 0x18180
movq 0x10cda(%rip), %rdi     # 0x18ae8
leaq 0x8d83(%rip), %rsi      # 0x10b98
xorl %edx, %edx
xorl %ecx, %ecx
callq *0x130(%rax)
movq 0x1035a(%rip), %rax     # 0x18180
movq 0x10cbb(%rip), %rdi     # 0x18ae8
callq *0x138(%rax)
movq 0x10346(%rip), %rax     # 0x18180
movq 0x10ca7(%rip), %rdi     # 0x18ae8
movq 0x18(%r12), %rcx
movq 0x28(%rcx), %rcx
movq 0x18(%rcx), %rcx
movq (%rcx), %rsi
callq *0x140(%rax)
movq 0x10322(%rip), %rax     # 0x18180
movq 0x10c83(%rip), %rdi     # 0x18ae8
callq *0x148(%rax)
movq 0x1030e(%rip), %rax     # 0x18180
movq 0x80(%rax), %rdi
movq 0x10c68(%rip), %rsi     # 0x18ae8
callq 0x3110
movl %ebx, %edi
callq 0x3a30
jmp 0x7eb5
movq 0x38(%rsp), %rdi
movswl (%r12), %eax
movl %eax, (%rsp)
leaq 0xdaf(%rip), %rsi       # 0x8c51
movq 0x48(%rsp), %rdx
pushq $-0x1
popq %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x8a79
movl 0x34(%rsp), %r13d
jmp 0x8336
testw %r13w, %r13w
je 0x8336
leaq 0x851b(%rip), %rdi      # 0x103eb
callq 0x6126
testw %ax, %ax
je 0x7f0e
movswl (%r12), %edx
cmpl %edx, 0x10c47(%rip)     # 0x18b2c
je 0x7f0e
movq 0x10bfa(%rip), %rdi     # 0x18ae8
movq 0x10293(%rip), %rcx     # 0x18188
leaq 0x84f4(%rip), %rsi      # 0x103f0
xorl %eax, %eax
callq 0x3150
movswl (%r12), %eax
movl %eax, 0x10c1e(%rip)     # 0x18b2c
movq 0x18(%r12), %rax
movl 0x38(%rax), %ecx
cmpl $0x3, %ecx
je 0x83e3
cmpl $0x2, %ecx
jne 0x8336
movq 0x48(%rsp), %rdi
callq 0x39c6
movq 0x18(%r12), %rax
movq (%rax), %rdi
leaq 0xa1c5(%rip), %rsi      # 0x12106
callq 0x3240
movq 0x10b9b(%rip), %rsi     # 0x18ae8
testl %eax, %eax
je 0x889d
leaq 0x8c77(%rip), %rdi      # 0x10bd3
callq 0x3110
movq 0x18(%r12), %rax
movq (%rax), %rdi
leaq 0x1(%rdi), %rbx
callq 0x30d0
leaq -0x2(%rax), %rdx
movq 0x10b6b(%rip), %rcx     # 0x18ae8
movq %rbx, %rdi
pushq $0x1
popq %rsi
callq 0x3210
movq 0x10b59(%rip), %rsi     # 0x18ae8
leaq 0x8c46(%rip), %rdi      # 0x10bdc
jmp 0x88f7
movq 0x38(%rsp), %rsi
leaq 0xa0(%rsp), %rbx
movq %rbx, %rdi
callq 0x651d
movq 0x68(%rsp), %rsi
movq %rbx, %rdi
callq 0x651d
movq 0x38(%rsp), %rsi
leaq 0xa8(%rsp), %rdi
callq 0x651d
movzwl 0x32(%rsp), %ebx
movswl %bx, %eax
movl %eax, 0x70(%rsp)
cmpw $0x0, 0x34(%rsp)
je 0x80b7
cmpw $0x0, 0x44(%rsp)
setne %r14b
movq 0x48(%rsp), %r15
movl %r15d, %edi
callq 0x39c6
movq 0x1017b(%rip), %rax     # 0x18180
movq 0x10adc(%rip), %rdi     # 0x18ae8
movl %r15d, %esi
callq *0xb0(%rax)
movq 0x18(%r12), %rsi
testw %bx, %bx
setne %al
andb %r14b, %al
movq 0xa0(%rsp), %rcx
movq 0x58(%rsp), %rdx
movq 0x110(%rsp), %rbx
movq %rbx, 0x10(%rsp)
andl $0x0, (%rsp)
movq %rdx, 0x8(%rsp)
movzbl %al, %edx
movq 0x88(%rsp), %rdi
movl 0x54(%rsp), %r15d
movl %r15d, %r8d
movl %r13d, %r9d
callq 0x75df
movq 0x58(%rsp), %r8
pushq $-0x1
popq %r14
movl %r14d, %edi
movl %r13d, %esi
movl 0x70(%rsp), %edx
movl %r15d, %ecx
movq %rbx, %r9
callq 0x8e57
movq 0x38(%rsp), %rdi
movq 0x68(%rsp), %rsi
callq 0x902e
testq %rax, %rax
je 0x8128
movq %rax, %rbx
cmpw $0x0, 0x20(%r12)
je 0x8901
movq %rbx, %rdi
xorl %esi, %esi
callq 0xb397
pushq $-0x1
popq %r14
jmp 0x8128
cmpw $0x0, 0x44(%rsp)
setne %al
movq 0x18(%r12), %rsi
testw %bx, %bx
setne %dl
andb %al, %dl
movq 0xa0(%rsp), %rcx
movq 0x58(%rsp), %rax
movq 0x110(%rsp), %rbx
movq %rbx, 0x10(%rsp)
andl $0x0, (%rsp)
movq %rax, 0x8(%rsp)
movzbl %dl, %edx
movq 0x88(%rsp), %rdi
movl 0x54(%rsp), %r15d
movl %r15d, %r8d
xorl %r9d, %r9d
callq 0x75df
movq 0x58(%rsp), %r8
pushq $-0x1
popq %r14
movl %r14d, %edi
xorl %esi, %esi
movl 0x70(%rsp), %edx
movl %r15d, %ecx
movq %rbx, %r9
callq 0x8e57
movq 0x38(%rsp), %rdi
movswl (%r12), %eax
movl %eax, (%rsp)
leaq 0xf38(%rip), %rsi       # 0x9074
movq 0x48(%rsp), %rdx
movl %r14d, %ecx
movl %r13d, %r8d
xorl %r9d, %r9d
callq 0x8a79
movq 0xa0(%rsp), %rdi
cmpq 0x38(%rsp), %rdi
movl 0x34(%rsp), %r13d
je 0x8336
xorl %esi, %esi
callq 0xb397
jmp 0x8336
movswl (%r12), %eax
movl %eax, (%rsp)
leaq 0xacf(%rip), %rsi       # 0x8c51
movq 0x48(%rsp), %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x8a79
andq $0x0, 0x80(%rsp)
andq $0x0, 0x98(%rsp)
leaq 0x98(%rsp), %r15
movq %r15, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x6378
movq 0x68(%rsp), %rsi
movq %r15, %rdi
callq 0x651d
movq 0x98(%rsp), %rsi
leaq 0x80(%rsp), %rdi
movq %rbx, %rdx
callq 0x6378
andq $0x0, 0x90(%rsp)
leaq 0x90(%rsp), %r15
movq %r15, %rdi
xorl %esi, %esi
movq %rbx, %rdx
callq 0x6378
testw %ax, %ax
je 0x821d
movq %r15, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x6378
movq 0x58(%rsp), %rsi
movq %r15, %rdi
callq 0x651d
cmpw $0x0, 0x32(%rsp)
setne %al
cmpw $0x0, 0x44(%rsp)
setne %dl
cmpw $0x0, 0x70(%rsp)
setne %cl
andb %al, %dl
andb %cl, %dl
movq 0x80(%rsp), %rcx
movq 0x90(%rsp), %rax
movq 0x110(%rsp), %rsi
movq %rsi, 0x10(%rsp)
andl $0x0, (%rsp)
movq %rax, 0x8(%rsp)
movzbl %dl, %edx
movq 0x88(%rsp), %rdi
movq %r14, %rsi
movl 0x54(%rsp), %r8d
movl %r13d, %r9d
callq 0x75df
movq 0x90(%rsp), %rdi
xorl %esi, %esi
callq 0xb397
movq 0x80(%rsp), %rdi
xorl %esi, %esi
callq 0xb397
movq 0x98(%rsp), %rdi
xorl %esi, %esi
callq 0xb397
jmp 0x8321
movq 0x38(%rsp), %rdi
movswl (%r12), %eax
movl %eax, (%rsp)
leaq 0x991(%rip), %rsi       # 0x8c51
movl %ebx, %edx
movl %r15d, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x8a79
cmpw $0x0, 0x44(%rsp)
setne %al
movq 0x18(%r12), %rsi
cmpw $0x0, 0x32(%rsp)
setne %dl
andb %al, %dl
movq 0x68(%rsp), %rcx
movq 0x58(%rsp), %rax
movq 0x110(%rsp), %rdi
movq %rdi, 0x10(%rsp)
andl $0x0, (%rsp)
movq %rax, 0x8(%rsp)
movzbl %dl, %edx
movq 0x88(%rsp), %rdi
movl 0x54(%rsp), %r8d
movl %r13d, %r9d
callq 0x75df
movl 0x34(%rsp), %r13d
testw %r13w, %r13w
je 0x8336
movq 0x48(%rsp), %rdi
callq 0x3a30
movq 0x28(%r12), %r12
movq 0x68(%rsp), %rdi
xorl %esi, %esi
callq 0xb397
movq 0x38(%rsp), %rdi
xorl %esi, %esi
callq 0xb397
movq 0xa8(%rsp), %rdi
xorl %esi, %esi
callq 0xb397
movq 0x58(%rsp), %rdi
xorl %esi, %esi
callq 0xb397
jmp 0x76df
testw %r13w, %r13w
je 0x838f
movq 0x50(%rax), %rax
testq %rax, %rax
je 0x84fd
movq 0x8(%rax), %rax
jmp 0x84ff
cmpw $0x0, 0x44(%rsp)
setne %al
cmpw $0x0, 0x32(%rsp)
setne %cl
movq 0x58(%rsp), %rsi
testq %rsi, %rsi
setne %dl
andb %al, %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x83c1
movq 0x110(%rsp), %rax
orw $-0x1, (%rax)
movq 0x10720(%rip), %rdi     # 0x18ae8
callq 0x8da7
jmp 0x8336
callq 0x8d1f
leaq 0x858a(%rip), %rbx      # 0x10968
jmp 0x8627
movq (%rax), %r15
movq 0x48(%rsp), %rdi
callq 0x39c6
movl 0x10736(%rip), %esi     # 0x18b2c
movzbl 0x10713(%rip), %ecx     # 0x18b10
leal 0x4(,%rcx,4), %edi
orl $0x2, %ecx
leaq 0x1(%r15), %r8
xorl %ebx, %ebx
movzbl -0x1(%r8), %eax
cmpl $0x9, %eax
je 0x8434
cmpl $0xa, %eax
je 0x8425
cmpl $0x20, %eax
jne 0x848e
incl %ebx
jmp 0x843f
incl %esi
movl %esi, 0x106ff(%rip)     # 0x18b2c
xorl %ebx, %ebx
movq %r8, %r15
jmp 0x843f
movl %ebx, %eax
cltd
idivl %edi
movl %eax, %ebx
incl %ebx
shll %cl, %ebx
incq %r8
jmp 0x840d
subl %ebx, %r14d
movq 0x48(%rsp), %rdi
callq 0x39c6
testl %r14d, %r14d
jle 0x8475
movq 0x1068b(%rip), %rsi     # 0x18ae8
movl %ebp, %edi
callq 0x3120
decl %r14d
jmp 0x8451
movq 0x10678(%rip), %rsi     # 0x18ae8
callq 0x3120
movzbl (%r15), %eax
movsbl %al, %edi
testl %eax, %eax
je 0x848e
incq %r15
cmpl $0xa, %eax
jne 0x8469
incl 0x1069e(%rip)           # 0x18b2c
movb (%r15), %al
testb %al, %al
je 0x8336
movzbl 0x10670(%rip), %ecx     # 0x18b10
leal 0x4(,%rcx,4), %esi
orl $0x2, %ecx
xorl %r14d, %r14d
cmpb $0x9, %al
je 0x84be
movzbl %al, %eax
cmpl $0x20, %eax
jne 0x84d6
incl %r14d
jmp 0x84cd
movl %r14d, %eax
cltd
idivl %esi
movl %eax, %r14d
incl %r14d
shll %cl, %r14d
movb 0x1(%r15), %al
incq %r15
jmp 0x84ad
testl %eax, %eax
je 0x8336
cmpl $0xa, %eax
jne 0x8444
cmpb $0x0, 0x1(%r15)
jne 0x8444
incl 0x10634(%rip)           # 0x18b2c
jmp 0x8336
xorl %eax, %eax
movq %rax, 0x70(%rsp)
movq 0x10(%r12), %rax
testq %rax, %rax
je 0x8547
movq 0x88(%rsp), %rcx
movq 0x50(%rcx), %rcx
testq %rcx, %rcx
je 0x8547
movq (%rcx), %rcx
testq %rcx, %rcx
je 0x8547
movq (%rax), %rdi
movq (%rcx), %rsi
callq 0x3240
testl %eax, %eax
movl $0x0, %eax
movq 0x70(%rsp), %rcx
cmoveq %rax, %rcx
movq %rcx, 0x70(%rsp)
movq 0x48(%rsp), %rdi
callq 0x39c6
movq 0x10590(%rip), %rbx     # 0x18ae8
movq 0x18(%r12), %rax
movq (%rax), %rcx
movq 0x8(%r12), %r13
movq 0x10(%r12), %r14
testq %r13, %r13
setne %dl
testq %r14, %r14
movq %rcx, 0xc0(%rsp)
movb %dl, 0x67(%rsp)
je 0x85b5
movq 0x88(%rsp), %rax
movq 0x50(%rax), %rax
testq %rax, %rax
je 0x85b5
movl $0x0, 0x7c(%rsp)
movq (%rax), %rax
testq %rax, %rax
je 0x85bd
movq (%r14), %rdi
movq (%rax), %rsi
callq 0x3240
testl %eax, %eax
sete %r15b
jmp 0x85c0
movl $0x0, 0x7c(%rsp)
xorl %r15d, %r15d
movq 0xfbb9(%rip), %rax      # 0x18180
movq 0x38(%rax), %rdi
movq %rbx, %rsi
callq 0x3110
movq 0xfba6(%rip), %rax      # 0x18180
movq 0x130(%rax), %rax
movq 0x70(%rsp), %rcx
testq %rcx, %rcx
je 0x86e1
movl $0x0, %edx
testb %r15b, %r15b
jne 0x86e3
movq (%rcx), %rdx
jmp 0x86e3
movq 0xfb74(%rip), %rax      # 0x18180
movq 0x104d5(%rip), %rdi     # 0x18ae8
leaq 0x86be(%rip), %rsi      # 0x10cd8
callq *0x140(%rax)
leaq 0x833c(%rip), %rbx      # 0x10963
movq 0xfb52(%rip), %rax      # 0x18180
movq 0x104b3(%rip), %rdi     # 0x18ae8
callq *0x138(%rax)
movq 0xfb3e(%rip), %rax      # 0x18180
movq 0x1049f(%rip), %rdi     # 0x18ae8
movq %rbx, %rsi
callq *0x140(%rax)
movq 0xfb27(%rip), %rax      # 0x18180
movq 0x10488(%rip), %rdi     # 0x18ae8
callq *0x148(%rax)
movq 0xfb13(%rip), %rax      # 0x18180
movq 0x80(%rax), %rdi
movq 0x1046d(%rip), %rsi     # 0x18ae8
callq 0x3110
movq 0x10(%r12), %rbx
testq %rbx, %rbx
je 0x8336
movq 0x88(%rsp), %rax
movq 0x50(%rax), %rax
testq %rax, %rax
je 0x86bb
movq (%rax), %rax
testq %rax, %rax
je 0x86bb
movq (%rbx), %rdi
movq (%rax), %rsi
callq 0x3240
xorl %ecx, %ecx
testl %eax, %eax
sete %cl
jmp 0x86bd
xorl %ecx, %ecx
movq 0xfabc(%rip), %rax      # 0x18180
movq 0x1041d(%rip), %rdi     # 0x18ae8
movzwl %cx, %ecx
movq 0x48(%rsp), %rsi
movq %rbx, %rdx
callq *0x160(%rax)
jmp 0x8336
xorl %edx, %edx
testq %r14, %r14
je 0x86ed
movq (%r14), %rcx
jmp 0x86ef
xorl %ecx, %ecx
movl 0x7c(%rsp), %esi
movb 0x67(%rsp), %dil
movb %dil, %sil
movl %esi, 0x7c(%rsp)
movq %rbx, %rdi
movq 0xc0(%rsp), %rsi
callq *%rax
movl $0x0, 0x70(%rsp)
testq %r13, %r13
je 0x87c6
movq 0x18(%r13), %r14
movswl (%r13), %r15d
subl $0x1, %r15d
jb 0x8738
movl %ebp, %edi
movq %rbx, %rsi
callq 0x3120
jmp 0x8726
cmpb $0x2c, (%r14)
jne 0x8770
cmpb $0x0, 0x1(%r14)
sete %al
cmpl $0x0, 0x70(%rsp)
sete %cl
testb %cl, %al
je 0x8770
movq 0xfa27(%rip), %rax      # 0x18180
movq %rbx, %rdi
callq *0x138(%rax)
incl 0x7c(%rsp)
movl $0x0, 0x70(%rsp)
jmp 0x87bd
movq 0xfa09(%rip), %rax      # 0x18180
movq %rbx, %rdi
movq %r14, %rsi
callq *0x140(%rax)
movzbl (%r14), %eax
cmpl $0x28, %eax
je 0x87a5
cmpl $0x29, %eax
je 0x87b2
cmpl $0x5b, %eax
je 0x87a5
cmpl $0x5d, %eax
je 0x87b2
cmpl $0x7d, %eax
je 0x87b2
cmpl $0x7b, %eax
jne 0x87bd
cmpb $0x0, 0x1(%r14)
jne 0x87bd
incl 0x70(%rsp)
jmp 0x87bd
cmpb $0x0, 0x1(%r14)
jne 0x87bd
decl 0x70(%rsp)
movq 0x28(%r13), %r13
jmp 0x8714
movq 0x18(%r12), %rax
movl 0x7c(%rsp), %ecx
cmpl 0x48(%rax), %ecx
jne 0x8a3e
movq 0xf9a1(%rip), %rax      # 0x18180
movq 0x10302(%rip), %rdi     # 0x18ae8
callq *0x138(%rax)
movq 0x58(%rsp), %rdi
cmpw $0x0, 0x44(%rsp)
movl 0x34(%rsp), %r13d
movzwl 0x32(%rsp), %eax
je 0x8896
testw %ax, %ax
je 0x8896
testq %rdi, %rdi
je 0x88b3
movq 0x102c8(%rip), %rsi     # 0x18ae8
leaq 0x819c(%rip), %rdi      # 0x109c3
callq 0x3110
movq 0xf94d(%rip), %rax      # 0x18180
cmpw $0x0, 0x10(%rax)
je 0x8864
movq 0x102a7(%rip), %rdi     # 0x18ae8
leaq 0x818b(%rip), %rsi      # 0x109d3
pushq $-0x1
popq %rdx
callq *0x100(%rax)
movq 0x10290(%rip), %rsi     # 0x18ae8
leaq 0x7c68(%rip), %rdi      # 0x104c7
callq 0x3110
movq 0x1027d(%rip), %rsi     # 0x18ae8
leaq 0x8167(%rip), %rdi      # 0x109d9
callq 0x3110
movq 0x58(%rsp), %rdi
callq 0x8d1f
movq 0x10260(%rip), %rsi     # 0x18ae8
leaq 0x95d0(%rip), %rdi      # 0x11e5f
callq 0x3110
jmp 0x88ce
callq 0x8d1f
jmp 0x88ce
movq %rsi, %rdi
leaq 0x8311(%rip), %rsi      # 0x10bb8
xorl %eax, %eax
callq 0x3150
jmp 0x8336
movq 0xf8c6(%rip), %rax      # 0x18180
movq 0x10227(%rip), %rdi     # 0x18ae8
leaq 0x8410(%rip), %rsi      # 0x10cd8
callq *0x140(%rax)
movq 0x10213(%rip), %rdi     # 0x18ae8
movq 0xf8a4(%rip), %rax      # 0x18180
callq *0x148(%rax)
movq 0xf897(%rip), %rax      # 0x18180
movq 0x80(%rax), %rdi
movq 0x101f1(%rip), %rsi     # 0x18ae8
callq 0x3110
jmp 0x8336
movq 0x48(%rsp), %rdi
callq 0x39c6
movq 0x101d6(%rip), %rsi     # 0x18ae8
leaq 0x8179(%rip), %rdi      # 0x10a92
callq 0x3110
movq 0xf6d3(%rip), %r14      # 0x17ff8
movq (%r14), %rdi
movq 0xf859(%rip), %rdx      # 0x18188
movswl (%r12), %ecx
leaq 0x8199(%rip), %rsi      # 0x10ad4
xorl %eax, %eax
callq 0x3150
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x8cca
movq (%r14), %rsi
pushq $0xa
popq %rdi
callq 0x3120
jmp 0x80a7
movl 0x54(%rsp), %edi
callq 0x39c6
movq 0x1017b(%rip), %rsi     # 0x18ae8
leaq 0x81a4(%rip), %rdi      # 0x10b18
callq 0x3110
movq 0xf678(%rip), %rax      # 0x17ff8
movq (%rax), %rdi
movq 0xf7fe(%rip), %rdx      # 0x18188
movswl (%r12), %ecx
leaq 0x81c1(%rip), %rsi      # 0x10b57
xorl %eax, %eax
callq 0x3150
movq 0xf654(%rip), %rax      # 0x17ff8
movq (%rax), %rdi
movq %r15, %rsi
callq 0x8cca
movq 0xf642(%rip), %rax      # 0x17ff8
movq (%rax), %rsi
pushq $0xa
popq %rdi
callq 0x3120
jmp 0x7c3a
movl 0x54(%rsp), %edi
callq 0x39c6
movq 0x10112(%rip), %rsi     # 0x18ae8
leaq 0x8032(%rip), %rdi      # 0x10a0f
callq 0x3110
movq 0xf60f(%rip), %r14      # 0x17ff8
movq (%r14), %rdi
movq 0xf795(%rip), %rdx      # 0x18188
movswl (%r12), %ecx
leaq 0x8051(%rip), %rsi      # 0x10a50
xorl %eax, %eax
callq 0x3150
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x8cca
movq (%r14), %rsi
pushq $0xa
popq %rdi
callq 0x3120
jmp 0x7d3e
movq 0xf5d0(%rip), %rax      # 0x17ff8
movq (%rax), %rdi
leaq 0x7fb9(%rip), %rsi      # 0x109eb
xorl %eax, %eax
callq 0x3150
jmp 0x7eb5
movq 0xf5b3(%rip), %rax      # 0x17ff8
movq (%rax), %rdi
movq 0xf739(%rip), %rdx      # 0x18188
movswl (%r12), %ecx
leaq 0x7f3e(%rip), %rsi      # 0x10999
xorl %eax, %eax
callq 0x3150
jmp 0x87d8
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq