// File: /workspace/github_cpp_makefile_star2_O1/menhits[P]phplus/src/PhplusStdLib.cpp
// Function: populateArrayFuncs()
void populateArrayFuncs()
{
	TupleTypeMaker maker;
	maker.add("_size", Int);
	maker.add("_capacity", Int);
	maker.add("_data", Whatev->getPtr());
	Array=maker.get(false);
	
	addType(Array, "Array");
	
	globalNamespace->addNode(
		AstWhatevToActionFactory::make(
			[](Type leftType, Type rightType) -> Action
			{
				assert leftType->isCreatable() && rightType->isVoid()
					otherwise return nullptr;
				
				Type contentsType=leftType;
				Type arrayType=Array->actuallyIs(makeTuple({{"a", Int}, {"b", Int}, {"c", contentsType->getPtr()}}, true))->getPtr();
				
				return lambdaAction(
					leftType,
					rightType,
					arrayType,
					
					[=](void* leftIn, void* rightIn) -> void*
					{
						void* out=malloc(arrayType->getSize());
						setValInTuple(out, arrayType, "_size", 0);
						setValInTuple(out, arrayType, "_capacity", 0);
						setValInTuple<void*>(out, arrayType, "_data", nullptr);
						return out;
					},
					
					[=](Action inLeft, Action inRight, CppProgram* prog)
					{
						throw PhplusError("not yet implemented", INTERNAL_ERROR);
					},
					
					"Array"
				);
			}
		),
		"Array"
	);
	
	globalNamespace->addNode(
		AstWhatevToActionFactory::make(
			[](Type leftType, Type rightType) -> Action
			{
				assert leftType->matches(Array)
					otherwise return nullptr;
				
				Type arrayType=Array->actuallyIs(leftType->getPtr());
				Type contentsType=arrayType->getSubType("_data").type->getSubType();
				
				assert rightType->matches(contentsType)
					otherwise return nullptr;
				
				return lambdaAction(
					leftType,
					rightType,
					Void,
					
					[=](void* leftIn, void* rightIn) -> void*
					{
						int size=getValFromTuple<int>(leftIn, arrayType, "_size");
						int capacity=getValFromTuple<int>(leftIn, arrayType, "_capacity");
						void* data=getValFromTuple<void*>(leftIn, arrayType, "_data");
						
						if (size+1>capacity)
						{
							if (capacity<1000)
								capacity=1000;
							else
								capacity*=2;
							
							setValInTuple<int>(leftIn, arrayType, "_capacity", capacity);
							void* newData=malloc(capacity*contentsType->getSize());
							memcpy(newData, data, size*contentsType->getSize());
							free(data);
							data=newData;
							setValInTuple<void*>(leftIn, arrayType, "_data", data);
						}
						
						setValInTuple<int>(leftIn, arrayType, "_size", size+1);
						memcpy((char*)data+size*contentsType->getSize(), rightIn, contentsType->getSize());
						
						return nullptr;
					},
					
					[=](Action inLeft, Action inRight, CppProgram* prog)
					{
						throw PhplusError("not yet implemented", INTERNAL_ERROR);
					},
					"append"
				);
			}
		),
		"append"
	);
	
	globalNamespace->addNode(
		AstWhatevToActionFactory::make(
			[](Type leftType, Type rightType) -> Action
			{
				assert leftType->matches(Array->getPtr()) && rightType->matches(Int)
					otherwise return nullptr;
				
				Type arrayType=Array->actuallyIs(leftType->getSubType());
				Type contentsType=arrayType->getSubType("_data").type->getSubType();
				size_t elemSize=contentsType->getSize();
				
				return lambdaAction(
					leftType,
					rightType,
					contentsType,
					
					[=](void* leftIn, void* rightIn) -> void*
					{
						int size=getValFromTuple<int>(leftIn, arrayType, "_size");
						if (*(int*)rightIn<0 || *(int*)rightIn>=size)
							throw PhplusError("index out of bounds, tried to get element at position "+to_string(*(int*)rightIn)+" in array "+to_string(size)+" long", RUNTIME_ERROR);
						
						void* out=malloc(contentsType->getSize());
						memcpy(out, getValFromTuple<char*>(leftIn, arrayType, "_data")+(*(int*)rightIn)*elemSize, elemSize);
						return out;
					},
					
					[=](Action inLeft, Action inRight, CppProgram* prog)
					{
						throw PhplusError("not yet implemented", INTERNAL_ERROR);
					},
					"get"
				);
			}
		),
		"get"
	);
	
	globalNamespace->addNode(
		AstWhatevToActionFactory::make(
			[](Type leftType, Type rightType) -> Action
			{
				Type arrayType=Array->actuallyIs(leftType->getSubType());
				Type contentsType=arrayType->getSubType("_data").type->getSubType();
				
				Type inputType=makeTuple({{"index", Int}, {"value", contentsType}}, true);
				
				assert leftType->getSubType()->matches(Array) && rightType->matches(inputType)
					otherwise return nullptr;
				
				size_t elemSize=contentsType->getSize();
				
				return lambdaAction(
					leftType,
					rightType,
					contentsType,
					
					[=](void* leftIn, void* rightIn) -> void*
					{
						int size=getValFromTuple<int>(leftIn, arrayType, "_size");
						int index=getValFromTuple<int>(rightIn, inputType, "index");
						
						if (index<0 || index>=size)
							throw PhplusError("index out of bounds, tried to set element at position "+to_string(index)+" in array "+to_string(size)+" long", RUNTIME_ERROR);
						
						char* data=getValFromTuple<char*>(leftIn, arrayType, "_data");
						
						memcpy(data+index*elemSize, (char*)rightIn+inputType->getSubType("value").offset, contentsType->getSize());
						
						return nullptr;
					},
					
					[=](Action inLeft, Action inRight, CppProgram* prog)
					{
						throw PhplusError("not yet implemented", INTERNAL_ERROR);
					},
					"set"
				);
			}
		),
		"set"
	);
	
	globalNamespace->addNode(
		AstWhatevToActionFactory::make(
			[](Type leftType, Type rightType) -> Action
			{
				assert leftType->matches(Array) && rightType->isVoid()
					otherwise return nullptr;
				
				Type arrayType=Array->actuallyIs(leftType);
				Type contentsType=arrayType->getSubType("_data").type->getSubType();
				
				return lambdaAction(
					leftType,
					rightType,
					Int,
					
					[=](void* leftIn, void* rightIn) -> void*
					{
						int* out=(int*)malloc(sizeof(int));
						*out=getValFromTuple<int>(leftIn, arrayType, "_size");
						return out;
					},
					
					[=](Action inLeft, Action inRight, CppProgram* prog)
					{
						throw PhplusError("not yet implemented", INTERNAL_ERROR);
					},
					"len"
				);
			}
		),
		"len"
	);
	
	globalNamespace->addNode(
		AstWhatevToActionFactory::make(
			[](Type leftType, Type rightType) -> Action
			{
				assert leftType->isVoid() && rightType->matches(Array)
					otherwise return nullptr;
				
				Type arrayType=Array->actuallyIs(rightType);
				Type contentsType=arrayType->getSubType("_data").type->getSubType();
				size_t elemSize=contentsType->getSize();
				
				return lambdaAction(
					Void,
					rightType,
					rightType,
					
					[=](void* leftIn, void* rightIn) -> void*
					{
						//error.log("Array destroyer called", JSYK);
						int size=getValFromTuple<int>(rightIn, arrayType, "_size");
						void* newData=malloc(elemSize*size);
						void* oldData=getValFromTuple<void*>(rightIn, arrayType, "_data");
						memcpy(newData, oldData, elemSize*size);
						setValInTuple(rightIn, arrayType, "_data", newData);
						void* out=malloc(arrayType->getSize());
						memcpy(out, rightIn, arrayType->getSize());
						return out;
					},
					
					[=](Action inLeft, Action inRight, CppProgram* prog)
					{
						throw PhplusError("not yet implemented", INTERNAL_ERROR);
					},
					"__copy__"
				);
			}
		),
		"__copy__"
	);
	
	globalNamespace->addNode(
		AstWhatevToActionFactory::make(
			[](Type leftType, Type rightType) -> Action
			{
				assert leftType->isVoid() && rightType->matches(Array)
					otherwise return nullptr;
				
				Type arrayType=Array->actuallyIs(rightType);
				
				return lambdaAction(
					Void,
					rightType,
					Void,
					
					[=](void* leftIn, void* rightIn) -> void*
					{
						//error.log("Array destroyer called", JSYK);
						
						free(getValFromTuple<void*>(rightIn, arrayType, "_data"));
						return nullptr;
					},
					
					[=](Action inLeft, Action inRight, CppProgram* prog)
					{
						throw PhplusError("not yet implemented", INTERNAL_ERROR);
					},
					"__destroy__"
				);
			}
		),
		"__destroy__"
	);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x2d8, %rsp            # imm = 0x2D8
leaq 0x38(%rsp), %rdi
callq 0x54d88
leaq 0x2c8(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x3c39c(%rip), %rsi     # 0x79a87
leaq 0x3c39a(%rip), %rdx     # 0x79a8c
leaq 0x2b8(%rsp), %rdi
callq 0xdf6a
leaq 0x5bd3a(%rip), %rbx     # 0x99440
movq (%rbx), %rcx
movq 0x8(%rbx), %rax
movq %rcx, 0x60(%rsp)
movq %rax, 0x68(%rsp)
testq %rax, %rax
je 0x3d731
movq 0x5b885(%rip), %rcx     # 0x98fa8
cmpb $0x0, (%rcx)
je 0x3d72d
incl 0x8(%rax)
jmp 0x3d731
lock
incl 0x8(%rax)
leaq 0x38(%rsp), %rdi
leaq 0x2b8(%rsp), %rsi
leaq 0x60(%rsp), %rdx
callq 0x54dd4
movq 0x68(%rsp), %rdi
testq %rdi, %rdi
je 0x3d757
callq 0xdcba
movq 0x2b8(%rsp), %rdi
cmpq %r14, %rdi
je 0x3d769
callq 0xa2b0
leaq 0x2a8(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x3c541(%rip), %rsi     # 0x79cbd
leaq 0x3c543(%rip), %rdx     # 0x79cc6
leaq 0x298(%rsp), %rdi
callq 0xdf6a
movq (%rbx), %rcx
movq 0x8(%rbx), %rax
movq %rcx, 0x50(%rsp)
movq %rax, 0x58(%rsp)
testq %rax, %rax
je 0x3d7bb
movq 0x5b7fb(%rip), %rcx     # 0x98fa8
cmpb $0x0, (%rcx)
je 0x3d7b7
incl 0x8(%rax)
jmp 0x3d7bb
lock
incl 0x8(%rax)
leaq 0x38(%rsp), %rdi
leaq 0x298(%rsp), %rsi
leaq 0x50(%rsp), %rdx
callq 0x54dd4
movq 0x58(%rsp), %rdi
testq %rdi, %rdi
je 0x3d7e1
callq 0xdcba
movq 0x298(%rsp), %rdi
cmpq %r14, %rdi
je 0x3d7f3
callq 0xa2b0
leaq 0x288(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x3c608(%rip), %rsi     # 0x79e0e
leaq 0x3c606(%rip), %rdx     # 0x79e13
leaq 0x278(%rsp), %rdi
callq 0xdf6a
leaq 0x5bbef(%rip), %rax     # 0x99410
movq (%rax), %rsi
leaq 0x80(%rsp), %rdi
callq 0x546ca
leaq 0x38(%rsp), %rdi
leaq 0x278(%rsp), %rsi
leaq 0x80(%rsp), %rdx
callq 0x54dd4
movq 0x88(%rsp), %rdi
testq %rdi, %rdi
je 0x3d85d
callq 0xdcba
movq 0x278(%rsp), %rdi
cmpq %r14, %rdi
je 0x3d86f
callq 0xa2b0
leaq 0x70(%rsp), %rdi
leaq 0x38(%rsp), %rsi
xorl %edx, %edx
callq 0x55306
movaps 0x70(%rsp), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, 0x70(%rsp)
movq 0x5bb24(%rip), %rdi     # 0x993b8
movaps %xmm0, 0x5bb15(%rip)    # 0x993b0
testq %rdi, %rdi
je 0x3d8a5
callq 0xdcba
movq 0x78(%rsp), %rdi
testq %rdi, %rdi
je 0x3d8b4
callq 0xdcba
movq 0x5baf5(%rip), %rax     # 0x993b0
movq %rax, 0x40(%rsp)
movq 0x5baf1(%rip), %rax     # 0x993b8
movq %rax, 0x48(%rsp)
testq %rax, %rax
je 0x3d8e6
movq 0x5b6d0(%rip), %rcx     # 0x98fa8
cmpb $0x0, (%rcx)
je 0x3d8e2
incl 0x8(%rax)
jmp 0x3d8e6
lock
incl 0x8(%rax)
leaq 0x268(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x3c14e(%rip), %rsi     # 0x79a47
leaq 0x3c14c(%rip), %rdx     # 0x79a4c
leaq 0x258(%rsp), %rdi
callq 0xdf6a
leaq 0x40(%rsp), %rdi
leaq 0x258(%rsp), %rsi
callq 0x2d3fd
movq 0x258(%rsp), %rdi
cmpq %r14, %rdi
je 0x3d931
callq 0xa2b0
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0x3d940
callq 0xdcba
movq 0x5ba39(%rip), %rbx     # 0x99380
xorps %xmm0, %xmm0
leaq 0x150(%rsp), %rsi
movaps %xmm0, (%rsi)
leaq 0x9596(%rip), %rax      # 0x46ef2
movq %rax, 0x18(%rsi)
leaq 0x9b0f(%rip), %rax      # 0x47476
movq %rax, 0x10(%rsi)
leaq 0x30(%rsp), %rdi
callq 0x4edc2
leaq 0x248(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x3c0bf(%rip), %rsi     # 0x79a47
leaq 0x3c0bd(%rip), %rdx     # 0x79a4c
leaq 0x238(%rsp), %rdi
callq 0xdf6a
leaq 0x30(%rsp), %rsi
leaq 0x238(%rsp), %rdx
movq %rbx, %rdi
callq 0x22f38
movq 0x238(%rsp), %rdi
cmpq %r14, %rdi
je 0x3d9c3
callq 0xa2b0
movq 0x30(%rsp), %rsi
testq %rsi, %rsi
je 0x3d9d7
leaq 0x30(%rsp), %rdi
callq 0x168f8
movq $0x0, 0x30(%rsp)
movq 0x160(%rsp), %rax
testq %rax, %rax
je 0x3d9ff
leaq 0x150(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x5b97a(%rip), %rbx     # 0x99380
xorps %xmm0, %xmm0
leaq 0x130(%rsp), %rsi
movaps %xmm0, (%rsi)
leaq 0x9e25(%rip), %rax      # 0x47840
movq %rax, 0x18(%rsi)
leaq 0xa388(%rip), %rax      # 0x47dae
movq %rax, 0x10(%rsi)
leaq 0x28(%rsp), %rdi
callq 0x4edc2
leaq 0x228(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x3c280(%rip), %rsi     # 0x79cc7
leaq 0x3c27f(%rip), %rdx     # 0x79ccd
leaq 0x218(%rsp), %rdi
callq 0xdf6a
leaq 0x28(%rsp), %rsi
leaq 0x218(%rsp), %rdx
movq %rbx, %rdi
callq 0x22f38
movq 0x218(%rsp), %rdi
cmpq %r14, %rdi
je 0x3da82
callq 0xa2b0
movq 0x28(%rsp), %rsi
testq %rsi, %rsi
je 0x3da96
leaq 0x28(%rsp), %rdi
callq 0x168f8
movq $0x0, 0x28(%rsp)
movq 0x140(%rsp), %rax
testq %rax, %rax
je 0x3dabe
leaq 0x130(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x5b8bb(%rip), %rbx     # 0x99380
xorps %xmm0, %xmm0
leaq 0x110(%rsp), %rsi
movaps %xmm0, (%rsi)
leaq 0xa9ac(%rip), %rax      # 0x48486
movq %rax, 0x18(%rsi)
leaq 0xaf17(%rip), %rax      # 0x489fc
movq %rax, 0x10(%rsi)
leaq 0x20(%rsp), %rdi
callq 0x4edc2
leaq 0x208(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x3c1c8(%rip), %rsi     # 0x79cce
leaq 0x3c1c4(%rip), %rdx     # 0x79cd1
leaq 0x1f8(%rsp), %rdi
callq 0xdf6a
leaq 0x20(%rsp), %rsi
leaq 0x1f8(%rsp), %rdx
movq %rbx, %rdi
callq 0x22f38
movq 0x1f8(%rsp), %rdi
cmpq %r14, %rdi
je 0x3db41
callq 0xa2b0
movq 0x20(%rsp), %rsi
testq %rsi, %rsi
je 0x3db55
leaq 0x20(%rsp), %rdi
callq 0x168f8
movq $0x0, 0x20(%rsp)
movq 0x120(%rsp), %rax
testq %rax, %rax
je 0x3db7d
leaq 0x110(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x5b7fc(%rip), %rbx     # 0x99380
xorps %xmm0, %xmm0
leaq 0xf0(%rsp), %rsi
movaps %xmm0, (%rsi)
leaq 0xb453(%rip), %rax      # 0x48fec
movq %rax, 0x18(%rsi)
leaq 0xbbc4(%rip), %rax      # 0x49768
movq %rax, 0x10(%rsi)
leaq 0x18(%rsp), %rdi
callq 0x4edc2
leaq 0x1e8(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x38ac5(%rip), %rsi     # 0x7668a
leaq 0x38ac1(%rip), %rdx     # 0x7668d
leaq 0x1d8(%rsp), %rdi
callq 0xdf6a
leaq 0x18(%rsp), %rsi
leaq 0x1d8(%rsp), %rdx
movq %rbx, %rdi
callq 0x22f38
movq 0x1d8(%rsp), %rdi
cmpq %r14, %rdi
je 0x3dc00
callq 0xa2b0
movq 0x18(%rsp), %rsi
testq %rsi, %rsi
je 0x3dc14
leaq 0x18(%rsp), %rdi
callq 0x168f8
movq $0x0, 0x18(%rsp)
movq 0x100(%rsp), %rax
testq %rax, %rax
je 0x3dc3c
leaq 0xf0(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x5b73d(%rip), %rbx     # 0x99380
xorps %xmm0, %xmm0
leaq 0xd0(%rsp), %rsi
movaps %xmm0, (%rsi)
leaq 0xc290(%rip), %rax      # 0x49ee8
movq %rax, 0x18(%rsi)
leaq 0xc723(%rip), %rax      # 0x4a386
movq %rax, 0x10(%rsi)
leaq 0x10(%rsp), %rdi
callq 0x4edc2
leaq 0x1c8(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x3c02f(%rip), %rsi     # 0x79cb3
leaq 0x3c02b(%rip), %rdx     # 0x79cb6
leaq 0x1b8(%rsp), %rdi
callq 0xdf6a
leaq 0x10(%rsp), %rsi
leaq 0x1b8(%rsp), %rdx
movq %rbx, %rdi
callq 0x22f38
movq 0x1b8(%rsp), %rdi
cmpq %r14, %rdi
je 0x3dcbf
callq 0xa2b0
movq 0x10(%rsp), %rsi
testq %rsi, %rsi
je 0x3dcd3
leaq 0x10(%rsp), %rdi
callq 0x168f8
movq $0x0, 0x10(%rsp)
movq 0xe0(%rsp), %rax
testq %rax, %rax
je 0x3dcfb
leaq 0xd0(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x5b67e(%rip), %rbx     # 0x99380
xorps %xmm0, %xmm0
leaq 0xb0(%rsp), %rsi
movaps %xmm0, (%rsi)
leaq 0xc8fd(%rip), %rax      # 0x4a614
movq %rax, 0x18(%rsi)
leaq 0xcdb8(%rip), %rax      # 0x4aada
movq %rax, 0x10(%rsi)
leaq 0x8(%rsp), %rdi
callq 0x4edc2
leaq 0x1a8(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x39561(%rip), %rsi     # 0x772a4
leaq 0x39562(%rip), %rdx     # 0x772ac
leaq 0x198(%rsp), %rdi
callq 0xdf6a
leaq 0x8(%rsp), %rsi
leaq 0x198(%rsp), %rdx
movq %rbx, %rdi
callq 0x22f38
movq 0x198(%rsp), %rdi
cmpq %r14, %rdi
je 0x3dd7e
callq 0xa2b0
movq 0x8(%rsp), %rsi
testq %rsi, %rsi
je 0x3dd92
leaq 0x8(%rsp), %rdi
callq 0x168f8
movq $0x0, 0x8(%rsp)
movq 0xc0(%rsp), %rax
testq %rax, %rax
je 0x3ddba
leaq 0xb0(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x5b5bf(%rip), %rbx     # 0x99380
xorps %xmm0, %xmm0
leaq 0x90(%rsp), %rsi
movaps %xmm0, (%rsi)
leaq 0xd124(%rip), %rax      # 0x4aefa
movq %rax, 0x18(%rsi)
leaq 0xd50f(%rip), %rax      # 0x4b2f0
movq %rax, 0x10(%rsi)
movq %rsp, %rdi
callq 0x4edc2
leaq 0x188(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x39498(%rip), %rsi     # 0x77298
leaq 0x3949c(%rip), %rdx     # 0x772a3
leaq 0x178(%rsp), %rdi
callq 0xdf6a
movq %rsp, %rsi
leaq 0x178(%rsp), %rdx
movq %rbx, %rdi
callq 0x22f38
movq 0x178(%rsp), %rdi
cmpq %r14, %rdi
je 0x3de39
callq 0xa2b0
movq (%rsp), %rsi
testq %rsi, %rsi
je 0x3de4a
movq %rsp, %rdi
callq 0x168f8
movq $0x0, (%rsp)
movq 0xa0(%rsp), %rax
testq %rax, %rax
je 0x3de71
leaq 0x90(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x38(%rsp), %rbx
testq %rbx, %rbx
je 0x3de8b
movq %rbx, %rdi
callq 0x16a16
movq %rbx, %rdi
callq 0xa2b0
addq $0x2d8, %rsp            # imm = 0x2D8
popq %rbx
popq %r14
retq
jmp 0x3e18c
jmp 0x3e18c
jmp 0x3e18c
jmp 0x3e18c
jmp 0x3e18c
jmp 0x3e18c
jmp 0x3e18c
movq %rax, %rbx
movq 0x178(%rsp), %rdi
cmpq %r14, %rdi
je 0x3ded3
callq 0xa2b0
jmp 0x3ded3
movq %rax, %rbx
movq (%rsp), %rsi
testq %rsi, %rsi
je 0x3dee4
movq %rsp, %rdi
callq 0x168f8
movq $0x0, (%rsp)
jmp 0x3def1
movq %rax, %rbx
movq 0xa0(%rsp), %rax
testq %rax, %rax
je 0x3e22e
leaq 0x90(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x3e22e
jmp 0x3e18c
movq %rax, %rbx
movq 0x198(%rsp), %rdi
cmpq %r14, %rdi
je 0x3df38
callq 0xa2b0
jmp 0x3df38
movq %rax, %rbx
movq 0x8(%rsp), %rsi
testq %rsi, %rsi
je 0x3df4c
leaq 0x8(%rsp), %rdi
callq 0x168f8
movq $0x0, 0x8(%rsp)
jmp 0x3df5a
movq %rax, %rbx
movq 0xc0(%rsp), %rax
testq %rax, %rax
je 0x3e22e
leaq 0xb0(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x3e22e
jmp 0x3e18c
movq %rax, %rbx
movq 0x1b8(%rsp), %rdi
cmpq %r14, %rdi
je 0x3dfa1
callq 0xa2b0
jmp 0x3dfa1
movq %rax, %rbx
movq 0x10(%rsp), %rsi
testq %rsi, %rsi
je 0x3dfb5
leaq 0x10(%rsp), %rdi
callq 0x168f8
movq $0x0, 0x10(%rsp)
jmp 0x3dfc3
movq %rax, %rbx
movq 0xe0(%rsp), %rax
testq %rax, %rax
je 0x3e22e
leaq 0xd0(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x3e22e
jmp 0x3e18c
movq %rax, %rbx
movq 0x1d8(%rsp), %rdi
cmpq %r14, %rdi
je 0x3e00a
callq 0xa2b0
jmp 0x3e00a
movq %rax, %rbx
movq 0x18(%rsp), %rsi
testq %rsi, %rsi
je 0x3e01e
leaq 0x18(%rsp), %rdi
callq 0x168f8
movq $0x0, 0x18(%rsp)
jmp 0x3e02c
movq %rax, %rbx
movq 0x100(%rsp), %rax
testq %rax, %rax
je 0x3e22e
leaq 0xf0(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x3e22e
jmp 0x3e18c
movq %rax, %rbx
movq 0x1f8(%rsp), %rdi
cmpq %r14, %rdi
je 0x3e073
callq 0xa2b0
jmp 0x3e073
movq %rax, %rbx
movq 0x20(%rsp), %rsi
testq %rsi, %rsi
je 0x3e087
leaq 0x20(%rsp), %rdi
callq 0x168f8
movq $0x0, 0x20(%rsp)
jmp 0x3e095
movq %rax, %rbx
movq 0x120(%rsp), %rax
testq %rax, %rax
je 0x3e22e
leaq 0x110(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x3e22e
jmp 0x3e18c
movq %rax, %rbx
movq 0x218(%rsp), %rdi
cmpq %r14, %rdi
je 0x3e0dc
callq 0xa2b0
jmp 0x3e0dc
movq %rax, %rbx
movq 0x28(%rsp), %rsi
testq %rsi, %rsi
je 0x3e0f0
leaq 0x28(%rsp), %rdi
callq 0x168f8
movq $0x0, 0x28(%rsp)
jmp 0x3e0fe
movq %rax, %rbx
movq 0x140(%rsp), %rax
testq %rax, %rax
je 0x3e22e
leaq 0x130(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x3e22e
jmp 0x3e18c
movq %rax, %rbx
movq 0x238(%rsp), %rdi
cmpq %r14, %rdi
je 0x3e142
callq 0xa2b0
jmp 0x3e142
movq %rax, %rbx
movq 0x30(%rsp), %rsi
testq %rsi, %rsi
je 0x3e156
leaq 0x30(%rsp), %rdi
callq 0x168f8
movq $0x0, 0x30(%rsp)
jmp 0x3e164
movq %rax, %rbx
movq 0x160(%rsp), %rax
testq %rax, %rax
je 0x3e22e
leaq 0x150(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x3e22e
movq %rax, %rdi
callq 0xdcaf
movq %rax, %rbx
movq 0x258(%rsp), %rdi
cmpq %r14, %rdi
je 0x3e1ae
callq 0xa2b0
jmp 0x3e1ae
movq %rax, %rbx
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0x3e22e
callq 0xdcba
jmp 0x3e22e
jmp 0x3e22b
movq %rax, %rbx
movq 0x88(%rsp), %rdi
testq %rdi, %rdi
je 0x3e1db
callq 0xdcba
jmp 0x3e1db
movq %rax, %rbx
movq 0x278(%rsp), %rdi
jmp 0x3e21f
jmp 0x3e22b
movq %rax, %rbx
movq 0x58(%rsp), %rdi
testq %rdi, %rdi
je 0x3e1f9
callq 0xdcba
movq 0x298(%rsp), %rdi
jmp 0x3e21f
jmp 0x3e22b
movq %rax, %rbx
movq 0x68(%rsp), %rdi
testq %rdi, %rdi
je 0x3e217
callq 0xdcba
movq 0x2b8(%rsp), %rdi
cmpq %r14, %rdi
je 0x3e22e
callq 0xa2b0
jmp 0x3e22e
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x169e8
movq %rbx, %rdi
callq 0xa510