// File: /workspace/github_cpp_makefile_star2_O2/rossy[P]crossc/SPIRV-Cross/spirv_glsl.cpp
// Function: spirv_cross::CompilerGLSL::to_function_args[abi:cxx11](unsigned int, spirv_cross::SPIRType const&, bool, bool, bool, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, bool*)
string CompilerGLSL::to_function_args(uint32_t img, const SPIRType &imgtype, bool is_fetch, bool is_gather,
                                      bool is_proj, uint32_t coord, uint32_t coord_components, uint32_t dref,
                                      uint32_t grad_x, uint32_t grad_y, uint32_t lod, uint32_t coffset, uint32_t offset,
                                      uint32_t bias, uint32_t comp, uint32_t sample, bool *p_forward)
{
	string farg_str;
	if (is_fetch)
		farg_str = convert_separate_image_to_expression(img);
	else
		farg_str = to_expression(img);

	bool swizz_func = backend.swizzle_is_function;
	auto swizzle = [swizz_func](uint32_t comps, uint32_t in_comps) -> const char * {
		if (comps == in_comps)
			return "";

		switch (comps)
		{
		case 1:
			return ".x";
		case 2:
			return swizz_func ? ".xy()" : ".xy";
		case 3:
			return swizz_func ? ".xyz()" : ".xyz";
		default:
			return "";
		}
	};

	bool forward = should_forward(coord);

	// The IR can give us more components than we need, so chop them off as needed.
	auto swizzle_expr = swizzle(coord_components, expression_type(coord).vecsize);
	// Only enclose the UV expression if needed.
	auto coord_expr = (*swizzle_expr == '\0') ? to_expression(coord) : (to_enclosed_expression(coord) + swizzle_expr);

	// texelFetch only takes int, not uint.
	auto &coord_type = expression_type(coord);
	if (coord_type.basetype == SPIRType::UInt)
	{
		auto expected_type = coord_type;
		expected_type.basetype = SPIRType::Int;
		coord_expr = bitcast_expression(expected_type, coord_type.basetype, coord_expr);
	}

	// textureLod on sampler2DArrayShadow and samplerCubeShadow does not exist in GLSL for some reason.
	// To emulate this, we will have to use textureGrad with a constant gradient of 0.
	// The workaround will assert that the LOD is in fact constant 0, or we cannot emit correct code.
	// This happens for HLSL SampleCmpLevelZero on Texture2DArray and TextureCube.
	bool workaround_lod_array_shadow_as_grad =
	    ((imgtype.image.arrayed && imgtype.image.dim == Dim2D) || imgtype.image.dim == DimCube) &&
	    image_is_comparison(imgtype, img) && lod;

	if (dref)
	{
		forward = forward && should_forward(dref);

		// SPIR-V splits dref and coordinate.
		if (is_gather || coord_components == 4) // GLSL also splits the arguments in two. Same for textureGather.
		{
			farg_str += ", ";
			farg_str += to_expression(coord);
			farg_str += ", ";
			farg_str += to_expression(dref);
		}
		else if (is_proj)
		{
			// Have to reshuffle so we get vec4(coord, dref, proj), special case.
			// Other shading languages splits up the arguments for coord and compare value like SPIR-V.
			// The coordinate type for textureProj shadow is always vec4 even for sampler1DShadow.
			farg_str += ", vec4(";

			if (imgtype.image.dim == Dim1D)
			{
				// Could reuse coord_expr, but we will mess up the temporary usage checking.
				farg_str += to_enclosed_expression(coord) + ".x";
				farg_str += ", ";
				farg_str += "0.0, ";
				farg_str += to_expression(dref);
				farg_str += ", ";
				farg_str += to_enclosed_expression(coord) + ".y)";
			}
			else if (imgtype.image.dim == Dim2D)
			{
				// Could reuse coord_expr, but we will mess up the temporary usage checking.
				farg_str += to_enclosed_expression(coord) + (swizz_func ? ".xy()" : ".xy");
				farg_str += ", ";
				farg_str += to_expression(dref);
				farg_str += ", ";
				farg_str += to_enclosed_expression(coord) + ".z)";
			}
			else
				SPIRV_CROSS_THROW("Invalid type for textureProj with shadow.");
		}
		else
		{
			// Create a composite which merges coord/dref into a single vector.
			auto type = expression_type(coord);
			type.vecsize = coord_components + 1;
			farg_str += ", ";
			farg_str += type_to_glsl_constructor(type);
			farg_str += "(";
			farg_str += coord_expr;
			farg_str += ", ";
			farg_str += to_expression(dref);
			farg_str += ")";
		}
	}
	else
	{
		farg_str += ", ";
		farg_str += coord_expr;
	}

	if (grad_x || grad_y)
	{
		forward = forward && should_forward(grad_x);
		forward = forward && should_forward(grad_y);
		farg_str += ", ";
		farg_str += to_expression(grad_x);
		farg_str += ", ";
		farg_str += to_expression(grad_y);
	}

	if (lod)
	{
		if (workaround_lod_array_shadow_as_grad)
		{
			// Implement textureGrad() instead. LOD == 0.0 is implemented as gradient of 0.0.
			// Implementing this as plain texture() is not safe on some implementations.
			if (imgtype.image.dim == Dim2D)
				farg_str += ", vec2(0.0), vec2(0.0)";
			else if (imgtype.image.dim == DimCube)
				farg_str += ", vec3(0.0), vec3(0.0)";
		}
		else
		{
			if (check_explicit_lod_allowed(lod))
			{
				forward = forward && should_forward(lod);
				farg_str += ", ";
				farg_str += to_expression(lod);
			}
		}
	}
	else if (is_fetch && imgtype.image.dim != DimBuffer && !imgtype.image.ms)
	{
		// Lod argument is optional in OpImageFetch, but we require a LOD value, pick 0 as the default.
		farg_str += ", 0";
	}

	if (coffset)
	{
		forward = forward && should_forward(coffset);
		farg_str += ", ";
		farg_str += to_expression(coffset);
	}
	else if (offset)
	{
		forward = forward && should_forward(offset);
		farg_str += ", ";
		farg_str += to_expression(offset);
	}

	if (bias)
	{
		forward = forward && should_forward(bias);
		farg_str += ", ";
		farg_str += to_expression(bias);
	}

	if (comp)
	{
		forward = forward && should_forward(comp);
		farg_str += ", ";
		farg_str += to_expression(comp);
	}

	if (sample)
	{
		farg_str += ", ";
		farg_str += to_expression(sample);
	}

	*p_forward = forward;

	return farg_str;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x138, %rsp            # imm = 0x138
movl %r9d, %r12d
movq %rcx, %rbp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movl %edx, %r15d
movq %rsi, %r14
movb $0x0, 0x10(%rdi)
movl %r8d, 0x3c(%rsp)
testl %r8d, %r8d
je 0x31d14
leaq 0x40(%rsp), %rdi
movq %r14, %rsi
movl %r15d, %edx
callq 0x31b44
jmp 0x31d24
leaq 0x40(%rsp), %rdi
movq %r14, %rsi
movl %r15d, %edx
callq 0x2b9f0
leaq 0x40(%rsp), %r13
movq %rbx, %rdi
movq %r13, %rsi
callq 0x6320
movq %r13, %rdi
callq 0x6548
movl 0x178(%rsp), %r13d
movb 0x620(%r14), %al
movb %al, 0xf(%rsp)
movq %r14, %rdi
movl %r13d, %esi
callq 0x2f360
movl %eax, 0x8(%rsp)
movq %rbp, 0x30(%rsp)
movq %r14, %rdi
movl %r13d, %esi
callq 0x104b0
movl 0x180(%rsp), %ebp
leaq 0x5db0b(%rip), %r13     # 0x8f887
cmpl %ebp, 0x14(%rax)
je 0x31dc0
cmpl $0x1, %ebp
je 0x31db9
cmpl $0x3, %ebp
je 0x31da0
cmpl $0x2, %ebp
jne 0x31dc0
leaq 0x61898(%rip), %rax     # 0x9362f
leaq 0x61897(%rip), %r13     # 0x93635
jmp 0x31dae
leaq 0x63f62(%rip), %rax     # 0x95d09
leaq 0x63f62(%rip), %r13     # 0x95d10
cmpb $0x0, 0xf(%rsp)
cmovneq %rax, %r13
jmp 0x31dc0
leaq 0x62f9c(%rip), %r13     # 0x94d5c
cmpb $0x0, (%r13)
je 0x31e04
leaq 0x40(%rsp), %rdi
movq %r14, %rsi
movl 0x178(%rsp), %edx
callq 0x2beca
leaq 0x118(%rsp), %rdi
leaq 0x40(%rsp), %rsi
movq %r13, %rdx
callq 0xab3f
leaq 0x40(%rsp), %rdi
callq 0x6548
movl 0x178(%rsp), %r13d
jmp 0x31e1f
leaq 0x118(%rsp), %rdi
movq %r14, %rsi
movl 0x178(%rsp), %r13d
movl %r13d, %edx
callq 0x2b9f0
movq %r14, %rdi
movl %r13d, %esi
callq 0x104b0
movq %rax, %r13
cmpl $0x5, 0xc(%rax)
jne 0x31e8c
leaq 0x40(%rsp), %rdi
movq %r13, %rsi
callq 0x1a29c
leaq 0x40(%rsp), %rdx
movl $0x4, 0xc(%rdx)
movl 0xc(%r13), %ecx
leaq 0x10(%rsp), %rdi
leaq 0x118(%rsp), %r8
movq %r14, %rsi
callq 0x32752
leaq 0x118(%rsp), %rdi
leaq 0x10(%rsp), %r13
movq %r13, %rsi
callq 0x6320
movq %r13, %rdi
callq 0x6548
leaq 0x40(%rsp), %rdi
callq 0x17a3e
movq 0x30(%rsp), %rsi
movl 0x84(%rsi), %eax
cmpl $0x1, %eax
sete %cl
andb 0x89(%rsi), %cl
cmpl $0x3, %eax
sete %al
orb %cl, %al
cmpb $0x1, %al
jne 0x31ecb
movq %r14, %rdi
movl %r15d, %edx
callq 0x16cd4
cmpl $0x0, 0x1a0(%rsp)
setne %r13b
andb %al, %r13b
jmp 0x31ece
xorl %r13d, %r13d
movl 0x188(%rsp), %r15d
testl %r15d, %r15d
je 0x31ef3
cmpb $0x0, 0x8(%rsp)
je 0x31f17
movq %r14, %rdi
movl %r15d, %esi
callq 0x2f360
movl %eax, 0x8(%rsp)
jmp 0x31f1f
leaq 0x63191(%rip), %rsi     # 0x9508b
movq %rbx, %rdi
callq 0x64d0
leaq 0x118(%rsp), %rsi
movq %rbx, %rdi
callq 0x64f0
jmp 0x3226a
movl $0x0, 0x8(%rsp)
cmpl $0x4, %ebp
setne %al
xorb $0x1, %r12b
testb %r12b, %al
jne 0x31f9e
leaq 0x63156(%rip), %rsi     # 0x9508b
movq %rbx, %rdi
callq 0x64d0
leaq 0x40(%rsp), %rdi
movq %r14, %rsi
movl 0x178(%rsp), %edx
callq 0x2b9f0
leaq 0x40(%rsp), %rsi
movq %rbx, %rdi
callq 0x64f0
leaq 0x40(%rsp), %rdi
callq 0x6548
leaq 0x6311c(%rip), %rsi     # 0x9508b
movq %rbx, %rdi
callq 0x64d0
leaq 0x40(%rsp), %rdi
movq %r14, %rsi
movl %r15d, %edx
callq 0x2b9f0
leaq 0x40(%rsp), %rsi
movq %rbx, %rdi
callq 0x64f0
leaq 0x40(%rsp), %rdi
jmp 0x32265
cmpb $0x0, 0x170(%rsp)
je 0x320b2
leaq 0x6166a(%rip), %rsi     # 0x9361d
movq %rbx, %rdi
callq 0x64d0
movq 0x30(%rsp), %rax
movl 0x84(%rax), %eax
cmpl $0x1, %eax
je 0x3217f
testl %eax, %eax
jne 0x32607
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
movl 0x178(%rsp), %edx
callq 0x2beca
leaq 0x62d6a(%rip), %rdx     # 0x94d5c
leaq 0x40(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xab3f
leaq 0x40(%rsp), %rsi
movq %rbx, %rdi
callq 0x64f0
leaq 0x40(%rsp), %rdi
callq 0x6548
leaq 0x10(%rsp), %rdi
callq 0x6548
leaq 0x63062(%rip), %rsi     # 0x9508b
movq %rbx, %rdi
callq 0x64d0
leaq 0x615ed(%rip), %rsi     # 0x93625
movq %rbx, %rdi
callq 0x64d0
leaq 0x40(%rsp), %rdi
movq %r14, %rsi
movl %r15d, %edx
callq 0x2b9f0
leaq 0x40(%rsp), %rsi
movq %rbx, %rdi
callq 0x64f0
leaq 0x40(%rsp), %rdi
callq 0x6548
leaq 0x6301d(%rip), %rsi     # 0x9508b
movq %rbx, %rdi
callq 0x64d0
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
movl 0x178(%rsp), %edx
callq 0x2beca
leaq 0x6159a(%rip), %rdx     # 0x9362b
leaq 0x40(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xab3f
leaq 0x40(%rsp), %rsi
movq %rbx, %rdi
callq 0x64f0
jmp 0x32256
movq %r14, %rdi
movl 0x178(%rsp), %esi
callq 0x104b0
leaq 0x40(%rsp), %rdi
movq %rax, %rsi
callq 0x1a29c
incl %ebp
movl %ebp, 0x54(%rsp)
leaq 0x62fb0(%rip), %rsi     # 0x9508b
movq %rbx, %rdi
callq 0x64d0
leaq 0x10(%rsp), %rdi
leaq 0x40(%rsp), %rdx
movq %r14, %rsi
callq 0x2c226
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x64f0
leaq 0x10(%rsp), %rdi
callq 0x6548
leaq 0x6bb16(%rip), %rsi     # 0x9dc29
movq %rbx, %rdi
callq 0x64d0
leaq 0x118(%rsp), %rsi
movq %rbx, %rdi
callq 0x64f0
leaq 0x62f59(%rip), %rsi     # 0x9508b
movq %rbx, %rdi
callq 0x64d0
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
movl %r15d, %edx
callq 0x2b9f0
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x64f0
leaq 0x10(%rsp), %rdi
callq 0x6548
leaq 0x6388d(%rip), %rsi     # 0x959f5
movq %rbx, %rdi
callq 0x64d0
leaq 0x40(%rsp), %rdi
callq 0x17a3e
jmp 0x3226a
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
movl 0x178(%rsp), %edx
callq 0x2beca
leaq 0x61495(%rip), %rax     # 0x9362f
leaq 0x61494(%rip), %rdx     # 0x93635
cmpb $0x0, 0xf(%rsp)
cmovneq %rax, %rdx
leaq 0x40(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xab3f
leaq 0x40(%rsp), %rsi
movq %rbx, %rdi
callq 0x64f0
leaq 0x40(%rsp), %rdi
callq 0x6548
leaq 0x10(%rsp), %rdi
callq 0x6548
leaq 0x62eaa(%rip), %rsi     # 0x9508b
movq %rbx, %rdi
callq 0x64d0
leaq 0x40(%rsp), %rdi
movq %r14, %rsi
movl %r15d, %edx
callq 0x2b9f0
leaq 0x40(%rsp), %rsi
movq %rbx, %rdi
callq 0x64f0
leaq 0x40(%rsp), %rdi
callq 0x6548
leaq 0x62e74(%rip), %rsi     # 0x9508b
movq %rbx, %rdi
callq 0x64d0
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
movl 0x178(%rsp), %edx
callq 0x2beca
leaq 0x613ff(%rip), %rdx     # 0x93639
leaq 0x40(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xab3f
leaq 0x40(%rsp), %rsi
movq %rbx, %rdi
callq 0x64f0
leaq 0x40(%rsp), %rdi
callq 0x6548
leaq 0x10(%rsp), %rdi
callq 0x6548
movl 0x198(%rsp), %r15d
movl 0x190(%rsp), %r12d
movl %r15d, %eax
orl %r12d, %eax
je 0x32328
cmpb $0x0, 0x8(%rsp)
je 0x322ad
movq %r14, %rdi
movl %r12d, %esi
callq 0x2f360
testb %al, %al
je 0x322ad
movq %r14, %rdi
movl %r15d, %esi
callq 0x2f360
movl %eax, 0x8(%rsp)
jmp 0x322b5
movl $0x0, 0x8(%rsp)
leaq 0x62dcf(%rip), %rsi     # 0x9508b
movq %rbx, %rdi
callq 0x64d0
leaq 0x40(%rsp), %rdi
movq %r14, %rsi
movl %r12d, %edx
callq 0x2b9f0
leaq 0x40(%rsp), %rsi
movq %rbx, %rdi
callq 0x64f0
leaq 0x40(%rsp), %rdi
callq 0x6548
leaq 0x62d99(%rip), %rsi     # 0x9508b
movq %rbx, %rdi
callq 0x64d0
leaq 0x40(%rsp), %rdi
movq %r14, %rsi
movl %r15d, %edx
callq 0x2b9f0
leaq 0x40(%rsp), %rsi
movq %rbx, %rdi
callq 0x64f0
movq 0x30(%rsp), %r15
leaq 0x40(%rsp), %rdi
callq 0x6548
jmp 0x3232d
movq 0x30(%rsp), %r15
cmpl $0x0, 0x1a0(%rsp)
je 0x3235a
testb %r13b, %r13b
je 0x3238a
movl 0x84(%r15), %eax
cmpl $0x1, %eax
je 0x323b9
cmpl $0x3, %eax
jne 0x3240c
leaq 0x61326(%rip), %rsi     # 0x9367e
jmp 0x323c0
cmpb $0x0, 0x3c(%rsp)
je 0x3240c
cmpl $0x5, 0x84(%r15)
je 0x3240c
cmpb $0x0, 0x8a(%r15)
jne 0x3240c
leaq 0x6b701(%rip), %rsi     # 0x9da89
jmp 0x323c0
movq %r14, %rdi
movl 0x1a0(%rsp), %esi
callq 0x301f4
testb %al, %al
je 0x3240c
cmpb $0x0, 0x8(%rsp)
je 0x323ca
movq %r14, %rdi
movl 0x1a0(%rsp), %esi
callq 0x2f360
movl %eax, 0x8(%rsp)
jmp 0x323d2
leaq 0x612a7(%rip), %rsi     # 0x93667
movq %rbx, %rdi
callq 0x64d0
jmp 0x3240c
movl $0x0, 0x8(%rsp)
leaq 0x62cb2(%rip), %rsi     # 0x9508b
movq %rbx, %rdi
callq 0x64d0
leaq 0x40(%rsp), %rdi
movq %r14, %rsi
movl 0x1a0(%rsp), %edx
callq 0x2b9f0
leaq 0x40(%rsp), %rsi
movq %rbx, %rdi
callq 0x64f0
leaq 0x40(%rsp), %rdi
callq 0x6548
movl 0x1a8(%rsp), %r15d
testl %r15d, %r15d
je 0x32431
cmpb $0x0, 0x8(%rsp)
je 0x3245a
movq %r14, %rdi
movl %r15d, %esi
callq 0x2f360
movl %eax, 0x8(%rsp)
jmp 0x32462
movl 0x1b0(%rsp), %r15d
testl %r15d, %r15d
je 0x324ce
cmpb $0x0, 0x8(%rsp)
je 0x32490
movq %r14, %rdi
movl %r15d, %esi
callq 0x2f360
movl %eax, 0x8(%rsp)
jmp 0x32498
movl $0x0, 0x8(%rsp)
leaq 0x62c22(%rip), %rsi     # 0x9508b
movq %rbx, %rdi
callq 0x64d0
leaq 0x40(%rsp), %rdi
movq %r14, %rsi
movl %r15d, %edx
callq 0x2b9f0
leaq 0x40(%rsp), %rsi
movq %rbx, %rdi
callq 0x64f0
jmp 0x324c4
movl $0x0, 0x8(%rsp)
leaq 0x62bec(%rip), %rsi     # 0x9508b
movq %rbx, %rdi
callq 0x64d0
leaq 0x40(%rsp), %rdi
movq %r14, %rsi
movl %r15d, %edx
callq 0x2b9f0
leaq 0x40(%rsp), %rsi
movq %rbx, %rdi
callq 0x64f0
leaq 0x40(%rsp), %rdi
callq 0x6548
movl 0x1b8(%rsp), %r15d
testl %r15d, %r15d
je 0x32531
cmpb $0x0, 0x8(%rsp)
je 0x324f3
movq %r14, %rdi
movl %r15d, %esi
callq 0x2f360
movl %eax, 0x8(%rsp)
jmp 0x324fb
movl $0x0, 0x8(%rsp)
leaq 0x62b89(%rip), %rsi     # 0x9508b
movq %rbx, %rdi
callq 0x64d0
leaq 0x40(%rsp), %rdi
movq %r14, %rsi
movl %r15d, %edx
callq 0x2b9f0
leaq 0x40(%rsp), %rsi
movq %rbx, %rdi
callq 0x64f0
leaq 0x40(%rsp), %rdi
callq 0x6548
movl 0x1c0(%rsp), %r15d
testl %r15d, %r15d
je 0x32594
cmpb $0x0, 0x8(%rsp)
je 0x32556
movq %r14, %rdi
movl %r15d, %esi
callq 0x2f360
movl %eax, 0x8(%rsp)
jmp 0x3255e
movl $0x0, 0x8(%rsp)
leaq 0x62b26(%rip), %rsi     # 0x9508b
movq %rbx, %rdi
callq 0x64d0
leaq 0x40(%rsp), %rdi
movq %r14, %rsi
movl %r15d, %edx
callq 0x2b9f0
leaq 0x40(%rsp), %rsi
movq %rbx, %rdi
callq 0x64f0
leaq 0x40(%rsp), %rdi
callq 0x6548
movl 0x1c8(%rsp), %r15d
testl %r15d, %r15d
je 0x325d7
leaq 0x62ae3(%rip), %rsi     # 0x9508b
movq %rbx, %rdi
callq 0x64d0
leaq 0x40(%rsp), %rdi
movq %r14, %rsi
movl %r15d, %edx
callq 0x2b9f0
leaq 0x40(%rsp), %rsi
movq %rbx, %rdi
callq 0x64f0
leaq 0x40(%rsp), %rdi
callq 0x6548
movq 0x1d0(%rsp), %rax
movl 0x8(%rsp), %ecx
movb %cl, (%rax)
leaq 0x118(%rsp), %rdi
callq 0x6548
movq %rbx, %rax
addq $0x138, %rsp            # imm = 0x138
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x6140
movq %rax, %r15
leaq 0x61024(%rip), %rsi     # 0x9363d
leaq 0x40(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0x6100
movb $0x1, %bpl
leaq 0x40(%rsp), %rsi
movq %r15, %rdi
callq 0x6f6e
xorl %ebp, %ebp
leaq 0xb477f(%rip), %rsi     # 0xe6dc0
movq 0xb5998(%rip), %rdx     # 0xe7fe0
movq %r15, %rdi
callq 0x6490
movq %rax, %r14
leaq 0x40(%rsp), %rdi
callq 0x6548
testb %bpl, %bpl
jne 0x3266a
jmp 0x32735
movq %rax, %r14
movq %r15, %rdi
callq 0x6200
jmp 0x32735
jmp 0x32699
jmp 0x32699
jmp 0x326aa
jmp 0x326aa
jmp 0x32732
jmp 0x32732
jmp 0x326fd
jmp 0x326fd
jmp 0x32732
jmp 0x32732
jmp 0x32699
movq %rax, %r14
leaq 0x40(%rsp), %rdi
callq 0x6548
jmp 0x326ad
jmp 0x326aa
movq %rax, %r14
leaq 0x10(%rsp), %rdi
jmp 0x32705
jmp 0x32732
jmp 0x32732
jmp 0x326fd
jmp 0x32732
jmp 0x326c0
jmp 0x3271a
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x6548
jmp 0x3271d
jmp 0x3271a
jmp 0x326fd
jmp 0x32732
jmp 0x326fd
jmp 0x32732
jmp 0x326fd
jmp 0x32732
jmp 0x32732
jmp 0x3272d
jmp 0x3271a
jmp 0x32732
jmp 0x3272d
jmp 0x3272d
jmp 0x326fd
jmp 0x32732
jmp 0x326fd
jmp 0x32732
jmp 0x326fd
jmp 0x32732
jmp 0x326fd
jmp 0x32732
jmp 0x326fd
jmp 0x32732
movq %rax, %r14
leaq 0x40(%rsp), %rdi
callq 0x6548
jmp 0x32735
jmp 0x32732
movq %rax, %r14
leaq 0x40(%rsp), %rdi
jmp 0x3273d
jmp 0x3272d
movq %rax, %r14
leaq 0x40(%rsp), %rdi
callq 0x17a3e
jmp 0x32735
jmp 0x32732
jmp 0x3272d
movq %rax, %r14
jmp 0x32742
movq %rax, %r14
leaq 0x118(%rsp), %rdi
callq 0x6548
movq %rbx, %rdi
callq 0x6548
movq %r14, %rdi
callq 0x64b0