LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsobject.c
// Function: Op_toString
static void Op_toString(js_State *J)
{
	if (js_isundefined(J, 0))
		js_pushliteral(J, "[object Undefined]");
	else if (js_isnull(J, 0))
		js_pushliteral(J, "[object Null]");
	else {
		js_Object *self = js_toobject(J, 0);
		switch (self->type) {
		case JS_COBJECT: js_pushliteral(J, "[object Object]"); break;
		case JS_CARRAY: js_pushliteral(J, "[object Array]"); break;
		case JS_CFUNCTION: js_pushliteral(J, "[object Function]"); break;
		case JS_CSCRIPT: js_pushliteral(J, "[object Function]"); break;
		case JS_CCFUNCTION: js_pushliteral(J, "[object Function]"); break;
		case JS_CERROR: js_pushliteral(J, "[object Error]"); break;
		case JS_CBOOLEAN: js_pushliteral(J, "[object Boolean]"); break;
		case JS_CNUMBER: js_pushliteral(J, "[object Number]"); break;
		case JS_CSTRING: js_pushliteral(J, "[object String]"); break;
		case JS_CREGEXP: js_pushliteral(J, "[object RegExp]"); break;
		case JS_CDATE: js_pushliteral(J, "[object Date]"); break;
		case JS_CMATH: js_pushliteral(J, "[object Math]"); break;
		case JS_CJSON: js_pushliteral(J, "[object JSON]"); break;
		case JS_CARGUMENTS: js_pushliteral(J, "[object Arguments]"); break;
		case JS_CITERATOR: js_pushliteral(J, "[object Iterator]"); break;
		case JS_CUSERDATA:
			js_pushliteral(J, "[object ");
			js_pushliteral(J, self->u.user.tag);
			js_concat(J);
			js_pushliteral(J, "]");
			js_concat(J);
			break;
		}
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %esi, %esi
callq 0xf8bb
testl %eax, %eax
je 0xc90b
leaq 0x1d12d(%rip), %rsi     # 0x29a36
jmp 0xc920
movq %rbx, %rdi
xorl %esi, %esi
callq 0xf8ce
testl %eax, %eax
je 0xc92f
leaq 0x1d129(%rip), %rsi     # 0x29a49
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x5a13
movq %rbx, %rdi
xorl %esi, %esi
callq 0xd49c
movq %rax, %r14
movl (%rax), %eax
cmpq $0xf, %rax
ja 0xca26
leaq 0x13d59(%rip), %rcx     # 0x206a8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x1d117(%rip), %rsi     # 0x29a76
jmp 0xc920
leaq 0x1d1ad(%rip), %rsi     # 0x29b15
jmp 0xc920
leaq 0x1d175(%rip), %rsi     # 0x29ae6
jmp 0xc920
leaq 0x1d17a(%rip), %rsi     # 0x29af4
jmp 0xc920
leaq 0x1d145(%rip), %rsi     # 0x29ac8
jmp 0xc920
leaq 0x1d19b(%rip), %rsi     # 0x29b27
movq %rbx, %rdi
callq 0x5a13
movq 0x20(%r14), %rsi
movq %rbx, %rdi
callq 0x5a13
movq %rbx, %rdi
callq 0x13be7
leaq 0x1d7f7(%rip), %rsi     # 0x2a1a6
movq %rbx, %rdi
callq 0x5a13
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x13be7
leaq 0x1d08a(%rip), %rsi     # 0x29a57
jmp 0xc920
leaq 0x1d08e(%rip), %rsi     # 0x29a67
jmp 0xc920
leaq 0x1d0c3(%rip), %rsi     # 0x29aa8
jmp 0xc920
leaq 0x1d097(%rip), %rsi     # 0x29a88
jmp 0xc920
leaq 0x1d105(%rip), %rsi     # 0x29b02
jmp 0xc920
leaq 0x1d08e(%rip), %rsi     # 0x29a97
jmp 0xc920
leaq 0x1d0c3(%rip), %rsi     # 0x29ad8
jmp 0xc920
leaq 0x1d097(%rip), %rsi     # 0x29ab8
jmp 0xc920
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsobject.c
// Function: Op_hasOwnProperty
static void Op_hasOwnProperty(js_State *J)
{
	js_Object *self = js_toobject(J, 0);
	const char *name = js_tostring(J, 1);
	js_Property *ref;
	int k;

	if (self->type == JS_CSTRING) {
		if (js_isarrayindex(J, name, &k) && k >= 0 && k < self->u.s.length) {
			js_pushboolean(J, 1);
			return;
		}
	}

	if (self->type == JS_CARRAY && self->u.a.simple) {
		if (js_isarrayindex(J, name, &k) && k >= 0 && k < self->u.a.flat_length) {
			js_pushboolean(J, 1);
			return;
		}
	}

	ref = jsV_getownproperty(J, self, name);
	js_pushboolean(J, ref != NULL);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
xorl %esi, %esi
callq 0xd49c
movq %rax, %r14
pushq $0x1
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
callq 0xf64d
movq %rax, %r15
movl (%r14), %eax
cmpl $0x1, %eax
je 0xca98
cmpl $0x8, %eax
jne 0xcaca
leaq 0xc(%rsp), %r12
movq %r15, %rsi
movq %r12, %rdx
callq 0x1022f
testl %eax, %eax
setne %cl
movl (%r12), %eax
testl %eax, %eax
setns %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0xcaca
cmpl 0x20(%r14), %eax
jge 0xcaca
jmp 0xcadf
cmpl $0x0, 0x24(%r14)
je 0xcaca
leaq 0xc(%rsp), %r12
movq %r15, %rsi
movq %r12, %rdx
callq 0x1022f
testl %eax, %eax
setne %cl
movl (%r12), %eax
testl %eax, %eax
setns %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0xcaca
cmpl 0x28(%r14), %eax
jl 0xcadf
movq 0x8(%r14), %rdi
movq %r15, %rsi
callq 0xdc30
xorl %ebp, %ebp
testq %rax, %rax
setne %bpl
movq %rbx, %rdi
movl %ebp, %esi
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xf7ba
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsobject.c
// Function: Op_isPrototypeOf
static void Op_isPrototypeOf(js_State *J)
{
	js_Object *self = js_toobject(J, 0);
	if (js_isobject(J, 1)) {
		js_Object *V = js_toobject(J, 1);
		do {
			V = V->prototype;
			if (V == self) {
				js_pushboolean(J, 1);
				return;
			}
		} while (V);
	}
	js_pushboolean(J, 0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %ebp, %ebp
xorl %esi, %esi
callq 0xd49c
movq %rax, %r14
pushq $0x1
popq %r15
movq %rbx, %rdi
movl %r15d, %esi
callq 0xd489
testl %eax, %eax
je 0xcb3c
movq %rbx, %rdi
movl %r15d, %esi
callq 0xd49c
movq 0x18(%rax), %rax
cmpq %r14, %rax
je 0xcb39
testq %rax, %rax
jne 0xcb29
jmp 0xcb3c
movl %r15d, %ebp
movq %rbx, %rdi
movl %ebp, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xf7ba
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsobject.c
// Function: Op_propertyIsEnumerable
static void Op_propertyIsEnumerable(js_State *J)
{
	js_Object *self = js_toobject(J, 0);
	const char *name = js_tostring(J, 1);
	js_Property *ref = jsV_getownproperty(J, self, name);
	js_pushboolean(J, ref && !(ref->atts & JS_DONTENUM));
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %ebp, %ebp
xorl %esi, %esi
callq 0xd49c
movq %rax, %r14
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0xf64d
movq 0x8(%r14), %rdi
movq %rax, %rsi
callq 0xdc30
testq %rax, %rax
je 0xcb89
xorl %ebp, %ebp
testb $0x2, 0x14(%rax)
sete %bpl
movq %rbx, %rdi
movl %ebp, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0xf7ba
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsobject.c
// Function: jsB_Object
static void jsB_Object(js_State *J)
{
	if (js_isundefined(J, 1) || js_isnull(J, 1))
		js_newobject(J);
	else
		js_pushobject(J, js_toobject(J, 1));
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0xf8bb
testl %eax, %eax
jne 0xcbb6
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0xf8ce
testl %eax, %eax
je 0xcbbf
movq %rbx, %rdi
popq %rbx
jmp 0x13813
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0xd49c
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
jmp 0x4274
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsobject.c
// Function: jsB_new_Object
static void jsB_new_Object(js_State *J)
{
	if (js_isundefined(J, 1) || js_isnull(J, 1))
		js_newobject(J);
	else
		js_pushobject(J, js_toobject(J, 1));
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0xf8bb
testl %eax, %eax
jne 0xcbf5
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0xf8ce
testl %eax, %eax
je 0xcbfe
movq %rbx, %rdi
popq %rbx
jmp 0x13813
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0xd49c
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
jmp 0x4274
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsobject.c
// Function: O_getPrototypeOf
static void O_getPrototypeOf(js_State *J)
{
	js_Object *obj;
	if (!js_isobject(J, 1))
		js_typeerror(J, "not an object");
	obj = js_toobject(J, 1);
	if (obj->prototype)
		js_pushobject(J, obj->prototype);
	else
		js_pushnull(J);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0xd489
testl %eax, %eax
je 0xcc48
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0xd49c
movq 0x18(%rax), %rsi
movq %rbx, %rdi
testq %rsi, %rsi
je 0xcc42
popq %rbx
jmp 0x4274
popq %rbx
jmp 0xe756
leaq 0x1d498(%rip), %rsi     # 0x2a0e7
movq %rbx, %rdi
xorl %eax, %eax
callq 0x99a6
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsobject.c
// Function: O_getOwnPropertyDescriptor
static void O_getOwnPropertyDescriptor(js_State *J)
{
	js_Object *obj;
	js_Property *ref;
	if (!js_isobject(J, 1))
		js_typeerror(J, "not an object");
	obj = js_toobject(J, 1);
	ref = jsV_getproperty(J, obj, js_tostring(J, 2));
	if (!ref) {
		/* TODO: builtin properties (string and array index and length, regexp flags, etc) */
		js_pushundefined(J);
	} else {
		js_newobject(J);
		if (!ref->getter && !ref->setter) {
			js_pushvalue(J, ref->value);
			js_defproperty(J, -2, "value", 0);
			js_pushboolean(J, !(ref->atts & JS_READONLY));
			js_defproperty(J, -2, "writable", 0);
		} else {
			if (ref->getter)
				js_pushobject(J, ref->getter);
			else
				js_pushundefined(J);
			js_defproperty(J, -2, "get", 0);
			if (ref->setter)
				js_pushobject(J, ref->setter);
			else
				js_pushundefined(J);
			js_defproperty(J, -2, "set", 0);
		}
		js_pushboolean(J, !(ref->atts & JS_DONTENUM));
		js_defproperty(J, -2, "enumerable", 0);
		js_pushboolean(J, !(ref->atts & JS_DONTCONF));
		js_defproperty(J, -2, "configurable", 0);
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0xd489
testl %eax, %eax
je 0xcda9
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0xd49c
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0xf64d
movq %r14, %rsi
movq %rax, %rdx
callq 0xdca4
testq %rax, %rax
je 0xccb7
movq %rax, %r14
movq %rbx, %rdi
callq 0x13813
movq 0x28(%r14), %rsi
testq %rsi, %rsi
je 0xccc3
movq %rbx, %rdi
callq 0x4274
jmp 0xccd6
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x7336
cmpq $0x0, 0x30(%r14)
je 0xcd68
movq %rbx, %rdi
callq 0x7336
leaq 0x1ce5c(%rip), %rdx     # 0x29b39
pushq $-0x2
popq %rsi
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x5963
movq 0x30(%r14), %rsi
movq %rbx, %rdi
testq %rsi, %rsi
je 0xccfd
callq 0x4274
jmp 0xcd02
callq 0x7336
leaq 0x1b249(%rip), %rdx     # 0x27f52
pushq $-0x2
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
xorl %ecx, %ecx
callq 0x5963
xorl %esi, %esi
testb $0x2, 0x14(%r14)
sete %sil
movq %rbx, %rdi
callq 0xf7ba
leaq 0x1ce0b(%rip), %rdx     # 0x29b3d
movq %rbx, %rdi
movl %ebp, %esi
xorl %ecx, %ecx
callq 0x5963
xorl %esi, %esi
testb $0x4, 0x14(%r14)
sete %sil
movq %rbx, %rdi
callq 0xf7ba
leaq 0x1d347(%rip), %rdx     # 0x2a09f
movq %rbx, %rdi
movl %ebp, %esi
xorl %ecx, %ecx
popq %rbx
popq %r14
popq %rbp
jmp 0x5963
movq 0x18(%r14), %rsi
movq 0x20(%r14), %rdx
movq %rbx, %rdi
callq 0xf74a
leaq 0x1bf39(%rip), %rdx     # 0x28cb8
pushq $-0x2
popq %rsi
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x5963
movl 0x14(%r14), %esi
notl %esi
andl $0x1, %esi
movq %rbx, %rdi
callq 0xf7ba
leaq 0x1cd8c(%rip), %rdx     # 0x29b30
jmp 0xcd09
leaq 0x1d337(%rip), %rsi     # 0x2a0e7
movq %rbx, %rdi
xorl %eax, %eax
callq 0x99a6
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsobject.c
// Function: O_create
static void O_create(js_State *J)
{
	js_Object *obj;
	js_Object *proto;
	js_Object *props;

	if (js_isobject(J, 1))
		proto = js_toobject(J, 1);
	else if (js_isnull(J, 1))
		proto = NULL;
	else
		js_typeerror(J, "not an object or null");

	obj = jsV_newobject(J, JS_COBJECT, proto);
	js_pushobject(J, obj);

	if (js_isdefined(J, 2)) {
		if (!js_isobject(J, 2))
			js_typeerror(J, "not an object");
		props = js_toobject(J, 2);
		if (props->properties->level)
			O_create_walk(J, obj, props->properties);
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0xd489
pushq $0x1
popq %rsi
movq %rbx, %rdi
testl %eax, %eax
je 0xcfe3
callq 0xd49c
movq %rax, %rdx
jmp 0xcfee
callq 0xf8ce
testl %eax, %eax
je 0xd05c
xorl %edx, %edx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x5d6b
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x4274
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0xf8a8
testl %eax, %eax
je 0xd04b
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0xd489
testl %eax, %eax
je 0xd053
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0xd49c
movq 0x8(%rax), %rdx
cmpl $0x0, 0x10(%rdx)
je 0xd04b
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x193e3
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x1d08d(%rip), %rsi     # 0x2a0e7
jmp 0xd063
leaq 0x1cb12(%rip), %rsi     # 0x29b75
movq %rbx, %rdi
xorl %eax, %eax
callq 0x99a6
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsobject.c
// Function: O_defineProperty
static void O_defineProperty(js_State *J)
{
	if (!js_isobject(J, 1)) js_typeerror(J, "not an object");
	if (!js_isobject(J, 3)) js_typeerror(J, "not an object");
	ToPropertyDescriptor(J, js_toobject(J, 1), js_tostring(J, 2), js_toobject(J, 3));
	js_copy(J, 1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0xd489
testl %eax, %eax
je 0xd0e0
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0xd489
testl %eax, %eax
je 0xd0e0
pushq $0x1
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
callq 0xd49c
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0xf64d
movq %rax, %r15
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0xd49c
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %rax, %rcx
callq 0x19448
movq %rbx, %rdi
movl %ebp, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xeee2
leaq 0x1d000(%rip), %rsi     # 0x2a0e7
movq %rbx, %rdi
xorl %eax, %eax
callq 0x99a6
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsobject.c
// Function: O_defineProperties
static void O_defineProperties(js_State *J)
{
	js_Object *props;

	if (!js_isobject(J, 1)) js_typeerror(J, "not an object");
	if (!js_isobject(J, 2)) js_typeerror(J, "not an object");

	props = js_toobject(J, 2);
	if (props->properties->level)
		O_defineProperties_walk(J, props->properties);

	js_copy(J, 1);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0xd489
testl %eax, %eax
je 0xd139
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0xd489
testl %eax, %eax
je 0xd139
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0xd49c
movq 0x8(%rax), %rsi
cmpl $0x0, 0x10(%rsi)
je 0xd12d
movq %rbx, %rdi
callq 0x195e2
pushq $0x1
popq %rsi
movq %rbx, %rdi
popq %rbx
jmp 0xeee2
leaq 0x1cfa7(%rip), %rsi     # 0x2a0e7
movq %rbx, %rdi
xorl %eax, %eax
callq 0x99a6
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsobject.c
// Function: O_seal
static void O_seal(js_State *J)
{
	js_Object *obj;

	if (!js_isobject(J, 1))
		js_typeerror(J, "not an object");

	obj = js_toobject(J, 1);
	jsR_unflattenarray(J, obj);
	obj->extensible = 0;

	if (obj->properties->level)
		O_seal_walk(J, obj->properties);

	js_copy(J, 1);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0xd489
testl %eax, %eax
je 0xd19c
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0xd49c
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10280
andl $0x0, 0x4(%r14)
movq 0x8(%r14), %rdi
cmpl $0x0, 0x10(%rdi)
je 0xd18a
callq 0x19671
pushq $0x1
popq %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xeee2
leaq 0x1cf44(%rip), %rsi     # 0x2a0e7
movq %rbx, %rdi
xorl %eax, %eax
callq 0x99a6
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsobject.c
// Function: O_freeze
static void O_freeze(js_State *J)
{
	js_Object *obj;

	if (!js_isobject(J, 1))
		js_typeerror(J, "not an object");

	obj = js_toobject(J, 1);
	jsR_unflattenarray(J, obj);
	obj->extensible = 0;

	if (obj->properties->level)
		O_freeze_walk(J, obj->properties);

	js_copy(J, 1);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0xd489
testl %eax, %eax
je 0xd1ff
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0xd49c
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10280
andl $0x0, 0x4(%r14)
movq 0x8(%r14), %rdi
cmpl $0x0, 0x10(%rdi)
je 0xd1ed
callq 0x19693
pushq $0x1
popq %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xeee2
leaq 0x1cee1(%rip), %rsi     # 0x2a0e7
movq %rbx, %rdi
xorl %eax, %eax
callq 0x99a6
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsobject.c
// Function: O_preventExtensions
static void O_preventExtensions(js_State *J)
{
	js_Object *obj;
	if (!js_isobject(J, 1))
		js_typeerror(J, "not an object");
	obj = js_toobject(J, 1);
	jsR_unflattenarray(J, obj);
	obj->extensible = 0;
	js_copy(J, 1);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0xd489
testl %eax, %eax
je 0xd251
pushq $0x1
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
callq 0xd49c
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10280
andl $0x0, 0x4(%r14)
movq %rbx, %rdi
movl %ebp, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0xeee2
leaq 0x1ce8f(%rip), %rsi     # 0x2a0e7
movq %rbx, %rdi
xorl %eax, %eax
callq 0x99a6
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsobject.c
// Function: O_isSealed
static void O_isSealed(js_State *J)
{
	js_Object *obj;

	if (!js_isobject(J, 1))
		js_typeerror(J, "not an object");

	obj = js_toobject(J, 1);
	if (obj->extensible) {
		js_pushboolean(J, 0);
		return;
	}

	if (obj->properties->level)
		js_pushboolean(J, O_isSealed_walk(J, obj->properties));
	else
		js_pushboolean(J, 1);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0xd489
testl %eax, %eax
je 0xd2aa
pushq $0x1
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
callq 0xd49c
xorl %esi, %esi
cmpl $0x0, 0x4(%rax)
jne 0xd29c
movq 0x8(%rax), %rdi
cmpl $0x0, 0x10(%rdi)
movl %ebp, %esi
je 0xd29c
callq 0x196b5
movl %eax, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xf7ba
leaq 0x1ce36(%rip), %rsi     # 0x2a0e7
movq %rbx, %rdi
xorl %eax, %eax
callq 0x99a6
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsobject.c
// Function: O_isFrozen
static void O_isFrozen(js_State *J)
{
	js_Object *obj;

	if (!js_isobject(J, 1))
		js_typeerror(J, "not an object");

	obj = js_toobject(J, 1);

	if (obj->properties->level) {
		if (!O_isFrozen_walk(J, obj->properties)) {
			js_pushboolean(J, 0);
			return;
		}
	}

	js_pushboolean(J, !obj->extensible);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0xd489
testl %eax, %eax
je 0xd30d
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0xd49c
movq %rax, %r14
movq 0x8(%rax), %rdi
cmpl $0x0, 0x10(%rdi)
je 0xd2ef
callq 0x196fb
testl %eax, %eax
je 0xd2fc
xorl %esi, %esi
cmpl $0x0, 0x4(%r14)
sete %sil
jmp 0xd2fe
xorl %esi, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xf7ba
leaq 0x1cdd3(%rip), %rsi     # 0x2a0e7
movq %rbx, %rdi
xorl %eax, %eax
callq 0x99a6
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsobject.c
// Function: O_keys
static void O_keys(js_State *J)
{
	js_Object *obj;
	char name[32];
	int i, k;

	if (!js_isobject(J, 1))
		js_typeerror(J, "not an object");
	obj = js_toobject(J, 1);

	js_newarray(J);

	if (obj->properties->level)
		i = O_keys_walk(J, obj->properties, 0);
	else
		i = 0;

	if (obj->type == JS_CSTRING) {
		for (k = 0; k < obj->u.s.length; ++k) {
			js_itoa(name, k);
			js_pushstring(J, name);
			js_setindex(J, -2, i++);
		}
	}

	if (obj->type == JS_CARRAY && obj->u.a.simple) {
		for (k = 0; k < obj->u.a.flat_length; ++k) {
			js_itoa(name, k);
			js_pushstring(J, name);
			js_setindex(J, -2, i++);
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0xd489
testl %eax, %eax
je 0xd445
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0xd49c
movq %rax, %r14
movq %rbx, %rdi
callq 0xe7d1
movq 0x8(%r14), %rsi
cmpl $0x0, 0x10(%rsi)
je 0xd3a6
movq %rbx, %rdi
xorl %edx, %edx
callq 0x19744
movl %eax, %r12d
jmp 0xd3a9
xorl %r12d, %r12d
movl (%r14), %eax
cmpl $0x8, %eax
jne 0xd3ef
xorl %r13d, %r13d
movq %rsp, %rbp
leal (%r12,%r13), %r15d
cmpl 0x20(%r14), %r13d
jge 0xd3ea
movq %rbp, %rdi
movl %r13d, %esi
callq 0xe0ad
movq %rbx, %rdi
movq %rbp, %rsi
callq 0xe7f7
movq %rbx, %rdi
pushq $-0x2
popq %rsi
movl %r15d, %edx
callq 0xe9c5
incl %r13d
jmp 0xd3b7
movl (%r14), %eax
jmp 0xd3f2
movl %r12d, %r15d
cmpl $0x1, %eax
jne 0xd436
cmpl $0x0, 0x24(%r14)
je 0xd436
xorl %r12d, %r12d
movq %rsp, %r13
cmpl 0x28(%r14), %r12d
jge 0xd436
leal (%r15,%r12), %ebp
movq %r13, %rdi
movl %r12d, %esi
callq 0xe0ad
movq %rbx, %rdi
movq %r13, %rsi
callq 0xe7f7
movq %rbx, %rdi
pushq $-0x2
popq %rsi
movl %ebp, %edx
callq 0xe9c5
incl %r12d
jmp 0xd404
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1cc9b(%rip), %rsi     # 0x2a0e7
movq %rbx, %rdi
xorl %eax, %eax
callq 0x99a6
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./json.c
// Function: JSON_parse
static void JSON_parse(js_State *J)
{
	const char *source = js_tostring(J, 1);
	jsY_initlex(J, "JSON", source);
	jsonnext(J);

	if (js_iscallable(J, 2)) {
		js_newobject(J);
		jsonvalue(J);
		js_defproperty(J, -2, "", 0);
		jsonrevive(J, "");
	} else {
		jsonvalue(J);
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0xf64d
leaq 0x1abb8(%rip), %rsi     # 0x28118
movq %rbx, %rdi
movq %rax, %rdx
callq 0xadfd
movq %rbx, %rdi
callq 0x197ab
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0xf950
testl %eax, %eax
je 0xd5bb
movq %rbx, %rdi
callq 0x13813
movq %rbx, %rdi
callq 0x197b9
leaq 0x1bdf8(%rip), %r14     # 0x29391
pushq $-0x2
popq %rsi
movq %rbx, %rdi
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x5963
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1995c
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x197b9
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsparse.c
// Function: jsP_freeparse
void jsP_freeparse(js_State *J)
{
	js_Ast *node = J->gcast;
	while (node) {
		js_Ast *next = node->gcnext;
		jsP_freejumps(J, node->jumps);
		js_free(J, node);
		node = next;
	}
	J->gcast = NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x88(%rdi), %r14
testq %r14, %r14
je 0xd7da
movq 0x40(%r14), %rsi
movq 0x50(%r14), %r15
testq %rsi, %rsi
je 0xd7ca
movq 0x8(%rsi), %r12
movq (%rbx), %rdi
xorl %edx, %edx
callq *0x10(%rbx)
movq %r12, %rsi
jmp 0xd7b4
movq (%rbx), %rdi
movq %r14, %rsi
xorl %edx, %edx
callq *0x10(%rbx)
movq %r15, %r14
jmp 0xd7a7
andq $0x0, 0x88(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsparse.c
// Function: jsP_parse
js_Ast *jsP_parse(js_State *J, const char *filename, const char *source)
{
	js_Ast *p;

	jsY_initlex(J, filename, source);
	jsP_next(J);
	J->astdepth = 0;
	p = script(J, 0);
	if (p)
		jsP_foldconst(p);

	return p;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0xadfd
movq %rbx, %rdi
callq 0xd822
andl $0x0, 0x70(%rbx)
movq %rbx, %rdi
xorl %esi, %esi
callq 0xd830
movq %rax, %rbx
testq %rax, %rax
je 0xd81d
movq %rbx, %rdi
callq 0xd8b2
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsparse.c
// Function: script
static js_Ast *script(js_State *J, int terminator)
{
	js_Ast *head, *tail;
	if (J->lookahead == terminator)
		return NULL;
	head = tail = LIST(scriptelement(J));
	while (J->lookahead != terminator)
		tail = tail->b = LIST(scriptelement(J));
	return jsP_list(head);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
cmpl %esi, 0x74(%rdi)
jne 0xd842
xorl %r15d, %r15d
jmp 0xd8a3
movl %esi, %ebx
movq %rdi, %r14
callq 0x1a3e0
andq $0x0, (%rsp)
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
movq %rax, %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0xdb92
movq %rax, %r15
movq %rax, %r12
cmpl %ebx, 0x74(%r14)
je 0xd89b
movq %r14, %rdi
callq 0x1a3e0
andq $0x0, (%rsp)
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
movq %rax, %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0xdb92
movq %rax, 0x18(%r12)
jmp 0xd869
movq %r15, %rdi
callq 0x1a4a6
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsparse.c
// Function: jsP_parsefunction
js_Ast *jsP_parsefunction(js_State *J, const char *filename, const char *params, const char *body)
{
	js_Ast *p = NULL;
	int line = 0;
	if (params) {
		jsY_initlex(J, filename, params);
		jsP_next(J);
		J->astdepth = 0;
		p = parameters(J);
	}
	return EXP3(FUN, NULL, p, jsP_parse(J, filename, body));
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, %rbx
testq %rdx, %rdx
je 0xdad4
movq %rbx, %rdi
movq %r15, %rsi
callq 0xadfd
movq %rbx, %rdi
callq 0xd822
andl $0x0, 0x70(%rbx)
movq %rbx, %rdi
callq 0xdb0b
movq %rax, %r12
jmp 0xdad7
xorl %r12d, %r12d
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xd7ee
andq $0x0, (%rsp)
pushq $0x11
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
movq %r12, %r8
movq %rax, %r9
callq 0xdb92
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsparse.c
// Function: parameters
static js_Ast *parameters(js_State *J)
{
	js_Ast *head, *tail;
	if (J->lookahead == ')')
		return NULL;
	head = tail = LIST(identifier(J));
	while (jsP_accept(J, ',')) {
		tail = tail->b = LIST(identifier(J));
	}
	return jsP_list(head);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
cmpl $0x29, 0x74(%rdi)
jne 0xdb1f
xorl %r14d, %r14d
jmp 0xdb85
movq %rdi, %rbx
callq 0x1acfa
andq $0x0, (%rsp)
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
movq %rax, %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0xdb92
movq %rax, %r14
movq %rax, %r15
cmpl $0x2c, 0x74(%rbx)
jne 0xdb7d
movq %rbx, %rdi
callq 0xd822
movq %rbx, %rdi
callq 0x1acfa
andq $0x0, (%rsp)
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
movq %rax, %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0xdb92
movq %rax, 0x18(%r15)
jmp 0xdb44
movq %r14, %rdi
callq 0x1a4a6
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsparse.c
// Function: jsP_newnode
static js_Ast *jsP_newnode(js_State *J, enum js_AstType type, int line, js_Ast *a, js_Ast *b, js_Ast *c, js_Ast *d)
{
	js_Ast *node = js_malloc(J, sizeof *node);

	node->type = type;
	node->line = line;
	node->a = a;
	node->b = b;
	node->c = c;
	node->d = d;
	node->number = 0;
	node->string = NULL;
	node->jumps = NULL;
	node->casejump = 0;

	node->parent = NULL;
	if (a) a->parent = node;
	if (b) b->parent = node;
	if (c) c->parent = node;
	if (d) d->parent = node;

	node->gcnext = J->gcast;
	J->gcast = node;

	return node;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r14
movq %r8, %r15
movq %rcx, %r12
movl %edx, %ebp
movl %esi, %r13d
movq %rdi, %rbx
pushq $0x58
popq %rsi
callq 0xa9e8
movq 0x40(%rsp), %rcx
movl %r13d, (%rax)
movl %ebp, 0x4(%rax)
movq %r12, 0x10(%rax)
movq %r15, 0x18(%rax)
movq %r14, 0x20(%rax)
movq %rcx, 0x28(%rax)
andq $0x0, 0x8(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x3c(%rax)
testq %r12, %r12
je 0xdbeb
movq %rax, 0x8(%r12)
testq %r15, %r15
je 0xdbf4
movq %rax, 0x8(%r15)
testq %r14, %r14
je 0xdbfd
movq %rax, 0x8(%r14)
testq %rcx, %rcx
je 0xdc06
movq %rax, 0x8(%rcx)
movq 0x88(%rbx), %rcx
movq %rcx, 0x50(%rax)
movq %rax, 0x88(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsproperty.c
// Function: lookup
static js_Property *lookup(js_Property *node, const char *name)
{
	while (node != &sentinel) {
		int c = strcmp(name, node->name);
		if (c == 0)
			return node;
		else if (c < 0)
			node = node->left;
		else
			node = node->right;
	}
	return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x29776(%rip), %r15     # 0x373b8
cmpq %r15, %rbx
je 0xdc62
leaq 0x38(%rbx), %rsi
movq %r14, %rdi
callq 0x32f0
testl %eax, %eax
je 0xdc64
notl %eax
shrl $0x1f, %eax
movq (%rbx,%rax,8), %rbx
jmp 0xdc42
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsproperty.c
// Function: jsV_getpropertyx
js_Property *jsV_getpropertyx(js_State *J, js_Object *obj, const char *name, int *own)
{
	*own = 1;
	do {
		js_Property *ref = lookup(obj->properties, name);
		if (ref)
			return ref;
		obj = obj->prototype;
		*own = 0;
	} while (obj);
	return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movl $0x1, (%rcx)
movq 0x8(%r15), %rdi
movq %r14, %rsi
callq 0xdc30
testq %rax, %rax
jne 0xdc9e
movq 0x18(%r15), %r15
andl $0x0, (%rbx)
testq %r15, %r15
jne 0xdc81
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsproperty.c
// Function: jsV_getproperty
js_Property *jsV_getproperty(js_State *J, js_Object *obj, const char *name)
{
	do {
		js_Property *ref = lookup(obj->properties, name);
		if (ref)
			return ref;
		obj = obj->prototype;
	} while (obj);
	return NULL;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0xdc30
testq %rax, %rax
jne 0xdcc8
movq 0x18(%r14), %r14
testq %r14, %r14
jne 0xdcae
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsproperty.c
// Function: jsV_setproperty
js_Property *jsV_setproperty(js_State *J, js_Object *obj, const char *name)
{
	js_Property *result;

	if (!obj->extensible) {
		result = lookup(obj->properties, name);
		if (J->strict && !result)
			js_typeerror(J, "object is non-extensible");
		return result;
	}

	obj->properties = insert(J, obj, obj->properties, name, &result);

	return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rcx
movq %rdi, %rbx
cmpl $0x0, 0x4(%rsi)
movq 0x8(%rsi), %rdx
je 0xdd05
movq %rsi, %r14
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
movq %r15, %r8
callq 0xdd3c
movq %rax, 0x8(%r14)
movq (%r15), %rax
jmp 0xdd21
movq %rdx, %rdi
movq %rcx, %rsi
callq 0xdc30
cmpl $0x0, 0x34(%rbx)
sete %cl
testq %rax, %rax
setne %dl
orb %cl, %dl
je 0xdd2b
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1a92c(%rip), %rsi     # 0x2865e
movq %rbx, %rdi
xorl %eax, %eax
callq 0x99a6
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsproperty.c
// Function: insert
static js_Property *insert(js_State *J, js_Object *obj, js_Property *node, const char *name, js_Property **result)
{
	if (node != &sentinel) {
		int c = strcmp(name, node->name);
		if (c < 0)
			node->left = insert(J, obj, node->left, name, result);
		else if (c > 0)
			node->right = insert(J, obj, node->right, name, result);
		else
			return *result = node;
		node = skew(node);
		node = split(node);
		return node;
	}
	return *result = newproperty(J, obj, name);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r12
movq %rsi, %r15
movq %rdi, %r13
leaq 0x2965e(%rip), %rbp     # 0x373b8
cmpq %rbp, %rdx
je 0xddb6
movq %rdx, %r14
leaq 0x38(%rdx), %rsi
movq %r12, %rdi
callq 0x32f0
movq %r14, %rbp
testl %eax, %eax
js 0xdd7f
je 0xde10
leaq 0x8(%r14), %rbp
movq (%rbp), %rdx
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rcx
movq %rbx, %r8
callq 0xdd3c
movq %rax, (%rbp)
movq %r14, %rdi
callq 0x1c6f4
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1c70f
movq %r12, %rdi
callq 0x3200
leal 0x1(%rax), %ecx
movslq %ecx, %rcx
movq %rcx, (%rsp)
leal 0x39(%rax), %esi
movq %r13, %rdi
callq 0xa9e8
movq %rax, %r14
movq %rbp, 0x8(%rax)
movq %rbp, (%rax)
movq $0x1, 0x10(%rax)
movb $0x1, 0x27(%rax)
andq $0x0, 0x18(%rax)
leaq 0x38(%rax), %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rax)
movq %r12, %rsi
movq (%rsp), %rdx
callq 0x33d0
incl 0x10(%r15)
incl 0x154(%r13)
movq %r14, (%rbx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsproperty.c
// Function: jsV_newiterator
js_Object *jsV_newiterator(js_State *J, js_Object *obj, int own)
{
	js_Object *io = jsV_newobject(J, JS_CITERATOR, NULL);
	io->u.iter.target = obj;
	io->u.iter.i = 0;
	io->u.iter.n = 0;
	if (own) {
		io->u.iter.head = NULL;
		if (obj->properties != &sentinel)
			io->u.iter.head = itwalk(J, io->u.iter.head, obj->properties, NULL);
	} else {
		io->u.iter.head = itflatten(J, obj);
	}
	io->u.iter.current = io->u.iter.head;

	if (obj->type == JS_CSTRING)
		io->u.iter.n = obj->u.s.length;

	if (obj->type == JS_CARRAY && obj->u.a.simple)
		io->u.iter.n = obj->u.a.flat_length;

	return io;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r15
pushq $0xe
popq %rsi
xorl %edx, %edx
callq 0x5d6b
movq %rax, %r14
movq %rbx, 0x20(%rax)
andq $0x0, 0x28(%rax)
testl %ebp, %ebp
je 0xdecd
andq $0x0, 0x30(%r14)
movq 0x8(%rbx), %rdx
leaq 0x294fe(%rip), %rax     # 0x373b8
cmpq %rax, %rdx
je 0xdede
movq %r15, %rdi
xorl %esi, %esi
xorl %ecx, %ecx
callq 0xdf14
jmp 0xded8
movq %r15, %rdi
movq %rbx, %rsi
callq 0xdfea
movq %rax, 0x30(%r14)
jmp 0xdee0
xorl %eax, %eax
movq %rax, 0x38(%r14)
movl (%rbx), %eax
cmpl $0x8, %eax
jne 0xdef4
movl 0x20(%rbx), %eax
movl %eax, 0x2c(%r14)
movl (%rbx), %eax
cmpl $0x1, %eax
jne 0xdf06
cmpl $0x0, 0x24(%rbx)
je 0xdf06
movl 0x28(%rbx), %eax
movl %eax, 0x2c(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsproperty.c
// Function: itwalk
static js_Iterator *itwalk(js_State *J, js_Iterator *iter, js_Property *prop, js_Object *seen)
{
	if (prop->right != &sentinel)
		iter = itwalk(J, iter, prop->right, seen);
	if (!(prop->atts & JS_DONTENUM)) {
		if (!seen || !jsV_getenumproperty(J, seen, prop->name)) {
			iter = itnewnode(J, prop->name, iter);
		}
	}
	if (prop->left != &sentinel)
		iter = itwalk(J, iter, prop->left, seen);
	return iter;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %rax
movq %rdi, 0x10(%rsp)
leaq 0x29481(%rip), %rbx     # 0x373b8
movq 0x8(%r14), %rdx
cmpq %rbx, %rdx
je 0xdf50
movq 0x10(%rsp), %rdi
movq %rax, %rsi
movq %r15, %rcx
callq 0xdf14
testb $0x2, 0x14(%r14)
jne 0xdfcf
movq %rax, 0x8(%rsp)
testq %r15, %r15
je 0xdf8a
leaq 0x38(%r14), %r13
movq %r15, %r12
movq 0x8(%r12), %rdi
movq %r13, %rsi
callq 0xdc30
testq %rax, %rax
je 0xdf80
testb $0x2, 0x14(%rax)
je 0xdfca
movq 0x18(%r12), %r12
testq %r12, %r12
jne 0xdf68
leaq 0x38(%r14), %r13
movq %r13, %rdi
callq 0x3200
leal 0x1(%rax), %ecx
movslq %ecx, %rbp
leal 0x9(%rax), %esi
movq 0x10(%rsp), %rdi
callq 0xa9e8
movq %rax, %r12
movq 0x8(%rsp), %rax
movq %rax, (%r12)
leaq 0x8(%r12), %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x33d0
movq %r12, %rax
jmp 0xdfcf
movq 0x8(%rsp), %rax
movq (%r14), %r14
cmpq %rbx, %r14
jne 0xdf37
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsproperty.c
// Function: itflatten
static js_Iterator *itflatten(js_State *J, js_Object *obj)
{
	js_Iterator *iter = NULL;
	if (obj->prototype)
		iter = itflatten(J, obj->prototype);
	if (obj->properties != &sentinel)
		iter = itwalk(J, iter, obj->properties, obj->prototype);
	return iter;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x18(%rsi), %rsi
testq %rsi, %rsi
je 0xe007
movq %rbx, %rdi
callq 0xdfea
jmp 0xe009
xorl %eax, %eax
movq 0x8(%r14), %rdx
leaq 0x293a4(%rip), %rcx     # 0x373b8
cmpq %rcx, %rdx
je 0xe02f
movq 0x18(%r14), %rcx
movq %rbx, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xdf14
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsproperty.c
// Function: jsV_nextiterator
const char *jsV_nextiterator(js_State *J, js_Object *io)
{
	if (io->type != JS_CITERATOR)
		js_typeerror(J, "not an iterator");
	if (io->u.iter.i < io->u.iter.n) {
		js_itoa(J->scratch, io->u.iter.i);
		io->u.iter.i++;
		return J->scratch;
	}
	while (io->u.iter.current) {
		const char *name = io->u.iter.current->name;
		io->u.iter.current = io->u.iter.current->next;
		if (jsV_getproperty(J, io->u.iter.target, name))
			return name;
	}
	return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
cmpl $0xe, (%rsi)
jne 0xe09c
movq %rsi, %rbx
movl 0x28(%rsi), %esi
cmpl 0x2c(%rbx), %esi
jge 0xe063
addq $0x10c, %r14            # imm = 0x10C
movq %r14, %rdi
callq 0xe0ad
incl 0x28(%rbx)
jmp 0xe093
movq 0x38(%rbx), %rcx
testq %rcx, %rcx
je 0xe090
movq (%rcx), %r15
movq %rcx, %r14
addq $0x8, %r14
movq %r15, 0x38(%rbx)
movq 0x20(%rbx), %rsi
movq %r14, %rdx
callq 0xdca4
movq %r15, %rcx
testq %rax, %rax
je 0xe067
jmp 0xe093
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1a5d4(%rip), %rsi     # 0x28677
movq %r14, %rdi
xorl %eax, %eax
callq 0x99a6
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsvalue.c
// Function: js_itoa
const char *js_itoa(char *out, int v)
{
	char buf[32], *s = out;
	unsigned int a;
	int i = 0;
	if (v < 0) {
		a = -v;
		*s++ = '-';
	} else {
		a = v;
	}
	while (a) {
		buf[i++] = (a % 10) + '0';
		a /= 10;
	}
	if (i == 0)
		buf[i++] = '0';
	while (i > 0)
		*s++ = buf[--i];
	*s = 0;
	return out;
}

// Assembly:
movl %esi, %eax
testl %esi, %esi
js 0xe0b8
movq %rdi, %rcx
jmp 0xe0c1
negl %eax
leaq 0x1(%rdi), %rcx
movb $0x2d, (%rdi)
xorl %esi, %esi
movl $0xa, %r8d
testl %eax, %eax
je 0xe0de
xorl %edx, %edx
divl %r8d
orb $0x30, %dl
movb %dl, -0x28(%rsp,%rsi)
incq %rsi
jmp 0xe0c9
testq %rsi, %rsi
jne 0xe0e8
movb $0x30, -0x28(%rsp)
cmpq $0x1, %rsi
adcq $0x0, %rsi
testq %rsi, %rsi
jle 0xe103
movb -0x29(%rsp,%rsi), %al
decq %rsi
movb %al, (%rcx)
incq %rcx
jmp 0xe0f0
movb $0x0, (%rcx)
movq %rdi, %rax
retq
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsproperty.c
// Function: jsV_resizearray
void jsV_resizearray(js_State *J, js_Object *obj, int newlen)
{
	char buf[32];
	const char *s;
	int k;
	assert(!obj->u.a.simple);
	if (newlen < obj->u.a.length) {
		if (obj->u.a.length > obj->count * 2) {
			js_Object *it = jsV_newiterator(J, obj, 1);
			while ((s = jsV_nextiterator(J, it))) {
				k = jsV_numbertointeger(jsV_stringtonumber(J, s));
				if (k >= newlen && !strcmp(s, jsV_numbertostring(J, buf, k)))
					jsV_delproperty(J, obj, s);
			}
		} else {
			for (k = newlen; k < obj->u.a.length; ++k) {
				jsV_delproperty(J, obj, js_itoa(buf, k));
			}
		}
	}
	obj->u.a.length = newlen;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
cmpl $0x0, 0x24(%rsi)
jne 0xe1de
movl %edx, %ebx
movq %rsi, %r14
movl 0x20(%rsi), %eax
cmpl %edx, %eax
jle 0xe1cb
movq %rdi, %r15
movl 0x10(%r14), %ecx
addl %ecx, %ecx
cmpl %ecx, %eax
jle 0xe1a2
pushq $0x1
popq %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0xde81
movq %rax, %r12
movq %rsp, %r13
movq %r15, %rdi
movq %r12, %rsi
callq 0xe037
testq %rax, %rax
je 0xe1cb
movq %rax, %rbp
movq %rax, %rsi
callq 0xe258
callq 0xe1fd
cmpl %ebx, %eax
jl 0xe153
cvtsi2sd %eax, %xmm0
movq %r13, %rsi
callq 0xe36d
movq %rbp, %rdi
movq %rax, %rsi
callq 0x32f0
testl %eax, %eax
jne 0xe153
movq %r15, %rdi
movq %r14, %rsi
movq %rbp, %rdx
callq 0xde25
jmp 0xe153
movq %rsp, %r12
movl %ebx, %ebp
cmpl %eax, %ebp
jge 0xe1cb
movq %r12, %rdi
movl %ebp, %esi
callq 0xe0ad
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0xde25
incl %ebp
movl 0x20(%r14), %eax
jmp 0xe1a7
movl %ebx, 0x20(%r14)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1a4a2(%rip), %rdi     # 0x28687
leaq 0x1a4ac(%rip), %rsi     # 0x28698
leaq 0x1a4b4(%rip), %rcx     # 0x286a7
movl $0x145, %edx            # imm = 0x145
callq 0x3130
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsvalue.c
// Function: jsV_numbertointeger
int jsV_numbertointeger(double n)
{
	if (n == 0) return 0;
	if (isnan(n)) return 0;
	n = (n < 0) ? -floor(-n) : floor(n);
	if (n < INT_MIN) return INT_MIN;
	if (n > INT_MAX) return INT_MAX;
	return (int)n;
}

// Assembly:
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
je 0xe225
pushq %rax
ucomisd %xmm0, %xmm1
jbe 0xe228
xorpd 0x1238a(%rip), %xmm0    # 0x205a0
callq 0x3370
xorpd 0x1237d(%rip), %xmm0    # 0x205a0
jmp 0xe22d
xorl %eax, %eax
retq
callq 0x3370
movl $0x80000000, %eax       # imm = 0x80000000
movsd 0x122ce(%rip), %xmm1    # 0x20508
ucomisd %xmm0, %xmm1
ja 0xe253
movl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
ucomisd 0x12283(%rip), %xmm0    # 0x204d0
ja 0xe253
cvttsd2si %xmm0, %eax
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsvalue.c
// Function: jsV_stringtonumber
double jsV_stringtonumber(js_State *J, const char *s)
{
	char *e;
	double n;
	while (jsY_iswhite(*s) || jsY_isnewline(*s)) ++s;
	if (s[0] == '0' && (s[1] == 'x' || s[1] == 'X') && s[2] != 0)
		n = js_strtol(s + 2, &e, 16);
	else if (!strncmp(s, "Infinity", 8))
		n = INFINITY, e = (char*)s + 8;
	else if (!strncmp(s, "+Infinity", 9))
		n = INFINITY, e = (char*)s + 9;
	else if (!strncmp(s, "-Infinity", 9))
		n = -INFINITY, e = (char*)s + 9;
	else
		n = js_stringtofloat(s, &e);
	while (jsY_iswhite(*e) || jsY_isnewline(*e)) ++e;
	if (*e) return NAN;
	return n;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movsbl (%rbx), %ebp
movl %ebp, %edi
callq 0xad6d
testl %eax, %eax
jne 0xe27c
movl %ebp, %edi
callq 0xad9c
testl %eax, %eax
je 0xe281
incq %rbx
jmp 0xe263
cmpb $0x30, %bpl
jne 0xe2ad
movzbl 0x1(%rbx), %eax
orl $0x20, %eax
cmpl $0x78, %eax
jne 0xe2ad
cmpb $0x0, 0x2(%rbx)
je 0xe2ad
addq $0x2, %rbx
movq %rsp, %rsi
pushq $0x10
popq %rdx
movq %rbx, %rdi
callq 0x134d4
jmp 0xe312
leaq 0x1a7d2(%rip), %rsi     # 0x28a86
pushq $0x8
popq %rdx
movq %rbx, %rdi
callq 0x3160
testl %eax, %eax
je 0xe2fc
leaq 0x1a7bb(%rip), %rsi     # 0x28a85
pushq $0x9
popq %rdx
movq %rbx, %rdi
callq 0x3160
testl %eax, %eax
je 0xe302
leaq 0x1a7af(%rip), %rsi     # 0x28a8f
pushq $0x9
popq %rdx
movq %rbx, %rdi
callq 0x3160
testl %eax, %eax
je 0xe35b
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x13611
jmp 0xe312
addq $0x8, %rbx
jmp 0xe306
addq $0x9, %rbx
movq %rbx, (%rsp)
movsd 0x1210e(%rip), %xmm0    # 0x20420
movsd %xmm0, 0x8(%rsp)
movq (%rsp), %r14
incq %r14
movsbl -0x1(%r14), %ebx
movl %ebx, %edi
callq 0xad6d
testl %eax, %eax
jne 0xe33a
movl %ebx, %edi
callq 0xad9c
testl %eax, %eax
je 0xe340
movq %r14, (%rsp)
jmp 0xe31c
testb %bl, %bl
movsd 0x8(%rsp), %xmm0
je 0xe352
movsd 0x120c6(%rip), %xmm0    # 0x20418
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
addq $0x9, %rbx
movq %rbx, (%rsp)
movsd 0x120cd(%rip), %xmm0    # 0x20438
jmp 0xe312
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsregexp.c
// Function: js_newregexpx
static void js_newregexpx(js_State *J, const char *pattern, int flags, int is_clone)
{
	const char *error;
	js_Object *obj;
	Reprog *prog;
	int opts;

	obj = jsV_newobject(J, JS_CREGEXP, J->RegExp_prototype);

	opts = 0;
	if (flags & JS_REGEXP_I) opts |= REG_ICASE;
	if (flags & JS_REGEXP_M) opts |= REG_NEWLINE;

	prog = js_regcompx(J->alloc, J->actx, pattern, opts, &error);
	if (!prog)
		js_syntaxerror(J, "regular expression: %s", error);

	obj->u.r.prog = prog;
	obj->u.r.source = is_clone ? js_strdup(J, pattern) : escaperegexp(J, pattern);
	obj->u.r.flags = flags;
	obj->u.r.last = 0;
	js_pushobject(J, obj);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %ecx, %r12d
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
movq 0xc0(%rdi), %rdx
pushq $0x9
popq %rsi
callq 0x5d6b
movq %rax, %r14
movl %ebp, %ecx
shrl %ecx
andl $0x3, %ecx
movq (%rbx), %rsi
movq 0x10(%rbx), %rdi
leaq 0x8(%rsp), %r8
movq %r15, %rdx
callq 0x5dd4
testq %rax, %rax
je 0xe5f0
movq %rax, 0x20(%r14)
testl %r12d, %r12d
je 0xe57b
movq %rbx, %rdi
movq %r15, %rsi
callq 0x615c
jmp 0xe5c9
xorl %esi, %esi
movq %r15, %rax
movzbl (%rax), %ecx
cmpl $0x2f, %ecx
je 0xe58e
testl %ecx, %ecx
jne 0xe590
jmp 0xe597
incl %esi
incl %esi
incq %rax
jmp 0xe580
incl %esi
movq %rbx, %rdi
callq 0xa9e8
movq %rax, %rcx
movzbl (%r15), %edx
cmpl $0x2f, %edx
je 0xe5b3
testl %edx, %edx
jne 0xe5bc
jmp 0xe5c6
movb $0x5c, (%rcx)
incq %rcx
movb (%r15), %dl
movb %dl, (%rcx)
incq %rcx
incq %r15
jmp 0xe5a4
movb $0x0, (%rcx)
movq %rax, 0x28(%r14)
movw %bp, 0x30(%r14)
andw $0x0, 0x32(%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4274
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%rsp), %rdx
leaq 0x1b82b(%rip), %rsi     # 0x29e27
movq %rbx, %rdi
xorl %eax, %eax
callq 0x98e8
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsregexp.c
// Function: js_RegExp_prototype_exec
void js_RegExp_prototype_exec(js_State *J, js_Regexp *re, const char *text)
{
	const char *haystack;
	int result;
	int i;
	int opts;
	Resub m;

	haystack = text;
	opts = 0;
	if (re->flags & JS_REGEXP_G) {
		if (re->last > strlen(haystack)) {
			re->last = 0;
			js_pushnull(J);
			return;
		}
		if (re->last > 0) {
			haystack = text + re->last;
			opts |= REG_NOTBOL;
		}
	}

	result = js_regexec(re->prog, haystack, &m, opts);
	if (result < 0)
		js_error(J, "regexec failed");
	if (result == 0) {
		js_newarray(J);
		js_pushstring(J, text);
		js_setproperty(J, -2, "input");
		js_pushnumber(J, js_utfptrtoidx(text, m.sub[0].sp));
		js_setproperty(J, -2, "index");
		for (i = 0; i < m.nsub; ++i) {
			js_pushlstring(J, m.sub[i].sp, m.sub[i].ep - m.sub[i].sp);
			js_setindex(J, -2, i);
		}
		if (re->flags & JS_REGEXP_G)
			re->last = m.sub[0].ep - text;
		return;
	}

	if (re->flags & JS_REGEXP_G)
		re->last = 0;

	js_pushnull(J);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
xorl %ecx, %ecx
testb $0x1, 0x10(%rsi)
movq %rdx, %r12
je 0xe669
movzwl 0x12(%rbx), %r12d
movq %r15, %rdi
callq 0x3200
cmpq %r12, %rax
jae 0xe65b
andw $0x0, 0x12(%rbx)
movq %r14, %rdi
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xe756
xorl %ecx, %ecx
testq %r12, %r12
setne %cl
addq %r15, %r12
shll $0x2, %ecx
movq (%rbx), %rdi
movq %rsp, %rdx
movq %r12, %rsi
callq 0xe782
testl %eax, %eax
js 0xe745
je 0xe699
testb $0x1, 0x10(%rbx)
je 0xe68c
andw $0x0, 0x12(%rbx)
movq %r14, %rdi
callq 0xe756
jmp 0xe733
movq %r14, %rdi
callq 0xe7d1
movq %r14, %rdi
movq %r15, %rsi
callq 0xe7f7
leaq 0x1a036(%rip), %rdx     # 0x286e9
pushq $-0x2
popq %rbp
movq %r14, %rdi
movl %ebp, %esi
callq 0x3fdd
leaq 0x10(%rsp), %r13
movq -0x8(%r13), %rsi
movq %r15, %rdi
callq 0xe8bd
cvtsi2sd %eax, %xmm0
movq %r14, %rdi
callq 0x3f9a
leaq 0x1a00b(%rip), %rdx     # 0x286ef
movq %r14, %rdi
movl %ebp, %esi
callq 0x3fdd
xorl %r12d, %r12d
movslq (%rsp), %rax
cmpq %rax, %r12
jge 0xe722
movq -0x8(%r13), %rsi
movl (%r13), %edx
subl %esi, %edx
movq %r14, %rdi
callq 0xe918
movq %r14, %rdi
movl %ebp, %esi
movl %r12d, %edx
callq 0xe9c5
incq %r12
addq $0x10, %r13
jmp 0xe6f1
testb $0x1, 0x10(%rbx)
je 0xe733
movl 0x10(%rsp), %eax
subl %r15d, %eax
movw %ax, 0x12(%rbx)
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x19f8e(%rip), %rsi     # 0x286da
movq %r14, %rdi
xorl %eax, %eax
callq 0x95fc
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./regexp.c
// Function: js_regexec
int regexec(Reprog *prog, const char *sp, Resub *sub, int eflags)
{
	Resub scratch;
	int i;

	if (!sub)
		sub = &scratch;

	sub->nsub = prog->nsub;
	for (i = 0; i < REG_MAXSUB; ++i)
		sub->sub[i].sp = sub->sub[i].ep = NULL;

	return match(prog->start, sp, sp, prog->flags | eflags, sub, 0);
}

// Assembly:
subq $0x108, %rsp            # imm = 0x108
testq %rdx, %rdx
movq %rsp, %r8
cmovneq %rdx, %r8
movl 0x1c(%rdi), %eax
movl %eax, (%r8)
leaq 0x8(%r8), %rax
xorl %edx, %edx
xorps %xmm0, %xmm0
cmpq $0x100, %rdx            # imm = 0x100
je 0xe7b5
movups %xmm0, (%rax,%rdx)
addq $0x10, %rdx
jmp 0xe7a2
movq (%rdi), %rax
orl 0x18(%rdi), %ecx
movq %rax, %rdi
movq %rsi, %rdx
xorl %r9d, %r9d
callq 0x14d12
addq $0x108, %rsp            # imm = 0x108
retq