LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./jsrun.c
// Function: js_setvar
static void js_setvar(js_State *J, const char *name)
{
	js_Environment *E = J->E;
	do {
		js_Property *ref = jsV_getproperty(J, E->variables, name);
		if (ref) {
			if (ref->setter) {
				js_pushobject(J, ref->setter);
				js_pushobject(J, E->variables);
				js_copy(J, -3);
				js_call(J, 1);
				js_pop(J, 1);
				return;
			}
			if (!(ref->atts & JS_READONLY))
				ref->value = *stackidx(J, -1);
			else if (J->strict)
				js_typeerror(J, "'%s' is read-only", name);
			return;
		}
		E = E->outer;
	} while (E);
	if (J->strict)
		js_referenceerror(J, "assignment to undeclared variable '%s'", name);
	jsR_setproperty(J, J->G, name, 0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x130(%rdi), %r12
leaq 0x17460(%rip), %r13     # 0x403f8
movq 0x8(%r12), %rsi
movq %rbx, %rdx
callq 0x12766
movq %rax, %r15
testq %rax, %rax
je 0x29003
movq 0x30(%r15), %rsi
testq %rsi, %rsi
je 0x29009
movq %r14, %rdi
callq 0x44e7
movq 0x8(%r12), %rsi
movq %r14, %rdi
callq 0x44e7
movq %r14, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x14073
movq %r14, %rdi
movl $0x1, %esi
callq 0x16c25
movl 0x140(%r14), %ecx
movl 0x144(%r14), %eax
leal -0x1(%rcx), %edx
movl %edx, 0x140(%r14)
cmpl %eax, %ecx
jg 0x29044
jmp 0x29080
movq (%r12), %r12
jmp 0x29044
testb $0x1, 0x14(%r15)
jne 0x2903d
movslq 0x140(%r14), %rax
movq %r13, %rcx
testq %rax, %rax
jle 0x29031
movq 0x148(%r14), %rcx
shlq $0x4, %rax
addq %rax, %rcx
addq $-0x10, %rcx
leaq 0x18(%r15), %rax
movups (%rcx), %xmm0
movups %xmm0, (%rax)
jmp 0x29044
cmpl $0x0, 0x34(%r14)
jne 0x29098
testq %r15, %r15
jne 0x29076
testq %r12, %r12
jne 0x28f98
cmpl $0x0, 0x34(%r14)
jne 0x290ac
movq 0x128(%r14), %rsi
movq %r14, %rdi
movq %rbx, %rdx
xorl %ecx, %ecx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x15dd3
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movl %eax, 0x140(%r14)
leaq 0xa6e0(%rip), %rsi      # 0x3376e
movq %r14, %rdi
xorl %eax, %eax
callq 0xc939
leaq 0xbf43(%rip), %rsi      # 0x34fe2
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0xcce3
leaq 0xc037(%rip), %rsi      # 0x350ea
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0xcb73
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./jsrun.c
// Function: js_delvar
static int js_delvar(js_State *J, const char *name)
{
	js_Environment *E = J->E;
	do {
		js_Property *ref = jsV_getownproperty(J, E->variables, name);
		if (ref) {
			if (ref->atts & JS_DONTCONF) {
				if (J->strict)
					js_typeerror(J, "'%s' is non-configurable", name);
				return 0;
			}
			jsV_delproperty(J, E->variables, name);
			return 1;
		}
		E = E->outer;
	} while (E);
	return jsR_delproperty(J, J->G, name);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, 0x10(%rsp)
movq 0x130(%rdi), %r12
leaq 0x172d4(%rip), %r13     # 0x403b8
movq 0x8(%r12), %r15
movq 0x8(%r15), %r14
cmpq %r13, %r14
je 0x29118
leaq 0x38(%r14), %rsi
movq %rbx, %rdi
callq 0x32f0
testl %eax, %eax
je 0x2910f
movl %eax, %ecx
notl %ecx
shrl $0x1f, %ecx
movq (%r14,%rcx,8), %r14
jmp 0x29112
movq %r14, %rbp
testl %eax, %eax
jne 0x290ed
jmp 0x2911a
xorl %ebp, %ebp
testq %rbp, %rbp
je 0x2913f
testb $0x4, 0x14(%rbp)
jne 0x29145
movq 0x10(%rsp), %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x12993
movl $0x1, 0xc(%rsp)
jmp 0x29158
movq (%r12), %r12
jmp 0x29158
movl $0x0, 0xc(%rsp)
movq 0x10(%rsp), %rax
cmpl $0x0, 0x34(%rax)
jne 0x29197
testq %rbp, %rbp
jne 0x29184
testq %r12, %r12
jne 0x290e4
movq 0x10(%rsp), %rdi
movq 0x128(%rdi), %rsi
movq %rbx, %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1622d
movl 0xc(%rsp), %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xbec4(%rip), %rsi      # 0x35062
movq 0x10(%rsp), %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0xcce3
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./jsrun.c
// Function: jsR_isindex
static int jsR_isindex(js_State *J, int idx, int *k)
{
	js_Value *v = stackidx(J, idx);
	if (v->t.type == JS_TNUMBER) {
		*k = v->u.number;
		return *k == v->u.number && *k >= 0;
	}
	return 0;
}

// Assembly:
movl %esi, %eax
notl %eax
shrl $0x1f, %eax
addl 0x140(%rdi,%rax,4), %esi
leaq 0x17236(%rip), %rcx     # 0x403f8
js 0x291d9
cmpl 0x140(%rdi), %esi
jge 0x291d9
movl %esi, %ecx
shlq $0x4, %rcx
addq 0x148(%rdi), %rcx
xorl %eax, %eax
cmpb $0x4, 0xf(%rcx)
jne 0x29209
movsd (%rcx), %xmm0
cvttsd2si %xmm0, %eax
cvttpd2dq %xmm0, %xmm0
cvtdq2pd %xmm0, %xmm0
movl %eax, (%rdx)
ucomisd (%rcx), %xmm0
setnp %cl
sete %dl
andb %cl, %dl
testl %eax, %eax
setns %al
andb %dl, %al
movzbl %al, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./jsstring.c
// Function: js_doregexec
static int js_doregexec(js_State *J, Reprog *prog, const char *string, Resub *sub, int eflags)
{
	int result = js_regexec(prog, string, sub, eflags);
	if (result < 0)
		js_error(J, "regexec failed");
	return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x110, %rsp            # imm = 0x110
movl %r8d, %ebp
movq %rdx, %r14
movq %rsi, %r15
testq %rcx, %rcx
leaq 0x8(%rsp), %r12
cmovneq %rcx, %r12
movq %rdi, %rbx
movl 0x1c(%rsi), %eax
movl %eax, (%r12)
leaq 0x8(%r12), %rdi
movl $0x100, %edx            # imm = 0x100
xorl %esi, %esi
callq 0x3060
movq (%r15), %rdi
orl 0x18(%r15), %ebp
movq %r14, %rsi
movq %r14, %rdx
movl %ebp, %ecx
movq %r12, %r8
xorl %r9d, %r9d
callq 0x1c171
testl %eax, %eax
js 0x2933c
addq $0x110, %rsp            # imm = 0x110
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0xa397(%rip), %rsi      # 0x336da
movq %rbx, %rdi
xorl %eax, %eax
callq 0xc939
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./regexp.c
// Function: newcclass
static void newcclass(struct cstate *g)
{
	if (g->ncclass >= REG_MAXCLASS)
		die(g, "too many character classes");
	g->yycc = g->cclass + g->ncclass++;
	g->yycc->end = g->yycc->spans;
}

// Assembly:
movslq 0x20(%rdi), %rax
cmpq $0x80, %rax
jge 0x2a238
leal 0x1(%rax), %ecx
movl %ecx, 0x20(%rdi)
movq %rax, %rcx
shlq $0x8, %rcx
leaq (%rcx,%rax,8), %rax
leaq (%rdi,%rax), %rcx
addq $0x190, %rcx            # imm = 0x190
movq %rcx, 0xb0(%rdi)
addq %rdi, %rax
addq $0x198, %rax            # imm = 0x198
movq %rax, -0x8(%rax)
retq
pushq %rax
leaq 0xb042(%rip), %rax      # 0x35282
movq %rax, 0xc0(%rdi)
addq $0xc8, %rdi
movl $0x1, %esi
callq 0x3320
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./regexp.c
// Function: addranges_s
static void addranges_s(struct cstate *g)
{
	addrange(g, 0x9, 0xD);
	addrange(g, 0x20, 0x20);
	addrange(g, 0xA0, 0xA0);
	addrange(g, 0x2028, 0x2029);
	addrange(g, 0xFEFF, 0xFEFF);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x9, %esi
movl $0xd, %edx
callq 0x2a33e
movq %rbx, %rdi
movl $0x20, %esi
movl $0x20, %edx
callq 0x2a33e
movq %rbx, %rdi
movl $0xa0, %esi
movl $0xa0, %edx
callq 0x2a33e
movq %rbx, %rdi
movl $0x2028, %esi           # imm = 0x2028
movl $0x2029, %edx           # imm = 0x2029
callq 0x2a33e
movq %rbx, %rdi
movl $0xfeff, %esi           # imm = 0xFEFF
movl $0xfeff, %edx           # imm = 0xFEFF
popq %rbx
jmp 0x2a33e
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./regexp.c
// Function: addranges_w
static void addranges_w(struct cstate *g)
{
	addrange(g, '0', '9');
	addrange(g, 'A', 'Z');
	addrange(g, '_', '_');
	addrange(g, 'a', 'z');
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x30, %esi
movl $0x39, %edx
callq 0x2a33e
movq %rbx, %rdi
movl $0x41, %esi
movl $0x5a, %edx
callq 0x2a33e
movq %rbx, %rdi
movl $0x5f, %esi
movl $0x5f, %edx
callq 0x2a33e
movq %rbx, %rdi
movl $0x61, %esi
movl $0x7a, %edx
popq %rbx
jmp 0x2a33e
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./regexp.c
// Function: hex
static int hex(struct cstate *g, int c)
{
	if (c >= '0' && c <= '9') return c - '0';
	if (c >= 'a' && c <= 'f') return c - 'a' + 0xA;
	if (c >= 'A' && c <= 'F') return c - 'A' + 0xA;
	die(g, "invalid escape sequence");
	return 0;
}

// Assembly:
leal -0x30(%rsi), %eax
cmpl $0xa, %eax
jb 0x2a31d
leal -0x61(%rsi), %eax
cmpl $0x5, %eax
ja 0x2a310
addl $-0x57, %esi
jmp 0x2a31b
leal -0x41(%rsi), %eax
cmpl $0x5, %eax
ja 0x2a31e
addl $-0x37, %esi
movl %esi, %eax
retq
pushq %rax
leaq 0x99c0(%rip), %rax      # 0x33ce6
movq %rax, 0xc0(%rdi)
addq $0xc8, %rdi
movl $0x1, %esi
callq 0x3320
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./regexp.c
// Function: addrange
static void addrange(struct cstate *g, Rune a, Rune b)
{
	Reclass *cc = g->yycc;
	Rune *p;

	if (a > b)
		die(g, "invalid character class range");

	/* extend existing ranges if they overlap */
	for (p = cc->spans; p < cc->end; p += 2) {
		/* completely inside old range */
		if (a >= p[0] && b <= p[1])
			return;

		/* completely swallows old range */
		if (a < p[0] && b >= p[1]) {
			p[0] = a;
			p[1] = b;
			return;
		}

		/* extend at start */
		if (b >= p[0] - 1 && b <= p[1] && a < p[0]) {
			p[0] = a;
			return;
		}

		/* extend at end */
		if (a >= p[0] && a <= p[1] + 1 && b > p[1]) {
			p[1] = b;
			return;
		}
	}

	if (cc->end + 2 >= cc->spans + nelem(cc->spans))
		die(g, "too many character class ranges");
	*cc->end++ = a;
	*cc->end++ = b;
}

// Assembly:
pushq %rax
cmpl %edx, %esi
jg 0x2a3dc
movq 0xb0(%rdi), %rax
movq (%rax), %rcx
leaq 0x8(%rax), %r8
cmpq %rcx, %r8
jae 0x2a3ad
movl (%r8), %r9d
cmpl %esi, %r9d
jg 0x2a36d
cmpl %edx, 0x4(%r8)
jge 0x2a3da
cmpl %esi, %r9d
jle 0x2a373
cmpl %edx, 0x4(%r8)
jle 0x2a3ce
leal -0x1(%r9), %r10d
cmpl %edx, %r10d
jg 0x2a387
cmpl %esi, %r9d
jle 0x2a387
cmpl %edx, 0x4(%r8)
jge 0x2a3d7
cmpl %esi, %r9d
jg 0x2a3a7
movl 0x4(%r8), %r9d
leal 0x1(%r9), %r10d
cmpl %esi, %r10d
setl %r10b
cmpl %edx, %r9d
setge %r9b
orb %r10b, %r9b
je 0x2a3d1
addq $0x8, %r8
jmp 0x2a355
leaq 0x8(%rcx), %r8
leaq 0x108(%rax), %r9
cmpq %r9, %r8
jae 0x2a3e5
leaq 0x4(%rcx), %rdi
movq %rdi, (%rax)
movl %esi, (%rcx)
movq %r8, (%rax)
movl %edx, 0x4(%rcx)
jmp 0x2a3da
movl %esi, (%r8)
movl %edx, 0x4(%r8)
jmp 0x2a3da
movl %esi, (%r8)
popq %rax
retq
leaq 0xaeba(%rip), %rax      # 0x3529d
jmp 0x2a3ec
leaq 0xaecf(%rip), %rax      # 0x352bb
movq %rax, 0xc0(%rdi)
addq $0xc8, %rdi
movl $0x1, %esi
callq 0x3320
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./regexp.c
// Function: parsecat
static Renode *parsecat(struct cstate *g)
{
	Renode *cat, *head, **tail;
	if (g->lookahead != EOF && g->lookahead != '|' && g->lookahead != ')') {
		/* Build a right-leaning tree by splicing in new 'cat' at the tail. */
		head = parserep(g);
		tail = &head;
		while (g->lookahead != EOF && g->lookahead != '|' && g->lookahead != ')') {
			cat = newnode(g, P_CAT);
			cat->x = *tail;
			cat->y = parserep(g);
			*tail = cat;
			tail = &cat->y;
		}
		return head;
	}
	return NULL;
}

// Assembly:
movl 0xa8(%rdi), %ecx
xorl %eax, %eax
cmpl $-0x1, %ecx
je 0x2a4b3
cmpl $0x29, %ecx
je 0x2a4b3
cmpl $0x7c, %ecx
je 0x2a4b3
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x2a4b4
movq %rsp, %r15
movq %rax, (%r15)
movabsq $-0x100000000, %r14     # imm = 0xFFFFFFFF00000000
movl 0xa8(%rbx), %eax
cmpl $-0x1, %eax
je 0x2a4a4
cmpl $0x29, %eax
je 0x2a4a4
cmpl $0x7c, %eax
je 0x2a4a4
movq 0x10(%rbx), %r12
leaq 0x20(%r12), %rax
movq %rax, 0x10(%rbx)
movb $0x0, (%r12)
movq %r14, 0x4(%r12)
movl $0x0, 0x1(%r12)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r12)
movq (%r15), %rax
movq %rax, 0x10(%r12)
movq %rbx, %rdi
callq 0x2a4b4
movq %rax, 0x18(%r12)
movq %r12, (%r15)
leaq 0x18(%r12), %r15
jmp 0x2a447
movq (%rsp), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./regexp.c
// Function: newrep
static Renode *newrep(struct cstate *g, Renode *atom, int ng, int min, int max)
{
	Renode *rep = newnode(g, P_REP);
	if (max == REPINF && empty(atom))
		die(g, "infinite loop matching the empty string");
	rep->ng = ng;
	rep->m = min;
	rep->n = max;
	rep->x = atom;
	return rep;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r13d
movq %rsi, %r14
movq 0x10(%rdi), %r15
leaq 0x20(%r15), %rax
movq %rax, 0x10(%rdi)
movb $0x2, (%r15)
movabsq $-0x100000000, %rax     # imm = 0xFFFFFFFF00000000
movq %rax, 0x4(%r15)
movl $0x0, 0x1(%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r15)
cmpl $0xff, %r8d
jne 0x2aa15
movq %rdi, %r12
movq %r14, %rdi
callq 0x2aa5a
testl %eax, %eax
jne 0x2aa37
movb %r13b, 0x1(%r15)
movb %bpl, 0x2(%r15)
movb %bl, 0x3(%r15)
movq %r14, 0x10(%r15)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xa91c(%rip), %rax      # 0x3535a
movq %rax, 0xc0(%r12)
addq $0xc8, %r12
movq %r12, %rdi
movl $0x1, %esi
callq 0x3320
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./regexp.c
// Function: empty
static int empty(Renode *node)
{
	if (!node) return 1;
	switch (node->type) {
	default: return 1;
	case P_CAT: return empty(node->x) && empty(node->y);
	case P_ALT: return empty(node->x) || empty(node->y);
	case P_REP: return empty(node->x) || node->m == 0;
	case P_PAR: return empty(node->x);
	case P_REF: return empty(node->x);
	case P_ANY: case P_CHAR: case P_CCLASS: case P_NCCLASS: return 0;
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x1400(%rip), %r14      # 0x2be68
movl $0x1, %ebp
testq %rbx, %rbx
je 0x2aaae
movzbl (%rbx), %eax
cmpq $0xe, %rax
ja 0x2aaae
movslq (%r14,%rax,4), %rax
addq %r14, %rax
jmpq *%rax
movq 0x10(%rbx), %rbx
jmp 0x2aa6d
movq 0x10(%rbx), %rdi
callq 0x2aa5a
testl %eax, %eax
je 0x2aaa6
jmp 0x2aaae
movq 0x10(%rbx), %rdi
callq 0x2aa5a
testl %eax, %eax
je 0x2aaac
movq 0x18(%rbx), %rbx
jmp 0x2aa6d
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq 0x10(%rbx), %rdi
callq 0x2aa5a
testl %eax, %eax
jne 0x2aaae
xorl %ebp, %ebp
cmpb $0x0, 0x2(%rbx)
sete %bpl
jmp 0x2aaae
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./regexp.c
// Function: incclasscanon
static int incclasscanon(Reclass *cc, Rune c)
{
	Rune *p, r;
	for (p = cc->spans; p < cc->end; p += 2)
		for (r = p[0]; r <= p[1]; ++r)
			if (c == canon(r))
				return 1;
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq (%rdi), %r12
leaq 0x8(%rdi), %rax
xorl %ebx, %ebx
cmpq %r12, %rax
jae 0x2ab35
movl %esi, %ebp
movq %rdi, %r14
movl 0x8(%r14), %r15d
movl 0xc(%r14), %r13d
movq %rax, %r14
cmpl %r13d, %r15d
jg 0x2ab25
incl %r13d
movl %r15d, %edi
callq 0x1c8bb
cmpl $0x80, %eax
movl %eax, %ecx
cmovll %r15d, %ecx
cmpl $0x7f, %r15d
cmovlel %eax, %ecx
cmpl %ebp, %ecx
je 0x2ab30
incl %r15d
cmpl %r15d, %r13d
jne 0x2aaff
leaq 0x8(%r14), %rax
cmpq %r12, %rax
jb 0x2aaec
jmp 0x2ab35
movl $0x1, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/vi[P]simple_cbor_stream_parse/cbor_to_jsonesque.c
// Function: q_bytestring_chunk
SCSP_INT q_bytestring_chunk (SCSP_USERDATA userdata, const uint8_t* buf, size_t len) {
    int i;
    for (i=0; i<len; ++i) {
        printf("%02X", (int)buf[i]);
    }
    return 0;
}

// Assembly:
testq %rdx, %rdx
je 0x1261
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x1dcf(%rip), %r15      # 0x300b
xorl %r12d, %r12d
movzbl (%r14,%r12), %esi
movq %r15, %rdi
xorl %eax, %eax
callq 0x1070
incq %r12
cmpq %r12, %rbx
jne 0x123f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/vi[P]simple_cbor_stream_parse/cbor_to_jsonesque.c
// Function: q_array_item
SCSP_INT q_array_item (SCSP_USERDATA userdata) {
    if (!just_opened) {
        printf(", ");
    }
    just_opened = 0;
    return 0;
}

// Assembly:
cmpb $0x0, 0x3e4a(%rip)      # 0x5114
jne 0x12df
pushq %rax
leaq 0x1d3c(%rip), %rdi      # 0x3010
xorl %eax, %eax
callq 0x1070
addq $0x8, %rsp
movb $0x0, 0x3e2e(%rip)      # 0x5114
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/vi[P]simple_cbor_stream_parse/cbor_to_jsonesque.c
// Function: q_map_key
SCSP_INT q_map_key (SCSP_USERDATA userdata) {
    if (!just_opened) {
        printf(", ");
    }
    just_opened = 0;
    return 0;
}

// Assembly:
cmpb $0x0, 0x3dff(%rip)      # 0x5114
jne 0x132a
pushq %rax
leaq 0x1cf1(%rip), %rdi      # 0x3010
xorl %eax, %eax
callq 0x1070
addq $0x8, %rsp
movb $0x0, 0x3de3(%rip)      # 0x5114
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/vi[P]simple_cbor_stream_parse/cbor_to_jsonesque.c
// Function: main
int main(int argc, char* argv[]) {
    if (argc != 2) {
        printf("Usage: cbor_to_jsonesque {filename|-}\n");
        return 1;
    }
    int f;
    if (argv[1][0] == '-' && argv[1][1] == '\0') {
        f = 0;
    } else {
        f = open(argv[1], O_RDONLY);
        if (f == -1) {
            perror("open");
            return 2;
        }
    }
    
    just_opened = 0;
    
    if ( -1 == scsp_parse_from_fd(f, &q_callbacks, NULL) ) {
        fprintf(stderr, "Error reading CBOR\n");
        return 4;
    }
    
    printf("\n");
    return 0;
}

// Assembly:
pushq %rbx
cmpl $0x2, %edi
jne 0x1428
movq 0x8(%rsi), %rdi
cmpb $0x2d, (%rdi)
jne 0x13ef
cmpb $0x0, 0x1(%rdi)
je 0x143d
xorl %esi, %esi
xorl %eax, %eax
callq 0x10a0
movl %eax, %edi
cmpl $-0x1, %eax
je 0x144d
movb $0x0, 0x3d0e(%rip)      # 0x5114
leaq 0x3c73(%rip), %rsi      # 0x5080
xorl %ebx, %ebx
xorl %edx, %edx
callq 0x200c
cmpq $-0x1, %rax
je 0x1441
movl $0xa, %edi
callq 0x1030
jmp 0x1439
leaq 0x1c34(%rip), %rdi      # 0x3063
callq 0x1060
movl $0x1, %ebx
movl %ebx, %eax
popq %rbx
retq
xorl %edi, %edi
jmp 0x13ff
callq 0x10f0
movl $0x4, %ebx
jmp 0x1439
leaq 0x1bf6(%rip), %rdi      # 0x304a
callq 0x10b0
movl $0x2, %ebx
jmp 0x1439
// File: /workspace/github_c_makefile_star2_O1/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_1/exercise_1_03/fahrenheit_celsius.c
// Function: main
int main(void)
{
  float fahr, celsius;
  int lower, upper, step;

  lower = 0;
  upper = 300;
  step = 20;

  // Printing a heading above the table
  printf("Fahr\tCelsius\n");
  printf("---------------\n");

  fahr = lower;
  while (fahr <= upper)
  {
    celsius = (5.0 / 9.0) * (fahr - 32.0);
    printf("%3.0f\t\t%6.1f\n", fahr, celsius);
    fahr = fahr + step;
  }

  return 0;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
leaq 0xed0(%rip), %rdi       # 0x2026
callq 0x1030
leaq 0xed1(%rip), %rdi       # 0x2033
callq 0x1030
movl $0xffffffec, %ebp       # imm = 0xFFFFFFEC
leaq 0xea5(%rip), %rbx       # 0x2018
addl $0x14, %ebp
xorps %xmm0, %xmm0
cvtsi2ss %ebp, %xmm0
cvtss2sd %xmm0, %xmm0
movaps %xmm0, %xmm1
addsd 0xe7c(%rip), %xmm1      # 0x2008
mulsd 0xe7c(%rip), %xmm1      # 0x2010
cvtsd2ss %xmm1, %xmm1
cvtss2sd %xmm1, %xmm1
movq %rbx, %rdi
movb $0x2, %al
callq 0x1040
cmpl $0x119, %ebp            # imm = 0x119
jb 0x1173
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/aap[P]rx-0/pdp1/mach.c
// Function: examinereg
Word
examinereg(int a)
{
	switch(a){
	case REG_PC: return pdp1.pc;
	case REG_AC: return pdp1.ac;
	case REG_IO: return pdp1.io;
	case REG_SS: return pdp1.ss;
	case REG_PF: return pdp1.pf;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $0x4, %edi
ja 0x4231
movl %edi, %eax
leaq 0x2070(%rip), %rcx      # 0x6270
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl 0xa381(%rip), %eax      # 0xe590
jmp 0x4233
movl 0xe3dd(%rip), %eax      # 0x125f4
jmp 0x4233
movl 0xa365(%rip), %eax      # 0xe584
jmp 0x4233
movl 0xe3c9(%rip), %eax      # 0x125f0
jmp 0x4233
movl 0xa351(%rip), %eax      # 0xe580
jmp 0x4233
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/aap[P]rx-0/pdp1/mach.c
// Function: spec
static void
spec(PDP1 *pdp)
{
	// PB
	pdp->run = 0;
	if(pdp->start_sw || pdp->deposit_sw || pdp->examine_sw)
		pdp->rim = 0;

	// SP1
	pdp->run_enable = 1;
	pdp->ma = 0;
	if(pdp->start_sw)
		pdp->cyc = 0;
	if(pdp->deposit_sw)
		pdp->ac = 0;
	if(pdp->start_sw || pdp->deposit_sw || pdp->examine_sw)
		sc(pdp);

	// SP2
	if(pdp->start_sw || pdp->deposit_sw || pdp->examine_sw)
		pdp->pc |= pdp->ta;
	if(pdp->deposit_sw || pdp->examine_sw || pdp->rim)
		pdp->cyc = 1;
	if(pdp->examine_sw)
		pdp->ir |= 020>>1;
	if(pdp->deposit_sw) {
		pdp->ir |= 024>>1;
		pdp->ac |= pdp->tw;
	}

	// SP3
	if(pdp->deposit_sw || pdp->examine_sw) {
		pdp->ma |= pdp->pc;
		pdp->cychack = 1;
	}

	// SP4
	if(pdp->start_sw || pdp->continue_sw)
		pdp->run = 1;

	pdp->start_sw = 0;
	pdp->stop_sw = 0;
	pdp->continue_sw = 0;
	pdp->examine_sw = 0;
	pdp->deposit_sw = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x0, 0x4034(%rdi)
movl 0x4020(%rdi), %eax
testl %eax, %eax
jne 0x483f
cmpl $0x0, 0x4030(%rdi)
jne 0x483f
cmpl $0x0, 0x402c(%rdi)
je 0x4849
movl $0x0, 0x4058(%rdi)
movl $0x1, 0x4038(%rdi)
movl $0x0, 0xc(%rdi)
testl %eax, %eax
je 0x4868
movl $0x0, 0x403c(%rdi)
movl 0x4030(%rdi), %ecx
testl %ecx, %ecx
je 0x4878
movl $0x0, (%rdi)
movl %ecx, %edx
orl %eax, %edx
jne 0x4887
cmpl $0x0, 0x402c(%rdi)
je 0x48bd
xorl %edx, %edx
movq %rdx, 0x4040(%rdi)
movq %rdx, 0x4050(%rdi)
movq %rdx, 0x4064(%rdi)
movl $0x0, 0x406c(%rdi)
movq %rdx, 0x10(%rdi)
movabsq $0x100000000, %rdx      # imm = 0x100000000
movq %rdx, 0x405c(%rdi)
movl %ecx, %edx
orl %eax, %edx
jne 0x48cc
cmpl $0x0, 0x402c(%rdi)
je 0x48d5
movl 0x4018(%rdi), %edx
orl %edx, 0x10(%rdi)
testl %ecx, %ecx
jne 0x48eb
cmpl $0x0, 0x402c(%rdi)
jne 0x48eb
cmpl $0x0, 0x4058(%rdi)
je 0x48f5
movl $0x1, 0x403c(%rdi)
movl 0x402c(%rdi), %edx
testl %edx, %edx
je 0x4903
orb $0x8, 0x14(%rdi)
testl %ecx, %ecx
je 0x4915
orb $0xa, 0x14(%rdi)
movl 0x401c(%rdi), %ecx
orl %ecx, (%rdi)
jmp 0x4919
testl %edx, %edx
je 0x4929
movl 0x10(%rdi), %ecx
movl %ecx, 0xc(%rdi)
movl $0x1, 0x4080(%rdi)
leaq 0x4020(%rdi), %rcx
testl %eax, %eax
jne 0x493d
cmpl $0x0, 0x4028(%rdi)
je 0x4947
movl $0x1, 0x4034(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rcx)
movl $0x0, 0x10(%rcx)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/aap[P]rx-0/pdp1/mach.c
// Function: initmach
void
initmach(void)
{
	memset(&pdp1, 0, sizeof(pdp1));
	pdp1.ioc = 1;

	int i = 0100;
	pdp1.core[i++] = 0760400;

	cmdchan = chancreate(sizeof(Msg), 1);
	threadcreate(simthread, &pdp1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0x902b(%rip), %rbx      # 0xe580
movl $0x4084, %edx           # imm = 0x4084
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2110
movl $0x1, 0xd072(%rip)      # 0x125e0
movl $0x3e100, 0x9120(%rip)  # imm = 0x3E100
movl $0x8, %edi
movl $0x1, %esi
callq 0x3ddf
movq %rax, 0xd0ea(%rip)      # 0x12678
leaq -0xc3f(%rip), %rdi      # 0x4956
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3be0
// File: /workspace/github_c_makefile_star2_O1/aap[P]rx-0/pdp1/mach.c
// Function: shro
static void
shro(PDP1 *pdp)
{
	int ac = AC;
	int io = IO;
	switch((MB>>9) & 017) {
	case 001:	// RAL
		ac = (AC&~B0)<<1 | (AC&B0)>>17;
		break;
	case 002:	// RIL
		io = (IO&~B0)<<1 | (IO&B0)>>17;
		break;
	case 003:	// RCL
		ac = (AC&~B0)<<1 | (IO&B0)>>17;
		io = (IO&~B0)<<1 | (AC&B0)>>17;
		break;
	case 005:	// SAL
		ac = (AC&B0) | (AC&~(B0|B1))<<1 | (AC&B0)>>17;
		break;
	case 006:	// SIL
		io = (IO&B0) | (IO&~(B0|B1))<<1 | (IO&B0)>>17;
		break;
	case 007:	// SCL
		ac = (AC&B0) | (AC&~(B0|B1))<<1 | (IO&B0)>>17;
		io = (IO&~B0)<<1 | (AC&B0)>>17;
		break;
	case 011:	// RAR
		ac = (AC&B17)<<17 | AC>>1;
		break;
	case 012:	// RIR
		io = (IO&B17)<<17 | IO>>1;
		break;
	case 013:	// RCR
		ac = (IO&B17)<<17 | AC>>1;
		io = (AC&B17)<<17 | IO>>1;
		break;
	case 015:	// SAR
		ac = (AC&B0) | AC>>1;
		break;
	case 016:	// SIR
		io = (IO&B0) | IO>>1;
		break;
	case 017:	// SCR
		ac = (AC&B0) | AC>>1;
		io = (AC&B17)<<17 | IO>>1;
		break;
	}
	AC = ac;
	IO = io;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl (%rdi), %ecx
movl 0x4(%rdi), %eax
movl 0x8(%rdi), %edx
shrl $0x9, %edx
andl $0xf, %edx
decl %edx
cmpl $0xe, %edx
ja 0x56d8
leaq 0xdcb(%rip), %rsi       # 0x6398
movslq (%rsi,%rdx,4), %rdx
addq %rsi, %rdx
jmpq *%rdx
movl %ecx, %edx
andl $0xfffdffff, %edx       # imm = 0xFFFDFFFF
shrl $0x11, %ecx
andl $0x1, %ecx
leal (%rcx,%rdx,2), %ecx
jmp 0x56d8
movl %eax, %edx
andl $0x20000, %edx          # imm = 0x20000
jmp 0x567b
movl $0xfffdffff, %edx       # imm = 0xFFFDFFFF
movl %ecx, %esi
andl %edx, %esi
movl %eax, %r8d
shrl $0x11, %r8d
andl $0x1, %r8d
leal (%r8,%rsi,2), %esi
andl %edx, %eax
shrl $0x11, %ecx
andl $0x1, %ecx
leal (%rcx,%rax,2), %eax
jmp 0x56d6
movl %ecx, %edx
andl $0x20000, %edx          # imm = 0x20000
andl $0xfffcffff, %ecx       # imm = 0xFFFCFFFF
movl %eax, %esi
shrl $0x11, %esi
andl $0x1, %esi
leal (%rsi,%rcx,2), %ecx
orl %edx, %ecx
andl $0xfffdffff, %eax       # imm = 0xFFFDFFFF
shrl $0x11, %edx
leal (%rdx,%rax,2), %eax
jmp 0x56d8
movl %ecx, %edx
andl $0x20000, %edx          # imm = 0x20000
jmp 0x56c6
movl %eax, %edx
andl $0xfffdffff, %edx       # imm = 0xFFFDFFFF
shrl $0x11, %eax
andl $0x1, %eax
leal (%rax,%rdx,2), %eax
jmp 0x56d8
movl %ecx, %edx
andl $0x1, %edx
shll $0x11, %edx
jmp 0x56b8
movl %eax, %edx
andl $0x1, %edx
shll $0x11, %edx
shrl %eax
jmp 0x56ac
movl %ecx, %edx
andl $0x20000, %edx          # imm = 0x20000
andl $0xfffcffff, %ecx       # imm = 0xFFFCFFFF
movl %edx, %esi
shrl $0x11, %esi
leal (%rsi,%rcx,2), %ecx
jmp 0x56ba
movl %eax, %edx
andl $0x20000, %edx          # imm = 0x20000
andl $0xfffcffff, %eax       # imm = 0xFFFCFFFF
movl %edx, %esi
shrl $0x11, %esi
leal (%rsi,%rax,2), %eax
orl %edx, %eax
jmp 0x56d8
movl %ecx, %edx
andl $0x20000, %edx          # imm = 0x20000
shrl %ecx
orl %edx, %ecx
jmp 0x56d8
movl %eax, %edx
andl $0x1, %edx
shll $0x11, %edx
movl %ecx, %esi
shrl %esi
orl %edx, %esi
andl $0x1, %ecx
shll $0x11, %ecx
shrl %eax
orl %ecx, %eax
movl %esi, %ecx
movl %ecx, (%rdi)
movl %eax, 0x4(%rdi)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/tyabu12[P]pl0compiler/codegen.c
// Function: genCodeV
int genCodeV(OpCode op, int v) { /* 命令語の生成、アドレス部にv         */
    checkMax();
    code[cIndex].opCode = op;
    code[cIndex].u.value = v;
    return cIndex;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebx
movl %edi, %ebp
movl 0x5df6(%rip), %eax      # 0x80d8
leal 0x1(%rax), %ecx
movl %ecx, 0x5ded(%rip)      # 0x80d8
cmpl $0xc7, %eax
jl 0x22fe
leaq 0x2f2e(%rip), %rdi      # 0x5227
callq 0x3953
movslq 0x5dd3(%rip), %rax      # 0x80d8
leaq (%rax,%rax,2), %rcx
leaq 0x5de0(%rip), %rdx      # 0x80f0
movl %ebp, (%rdx,%rcx,4)
movl %ebx, 0x4(%rdx,%rcx,4)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/tyabu12[P]pl0compiler/codegen.c
// Function: genCodeT
int genCodeT(OpCode op, int ti) { /* 命令語の生成、アドレスは名前表から */
    checkMax();
    code[cIndex].opCode = op;
    code[cIndex].u.addr = relAddr(ti);
    return cIndex;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movl %edi, %ebp
movl 0x5da9(%rip), %eax      # 0x80d8
leal 0x1(%rax), %ecx
movl %ecx, 0x5da0(%rip)      # 0x80d8
cmpl $0xc7, %eax
jl 0x234b
leaq 0x2ee1(%rip), %rdi      # 0x5227
callq 0x3953
movslq 0x5d86(%rip), %rax      # 0x80d8
leaq (%rax,%rax,2), %r14
leaq 0x5d93(%rip), %r15      # 0x80f0
movl %ebp, (%r15,%r14,4)
movl %ebx, %edi
callq 0x34e1
movq %rax, 0x4(%r15,%r14,4)
movl 0x5d65(%rip), %eax      # 0x80d8
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/tyabu12[P]pl0compiler/codegen.c
// Function: genCodeO
int genCodeO(Operator p) {      /* 命令語の生成、アドレス部に演算命令    */
    checkMax();
    code[cIndex].opCode = opr;
    code[cIndex].u.optr = p;
    return cIndex;
}

// Assembly:
pushq %rbx
movl %edi, %ebx
movl 0x5d51(%rip), %eax      # 0x80d8
leal 0x1(%rax), %ecx
movl %ecx, 0x5d48(%rip)      # 0x80d8
cmpl $0xc7, %eax
jl 0x23a3
leaq 0x2e89(%rip), %rdi      # 0x5227
callq 0x3953
movslq 0x5d2e(%rip), %rax      # 0x80d8
leaq (%rax,%rax,2), %rcx
leaq 0x5d3b(%rip), %rdx      # 0x80f0
movl $0x1, (%rdx,%rcx,4)
movl %ebx, 0x4(%rdx,%rcx,4)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/tyabu12[P]pl0compiler/codegen.c
// Function: genCodeR
int genCodeR() {                /* ret命令語の生成                      */
    if (code[cIndex].opCode == ret)
        return cIndex;          /* 直前がretなら生成せず                */
    checkMax();
    code[cIndex].opCode = ret;
    code[cIndex].u.addr.level = bLevel();
    code[cIndex].u.addr.addr = fPars(); /* パラメタ数（実行スタックの解放用） */
    return cIndex;
}

// Assembly:
pushq %rbx
movslq 0x5d0e(%rip), %rax      # 0x80d8
leaq (%rax,%rax,2), %rcx
leaq 0x5d1b(%rip), %rbx      # 0x80f0
cmpl $0x5, (%rbx,%rcx,4)
je 0x2437
leal 0x1(%rax), %ecx
movl %ecx, 0x5cf4(%rip)      # 0x80d8
cmpl $0xc7, %eax
jl 0x23f7
leaq 0x2e35(%rip), %rdi      # 0x5227
callq 0x3953
movslq 0x5cda(%rip), %rax      # 0x80d8
leaq (%rax,%rax,2), %rax
movl $0x5, (%rbx,%rax,4)
xorl %eax, %eax
callq 0x324a
movslq 0x5cc1(%rip), %rcx      # 0x80d8
leaq (%rcx,%rcx,2), %rcx
movl %eax, 0x4(%rbx,%rcx,4)
xorl %eax, %eax
callq 0x3251
movl %eax, %ecx
movslq 0x5ca9(%rip), %rax      # 0x80d8
leaq (%rax,%rax,2), %rdx
movl %ecx, 0x8(%rbx,%rdx,4)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/tyabu12[P]pl0compiler/codegen.c
// Function: listCode
void listCode(FILE *fp, int showLineNumber) { /* 命令語のリスティング */
    int i;
    if (fp == NULL) {
      fp = stdin;
      fprintf(stdout, "\ncode\n");
    }
    for (i = 0; i <= cIndex; i++) {
        if (showLineNumber) fprintf(fp, "%3d: ", i);
        printCode(fp, i, '\n');
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
testq %rdi, %rdi
jne 0x248f
movq 0x5b5c(%rip), %rax      # 0x7fc8
movq (%rax), %r14
movq 0x5b4a(%rip), %rax      # 0x7fc0
movq (%rax), %rcx
leaq 0x2cc8(%rip), %rdi      # 0x5148
movl $0x6, %esi
movl $0x1, %edx
callq 0x2180
cmpl $0x0, 0x5c42(%rip)      # 0x80d8
js 0x24d0
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
leaq 0x2cab(%rip), %r15      # 0x514f
incl %ebp
testl %ebx, %ebx
je 0x24b9
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
xorl %eax, %eax
callq 0x2110
movq %r14, %rdi
movl %ebp, %esi
movl $0xa, %edx
callq 0x24db
cmpl 0x5c0a(%rip), %ebp      # 0x80d8
jl 0x24a4
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/tyabu12[P]pl0compiler/codegen.c
// Function: initMemory
void initMemory(Mem *m, const int *secretValue) { /* 目的コード（命令語）の実行メモリの初期化 */
    int i;
    m->top = m->pc = 0;             /* top:次にスタックに入れる場所、pc:命令語のカウンタ */
    m->stack[0] = m->stack[1] = 0;  /* stack[top]はcalleeで壊すディスプレイの退避場所 */
                                    /* stack[top+1]はcallerへの戻り番地 */
    m->topMax = 1;
    for (i = 2; i < MAXMEM; i++) m->stack[i] = -1;
    m->display[0] = 0;              /* 主ブロックの先頭番地は 0 */
    for (i = 1; i < MAXLEVEL; i++) m->display[i] = -1;
    m->exitCode = 0;                /* 未終了状態 */
    m->stepCount = 0;               /* 初期ステップ数は 0 */
    for (i = 0;i < MAXSCREEN; i++) m->screen[i] = '\0';
    m->breakPoint = -1;             /* ブレークポイントは未設定 */
    if (secretValue) { /* シークレットモード */
      m->stack[2] = *secretValue; /* 第3セルに値を格納 */
      m->topMax = 2;
      m->secretMode = 1;
      m->secretValue = *secretValue;
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
xorl %eax, %eax
movq %rax, 0x1f54(%rdi)
movq %rax, (%rdi)
movl $0x1, 0x1f5c(%rdi)
addq $0x8, %rdi
movl $0x1f38, %edx           # imm = 0x1F38
movl $0xff, %esi
callq 0x20c0
movl $0x0, 0x1f40(%rbx)
pcmpeqd %xmm0, %xmm0
movdqu %xmm0, 0x1f44(%rbx)
leaq 0x1f60(%rbx), %rdi
movl $0x208, %edx            # imm = 0x208
xorl %esi, %esi
callq 0x20c0
movl $0xffffffff, 0x2168(%rbx) # imm = 0xFFFFFFFF
testq %r14, %r14
je 0x294e
movl (%r14), %eax
movl %eax, 0x8(%rbx)
movl $0x2, 0x1f5c(%rbx)
movl $0x1, 0x216c(%rbx)
movl (%r14), %eax
movl %eax, 0x2170(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/tyabu12[P]pl0compiler/codegen.c
// Function: stepBackward
void stepBackward(Mem *m) {     /* 目的コード（命令語）の1ステップ後退 */
  const int stepCount = m->stepCount;
  const int secretMode = m->secretMode, secretValue = m->secretValue;
  if (stepCount == 0) return; /* これ以上後退できない */
  initMemory(m, (secretMode ? &secretValue : NULL));
  while (m->stepCount != stepCount-1) stepForward(m); /* 1つ前のステップまで前進 */
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl 0x1f64(%rdi), %ebp
movl 0x216c(%rdi), %eax
movl 0x2170(%rdi), %ecx
movl %ecx, 0x4(%rsp)
testl %ebp, %ebp
je 0x2ef5
movq %rdi, %rbx
xorl %ecx, %ecx
testl %eax, %eax
leaq 0x4(%rsp), %rsi
cmoveq %rcx, %rsi
callq 0x28c0
decl %ebp
cmpl %ebp, 0x1f64(%rbx)
je 0x2ef5
movq %rbx, %rdi
callq 0x2b83
jmp 0x2ee3
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/tyabu12[P]pl0compiler/table.c
// Function: blockBegin
void blockBegin(int firstAddr) { /* ブロックの始まり(最初の変数の番地)で呼ばれる */
    if (level == -1) {          /* 主ブロックの時、初期設定             */
        localAddr = firstAddr;
        tIndex = 0;
        level++;
        return;
    }
    if (level == MAXLEVEL-1)
        errorF("too many nested blocks");
    lIndex[level] = tIndex;     /* 今までのブロックの情報を格納         */
    addr[level] = localAddr;
    localAddr = firstAddr;      /* 新しいブロックの最初の変数の番地     */
    level++;                    /* 新しいブロックのレベル               */
    return;
}

// Assembly:
pushq %rbx
movl %edi, %ebx
movl 0x4f23(%rip), %eax      # 0x80dc
cmpl $0x4, %eax
je 0x31d5
cmpl $-0x1, %eax
jne 0x31e1
movl %ebx, 0x5887(%rip)      # 0x8a50
movl $0x0, 0x5881(%rip)      # 0x8a54
jmp 0x320e
leaq 0x2104(%rip), %rdi      # 0x52e0
callq 0x3953
movl 0x586d(%rip), %eax      # 0x8a54
movslq 0x4eee(%rip), %rcx      # 0x80dc
leaq 0x586b(%rip), %rdx      # 0x8a60
movl %eax, (%rdx,%rcx,4)
movl 0x5852(%rip), %eax      # 0x8a50
leaq 0x587b(%rip), %rdx      # 0x8a80
movl %eax, (%rdx,%rcx,4)
movl %ebx, 0x5842(%rip)      # 0x8a50
incl 0x4ec8(%rip)            # 0x80dc
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/tyabu12[P]pl0compiler/table.c
// Function: enterTfunc
int enterTfunc(char *id, int v) { /* 名前表に関数名と先頭番地を登録     */
    enterT(id);
    nameTable[tIndex].kind = funcId;
    nameTable[tIndex].u.f.raddr.level = level;
    nameTable[tIndex].u.f.raddr.addr = v; /* 関数の先頭番地             */
    nameTable[tIndex].u.f.pars = 0; /* パラメタ数の初期値               */
    tfIndex = tIndex;
    return tIndex;
}

// Assembly:
pushq %rbx
movl %esi, %ebx
callq 0x3278
movslq 0x578b(%rip), %rax      # 0x8a54
leaq (%rax,%rax,2), %rcx
shlq $0x4, %rcx
leaq 0x57c8(%rip), %rdx      # 0x8aa0
movl $0x1, (%rcx,%rdx)
movl 0x4df7(%rip), %esi      # 0x80dc
movl %esi, 0x24(%rcx,%rdx)
movl %ebx, 0x28(%rcx,%rdx)
movl $0x0, 0x2c(%rcx,%rdx)
movl %eax, 0x6a65(%rip)      # 0x9d60
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/tyabu12[P]pl0compiler/table.c
// Function: enterTpar
int enterTpar(char *id) {       /* 名前表にパラメタ名を登録             */
    enterT(id);
    nameTable[tIndex].kind = parId;
    nameTable[tIndex].u.raddr.level = level;
    nameTable[tfIndex].u.f.pars++; /* 関数のパラメタ数のカウント        */
    return tIndex;
}

// Assembly:
pushq %rax
callq 0x3278
movslq 0x574a(%rip), %rax      # 0x8a54
leaq (%rax,%rax,2), %rcx
shlq $0x4, %rcx
leaq 0x5787(%rip), %rdx      # 0x8aa0
movl $0x2, (%rcx,%rdx)
movl 0x4db6(%rip), %esi      # 0x80dc
movl %esi, 0x24(%rcx,%rdx)
movslq 0x6a2f(%rip), %rcx      # 0x9d60
leaq (%rcx,%rcx,2), %rcx
shlq $0x4, %rcx
incl 0x2c(%rcx,%rdx)
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/tyabu12[P]pl0compiler/table.c
// Function: enterTvar
int enterTvar(char *id) {       /* 名前表に変数名を登録                 */
    enterT(id);
    nameTable[tIndex].kind = varId;
    nameTable[tIndex].u.raddr.level = level;
    nameTable[tIndex].u.raddr.addr = localAddr++;
    return tIndex;
}

// Assembly:
pushq %rax
callq 0x3278
movslq 0x5708(%rip), %rax      # 0x8a54
leaq (%rax,%rax,2), %rcx
shlq $0x4, %rcx
leaq 0x5745(%rip), %rdx      # 0x8aa0
movl $0x0, (%rcx,%rdx)
movl 0x4d74(%rip), %esi      # 0x80dc
movl %esi, 0x24(%rcx,%rdx)
movl 0x56de(%rip), %esi      # 0x8a50
leal 0x1(%rsi), %edi
movl %edi, 0x56d5(%rip)      # 0x8a50
movl %esi, 0x28(%rcx,%rdx)
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/tyabu12[P]pl0compiler/table.c
// Function: enterTconst
int enterTconst(char *id, int v) { /* 名前表に定数名とその値を登録      */
    enterT(id);
    nameTable[tIndex].kind = constId;
    nameTable[tIndex].u.value = v;
    return tIndex;
}

// Assembly:
pushq %rbx
movl %esi, %ebx
callq 0x3278
movslq 0x56c4(%rip), %rax      # 0x8a54
leaq (%rax,%rax,2), %rcx
shlq $0x4, %rcx
leaq 0x5701(%rip), %rdx      # 0x8aa0
movl $0x3, (%rcx,%rdx)
movl %ebx, 0x24(%rcx,%rdx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/tyabu12[P]pl0compiler/table.c
// Function: endpar
void endpar() {                 /* パラメタ宣言部の最後で呼ばれる       */
    int i;
    int pars = nameTable[tfIndex].u.f.pars;
    if (pars == 0)  return;
    for (i=1; i <= pars; i++)   /* 各パラメタの番地を求める             */
         nameTable[tfIndex+i].u.raddr.addr = i-1-pars;
}

// Assembly:
movslq 0x69ad(%rip), %rax      # 0x9d60
leaq (%rax,%rax,2), %rcx
shlq $0x4, %rcx
leaq 0x56de(%rip), %rdx      # 0x8aa0
movl 0x2c(%rcx,%rdx), %esi
testl %esi, %esi
jle 0x33ed
movl %esi, %eax
negl %eax
addq %rdx, %rcx
addq $0x58, %rcx
xorl %edx, %edx
shlq $0x4, %rsi
leaq (%rsi,%rsi,2), %rsi
movl %eax, (%rcx,%rdx)
incl %eax
addq $0x30, %rdx
cmpq %rdx, %rsi
jne 0x33df
retq
// File: /workspace/github_c_makefile_star2_O1/tyabu12[P]pl0compiler/table.c
// Function: searchT
int searchT(char *id, KindT k) { /* 名前idの名前表の位置を返す          */
                                /* 未宣言の時エラーとする               */
    int i;
    i = tIndex;
    strcpy(nameTable[0].name, id); /* 番兵をたてる                      */
    while ( strcmp(id, nameTable[i].name) )
        i--;
    if (i)                      /* 名前があった                         */
        return i;
    else {                      /* 名前がなかった                       */
        errorType("undef");
        if (k == varId) return enterTvar(id); /* 変数の時は仮登録       */
        return 0;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movslq 0x5638(%rip), %r12      # 0x8a54
leaq 0x5681(%rip), %rdi      # 0x8aa4
movq %rbx, %rsi
callq 0x2050
leaq 0x566e(%rip), %r15      # 0x8aa0
leaq (%r12,%r12,2), %rax
shlq $0x4, %rax
leaq (%rax,%r15), %r14
addq $0x4, %r14
movq $-0x1, %r13
movq %rbx, %rdi
movq %r14, %rsi
callq 0x20f0
incq %r13
addq $-0x30, %r14
testl %eax, %eax
jne 0x3449
cmpq %r13, %r12
jne 0x34b6
leaq 0x1e9b(%rip), %rdi      # 0x5306
callq 0x37fd
xorl %eax, %eax
testl %ebp, %ebp
jne 0x34bc
movq %rbx, %rdi
callq 0x3278
movslq 0x55cf(%rip), %rax      # 0x8a54
leaq (%rax,%rax,2), %rcx
shlq $0x4, %rcx
movl $0x0, (%rcx,%r15)
movl 0x4c41(%rip), %edx      # 0x80dc
movl %edx, 0x24(%rcx,%r15)
movl 0x55aa(%rip), %edx      # 0x8a50
leal 0x1(%rdx), %esi
movl %esi, 0x55a1(%rip)      # 0x8a50
movl %edx, 0x28(%rcx,%r15)
jmp 0x34bc
movl %r12d, %eax
subq %r13, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/tyabu12[P]pl0compiler/getSource.c
// Function: openSource
int openSource(char fileName[], int outHtml) { /* ソースファイルのopen */
    char *fileNameO = "g.out.html";
    if ((fpi = fopen(fileName, "r")) == NULL ) {
        printf("can't open %s\n", fileName);
        return 0;
    }
    if (outHtml) {
        if ((fphtml = fopen(fileNameO, "w")) == NULL) { /* .htmlファイルを作る */
            printf("can't open %s\n", fileNameO);
            return 0;
        }
    } else {
        fphtml = fopen("/dev/null", "w"); /* 書き込みを破棄 */
    }
    return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
leaq 0x1f86(%rip), %rsi      # 0x54c6
callq 0x2140
movq %rax, 0x6824(%rip)      # 0x9d70
testq %rax, %rax
je 0x358b
testl %ebx, %ebx
je 0x35a0
leaq 0x1dc0(%rip), %rdi      # 0x531c
leaq 0x1caa(%rip), %rsi      # 0x520d
callq 0x2140
movq %rax, 0x6809(%rip)      # 0x9d78
movl $0x1, %ebx
testq %rax, %rax
jne 0x35bf
leaq 0x1da7(%rip), %rdi      # 0x5327
leaq 0x1d95(%rip), %rsi      # 0x531c
xorl %ebx, %ebx
jmp 0x3597
leaq 0x1d95(%rip), %rdi      # 0x5327
xorl %ebx, %ebx
movq %r14, %rsi
xorl %eax, %eax
callq 0x2090
jmp 0x35bf
leaq 0x1d8f(%rip), %rdi      # 0x5336
leaq 0x1c5f(%rip), %rsi      # 0x520d
callq 0x2140
movq %rax, 0x67be(%rip)      # 0x9d78
movl $0x1, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/tyabu12[P]pl0compiler/getSource.c
// Function: initSource
void initSource() {
    lineIndex = -1;             /* 初期設定                             */
    ch = '\n';
    printed = 1;
    initCharClassT();
    fprintf(fphtml, "<HTML>\n");  /* htmlコマンド                         */
    fprintf(fphtml, "<HEAD>\n<TITLE>compiled source program</TITLE>\n</HEAD>\n");
    fprintf(fphtml, "<BODY>\n<PRE>\n");
}

// Assembly:
movl $0xffffffff, 0x6793(%rip) # imm = 0xFFFFFFFF
movb $0xa, 0x6790(%rip)      # 0x9d84
movb $0x1, 0x678d(%rip)      # 0x9d88
xorl %ecx, %ecx
leaq 0x67bc(%rip), %rax      # 0x9dc0
movl $0x27, (%rcx,%rax)
addq $0x4, %rcx
cmpq $0x400, %rcx            # imm = 0x400
jne 0x3604
xorl %ecx, %ecx
movl $0x25, 0xc0(%rax,%rcx,4)
incq %rcx
cmpq $0xa, %rcx
jne 0x361a
xorl %ecx, %ecx
movl $0x24, 0x104(%rax,%rcx,4)
incq %rcx
cmpq $0x1a, %rcx
jne 0x3630
xorl %ecx, %ecx
movl $0x24, 0x184(%rax,%rcx,4)
incq %rcx
cmpq $0x1a, %rcx
jne 0x3646
pushq %rax
movabsq $0x1b0000000f, %rax     # imm = 0x1B0000000F
movq %rax, 0x6800(%rip)      # 0x9e6c
movl $0x10, 0x67fe(%rip)     # 0x9e74
movl $0x11, 0x67e8(%rip)     # 0x9e68
movabsq $0x1400000013, %rax     # imm = 0x1400000013
movq %rax, 0x67cf(%rip)      # 0x9e60
movabsq $0x1500000016, %rax     # imm = 0x1500000016
movq %rax, 0x680e(%rip)      # 0x9eb0
movl $0x17, 0x680c(%rip)     # 0x9eb8
movabsq $0x120000001c, %rax     # imm = 0x120000001C
movq %rax, 0x67bb(%rip)      # 0x9e78
movabsq $0x1d00000026, %rax     # imm = 0x1D00000026
movq %rax, 0x67da(%rip)      # 0x9ea8
movq 0x66a3(%rip), %rcx      # 0x9d78
leaq 0x1c64(%rip), %rdi      # 0x5340
movl $0x7, %esi
movl $0x1, %edx
callq 0x2180
movq 0x6686(%rip), %rcx      # 0x9d78
leaq 0x1c4f(%rip), %rdi      # 0x5348
movl $0x36, %esi
movl $0x1, %edx
callq 0x2180
movq 0x6669(%rip), %rcx      # 0x9d78
leaq 0x1c69(%rip), %rdi      # 0x537f
movl $0xd, %esi
movl $0x1, %edx
popq %rax
jmp 0x2180
// File: /workspace/github_c_makefile_star2_O1/tyabu12[P]pl0compiler/getSource.c
// Function: finalSource
void finalSource() {
    if (cToken.kind == Period)
        printcToken();
    else
        errorInsert(Period);
    fprintf(fphtml, "\n</PRE>\n</BODY>\n</HTML>\n");
}

// Assembly:
pushq %rax
cmpl $0x1c, 0x665e(%rip)     # 0x9d8c
jne 0x3737
callq 0x3e2b
jmp 0x375f
movq 0x663a(%rip), %rdi      # 0x9d78
leaq 0x1c91(%rip), %rsi      # 0x53d6
leaq 0x1caa(%rip), %rdx      # 0x53f6
leaq 0x1dad(%rip), %rcx      # 0x5500
xorl %eax, %eax
callq 0x2110
callq 0x37b4
movq 0x6612(%rip), %rcx      # 0x9d78
leaq 0x1cef(%rip), %rdi      # 0x545c
movl $0x18, %esi
movl $0x1, %edx
popq %rax
jmp 0x2180
// File: /workspace/github_c_makefile_star2_O1/tyabu12[P]pl0compiler/getSource.c
// Function: errorNoCheck
void errorNoCheck() {           /* エラーの個数のカウント、多すぎたら終わり */
    if (errorNo++ > MAXERROR) {
        fprintf(fphtml, "too many errors\n</PRE>\n</BODY>\n</HTML>\n");
        printf("abort compilation\n");
        exit(1);
    }
}

// Assembly:
movl 0x65f6(%rip), %eax      # 0x9db0
leal 0x1(%rax), %ecx
movl %ecx, 0x65ed(%rip)      # 0x9db0
cmpl $0x1f, %eax
jge 0x37c9
retq
pushq %rax
movq 0x65a7(%rip), %rcx      # 0x9d78
leaq 0x1bb5(%rip), %rdi      # 0x538d
movl $0x27, %esi
movl $0x1, %edx
callq 0x2180
leaq 0x1d4e(%rip), %rdi      # 0x553c
callq 0x2060
movl $0x1, %edi
callq 0x2170
// File: /workspace/github_c_makefile_star2_O1/tyabu12[P]pl0compiler/getSource.c
// Function: errorType
void errorType(char *m) {       /* 型エラーを.htmlファイルに出力 */
    printSpaces();
    fprintf(fphtml, "<FONT COLOR=%s>%s</FONT>", TYPE_C, m);
    printcToken();
    errorNoCheck();
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x3dd0
movq 0x656b(%rip), %rdi      # 0x9d78
leaq 0x1ba1(%rip), %rsi      # 0x53b5
leaq 0x1bb3(%rip), %rdx      # 0x53ce
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2110
callq 0x3e2b
popq %rbx
jmp 0x37b4
// File: /workspace/github_c_makefile_star2_O1/tyabu12[P]pl0compiler/getSource.c
// Function: errorDelete
void errorDelete() {            /* 今読んだトークンを読み捨てる         */
    int i = (int)cToken.kind;
    printSpaces();
    printed = 1;
    if (i < end_of_KeyWd)       /* 予約語                               */
        fprintf(fphtml, "<FONT COLOR=%s><b>%s</b></FONT>", DELETE_C, KeyWdT[i].word);
    else if (i < end_of_KeySym) /* 演算子か区切り記号                   */
        fprintf(fphtml, "<FONT COLOR=%s>%s</FONT>", DELETE_C, KeyWdT[i].word);
    else if (i==(int)Id)        /* Identfier */
        fprintf(fphtml, "<FONT COLOR=%s>%s</FONT>", DELETE_C, cToken.u.id);
    else if (i==(int)Num)       /* Num */
        fprintf(fphtml, "<FONT COLOR=%s>%d</FONT>", DELETE_C, cToken.u.value);
}

// Assembly:
pushq %rbx
movslq 0x650e(%rip), %rbx      # 0x9d8c
callq 0x3dd0
movb $0x1, 0x64fe(%rip)      # 0x9d88
cmpq $0xd, %rbx
jg 0x38af
movq 0x64e1(%rip), %rdi      # 0x9d78
shlq $0x4, %rbx
leaq 0x432e(%rip), %rax      # 0x7bd0
movq (%rbx,%rax), %rcx
leaq 0x1b29(%rip), %rsi      # 0x53d6
jmp 0x38d1
cmpl $0x1e, %ebx
jg 0x38e0
movq 0x64bd(%rip), %rdi      # 0x9d78
shlq $0x4, %rbx
leaq 0x430a(%rip), %rax      # 0x7bd0
movq (%rbx,%rax), %rcx
leaq 0x1ae4(%rip), %rsi      # 0x53b5
leaq 0x1b57(%rip), %rdx      # 0x542f
xorl %eax, %eax
popq %rbx
jmp 0x2110
cmpl $0x21, %ebx
je 0x3908
cmpl $0x20, %ebx
jne 0x392b
movq 0x6487(%rip), %rdi      # 0x9d78
leaq 0x1abd(%rip), %rsi      # 0x53b5
leaq 0x1b30(%rip), %rdx      # 0x542f
leaq 0x648a(%rip), %rcx      # 0x9d90
jmp 0x38d8
movq 0x6469(%rip), %rdi      # 0x9d78
movl 0x647b(%rip), %ecx      # 0x9d90
leaq 0x1b1b(%rip), %rsi      # 0x5437
leaq 0x1b0c(%rip), %rdx      # 0x542f
xorl %eax, %eax
popq %rbx
jmp 0x2110
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/tyabu12[P]pl0compiler/getSource.c
// Function: errorF
void errorF(char *m) {          /* エラーメッセージを出力し、コンパイル終了 */
    errorMessage(m);
    fprintf(fphtml, "fatal errors\n</PRE>\n</BODY>\n</HTML>\n");
    if (errorNo)
        printf("total %d errors\n", errorNo);
    printf("abort compilation\n");
    exit (1);
}

// Assembly:
pushq %rax
movq %rdi, %rcx
movq 0x641a(%rip), %rdi      # 0x9d78
leaq 0x1a50(%rip), %rsi      # 0x53b5
leaq 0x1a62(%rip), %rdx      # 0x53ce
xorl %eax, %eax
callq 0x2110
callq 0x37b4
movq 0x63f9(%rip), %rcx      # 0x9d78
leaq 0x1aca(%rip), %rdi      # 0x5450
movl $0x24, %esi
movl $0x1, %edx
callq 0x2180
movl 0x6415(%rip), %esi      # 0x9db0
testl %esi, %esi
je 0x39ad
leaq 0x1acf(%rip), %rdi      # 0x5475
xorl %eax, %eax
callq 0x2090
leaq 0x1b88(%rip), %rdi      # 0x553c
callq 0x2060
movl $0x1, %edi
callq 0x2170
// File: /workspace/github_c_makefile_star2_O1/tyabu12[P]pl0compiler/getSource.c
// Function: checkGet
Token checkGet(Token t, KeyId k) { /* t.kind == k のチェック            */
    /* t.kind == k なら、次のトークンを読んで返す                       */
    /* t.kind != k ならエラーメッセージを出し、t と k が共に記号、または予約語なら */
    /* t を捨て、次のトークンを読んで返す（ t を k で置き換えたことになる） */
    /* それ以外の場合、k を挿入したことにして、t を返す                 */
    if (t.kind == k)
        return nextToken();
    if ((isKeyWd(k) && isKeyWd(t.kind)) ||
        (isKeySym(k) && isKeySym(t.kind))){
        errorDelete();
        errorInsert(k);
        return nextToken();
    }
    errorInsert(k);
    return t;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0x20(%rsp), %eax
cmpl %esi, %eax
je 0x3d55
movl %esi, %r14d
cmpl $0xe, %esi
setb %cl
cmpl $0xe, %eax
setb %dl
testb %dl, %cl
jne 0x3d1d
leal -0x1f(%r14), %ecx
cmpl $-0x11, %ecx
setb %cl
addl $-0x1f, %eax
cmpl $-0x11, %eax
setb %al
orb %cl, %al
je 0x3d1d
leaq 0x20(%rsp), %r15
movq 0x60a0(%rip), %rdi      # 0x9d78
movl %r14d, %eax
shlq $0x4, %rax
leaq 0x3eea(%rip), %rcx      # 0x7bd0
movq (%rax,%rcx), %rcx
leaq 0x16e5(%rip), %rsi      # 0x53d6
leaq 0x16fe(%rip), %rdx      # 0x53f6
xorl %eax, %eax
callq 0x2110
callq 0x37b4
movl 0x20(%r15), %eax
movl %eax, 0x20(%rbx)
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
jmp 0x3d5d
callq 0x3876
movq 0x604f(%rip), %rdi      # 0x9d78
movl %r14d, %eax
shlq $0x4, %rax
leaq 0x3e99(%rip), %rcx      # 0x7bd0
movq (%rax,%rcx), %rcx
leaq 0x1694(%rip), %rsi      # 0x53d6
leaq 0x16ad(%rip), %rdx      # 0x53f6
xorl %eax, %eax
callq 0x2110
callq 0x37b4
movq %rbx, %rdi
callq 0x39ca
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq