// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x2d0, %rsp            # imm = 0x2D0
leaq 0x38(%rsp), %rdi
callq 0x559bc
leaq 0x2c0(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x3c9e2(%rip), %rsi     # 0x7aa47
leaq 0x3c9e0(%rip), %rdx     # 0x7aa4c
leaq 0x2b0(%rsp), %rdi
callq 0xdfa8
leaq 0x5c3c0(%rip), %rbx     # 0x9a440
movq (%rbx), %rcx
movq 0x8(%rbx), %rax
movq %rcx, 0x70(%rsp)
movq %rax, 0x78(%rsp)
testq %rax, %rax
je 0x3e0ab
movq 0x5bf0b(%rip), %rcx     # 0x99fa8
cmpb $0x0, (%rcx)
je 0x3e0a7
incl 0x8(%rax)
jmp 0x3e0ab
lock
incl 0x8(%rax)
leaq 0x38(%rsp), %rdi
leaq 0x2b0(%rsp), %rsi
leaq 0x70(%rsp), %rdx
callq 0x55a08
movq 0x78(%rsp), %rdi
testq %rdi, %rdi
je 0x3e0d1
callq 0xdce4
movq 0x2b0(%rsp), %rdi
cmpq %r14, %rdi
je 0x3e0e3
callq 0xa2b0
leaq 0x2a0(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x3cb87(%rip), %rsi     # 0x7ac7d
leaq 0x3cb89(%rip), %rdx     # 0x7ac86
leaq 0x290(%rsp), %rdi
callq 0xdfa8
movq (%rbx), %rcx
movq 0x8(%rbx), %rax
movq %rcx, 0x60(%rsp)
movq %rax, 0x68(%rsp)
testq %rax, %rax
je 0x3e135
movq 0x5be81(%rip), %rcx     # 0x99fa8
cmpb $0x0, (%rcx)
je 0x3e131
incl 0x8(%rax)
jmp 0x3e135
lock
incl 0x8(%rax)
leaq 0x38(%rsp), %rdi
leaq 0x290(%rsp), %rsi
leaq 0x60(%rsp), %rdx
callq 0x55a08
movq 0x68(%rsp), %rdi
testq %rdi, %rdi
je 0x3e15b
callq 0xdce4
movq 0x290(%rsp), %rdi
cmpq %r14, %rdi
je 0x3e16d
callq 0xa2b0
leaq 0x280(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x3cc4e(%rip), %rsi     # 0x7adce
leaq 0x3cc4c(%rip), %rdx     # 0x7add3
leaq 0x270(%rsp), %rdi
callq 0xdfa8
leaq 0x5c275(%rip), %rax     # 0x9a410
movq (%rax), %rsi
leaq 0x160(%rsp), %rdi
callq 0x55358
leaq 0x38(%rsp), %rdi
leaq 0x270(%rsp), %rsi
leaq 0x160(%rsp), %rdx
callq 0x55a08
movq 0x168(%rsp), %rdi
testq %rdi, %rdi
je 0x3e1d7
callq 0xdce4
movq 0x270(%rsp), %rdi
cmpq %r14, %rdi
je 0x3e1e9
callq 0xa2b0
leaq 0x40(%rsp), %rdi
leaq 0x38(%rsp), %rsi
xorl %edx, %edx
callq 0x55f2c
movq 0x40(%rsp), %rcx
movq 0x48(%rsp), %rax
xorps %xmm0, %xmm0
movaps %xmm0, 0x40(%rsp)
movq %rcx, 0x5c19d(%rip)     # 0x9a3b0
movq 0x5c19e(%rip), %rdi     # 0x9a3b8
movq %rax, 0x5c197(%rip)     # 0x9a3b8
testq %rdi, %rdi
je 0x3e241
callq 0xdce4
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0x3e23a
callq 0xdce4
movq 0x5c177(%rip), %rax     # 0x9a3b8
movq 0x5c168(%rip), %rcx     # 0x9a3b0
movq %rcx, 0x50(%rsp)
movq %rax, 0x58(%rsp)
testq %rax, %rax
je 0x3e26c
movq 0x5bd4a(%rip), %rcx     # 0x99fa8
cmpb $0x0, (%rcx)
je 0x3e268
incl 0x8(%rax)
jmp 0x3e26c
lock
incl 0x8(%rax)
leaq 0x260(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x3c788(%rip), %rsi     # 0x7aa07
leaq 0x3c786(%rip), %rdx     # 0x7aa0c
leaq 0x250(%rsp), %rdi
callq 0xdfa8
leaq 0x50(%rsp), %rdi
leaq 0x250(%rsp), %rsi
callq 0x2d6d9
movq 0x250(%rsp), %rdi
cmpq %r14, %rdi
je 0x3e2b7
callq 0xa2b0
movq 0x58(%rsp), %rdi
testq %rdi, %rdi
je 0x3e2c6
callq 0xdce4
movq 0x5c0b3(%rip), %rbx     # 0x9a380
xorps %xmm0, %xmm0
movaps %xmm0, 0x140(%rsp)
leaq 0x99ab(%rip), %rax      # 0x47c8a
movq %rax, 0x158(%rsp)
leaq 0x9f30(%rip), %rax      # 0x4821e
movq %rax, 0x150(%rsp)
movl $0xa8, %edi
callq 0xa2d0
movq %rax, %r14
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x40(%rax)
movaps %xmm0, 0x50(%rax)
movaps %xmm0, 0x60(%rax)
movaps %xmm0, 0x80(%rax)
movaps %xmm0, 0x10(%rax)
addq $0x18, %rax
movq %rax, 0x8(%r14)
movups %xmm0, 0x28(%r14)
movups %xmm0, 0x38(%r14)
movups %xmm0, 0x48(%r14)
movups %xmm0, 0x58(%r14)
xorl %eax, %eax
movb %al, 0x68(%r14)
movups %xmm0, 0x70(%r14)
movb %al, 0x80(%r14)
leaq 0x59c2e(%rip), %r15     # 0x97f88
movq %r15, (%r14)
movq %r14, %rdi
addq $0x88, %rdi
movups %xmm0, 0x88(%r14)
movups %xmm0, 0x98(%r14)
leaq 0x140(%rsp), %rsi
callq 0x4fb9a
movq %r14, 0x30(%rsp)
leaq 0x240(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x3c66b(%rip), %rsi     # 0x7aa07
leaq 0x3c669(%rip), %rdx     # 0x7aa0c
leaq 0x230(%rsp), %rdi
callq 0xdfa8
leaq 0x30(%rsp), %rsi
leaq 0x230(%rsp), %rdx
movq %rbx, %rdi
callq 0x231bc
movq 0x230(%rsp), %rdi
cmpq %r14, %rdi
je 0x3e3d7
callq 0xa2b0
movq 0x30(%rsp), %rsi
testq %rsi, %rsi
je 0x3e3eb
leaq 0x30(%rsp), %rdi
callq 0x16b80
movq $0x0, 0x30(%rsp)
movq 0x150(%rsp), %rax
testq %rax, %rax
je 0x3e413
leaq 0x140(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x5bf66(%rip), %rbx     # 0x9a380
xorps %xmm0, %xmm0
movaps %xmm0, 0x120(%rsp)
leaq 0xa1ba(%rip), %rax      # 0x485e6
movq %rax, 0x138(%rsp)
leaq 0xa711(%rip), %rax      # 0x48b4c
movq %rax, 0x130(%rsp)
movl $0xa8, %edi
callq 0xa2d0
movq %rax, %r14
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x40(%rax)
movaps %xmm0, 0x50(%rax)
movaps %xmm0, 0x60(%rax)
movaps %xmm0, 0x80(%rax)
movaps %xmm0, 0x10(%rax)
addq $0x18, %rax
movq %rax, 0x8(%r14)
movups %xmm0, 0x28(%r14)
movups %xmm0, 0x38(%r14)
movups %xmm0, 0x48(%r14)
movups %xmm0, 0x58(%r14)
xorl %eax, %eax
movb %al, 0x68(%r14)
movups %xmm0, 0x70(%r14)
movb %al, 0x80(%r14)
movq %r15, (%r14)
movq %r14, %rdi
addq $0x88, %rdi
movups %xmm0, 0x88(%r14)
movups %xmm0, 0x98(%r14)
leaq 0x120(%rsp), %rsi
callq 0x4fb9a
movq %r14, 0x28(%rsp)
leaq 0x220(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x3c7a5(%rip), %rsi     # 0x7ac87
leaq 0x3c7a4(%rip), %rdx     # 0x7ac8d
leaq 0x210(%rsp), %rdi
callq 0xdfa8
leaq 0x28(%rsp), %rsi
leaq 0x210(%rsp), %rdx
movq %rbx, %rdi
callq 0x231bc
movq 0x210(%rsp), %rdi
cmpq %r14, %rdi
je 0x3e51d
callq 0xa2b0
movq 0x28(%rsp), %rsi
testq %rsi, %rsi
je 0x3e531
leaq 0x28(%rsp), %rdi
callq 0x16b80
movq $0x0, 0x28(%rsp)
movq 0x130(%rsp), %rax
testq %rax, %rax
je 0x3e559
leaq 0x120(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x5be20(%rip), %rbx     # 0x9a380
xorps %xmm0, %xmm0
movaps %xmm0, 0x100(%rsp)
leaq 0xacac(%rip), %rax      # 0x4921e
movq %rax, 0x118(%rsp)
leaq 0xb1f5(%rip), %rax      # 0x49776
movq %rax, 0x110(%rsp)
movl $0xa8, %edi
callq 0xa2d0
movq %rax, %r14
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x40(%rax)
movaps %xmm0, 0x50(%rax)
movaps %xmm0, 0x60(%rax)
movaps %xmm0, 0x80(%rax)
movaps %xmm0, 0x10(%rax)
addq $0x18, %rax
movq %rax, 0x8(%r14)
movups %xmm0, 0x28(%r14)
movups %xmm0, 0x38(%r14)
movups %xmm0, 0x48(%r14)
movups %xmm0, 0x58(%r14)
xorl %eax, %eax
movb %al, 0x68(%r14)
movups %xmm0, 0x70(%r14)
movb %al, 0x80(%r14)
movq %r15, (%r14)
movq %r14, %rdi
addq $0x88, %rdi
movups %xmm0, 0x88(%r14)
movups %xmm0, 0x98(%r14)
leaq 0x100(%rsp), %rsi
callq 0x4fb9a
movq %r14, 0x20(%rsp)
leaq 0x200(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x3c666(%rip), %rsi     # 0x7ac8e
leaq 0x3c662(%rip), %rdx     # 0x7ac91
leaq 0x1f0(%rsp), %rdi
callq 0xdfa8
leaq 0x20(%rsp), %rsi
leaq 0x1f0(%rsp), %rdx
movq %rbx, %rdi
callq 0x231bc
movq 0x1f0(%rsp), %rdi
cmpq %r14, %rdi
je 0x3e663
callq 0xa2b0
movq 0x20(%rsp), %rsi
testq %rsi, %rsi
je 0x3e677
leaq 0x20(%rsp), %rdi
callq 0x16b80
movq $0x0, 0x20(%rsp)
movq 0x110(%rsp), %rax
testq %rax, %rax
je 0x3e69f
leaq 0x100(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x5bcda(%rip), %rbx     # 0x9a380
xorps %xmm0, %xmm0
movaps %xmm0, 0xe0(%rsp)
leaq 0xb6b8(%rip), %rax      # 0x49d70
movq %rax, 0xf8(%rsp)
leaq 0xbe17(%rip), %rax      # 0x4a4de
movq %rax, 0xf0(%rsp)
movl $0xa8, %edi
callq 0xa2d0
movq %rax, %r14
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x40(%rax)
movaps %xmm0, 0x50(%rax)
movaps %xmm0, 0x60(%rax)
movaps %xmm0, 0x80(%rax)
movaps %xmm0, 0x10(%rax)
addq $0x18, %rax
movq %rax, 0x8(%r14)
movups %xmm0, 0x28(%r14)
movups %xmm0, 0x38(%r14)
movups %xmm0, 0x48(%r14)
movups %xmm0, 0x58(%r14)
xorl %eax, %eax
movb %al, 0x68(%r14)
movups %xmm0, 0x70(%r14)
movb %al, 0x80(%r14)
movq %r15, (%r14)
movq %r14, %rdi
addq $0x88, %rdi
movups %xmm0, 0x88(%r14)
movups %xmm0, 0x98(%r14)
leaq 0xe0(%rsp), %rsi
callq 0x4fb9a
movq %r14, 0x18(%rsp)
leaq 0x1e0(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x38f1c(%rip), %rsi     # 0x7768a
leaq 0x38f18(%rip), %rdx     # 0x7768d
leaq 0x1d0(%rsp), %rdi
callq 0xdfa8
leaq 0x18(%rsp), %rsi
leaq 0x1d0(%rsp), %rdx
movq %rbx, %rdi
callq 0x231bc
movq 0x1d0(%rsp), %rdi
cmpq %r14, %rdi
je 0x3e7a9
callq 0xa2b0
movq 0x18(%rsp), %rsi
testq %rsi, %rsi
je 0x3e7bd
leaq 0x18(%rsp), %rdi
callq 0x16b80
movq $0x0, 0x18(%rsp)
movq 0xf0(%rsp), %rax
testq %rax, %rax
je 0x3e7e5
leaq 0xe0(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x5bb94(%rip), %rbx     # 0x9a380
xorps %xmm0, %xmm0
movaps %xmm0, 0xc0(%rsp)
leaq 0xc46a(%rip), %rax      # 0x4ac68
movq %rax, 0xd8(%rsp)
leaq 0xc8f7(%rip), %rax      # 0x4b104
movq %rax, 0xd0(%rsp)
movl $0xa8, %edi
callq 0xa2d0
movq %rax, %r14
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x40(%rax)
movaps %xmm0, 0x50(%rax)
movaps %xmm0, 0x60(%rax)
movaps %xmm0, 0x80(%rax)
movaps %xmm0, 0x10(%rax)
addq $0x18, %rax
movq %rax, 0x8(%r14)
movups %xmm0, 0x28(%r14)
movups %xmm0, 0x38(%r14)
movups %xmm0, 0x48(%r14)
movups %xmm0, 0x58(%r14)
xorl %eax, %eax
movb %al, 0x68(%r14)
movups %xmm0, 0x70(%r14)
movb %al, 0x80(%r14)
movq %r15, (%r14)
movq %r14, %rdi
addq $0x88, %rdi
movups %xmm0, 0x88(%r14)
movups %xmm0, 0x98(%r14)
leaq 0xc0(%rsp), %rsi
callq 0x4fb9a
movq %r14, 0x10(%rsp)
leaq 0x1c0(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x3c3bf(%rip), %rsi     # 0x7ac73
leaq 0x3c3bb(%rip), %rdx     # 0x7ac76
leaq 0x1b0(%rsp), %rdi
callq 0xdfa8
leaq 0x10(%rsp), %rsi
leaq 0x1b0(%rsp), %rdx
movq %rbx, %rdi
callq 0x231bc
movq 0x1b0(%rsp), %rdi
cmpq %r14, %rdi
je 0x3e8ef
callq 0xa2b0
movq 0x10(%rsp), %rsi
testq %rsi, %rsi
je 0x3e903
leaq 0x10(%rsp), %rdi
callq 0x16b80
movq $0x0, 0x10(%rsp)
movq 0xd0(%rsp), %rax
testq %rax, %rax
je 0x3e92b
leaq 0xc0(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x5ba4e(%rip), %rbx     # 0x9a380
xorps %xmm0, %xmm0
movaps %xmm0, 0xa0(%rsp)
leaq 0xca54(%rip), %rax      # 0x4b398
movq %rax, 0xb8(%rsp)
leaq 0xcf23(%rip), %rax      # 0x4b876
movq %rax, 0xb0(%rsp)
movl $0xa8, %edi
callq 0xa2d0
movq %rax, %r14
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x40(%rax)
movaps %xmm0, 0x50(%rax)
movaps %xmm0, 0x60(%rax)
movaps %xmm0, 0x80(%rax)
movaps %xmm0, 0x10(%rax)
addq $0x18, %rax
movq %rax, 0x8(%r14)
movups %xmm0, 0x28(%r14)
movups %xmm0, 0x38(%r14)
movups %xmm0, 0x48(%r14)
movups %xmm0, 0x58(%r14)
xorl %eax, %eax
movb %al, 0x68(%r14)
movups %xmm0, 0x70(%r14)
movb %al, 0x80(%r14)
movq %r15, (%r14)
movq %r14, %rdi
addq $0x88, %rdi
movups %xmm0, 0x88(%r14)
movups %xmm0, 0x98(%r14)
leaq 0xa0(%rsp), %rsi
callq 0x4fb9a
movq %r14, 0x8(%rsp)
leaq 0x1a0(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x398aa(%rip), %rsi     # 0x782a4
leaq 0x398ab(%rip), %rdx     # 0x782ac
leaq 0x190(%rsp), %rdi
callq 0xdfa8
leaq 0x8(%rsp), %rsi
leaq 0x190(%rsp), %rdx
movq %rbx, %rdi
callq 0x231bc
movq 0x190(%rsp), %rdi
cmpq %r14, %rdi
je 0x3ea35
callq 0xa2b0
movq 0x8(%rsp), %rsi
testq %rsi, %rsi
je 0x3ea49
leaq 0x8(%rsp), %rdi
callq 0x16b80
movq $0x0, 0x8(%rsp)
movq 0xb0(%rsp), %rax
testq %rax, %rax
je 0x3ea71
leaq 0xa0(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x5b908(%rip), %rbx     # 0x9a380
xorps %xmm0, %xmm0
movaps %xmm0, 0x80(%rsp)
leaq 0xd200(%rip), %rax      # 0x4bc8a
movq %rax, 0x98(%rsp)
leaq 0xd5db(%rip), %rax      # 0x4c074
movq %rax, 0x90(%rsp)
movl $0xa8, %edi
callq 0xa2d0
movq %rax, %r14
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x40(%rax)
movaps %xmm0, 0x50(%rax)
movaps %xmm0, 0x60(%rax)
movaps %xmm0, 0x80(%rax)
movaps %xmm0, 0x10(%rax)
addq $0x18, %rax
movq %rax, 0x8(%r14)
movups %xmm0, 0x28(%r14)
movups %xmm0, 0x38(%r14)
movups %xmm0, 0x48(%r14)
movups %xmm0, 0x58(%r14)
xorl %eax, %eax
movb %al, 0x68(%r14)
movups %xmm0, 0x70(%r14)
movb %al, 0x80(%r14)
movq %r15, (%r14)
movq %r14, %rdi
addq $0x88, %rdi
movups %xmm0, 0x88(%r14)
movups %xmm0, 0x98(%r14)
leaq 0x80(%rsp), %rsi
callq 0x4fb9a
movq %r14, (%rsp)
leaq 0x180(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x39759(%rip), %rsi     # 0x78298
leaq 0x3975d(%rip), %rdx     # 0x782a3
leaq 0x170(%rsp), %rdi
callq 0xdfa8
movq %rsp, %rsi
leaq 0x170(%rsp), %rdx
movq %rbx, %rdi
callq 0x231bc
movq 0x170(%rsp), %rdi
cmpq %r14, %rdi
je 0x3eb78
callq 0xa2b0
movq (%rsp), %rsi
testq %rsi, %rsi
je 0x3eb89
movq %rsp, %rdi
callq 0x16b80
movq $0x0, (%rsp)
movq 0x90(%rsp), %rax
testq %rax, %rax
je 0x3ebb0
leaq 0x80(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x38(%rsp), %rbx
testq %rbx, %rbx
je 0x3ebca
movq %rbx, %rdi
callq 0x16c9e
movq %rbx, %rdi
callq 0xa2b0
addq $0x2d0, %rsp            # imm = 0x2D0
popq %rbx
popq %r14
popq %r15
retq
jmp 0x3ef84
jmp 0x3ef84
jmp 0x3ef84
jmp 0x3ef84
jmp 0x3ef84
jmp 0x3ef84
jmp 0x3ef84
movq %rax, %rbx
movq 0x170(%rsp), %rdi
cmpq %r14, %rdi
je 0x3ec14
callq 0xa2b0
jmp 0x3ec14
movq %rax, %rbx
movq (%rsp), %rsi
testq %rsi, %rsi
je 0x3ec25
movq %rsp, %rdi
callq 0x16b80
movq $0x0, (%rsp)
jmp 0x3ee4a
movq %rax, %rbx
movq 0x190(%rsp), %rdi
cmpq %r14, %rdi
je 0x3ec4c
callq 0xa2b0
jmp 0x3ec4c
movq %rax, %rbx
movq 0x8(%rsp), %rsi
testq %rsi, %rsi
je 0x3ec60
leaq 0x8(%rsp), %rdi
callq 0x16b80
movq $0x0, 0x8(%rsp)
jmp 0x3ee7a
movq %rax, %rbx
movq 0x1b0(%rsp), %rdi
cmpq %r14, %rdi
je 0x3ec88
callq 0xa2b0
jmp 0x3ec88
movq %rax, %rbx
movq 0x10(%rsp), %rsi
testq %rsi, %rsi
je 0x3ec9c
leaq 0x10(%rsp), %rdi
callq 0x16b80
movq $0x0, 0x10(%rsp)
jmp 0x3eeaa
movq %rax, %rbx
movq 0x1d0(%rsp), %rdi
cmpq %r14, %rdi
je 0x3ecc4
callq 0xa2b0
jmp 0x3ecc4
movq %rax, %rbx
movq 0x18(%rsp), %rsi
testq %rsi, %rsi
je 0x3ecd8
leaq 0x18(%rsp), %rdi
callq 0x16b80
movq $0x0, 0x18(%rsp)
jmp 0x3eeda
movq %rax, %rbx
movq 0x1f0(%rsp), %rdi
cmpq %r14, %rdi
je 0x3ed00
callq 0xa2b0
jmp 0x3ed00
movq %rax, %rbx
movq 0x20(%rsp), %rsi
testq %rsi, %rsi
je 0x3ed14
leaq 0x20(%rsp), %rdi
callq 0x16b80
movq $0x0, 0x20(%rsp)
jmp 0x3ef07
movq %rax, %rbx
movq 0x210(%rsp), %rdi
cmpq %r14, %rdi
je 0x3ed3c
callq 0xa2b0
jmp 0x3ed3c
movq %rax, %rbx
movq 0x28(%rsp), %rsi
testq %rsi, %rsi
je 0x3ed50
leaq 0x28(%rsp), %rdi
callq 0x16b80
movq $0x0, 0x28(%rsp)
jmp 0x3ef2d
movq %rax, %rbx
movq 0x230(%rsp), %rdi
cmpq %r14, %rdi
je 0x3ed78
callq 0xa2b0
jmp 0x3ed78
movq %rax, %rbx
movq 0x30(%rsp), %rsi
testq %rsi, %rsi
je 0x3ed8c
leaq 0x30(%rsp), %rdi
callq 0x16b80
movq $0x0, 0x30(%rsp)
jmp 0x3ef53
movq %rax, %rbx
movq 0x250(%rsp), %rdi
cmpq %r14, %rdi
je 0x3edb4
callq 0xa2b0
jmp 0x3edb4
movq %rax, %rbx
movq 0x58(%rsp), %rdi
testq %rdi, %rdi
je 0x3ef72
callq 0xdce4
jmp 0x3ef72
jmp 0x3ee3f
movq %rax, %rbx
movq 0x168(%rsp), %rdi
testq %rdi, %rdi
je 0x3ede8
callq 0xdce4
jmp 0x3ede8
movq %rax, %rbx
movq 0x270(%rsp), %rdi
jmp 0x3ee2c
jmp 0x3ee3f
movq %rax, %rbx
movq 0x68(%rsp), %rdi
testq %rdi, %rdi
je 0x3ee06
callq 0xdce4
movq 0x290(%rsp), %rdi
jmp 0x3ee2c
jmp 0x3ee3f
movq %rax, %rbx
movq 0x78(%rsp), %rdi
testq %rdi, %rdi
je 0x3ee24
callq 0xdce4
movq 0x2b0(%rsp), %rdi
cmpq %r14, %rdi
je 0x3ef72
callq 0xa2b0
jmp 0x3ef72
movq %rax, %rbx
jmp 0x3ef72
movq %rax, %rbx
movq 0x90(%rsp), %rax
testq %rax, %rax
je 0x3ef72
leaq 0x80(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x3ef72
jmp 0x3ef84
movq %rax, %rbx
movq 0xb0(%rsp), %rax
testq %rax, %rax
je 0x3ef72
leaq 0xa0(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x3ef72
jmp 0x3ef84
movq %rax, %rbx
movq 0xd0(%rsp), %rax
testq %rax, %rax
je 0x3ef72
leaq 0xc0(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x3ef72
jmp 0x3ef84
movq %rax, %rbx
movq 0xf0(%rsp), %rax
testq %rax, %rax
je 0x3ef72
leaq 0xe0(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x3ef72
jmp 0x3ef84
movq %rax, %rbx
movq 0x110(%rsp), %rax
testq %rax, %rax
je 0x3ef72
leaq 0x100(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x3ef72
jmp 0x3ef84
movq %rax, %rbx
movq 0x130(%rsp), %rax
testq %rax, %rax
je 0x3ef72
leaq 0x120(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x3ef72
jmp 0x3ef84
movq %rax, %rbx
movq 0x150(%rsp), %rax
testq %rax, %rax
je 0x3ef72
leaq 0x140(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
leaq 0x38(%rsp), %rdi
callq 0x16c70
movq %rbx, %rdi
callq 0xa510
movq %rax, %rdi
callq 0xdcd8