// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
movw %r9w, %ax
movq 0x20(%rbp), %r9
movq 0x18(%rbp), %r9
movw 0x10(%rbp), %r9w
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movw %dx, -0x22(%rbp)
movq %rcx, -0x30(%rbp)
movl %r8d, -0x34(%rbp)
movw %ax, -0x36(%rbp)
movl $0x1, -0x3c(%rbp)
movswl -0x36(%rbp), %eax
cmpl $0x0, %eax
je 0x99e0
leaq 0x10094(%rip), %rdi     # 0x199d6
callq 0x4940
cwtl
cmpl $0x0, %eax
je 0x99e0
movl -0x34(%rbp), %edi
callq 0x4000
movq 0x173d8(%rip), %rsi     # 0x20d38
leaq 0x10077(%rip), %rdi     # 0x199de
callq 0x3100
movq 0x173c5(%rip), %rdi     # 0x20d38
movq -0x30(%rbp), %rsi
callq 0xaff0
movq 0x173b5(%rip), %rsi     # 0x20d38
leaq 0x10060(%rip), %rdi     # 0x199ea
callq 0x3100
movq 0x173a2(%rip), %rdi     # 0x20d38
movq 0x18(%rbp), %rsi
callq 0xaff0
movq 0x17392(%rip), %rdi     # 0x20d38
movswl -0x22(%rbp), %ecx
leaq 0x10063(%rip), %rdx     # 0x19a14
leaq 0x10057(%rip), %rax     # 0x19a0f
cmpl $0x0, %ecx
cmovneq %rax, %rdx
leaq 0x10032(%rip), %rsi     # 0x199f8
movb $0x0, %al
callq 0x3140
movq 0x17364(%rip), %rsi     # 0x20d38
leaq 0x11ea2(%rip), %rdi     # 0x1b87d
callq 0x3100
jmp 0x99e2
cmpq $0x0, -0x20(%rbp)
je 0xad19
movq $0x0, -0x70(%rbp)
movq $0x0, -0x78(%rbp)
movq $0x0, -0x80(%rbp)
movq $0x0, -0x88(%rbp)
movq $0x0, -0x90(%rbp)
movq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rdx
leaq -0x78(%rbp), %rdi
callq 0x5ba0
movq 0x18(%rbp), %rsi
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rdx
leaq -0x80(%rbp), %rdi
callq 0x5ba0
movw %ax, -0x64(%rbp)
movswl -0x36(%rbp), %eax
cmpl $0x0, %eax
je 0x9afb
leaq 0xff79(%rip), %rdi      # 0x199d6
callq 0x4940
cwtl
cmpl $0x0, %eax
je 0x9afb
movl -0x34(%rbp), %edi
callq 0x4000
movq 0x172bd(%rip), %rsi     # 0x20d38
leaq 0xff98(%rip), %rdi      # 0x19a1a
callq 0x3100
movq 0x172aa(%rip), %rdi     # 0x20d38
movq -0x78(%rbp), %rsi
callq 0xaff0
movq 0x1729a(%rip), %rsi     # 0x20d38
leaq 0xff84(%rip), %rdi      # 0x19a29
callq 0x3100
movq 0x17287(%rip), %rdi     # 0x20d38
movq -0x80(%rbp), %rsi
callq 0xaff0
movq 0x17277(%rip), %rdi     # 0x20d38
movswl -0x64(%rbp), %ecx
leaq 0xff48(%rip), %rdx      # 0x19a14
leaq 0xff3c(%rip), %rax      # 0x19a0f
cmpl $0x0, %ecx
cmovneq %rax, %rdx
leaq 0xff57(%rip), %rsi      # 0x19a38
movb $0x0, %al
callq 0x3140
movq 0x17249(%rip), %rsi     # 0x20d38
leaq 0x11d87(%rip), %rdi     # 0x1b87d
callq 0x3100
movq -0x20(%rbp), %rax
movl 0x4(%rax), %eax
movq %rax, -0xd8(%rbp)
subq $0x6, %rax
ja 0xacd1
movq -0xd8(%rbp), %rax
leaq 0xf657(%rip), %rcx      # 0x19178
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
cmpl $0x0, 0x38(%rax)
jne 0x9e29
cmpw $0x0, -0x36(%rbp)
je 0x9df2
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x50(%rax), %rax
movq %rax, -0x98(%rbp)
cmpq $0x0, -0x98(%rbp)
jne 0x9b6f
xorl %eax, %eax
movq %rax, -0xe0(%rbp)
jmp 0x9b81
movq -0x98(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0xe0(%rbp)
movq -0xe0(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0xa8(%rbp)
xorl %eax, %eax
cmpq $0x0, -0xa8(%rbp)
movb %al, -0xe1(%rbp)
je 0x9c02
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, 0x50(%rcx)
movb %al, -0xe1(%rbp)
je 0x9c02
movq -0x18(%rbp), %rax
movq 0x50(%rax), %rcx
xorl %eax, %eax
cmpq $0x0, (%rcx)
movb %al, -0xe1(%rbp)
je 0x9c02
movq -0xa8(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x50(%rax), %rax
movq (%rax), %rax
movq (%rax), %rsi
callq 0x3220
cmpl $0x0, %eax
sete %al
movb %al, -0xe1(%rbp)
movb -0xe1(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movw %ax, -0xaa(%rbp)
movl -0x34(%rbp), %edi
callq 0x4000
movq 0x17115(%rip), %rax     # 0x20d38
movq %rax, -0x100(%rbp)
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq %rax, -0xf8(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0xf0(%rbp)
movswl -0xaa(%rbp), %eax
cmpl $0x0, %eax
je 0x9c62
xorl %eax, %eax
movq %rax, -0x108(%rbp)
jmp 0x9c70
movq -0xa0(%rbp), %rax
movq %rax, -0x108(%rbp)
movq -0xf0(%rbp), %rdx
movq -0xf8(%rbp), %rsi
movq -0x100(%rbp), %rdi
movq -0x108(%rbp), %rcx
movq -0x20(%rbp), %rax
movq 0x10(%rax), %r8
movq -0x18(%rbp), %r9
callq 0xb070
movl %eax, -0xb0(%rbp)
movl -0xb0(%rbp), %eax
movq -0x20(%rbp), %rcx
movq 0x18(%rcx), %rcx
cmpl 0x48(%rcx), %eax
je 0x9cdc
movq 0x1633b(%rip), %rax     # 0x1fff8
movq (%rax), %rdi
movq 0x164b1(%rip), %rdx     # 0x20178
movq -0x20(%rbp), %rax
movswl (%rax), %ecx
leaq 0xfd70(%rip), %rsi      # 0x19a45
movb $0x0, %al
callq 0x3140
movq 0x1648d(%rip), %rax     # 0x20170
movq 0x138(%rax), %rax
movq 0x17047(%rip), %rdi     # 0x20d38
callq *%rax
movswl -0x64(%rbp), %eax
cmpl $0x0, %eax
je 0x9dc1
movswl -0x22(%rbp), %eax
cmpl $0x0, %eax
je 0x9dc1
cmpq $0x0, -0x80(%rbp)
jne 0x9d37
movq 0x16455(%rip), %rax     # 0x20170
movq 0x140(%rax), %rax
movq 0x1700f(%rip), %rdi     # 0x20d38
leaq 0x10072(%rip), %rsi     # 0x19da2
callq *%rax
jmp 0x9dbf
movq 0x16ffa(%rip), %rsi     # 0x20d38
leaq 0xfd2a(%rip), %rdi      # 0x19a6f
callq 0x3100
movq 0x1641f(%rip), %rax     # 0x20170
cmpw $0x0, 0x10(%rax)
je 0x9d90
movq 0x16411(%rip), %rax     # 0x20170
movq 0x100(%rax), %rax
movq 0x16fcb(%rip), %rdi     # 0x20d38
leaq 0xfd0b(%rip), %rsi      # 0x19a7f
movq $-0x1, %rdx
callq *%rax
movq 0x16fb4(%rip), %rsi     # 0x20d38
leaq 0xf7e8(%rip), %rdi      # 0x19573
callq 0x3100
movq 0x16fa1(%rip), %rsi     # 0x20d38
leaq 0xfce7(%rip), %rdi      # 0x19a85
callq 0x3100
movq -0x80(%rbp), %rdi
callq 0xb300
movq 0x16f85(%rip), %rsi     # 0x20d38
leaq 0x11244(%rip), %rdi     # 0x1affe
callq 0x3100
jmp 0x9dca
movq -0x80(%rbp), %rdi
callq 0xb300
movq 0x16f67(%rip), %rdi     # 0x20d38
callq 0xb3b0
movq 0x16393(%rip), %rax     # 0x20170
movq 0x80(%rax), %rdi
movq 0x16f4d(%rip), %rsi     # 0x20d38
callq 0x3100
jmp 0x9e24
movswl -0x64(%rbp), %eax
cmpl $0x0, %eax
je 0x9e14
movswl -0x22(%rbp), %eax
cmpl $0x0, %eax
je 0x9e14
cmpq $0x0, -0x80(%rbp)
je 0x9e14
movq 0x20(%rbp), %rax
movw $0xffff, (%rax)         # imm = 0xFFFF
movq 0x16f1d(%rip), %rdi     # 0x20d38
movq -0x80(%rbp), %rsi
callq 0xb3e0
jmp 0xa1de
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
cmpl $0x4, 0x38(%rax)
je 0x9e49
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
cmpl $0x1, 0x38(%rax)
jne 0xa186
cmpw $0x0, -0x36(%rbp)
je 0xa152
movl -0x34(%rbp), %edi
callq 0x4000
movq 0x1630d(%rip), %rax     # 0x20170
movq 0x38(%rax), %rdi
movq 0x16eca(%rip), %rsi     # 0x20d38
callq 0x3100
movq 0x162f6(%rip), %rax     # 0x20170
movq 0x130(%rax), %rax
movq 0x16eb0(%rip), %rdi     # 0x20d38
leaq 0xfbff(%rip), %rsi      # 0x19a8e
xorl %ecx, %ecx
movq %rcx, %rdx
callq *%rax
movq 0x162d3(%rip), %rax     # 0x20170
movq 0x138(%rax), %rax
movq 0x16e8d(%rip), %rdi     # 0x20d38
callq *%rax
movq 0x162bc(%rip), %rax     # 0x20170
movq 0x108(%rax), %rax
movq 0x16e76(%rip), %rdi     # 0x20d38
movq -0x20(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq 0x28(%rcx), %rsi
movq -0x20(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq (%rcx), %rdx
callq *%rax
movq 0x1628e(%rip), %rax     # 0x20170
movq 0x138(%rax), %rax
movq 0x16e48(%rip), %rdi     # 0x20d38
callq *%rax
movq -0x80(%rbp), %rdi
callq 0xb300
movq 0x1626e(%rip), %rax     # 0x20170
movq 0x138(%rax), %rax
movq 0x16e28(%rip), %rdi     # 0x20d38
callq *%rax
movswl -0x64(%rbp), %eax
cmpl $0x0, %eax
je 0x9fe0
movswl -0x22(%rbp), %eax
cmpl $0x0, %eax
je 0x9fe0
cmpq $0x0, -0x80(%rbp)
jne 0x9f56
movq 0x16236(%rip), %rax     # 0x20170
movq 0x140(%rax), %rax
movq 0x16df0(%rip), %rdi     # 0x20d38
leaq 0xfe53(%rip), %rsi      # 0x19da2
callq *%rax
jmp 0x9fde
movq 0x16ddb(%rip), %rsi     # 0x20d38
leaq 0xfb0b(%rip), %rdi      # 0x19a6f
callq 0x3100
movq 0x16200(%rip), %rax     # 0x20170
cmpw $0x0, 0x10(%rax)
je 0x9faf
movq 0x161f2(%rip), %rax     # 0x20170
movq 0x100(%rax), %rax
movq 0x16dac(%rip), %rdi     # 0x20d38
leaq 0xfaec(%rip), %rsi      # 0x19a7f
movq $-0x1, %rdx
callq *%rax
movq 0x16d95(%rip), %rsi     # 0x20d38
leaq 0xf5c9(%rip), %rdi      # 0x19573
callq 0x3100
movq 0x16d82(%rip), %rsi     # 0x20d38
leaq 0xfac8(%rip), %rdi      # 0x19a85
callq 0x3100
movq -0x80(%rbp), %rdi
callq 0xb300
movq 0x16d66(%rip), %rsi     # 0x20d38
leaq 0x11025(%rip), %rdi     # 0x1affe
callq 0x3100
jmp 0x9fe9
movq -0x80(%rbp), %rdi
callq 0xb300
movq 0x16180(%rip), %rax     # 0x20170
movq 0x138(%rax), %rax
movq 0x16d3a(%rip), %rdi     # 0x20d38
callq *%rax
movq 0x16169(%rip), %rax     # 0x20170
movq 0x140(%rax), %rax
movq %rax, -0x120(%rbp)
movq 0x16d1c(%rip), %rax     # 0x20d38
movq %rax, -0x118(%rbp)
movswl -0x64(%rbp), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x109(%rbp)
je 0xa044
movswl -0x22(%rbp), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x109(%rbp)
movq -0x120(%rbp), %rax
movq -0x118(%rbp), %rdi
movb -0x109(%rbp), %dl
leaq 0xf9b5(%rip), %rsi      # 0x19a14
leaq 0xf9a9(%rip), %rcx      # 0x19a0f
testb $0x1, %dl
cmovneq %rcx, %rsi
callq *%rax
movq 0x160fa(%rip), %rax     # 0x20170
movq 0x148(%rax), %rax
movq 0x16cb4(%rip), %rdi     # 0x20d38
callq *%rax
movq 0x160e3(%rip), %rax     # 0x20170
movq 0x80(%rax), %rdi
movq 0x16c9d(%rip), %rsi     # 0x20d38
callq 0x3100
movq -0x20(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xa150
movq -0x20(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, 0x10(%rcx)
movb %al, -0x121(%rbp)
je 0xa115
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, 0x50(%rcx)
movb %al, -0x121(%rbp)
je 0xa115
movq -0x18(%rbp), %rax
movq 0x50(%rax), %rcx
xorl %eax, %eax
cmpq $0x0, (%rcx)
movb %al, -0x121(%rbp)
je 0xa115
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x50(%rax), %rax
movq (%rax), %rax
movq (%rax), %rsi
callq 0x3220
cmpl $0x0, %eax
sete %al
movb %al, -0x121(%rbp)
movb -0x121(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movw %ax, -0xb2(%rbp)
movq 0x16042(%rip), %rax     # 0x20170
movq 0x160(%rax), %rax
movq 0x16bfc(%rip), %rdi     # 0x20d38
movl -0x34(%rbp), %esi
movq -0x20(%rbp), %rcx
movq 0x10(%rcx), %rdx
movswl -0xb2(%rbp), %ecx
callq *%rax
jmp 0xa184
movswl -0x64(%rbp), %eax
cmpl $0x0, %eax
je 0xa174
movswl -0x22(%rbp), %eax
cmpl $0x0, %eax
je 0xa174
cmpq $0x0, -0x80(%rbp)
je 0xa174
movq 0x20(%rbp), %rax
movw $0xffff, (%rax)         # imm = 0xFFFF
movq 0x16bbd(%rip), %rdi     # 0x20d38
movq -0x80(%rbp), %rsi
callq 0xb3e0
jmp 0xa1dc
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
cmpl $0x2, 0x38(%rax)
je 0xa1a2
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
cmpl $0x3, 0x38(%rax)
jne 0xa1b7
movq -0x20(%rbp), %rdi
movl -0x3c(%rbp), %esi
movl -0x34(%rbp), %edx
movswl -0x36(%rbp), %ecx
callq 0xb4d0
jmp 0xa1da
movq 0x15e3a(%rip), %rax     # 0x1fff8
movq (%rax), %rdi
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movl 0x38(%rax), %edx
leaq 0xf8c4(%rip), %rsi      # 0x19a97
movb $0x0, %al
callq 0x3140
jmp 0xa1dc
jmp 0xa1de
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movl 0x38(%rax), %eax
movl %eax, -0x3c(%rbp)
jmp 0xacd1
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rdx
leaq -0x70(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x5ba0
movw %ax, -0x62(%rbp)
movw 0x10(%rbp), %di
movw -0x36(%rbp), %si
movl -0x34(%rbp), %ecx
movq -0x70(%rbp), %r8
movq 0x20(%rbp), %rax
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
xorl %r9d, %r9d
movswl %di, %edi
movswl %si, %esi
movq %rax, (%rsp)
callq 0xb670
movq $0x0, -0x88(%rbp)
cmpw $0x0, -0x36(%rbp)
je 0xa24e
movl -0x34(%rbp), %edi
callq 0x4000
movq -0x70(%rbp), %rdi
movl -0x34(%rbp), %edx
movw -0x36(%rbp), %r8w
movq -0x20(%rbp), %rax
movswl (%rax), %r11d
movw -0x62(%rbp), %r10w
movq 0x20(%rbp), %rax
leaq 0xc9e(%rip), %rsi       # 0xaf10
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
xorl %r9d, %r9d
movswl %r8w, %r8d
movl %r11d, (%rsp)
movswl %r10w, %r10d
movl %r10d, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0xad30
cmpw $0x0, -0x36(%rbp)
je 0xa356
movl -0x34(%rbp), %edi
callq 0x4050
movq -0x70(%rbp), %rdi
movq -0x78(%rbp), %rsi
callq 0xb8f0
movq %rax, -0x60(%rbp)
cmpq $0x0, -0x60(%rbp)
je 0xa354
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
cmpw $0x0, 0x20(%rax)
jne 0xa347
movl -0x34(%rbp), %edi
addl $0x1, %edi
callq 0x4000
movq 0x16a53(%rip), %rsi     # 0x20d38
leaq 0xf7cf(%rip), %rdi      # 0x19abb
callq 0x3100
movq 0x15d00(%rip), %rax     # 0x1fff8
movq (%rax), %rdi
movq 0x15e76(%rip), %rdx     # 0x20178
movq -0x20(%rbp), %rax
movswl (%rax), %ecx
leaq 0xf7ec(%rip), %rsi      # 0x19afc
movb $0x0, %al
callq 0x3140
movq 0x15cda(%rip), %rax     # 0x1fff8
movq (%rax), %rdi
movq -0x60(%rbp), %rsi
callq 0xaff0
movq 0x15cc7(%rip), %rax     # 0x1fff8
movq (%rax), %rsi
movl $0xa, %edi
callq 0x3120
movw $0xffff, 0x16a3b(%rip)  # imm = 0xFFFF
movq -0x60(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x106c0
jmp 0xa356
movq -0x18(%rbp), %rax
movq %rax, -0x138(%rbp)
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x130(%rbp)
movswl -0x64(%rbp), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x122(%rbp)
je 0xa391
movswl -0x22(%rbp), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x122(%rbp)
movq -0x130(%rbp), %rsi
movq -0x138(%rbp), %rdi
movb -0x122(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movw %ax, %dx
movq -0x78(%rbp), %rcx
movl -0x34(%rbp), %r8d
addl $0x1, %r8d
movw -0x36(%rbp), %r9w
movq -0x80(%rbp), %r10
movq 0x20(%rbp), %rax
xorl %r11d, %r11d
movswl %dx, %edx
movswl %r9w, %r9d
movl $0x0, (%rsp)
movq %r10, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x98f0
cmpw $0x0, -0x36(%rbp)
je 0xa3f5
movl -0x34(%rbp), %edi
callq 0x40a0
jmp 0xacd1
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rdx
leaq -0x70(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x5ba0
movw %ax, -0x62(%rbp)
movq -0x70(%rbp), %rsi
leaq -0x80(%rbp), %rdi
callq 0x5e00
movw 0x10(%rbp), %di
movw -0x36(%rbp), %si
movw -0x62(%rbp), %dx
movl -0x34(%rbp), %ecx
movq -0x70(%rbp), %r8
movq 0x20(%rbp), %rax
xorl %r9d, %r9d
movswl %di, %edi
movswl %si, %esi
movswl %dx, %edx
movq %rax, (%rsp)
callq 0xb670
cmpw $0x0, -0x62(%rbp)
je 0xa46d
movq -0x78(%rbp), %rsi
leaq -0x70(%rbp), %rdi
callq 0x5e00
movq -0x70(%rbp), %rax
movq %rax, -0x90(%rbp)
jmp 0xa48d
movq -0x70(%rbp), %rsi
leaq -0x90(%rbp), %rdi
callq 0x5e00
movq -0x78(%rbp), %rsi
leaq -0x90(%rbp), %rdi
callq 0x5e00
movq -0x70(%rbp), %rsi
leaq -0x88(%rbp), %rdi
callq 0x5e00
cmpw $0x0, -0x36(%rbp)
je 0xa4ac
movl -0x34(%rbp), %edi
callq 0xb950
movq -0x18(%rbp), %rax
movq %rax, -0x150(%rbp)
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x148(%rbp)
movswl -0x64(%rbp), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x139(%rbp)
je 0xa4e7
movswl -0x22(%rbp), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x139(%rbp)
movq -0x148(%rbp), %rsi
movq -0x150(%rbp), %rdi
movb -0x139(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movw %ax, %dx
movq -0x90(%rbp), %rcx
movl -0x34(%rbp), %r8d
addl $0x1, %r8d
movw -0x36(%rbp), %r9w
movq -0x80(%rbp), %r10
movq 0x20(%rbp), %rax
xorl %r11d, %r11d
movswl %dx, %edx
movswl %r9w, %r9d
movl $0x0, (%rsp)
movq %r10, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x98f0
movw -0x36(%rbp), %si
movw -0x64(%rbp), %dx
movl -0x34(%rbp), %ecx
addl $0x1, %ecx
movq -0x80(%rbp), %r8
movq 0x20(%rbp), %rax
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
xorl %r9d, %r9d
movswl %si, %esi
movswl %dx, %edx
movq %rax, (%rsp)
callq 0xb670
cmpw $0x0, -0x36(%rbp)
je 0xa61e
movq -0x70(%rbp), %rdi
movq -0x78(%rbp), %rsi
callq 0xb8f0
movq %rax, -0x60(%rbp)
cmpq $0x0, -0x60(%rbp)
je 0xa61c
movq -0x20(%rbp), %rax
cmpw $0x0, 0x20(%rax)
jne 0xa60f
movl -0x34(%rbp), %edi
callq 0x4000
movq 0x1678b(%rip), %rsi     # 0x20d38
leaq 0xf58a(%rip), %rdi      # 0x19b3e
callq 0x3100
movq 0x15a38(%rip), %rax     # 0x1fff8
movq (%rax), %rdi
movq 0x15bae(%rip), %rdx     # 0x20178
movq -0x20(%rbp), %rax
movswl (%rax), %ecx
leaq 0xf5a8(%rip), %rsi      # 0x19b80
movb $0x0, %al
callq 0x3140
movq 0x15a12(%rip), %rax     # 0x1fff8
movq (%rax), %rdi
movq -0x60(%rbp), %rsi
callq 0xaff0
movq 0x159ff(%rip), %rax     # 0x1fff8
movq (%rax), %rsi
movl $0xa, %edi
callq 0x3120
movw $0xffff, 0x16773(%rip)  # imm = 0xFFFF
movq -0x60(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x106c0
jmp 0xa61e
movq -0x70(%rbp), %rdi
movl -0x34(%rbp), %edx
movw -0x36(%rbp), %r8w
movq -0x20(%rbp), %rax
movswl (%rax), %r10d
movq 0x20(%rbp), %rax
leaq 0x1353(%rip), %rsi      # 0xb990
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
xorl %r9d, %r9d
xorl %r11d, %r11d
movswl %r8w, %r8d
movl %r10d, (%rsp)
movl $0x0, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0xad30
movq -0x90(%rbp), %rax
cmpq -0x70(%rbp), %rax
je 0xa67f
movq -0x90(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x106c0
jmp 0xacd1
cmpw $0x0, -0x36(%rbp)
je 0xa693
movl -0x34(%rbp), %edi
callq 0xb9d0
movq $0x0, -0x48(%rbp)
movq $0x0, -0x50(%rbp)
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0xc0(%rbp)
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x28(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0xc8(%rbp)
movq -0x78(%rbp), %rsi
movq -0xc0(%rbp), %rdx
leaq -0x50(%rbp), %rdi
callq 0x5ba0
movw %ax, -0xca(%rbp)
movq -0x50(%rbp), %rsi
movq -0xc8(%rbp), %rdx
leaq -0x48(%rbp), %rdi
callq 0x5ba0
movq -0x78(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x5e00
movq $0x0, -0x58(%rbp)
movq -0xc8(%rbp), %rdx
leaq -0x58(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x5ba0
cmpw $0x0, %ax
je 0xa73f
movq -0xc0(%rbp), %rdx
leaq -0x58(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x5ba0
movq -0x80(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0x5e00
movq -0x18(%rbp), %rax
movq %rax, -0x168(%rbp)
movq -0xc0(%rbp), %rax
movq %rax, -0x160(%rbp)
movswl -0x64(%rbp), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x151(%rbp)
je 0xa786
movswl -0x22(%rbp), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x151(%rbp)
movq -0x160(%rbp), %rsi
movq -0x168(%rbp), %rdi
movb -0x151(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movw %ax, %dx
movq -0x48(%rbp), %rcx
movl -0x34(%rbp), %r8d
addl $0x1, %r8d
movw -0x36(%rbp), %r9w
movq -0x58(%rbp), %r10
movq 0x20(%rbp), %rax
movswl %dx, %edx
movswl %r9w, %r9d
movl $0xffffffff, (%rsp)     # imm = 0xFFFFFFFF
movq %r10, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x98f0
movq -0x58(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x106c0
movq -0x48(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x106c0
movq -0x50(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x106c0
movq $0x0, -0x48(%rbp)
movq -0x78(%rbp), %rsi
movq -0xc0(%rbp), %rdx
leaq -0x48(%rbp), %rdi
callq 0x5ba0
movq -0x48(%rbp), %rsi
movq -0xc8(%rbp), %rdx
leaq -0x70(%rbp), %rdi
callq 0x5ba0
movq -0x48(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x106c0
cmpw $0x0, -0x36(%rbp)
je 0xa8fa
movq -0x70(%rbp), %rdi
movq -0x78(%rbp), %rsi
callq 0xb8f0
movq %rax, -0x60(%rbp)
cmpq $0x0, -0x60(%rbp)
je 0xa8ef
movq -0x20(%rbp), %rax
cmpw $0x0, 0x20(%rax)
jne 0xa8e2
movl -0x34(%rbp), %edi
addl $0x1, %edi
callq 0x4000
movq 0x164b8(%rip), %rsi     # 0x20d38
leaq 0xf33d(%rip), %rdi      # 0x19bc4
callq 0x3100
movq 0x15765(%rip), %rax     # 0x1fff8
movq (%rax), %rdi
movq 0x158db(%rip), %rdx     # 0x20178
movq -0x20(%rbp), %rax
movswl (%rax), %ecx
leaq 0xf358(%rip), %rsi      # 0x19c03
movb $0x0, %al
callq 0x3140
movq 0x1573f(%rip), %rax     # 0x1fff8
movq (%rax), %rdi
movq -0x60(%rbp), %rsi
callq 0xaff0
movq 0x1572c(%rip), %rax     # 0x1fff8
movq (%rax), %rsi
movl $0xa, %edi
callq 0x3120
movw $0xffff, 0x164a0(%rip)  # imm = 0xFFFF
movq -0x60(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x106c0
movl -0x34(%rbp), %edi
addl $0x1, %edi
callq 0x4000
movq -0x70(%rbp), %rdi
movl -0x34(%rbp), %edx
movw -0x36(%rbp), %r8w
movq -0x20(%rbp), %rax
movswl (%rax), %r10d
movq 0x20(%rbp), %rax
leaq 0x5f7(%rip), %rsi       # 0xaf10
xorl %ecx, %ecx
xorl %r9d, %r9d
movswl %r8w, %r8d
movl %r10d, (%rsp)
movl $0x0, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0xad30
cmpw $0x0, -0x36(%rbp)
je 0xa960
movl -0x34(%rbp), %edi
addl $0x1, %edi
callq 0x4050
movl -0x34(%rbp), %edi
addl $0x2, %edi
callq 0xba10
movl -0x34(%rbp), %edi
addl $0x1, %edi
callq 0x40a0
movq $0x0, -0x48(%rbp)
movq $0x0, -0x50(%rbp)
movq -0xc8(%rbp), %rdx
leaq -0x50(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x5ba0
movq -0x78(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x5e00
movq -0x50(%rbp), %rsi
movq -0xc0(%rbp), %rdx
leaq -0x48(%rbp), %rdi
callq 0x5ba0
movq $0x0, -0x58(%rbp)
movq -0xc0(%rbp), %rdx
leaq -0x58(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x5ba0
cmpw $0x0, %ax
je 0xa9e8
movq -0xc8(%rbp), %rdx
leaq -0x58(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x5ba0
movq -0x80(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0x5e00
movq -0x18(%rbp), %rax
movq %rax, -0x180(%rbp)
movq -0xc8(%rbp), %rax
movq %rax, -0x178(%rbp)
movswl -0xca(%rbp), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x169(%rbp)
je 0xaa36
movswl -0x64(%rbp), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x169(%rbp)
je 0xaa36
movswl -0x22(%rbp), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x169(%rbp)
movq -0x178(%rbp), %rsi
movq -0x180(%rbp), %rdi
movb -0x169(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movw %ax, %dx
movq -0x48(%rbp), %rcx
movl -0x34(%rbp), %r8d
addl $0x1, %r8d
movw -0x36(%rbp), %r9w
movq -0x58(%rbp), %r10
movq 0x20(%rbp), %rax
xorl %r11d, %r11d
movswl %dx, %edx
movswl %r9w, %r9d
movl $0x0, (%rsp)
movq %r10, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x98f0
movq -0x58(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x106c0
movq -0x48(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x106c0
movq -0x50(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x106c0
cmpw $0x0, -0x36(%rbp)
je 0xaac1
movl -0x34(%rbp), %edi
callq 0xba60
jmp 0xacd1
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rsi
movw -0x22(%rbp), %dx
movq -0x78(%rbp), %rcx
movl -0x34(%rbp), %r8d
movq 0x1568b(%rip), %rax     # 0x20170
movq 0x28(%rax), %r9
movq 0x15680(%rip), %rax     # 0x20170
movq 0x30(%rax), %r14
movw -0x36(%rbp), %bx
movq -0x80(%rbp), %r11
movq 0x20(%rbp), %r10
movq -0x20(%rbp), %rax
movswl (%rax), %eax
movswl %dx, %edx
movq %r14, (%rsp)
movswl %bx, %ebx
movl %ebx, 0x8(%rsp)
movq %r11, 0x10(%rsp)
movq %r10, 0x18(%rsp)
movl %eax, 0x20(%rsp)
callq 0x9370
jmp 0xacd1
movq -0x20(%rbp), %rsi
leaq -0x70(%rbp), %rdi
callq 0xba80
cmpw $0x0, -0x36(%rbp)
je 0xab49
movl -0x34(%rbp), %edi
callq 0x4000
movq -0x70(%rbp), %rdi
movl -0x34(%rbp), %edx
movw -0x36(%rbp), %r8w
movq -0x20(%rbp), %rax
movswl (%rax), %r10d
movq 0x20(%rbp), %rax
leaq 0x3a8(%rip), %rsi       # 0xaf10
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
xorl %r9d, %r9d
xorl %r11d, %r11d
movswl %r8w, %r8d
movl %r10d, (%rsp)
movl $0x0, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0xad30
cmpw $0x0, -0x36(%rbp)
je 0xabaf
movl -0x34(%rbp), %edi
callq 0x4050
movl -0x34(%rbp), %edi
addl $0x1, %edi
callq 0xba10
movl -0x34(%rbp), %edi
callq 0x40a0
jmp 0xacd1
movq -0x20(%rbp), %rsi
leaq -0x70(%rbp), %rdi
callq 0xba80
cmpw $0x0, -0x36(%rbp)
je 0xabd0
movl -0x34(%rbp), %edi
callq 0x4000
movq -0x70(%rbp), %rdi
movl -0x34(%rbp), %edx
movw -0x36(%rbp), %r8w
movq -0x20(%rbp), %rax
movswl (%rax), %r10d
movq 0x20(%rbp), %rax
leaq 0x321(%rip), %rsi       # 0xaf10
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
xorl %r9d, %r9d
xorl %r11d, %r11d
movswl %r8w, %r8d
movl %r10d, (%rsp)
movl $0x0, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0xad30
cmpw $0x0, -0x36(%rbp)
je 0xaccf
movl -0x34(%rbp), %edi
callq 0x4050
movl -0x34(%rbp), %edi
addl $0x1, %edi
callq 0x4000
movq 0x15537(%rip), %rax     # 0x20170
movq 0x130(%rax), %rax
movq 0x160f1(%rip), %rdi     # 0x20d38
leaq 0xeff6(%rip), %rsi      # 0x19c44
xorl %ecx, %ecx
movq %rcx, %rdx
callq *%rax
movq 0x15514(%rip), %rax     # 0x20170
movq 0x138(%rax), %rax
movq 0x160ce(%rip), %rdi     # 0x20d38
callq *%rax
movq 0x154fd(%rip), %rax     # 0x20170
movq 0x140(%rax), %rax
movq 0x160b7(%rip), %rdi     # 0x20d38
movq -0x20(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq 0x28(%rcx), %rcx
movq 0x18(%rcx), %rcx
movq (%rcx), %rsi
callq *%rax
movq 0x154d3(%rip), %rax     # 0x20170
movq 0x148(%rax), %rax
movq 0x1608d(%rip), %rdi     # 0x20d38
callq *%rax
movq 0x154bc(%rip), %rax     # 0x20170
movq 0x80(%rax), %rdi
movq 0x16076(%rip), %rsi     # 0x20d38
callq 0x3100
movl -0x34(%rbp), %edi
callq 0x40a0
jmp 0xacd1
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x78(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x106c0
movq -0x70(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x106c0
movq -0x88(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x106c0
movq -0x80(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x106c0
jmp 0x99e2
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r14
popq %rbp
retq
nopw %cs:(%rax,%rax)