LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/kernfel[P]fNEAT/robot-simplistic.c
// Function: move_robot_in_room
void move_robot_in_room( Robot *bot, Room *room, struct Robot_Params *params, double *controller_outputs ) {
	// Adjust heading
	adjust_heading( bot, params, controller_outputs );

	// Calculate forward move
	double motor_output = controller_outputs[0];
	if ( fabs(motor_output) > params->motor_threshold ) {
		if ( motor_output > 0 )
			motor_output = motor_output - params->motor_threshold;
		else
			motor_output = motor_output + params->motor_threshold;
		double m_x = cos(bot->heading) * motor_output * params->motor_sensitivity;
		double m_y = sin(bot->heading) * motor_output * params->motor_sensitivity;

		// Detect depth of collision, if any
		double new_x = bot->x + m_x, new_y = bot->y + m_y;
		double adjust_x=0, adjust_y=0;
		if ( new_x - params->radius < 0 ) {
			adjust_x = -(params->radius - new_x) / m_x;
		} else if ( new_x + params->radius > room->x ) {
			adjust_x = (new_x + params->radius - room->x) / m_x;
		}
		if ( new_y - params->radius < 0 ) {
			adjust_y = -(params->radius - new_y) / m_y;
		} else if ( new_y + params->radius > room->y ) {
			adjust_y = (new_y + params->radius - room->y) / m_y;
		}

		// Apply the adjusted movement vector
		bot->x += (1-max(adjust_x, adjust_y)) * m_x;
		bot->y += (1-max(adjust_x, adjust_y)) * m_y;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r12
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %rdx, %rsi
movq %rcx, %rdx
callq 0x5468
movsd (%r12), %xmm0
movapd 0x1c80(%rip), %xmm2     # 0x7180
andpd %xmm0, %xmm2
movsd 0x10(%r15), %xmm1
ucomisd %xmm1, %xmm2
jbe 0x5638
movapd 0x1dc4(%rip), %xmm2     # 0x72e0
xorpd %xmm1, %xmm2
xorpd %xmm3, %xmm3
cmpltsd %xmm0, %xmm3
andpd %xmm3, %xmm2
andnpd %xmm1, %xmm3
orpd %xmm2, %xmm3
addsd %xmm0, %xmm3
movapd %xmm3, 0x10(%rsp)
movsd 0x10(%rbx), %xmm0
callq 0x1080
mulsd 0x10(%rsp), %xmm0
mulsd 0x8(%r15), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rbx), %xmm0
callq 0x1130
movsd 0x8(%rsp), %xmm8
mulsd 0x10(%rsp), %xmm0
mulsd 0x8(%r15), %xmm0
movsd (%rbx), %xmm2
movsd 0x8(%rbx), %xmm1
movapd %xmm8, %xmm5
addsd %xmm2, %xmm5
movapd %xmm0, %xmm4
addsd %xmm1, %xmm4
movsd (%r15), %xmm3
ucomisd %xmm5, %xmm3
jbe 0x55b4
movapd %xmm3, %xmm7
subsd %xmm5, %xmm7
xorpd 0x1d33(%rip), %xmm7     # 0x72e0
divsd %xmm8, %xmm7
jmp 0x55d4
addsd %xmm3, %xmm5
movsd (%r14), %xmm6
ucomisd %xmm6, %xmm5
xorpd %xmm7, %xmm7
jbe 0x55d4
subsd %xmm6, %xmm5
divsd %xmm8, %xmm5
movapd %xmm5, %xmm7
ucomisd %xmm4, %xmm3
jbe 0x55ec
subsd %xmm4, %xmm3
xorpd 0x1cfa(%rip), %xmm3     # 0x72e0
divsd %xmm0, %xmm3
jmp 0x560c
addsd %xmm3, %xmm4
movsd 0x8(%r14), %xmm5
xorpd %xmm3, %xmm3
ucomisd %xmm5, %xmm4
jbe 0x560c
subsd %xmm5, %xmm4
divsd %xmm0, %xmm4
movapd %xmm4, %xmm3
maxsd %xmm3, %xmm7
movsd 0x1a28(%rip), %xmm3     # 0x7040
subsd %xmm7, %xmm3
mulsd %xmm3, %xmm8
addsd %xmm2, %xmm8
movsd %xmm8, (%rbx)
mulsd %xmm0, %xmm3
addsd %xmm1, %xmm3
movsd %xmm3, 0x8(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/kernfel[P]fNEAT/robot-simplistic.c
// Function: get_sensor_readings_in_room
void get_sensor_readings_in_room( Robot *bot, Room *room, struct Robot_Params *params, double *sensor_inputs ) {
	// Calculate sensor data
	int i;
	double s_length = params->dist_sensor_length + params->radius;
	for ( i=0; i<params->num_dist_sensors; i++ ) {
		double s_x = cos(bot->heading + params->dist_sensor_pos[i]) * s_length;
		double s_y = sin(bot->heading + params->dist_sensor_pos[i]) * s_length;
		double depth_x=0, depth_y=0;
		if ( bot->x + s_x < 0 )
			depth_x = -(bot->x + s_x) / s_x;
		else if ( bot->x + s_x > room->x )
			depth_x = (bot->x + s_x - room->x) / s_x;
		if ( bot->y + s_y < 0 )
			depth_y = -(bot->y + s_y) / s_y;
		else if ( bot->y + s_y > room->y )
			depth_y = (bot->y + s_y - room->y) / s_y;
		double reading = max(depth_x, depth_y) * s_length / params->dist_sensor_length;
		sensor_inputs[i] = params->invert_dist_sensors ? 1-reading : reading;
	}
}

// Assembly:
cmpl $0x0, 0x28(%rdx)
jle 0x5773
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movsd 0x30(%rdx), %xmm0
addsd (%rdx), %xmm0
movsd %xmm0, (%rsp)
xorl %r13d, %r13d
movsd 0x10(%r12), %xmm0
movq 0x38(%r14), %rax
addsd (%rax,%r13,8), %xmm0
callq 0x1080
mulsd (%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%r12), %xmm0
movq 0x38(%r14), %rax
addsd (%rax,%r13,8), %xmm0
callq 0x1130
movsd 0x8(%rsp), %xmm5
xorpd %xmm4, %xmm4
movsd (%r12), %xmm2
addsd %xmm5, %xmm2
ucomisd %xmm2, %xmm4
jbe 0x56d3
xorpd 0x1c0f(%rip), %xmm2     # 0x72e0
jmp 0x56e6
movsd (%r15), %xmm3
xorpd %xmm1, %xmm1
ucomisd %xmm3, %xmm2
jbe 0x56ee
subsd %xmm3, %xmm2
divsd %xmm5, %xmm2
movapd %xmm2, %xmm1
mulsd (%rsp), %xmm0
movsd 0x8(%r12), %xmm2
addsd %xmm0, %xmm2
ucomisd %xmm2, %xmm4
jbe 0x570e
xorpd 0x1bd4(%rip), %xmm2     # 0x72e0
jmp 0x5722
movsd 0x8(%r15), %xmm4
xorpd %xmm3, %xmm3
ucomisd %xmm4, %xmm2
jbe 0x572a
subsd %xmm4, %xmm2
divsd %xmm0, %xmm2
movapd %xmm2, %xmm3
maxsd %xmm3, %xmm1
mulsd (%rsp), %xmm1
divsd 0x30(%r14), %xmm1
cmpb $0x0, 0x40(%r14)
je 0x5750
movsd 0x18f8(%rip), %xmm0     # 0x7040
subsd %xmm1, %xmm0
movapd %xmm0, %xmm1
movsd %xmm1, (%rbx,%r13,8)
incq %r13
movslq 0x28(%r14), %rax
cmpq %rax, %r13
jl 0x5678
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/kernfel[P]fNEAT/network-static.c
// Function: delete_eNetwork
void delete_eNetwork( eNetwork *e ) {
	free( e->nodes );
	free( e->inputs );
	free( e->outputs );
	free( e->links );

	e->nodes = 0;
	e->inputs = 0;
	e->outputs = 0;
	e->links = 0;

	e->num_nodes = 0;
	e->num_inputs = 0;
	e->num_outputs = 0;
	e->num_links = 0;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x1030
movq 0x18(%rbx), %rdi
callq 0x1030
movq 0x20(%rbx), %rdi
callq 0x1030
movq 0x30(%rbx), %rdi
callq 0x1030
movq $0x0, 0x30(%rbx)
xorl %eax, %eax
movl %eax, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
movups %xmm0, 0x18(%rbx)
movl %eax, 0x28(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/kernfel[P]fNEAT/network-static.c
// Function: activate
void activate( eNetwork *net, double *inputs, double *outputs ) {
	unsigned int i, j=0;
	eNode *n = net->nodes;
	eLink *l = net->links;

	// Load input values
	for ( i=0; i<net->num_inputs; i++ ) {
		if ( net->inputs[i] ) {
			net->inputs[i]->a = inputs[i];
			n++;
			j++;
			l += net->inputs[i]->num_inputs;
		}
	}

	// Propagate
	for ( i=j; i<net->num_nodes; i++ ) {
		double sum=0;
		for ( j=0; j<n->num_inputs; j++ ) {
			sum += l->w * l->from->a;
			l++;
		}
		n->a = tanh(sum);
		n++;
	}

	// Load output values
	for ( i=0; i<net->num_outputs; i++ ) {
		if ( net->outputs[i] ) {
			outputs[i] = net->outputs[i]->a;
		} else {
			outputs[i] = 0;
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %r15
movq 0x30(%rdi), %r12
movl 0x10(%rdi), %eax
testq %rax, %rax
je 0x6504
movq 0x18(%r14), %rcx
xorl %edx, %edx
xorl %ebp, %ebp
movq (%rcx,%rdx,8), %rdi
testq %rdi, %rdi
je 0x64fa
movsd (%rsi,%rdx,8), %xmm0
movsd %xmm0, (%rdi)
addq $0x10, %r15
incl %ebp
movslq 0x8(%rdi), %rdi
shlq $0x4, %rdi
addq %rdi, %r12
incq %rdx
cmpq %rdx, %rax
jne 0x64d7
jmp 0x653f
xorl %ebp, %ebp
jmp 0x653f
movl 0x8(%r15), %eax
xorpd %xmm0, %xmm0
testl %eax, %eax
je 0x652f
movsd (%r12), %xmm1
movq 0x8(%r12), %rcx
mulsd (%rcx), %xmm1
addsd %xmm1, %xmm0
addq $0x10, %r12
decl %eax
jne 0x6514
callq 0x1150
movsd %xmm0, (%r15)
addq $0x10, %r15
incl %ebp
cmpl (%r14), %ebp
jb 0x6508
movl 0x14(%r14), %eax
testq %rax, %rax
je 0x6573
movq 0x20(%r14), %rcx
xorl %edx, %edx
movq (%rcx,%rdx,8), %rsi
testq %rsi, %rsi
je 0x6562
movsd (%rsi), %xmm0
jmp 0x6566
xorpd %xmm0, %xmm0
movsd %xmm0, (%rbx,%rdx,8)
incq %rdx
cmpq %rdx, %rax
jne 0x6553
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/kernfel[P]fNEAT/network-static.c
// Function: dump_eNetwork
void dump_eNetwork( eNetwork *net, FILE *fp ) {
	unsigned int i;
	for ( i=0; i<net->num_nodes; i++ ) {
		fprintf( fp, "0x%08x | %4d\n",
			(unsigned int) &net->nodes[i],
			net->nodes[i].num_inputs
		);
	}

	for ( i=0; i<net->num_links; i++ ) {
		fprintf( fp, "0x%08x | 0x%08x > ... | %+6.4f\n",
			(unsigned int) &net->links[i],
			(unsigned int) net->links[i].from,
			net->links[i].w
		);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x0, (%rdi)
je 0x65c6
leaq 0xd61(%rip), %r15       # 0x72f8
xorl %r12d, %r12d
xorl %r13d, %r13d
movq 0x8(%r14), %rax
leal (%rax,%r12), %edx
movl 0x8(%rax,%r12), %ecx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x10b0
incq %r13
movl (%r14), %eax
addq $0x10, %r12
cmpq %rax, %r13
jb 0x659d
cmpl $0x0, 0x28(%r14)
je 0x660a
xorl %r12d, %r12d
leaq 0xd2f(%rip), %r15       # 0x7306
xorl %r13d, %r13d
movq 0x30(%r14), %rax
leal (%rax,%r12), %edx
movl 0x8(%rax,%r12), %ecx
movsd (%rax,%r12), %xmm0
movq %rbx, %rdi
movq %r15, %rsi
movb $0x1, %al
callq 0x10b0
incq %r13
movl 0x28(%r14), %eax
addq $0x10, %r12
cmpq %rax, %r13
jb 0x65da
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/aligrudi[P]gpss/sum.c
// Function: main
int main(void)
{
	int cnt = 0;
	int npt;
	int r[NALG];
	int amax[NALG] = {0};
	int arat[NALG] = {0};
	int i;
	while (scanf("%d", &npt) == 1) {
		int best = 0;
		for (i = 0; i < NALG; i++)
			scanf("%d", &r[i]);
		for (i = 0; i < NALG; i++)
			if (best < r[i])
				best = r[i];
		for (i = 0; i < NALG; i++)
			if (r[i] == best)
				amax[i]++;
		for (i = 0; i < NALG; i++)
			arat[i] += r[i] * 10000 / best;
		cnt++;
	}
	for (i = 0; i < NALG; i++) {
		int maxrat = amax[i] * 10000 / cnt;
		int sizerat = arat[i] / cnt;
		printf("%2d.%02d %2d.%02d\n", maxrat / 100, maxrat % 100,
			sizerat / 100, sizerat % 100);
	}
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
leaq 0xe9a(%rip), %rdi       # 0x2004
xorl %ebp, %ebp
leaq 0xc(%rsp), %rsi
xorl %eax, %eax
callq 0x1040
cmpl $0x1, %eax
jne 0x1209
leaq 0xe7c(%rip), %rbx       # 0x2004
leaq 0xc(%rsp), %r14
xorl %ebp, %ebp
xorl %r15d, %r15d
leaq (%rsp,%r15), %rsi
addq $0x10, %rsi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1040
addq $0x4, %r15
cmpq $0x10, %r15
jne 0x1192
xorl %eax, %eax
xorl %ecx, %ecx
movl %ecx, %edx
movl 0x10(%rsp,%rax,4), %ecx
cmpl %ecx, %edx
cmovgl %edx, %ecx
incq %rax
cmpq $0x4, %rax
jne 0x11b2
xorl %eax, %eax
cmpl %ecx, 0x10(%rsp,%rax,4)
jne 0x11d2
incl 0x30(%rsp,%rax,4)
incq %rax
cmpq $0x4, %rax
jne 0x11c8
xorl %esi, %esi
imull $0x2710, 0x10(%rsp,%rsi,4), %eax # imm = 0x2710
cltd
idivl %ecx
addl %eax, 0x20(%rsp,%rsi,4)
incq %rsi
cmpq $0x4, %rsi
jne 0x11dd
incl %ebp
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x1040
cmpl $0x1, %eax
je 0x118f
leaq 0xdf7(%rip), %rbx       # 0x2007
xorl %r14d, %r14d
imull $0x2710, 0x30(%rsp,%r14,4), %eax # imm = 0x2710
cltd
idivl %ebp
movl %eax, %ecx
movl 0x20(%rsp,%r14,4), %eax
cltd
idivl %ebp
movslq %ecx, %rdx
imulq $0x51eb851f, %rdx, %rsi # imm = 0x51EB851F
movq %rsi, %rcx
shrq $0x3f, %rcx
sarq $0x25, %rsi
addl %ecx, %esi
imull $0x64, %esi, %ecx
subl %ecx, %edx
movslq %eax, %r8
imulq $0x51eb851f, %r8, %rcx  # imm = 0x51EB851F
movq %rcx, %rax
shrq $0x3f, %rax
sarq $0x25, %rcx
addl %eax, %ecx
imull $0x64, %ecx, %eax
subl %eax, %r8d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1030
incq %r14
cmpq $0x4, %r14
jne 0x1213
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/pipde[P]deos-songlib/utils/chorus/chorus.c
// Function: getDatum
static double
getDatum(FILE *in,FILE *out,RRA *h,double t)
    {
    static int edge = -1;
    int ceiling;
    double result;
    
    if (t < 0) return 0;

    if (edge == -1) createRRAData(h);

    /* read in five or so samples ahead */

    ceiling = (int) (t + 0.5) + ReadAhead;

    if (ceiling >= h->samples) ceiling = h->samples - 1;

    while (edge < ceiling)
        {
        ++edge;
        h->data[0][edge] = 
            readRRAAmplitude(in,out,h->bitsPerSample,outputComment);
        }

    result = interp(h->data[0],h->samples,t);

    return result;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movapd %xmm0, %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm1, %xmm0
ja 0x1d27
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
cmpl $-0x1, 0x55aa(%rip)     # 0x7170
movsd %xmm1, -0x30(%rbp)
jne 0x1bda
movq %rbx, %rdi
callq 0x2026
movsd -0x30(%rbp), %xmm1
movsd 0x2466(%rip), %xmm0     # 0x4048
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
addl 0x5584(%rip), %eax      # 0x7174
movl 0xc(%rbx), %ecx
leal -0x1(%rcx), %r13d
cmpl %ecx, %eax
cmovll %eax, %r13d
movl 0x556d(%rip), %ecx      # 0x7170
cmpl %r13d, %ecx
jge 0x1c3e
leaq 0x158a(%rip), %r12      # 0x3199
incl %ecx
movl %ecx, 0x5559(%rip)      # 0x7170
movl 0x8(%rbx), %edx
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rcx
callq 0x2968
movq 0x18(%rbx), %rcx
movq (%rcx), %rdx
movslq 0x553a(%rip), %rcx      # 0x7170
movl %eax, (%rdx,%rcx,4)
cmpl %r13d, %ecx
jl 0x1c0f
xorpd %xmm0, %xmm0
movsd -0x30(%rbp), %xmm4
ucomisd %xmm0, %xmm4
jb 0x1d36
movq 0x18(%rbx), %rcx
cvttsd2si %xmm4, %eax
movq (%rcx), %rcx
movslq 0xc(%rbx), %rsi
leal -0x1(%rsi), %edx
cmpl %eax, %edx
jle 0x1d00
leal 0x1(%rax), %esi
xorl %edi, %edi
testl %eax, %eax
setg %dil
movl %eax, %r8d
subl %edi, %r8d
leal 0x2(%rax), %edi
cmpl %edx, %esi
cmovgel %esi, %edi
movslq %eax, %rdx
xorps %xmm1, %xmm1
cvtsi2sdl (%rcx,%rdx,4), %xmm1
movslq %r8d, %rdx
cvtsi2sdl (%rcx,%rdx,4), %xmm2
movsd 0x23b1(%rip), %xmm0     # 0x4050
movapd %xmm1, %xmm3
mulsd %xmm0, %xmm3
subsd %xmm2, %xmm3
movslq %esi, %rdx
xorps %xmm2, %xmm2
cvtsi2sdl (%rcx,%rdx,4), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm3, %xmm0
movslq %edi, %rdx
xorps %xmm3, %xmm3
cvtsi2sdl (%rcx,%rdx,4), %xmm3
subsd %xmm3, %xmm0
xorps %xmm3, %xmm3
cvtsi2sd %eax, %xmm3
mulsd 0x237c(%rip), %xmm0     # 0x4058
subsd %xmm3, %xmm4
movsd 0x2360(%rip), %xmm3     # 0x4048
ucomisd %xmm4, %xmm3
jbe 0x1d0b
subsd %xmm1, %xmm0
addsd %xmm0, %xmm0
mulsd %xmm4, %xmm0
addsd %xmm1, %xmm0
jmp 0x1d27
xorps %xmm0, %xmm0
cvtsi2sdl -0x4(%rcx,%rsi,4), %xmm0
jmp 0x1d27
subsd %xmm0, %xmm2
addsd 0x2349(%rip), %xmm4     # 0x4060
addsd %xmm2, %xmm2
mulsd %xmm2, %xmm4
addsd %xmm0, %xmm4
movapd %xmm4, %xmm0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2365(%rip), %rdi      # 0x40a2
leaq 0x2365(%rip), %rsi      # 0x40a9
leaq 0x2367(%rip), %rcx      # 0x40b2
movl $0xa9, %edx
callq 0x10d0
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/mjosaarinen[P]brutus/crypto_aead/lakekeyakv2/SandyBridge/KeccakP-1600-times2-SIMD128.c
// Function: KeccakP1600times2_AddBytes
void KeccakP1600times2_AddBytes(void *states, unsigned int instanceIndex, const unsigned char *data, unsigned int offset, unsigned int length)
{
    unsigned int sizeLeft = length;
    unsigned int lanePosition = offset/SnP_laneLengthInBytes;
    unsigned int offsetInLane = offset%SnP_laneLengthInBytes;
    const unsigned char *curData = data;
    UINT64 *statesAsLanes = states;

    if ((sizeLeft > 0) && (offsetInLane != 0)) {
        unsigned int bytesInLane = SnP_laneLengthInBytes - offsetInLane;
        UINT64 lane = 0;
        if (bytesInLane > sizeLeft)
            bytesInLane = sizeLeft;
        memcpy((unsigned char*)&lane + offsetInLane, curData, bytesInLane);
        statesAsLanes[laneIndex(instanceIndex, lanePosition)] ^= lane;
        sizeLeft -= bytesInLane;
        lanePosition++;
        curData += bytesInLane;
    }

    while(sizeLeft >= SnP_laneLengthInBytes) {
        UINT64 lane = *((const UINT64*)curData);
        statesAsLanes[laneIndex(instanceIndex, lanePosition)] ^= lane;
        sizeLeft -= SnP_laneLengthInBytes;
        lanePosition++;
        curData += SnP_laneLengthInBytes;
    }

    if (sizeLeft > 0) {
        UINT64 lane = 0;
        memcpy(&lane, curData, sizeLeft);
        statesAsLanes[laneIndex(instanceIndex, lanePosition)] ^= lane;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %r12d
movq %rdx, %r15
movl %esi, %r14d
movq %rdi, %rbx
movl %ecx, %ebp
shrl $0x3, %ebp
testl %r8d, %r8d
sete %al
andl $0x7, %ecx
sete %dl
orb %al, %dl
jne 0x12a55
movl $0x8, %r13d
subl %ecx, %r13d
movq $0x0, (%rsp)
cmpl %r12d, %r13d
cmovael %r12d, %r13d
movl %ecx, %eax
leaq (%rsp,%rax), %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x5590
movq (%rsp), %rax
leal (%r14,%rbp,2), %ecx
xorq %rax, (%rbx,%rcx,8)
subl %r13d, %r12d
incl %ebp
addq %r13, %r15
cmpl $0x8, %r12d
jb 0x12a85
leal (%r14,%rbp,2), %eax
leal -0x8(%r12), %ecx
shrl $0x3, %ecx
addl %ecx, %ebp
incl %ebp
movq (%r15), %rcx
movl %eax, %edx
xorq %rcx, (%rbx,%rdx,8)
addl $-0x8, %r12d
addq $0x8, %r15
addl $0x2, %eax
cmpl $0x7, %r12d
ja 0x12a6b
testl %r12d, %r12d
je 0x12aaf
movq %rsp, %r13
movq $0x0, (%r13)
movl %r12d, %edx
movq %r13, %rdi
movq %r15, %rsi
callq 0x5590
movq (%r13), %rax
leal (%r14,%rbp,2), %ecx
xorq %rax, (%rbx,%rcx,8)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mjosaarinen[P]brutus/crypto_aead/lakekeyakv2/SandyBridge/KeccakP-1600-times2-SIMD128.c
// Function: KeccakP1600times2_OverwriteWithZeroes
void KeccakP1600times2_OverwriteWithZeroes(void *states, unsigned int instanceIndex, unsigned int byteCount)
{
    unsigned int sizeLeft = byteCount;
    unsigned int lanePosition = 0;
    UINT64 *statesAsLanes = states;

    while(sizeLeft >= SnP_laneLengthInBytes) {
        statesAsLanes[laneIndex(instanceIndex, lanePosition)] = 0;
        sizeLeft -= SnP_laneLengthInBytes;
        lanePosition++;
    }

    if (sizeLeft > 0) {
        memset(&statesAsLanes[laneIndex(instanceIndex, lanePosition)], 0, sizeLeft);
    }
}

// Assembly:
xorl %eax, %eax
cmpl $0x8, %edx
jb 0x13143
leal -0x8(%rdx), %eax
movl %esi, %ecx
shrl $0x3, %eax
leaq 0x2(,%rax,2), %r8
xorl %eax, %eax
leal (%rcx,%rax), %r9d
movq $0x0, (%rdi,%r9,8)
addl $-0x8, %edx
addq $0x2, %rax
cmpq %rax, %r8
jne 0x1312b
testl %edx, %edx
je 0x13156
addl %esi, %eax
leaq (%rdi,%rax,8), %rdi
movl %edx, %edx
xorl %esi, %esi
jmp 0x5060
retq
// File: /workspace/github_c_makefile_star2_O1/mjosaarinen[P]brutus/crypto_aead/lakekeyakv2/SandyBridge/KeccakP-1600-times2-SIMD128.c
// Function: KeccakP1600times2_ExtractBytes
void KeccakP1600times2_ExtractBytes(const void *states, unsigned int instanceIndex, unsigned char *data, unsigned int offset, unsigned int length)
{
    unsigned int sizeLeft = length;
    unsigned int lanePosition = offset/SnP_laneLengthInBytes;
    unsigned int offsetInLane = offset%SnP_laneLengthInBytes;
    unsigned char *curData = data;
    const UINT64 *statesAsLanes = states;

    if ((sizeLeft > 0) && (offsetInLane != 0)) {
        unsigned int bytesInLane = SnP_laneLengthInBytes - offsetInLane;
        if (bytesInLane > sizeLeft)
            bytesInLane = sizeLeft;
        memcpy( curData, ((unsigned char *)&statesAsLanes[laneIndex(instanceIndex, lanePosition)]) + offsetInLane, bytesInLane);
        sizeLeft -= bytesInLane;
        lanePosition++;
        curData += bytesInLane;
    }

    while(sizeLeft >= SnP_laneLengthInBytes) {
        *(UINT64*)curData = statesAsLanes[laneIndex(instanceIndex, lanePosition)];
        sizeLeft -= SnP_laneLengthInBytes;
        lanePosition++;
        curData += SnP_laneLengthInBytes;
    }

    if (sizeLeft > 0) {
        memcpy( curData, &statesAsLanes[laneIndex(instanceIndex, lanePosition)], sizeLeft);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %r14d
movq %rdx, %rbx
movl %esi, %r12d
movq %rdi, %r15
movl %ecx, %ebp
shrl $0x3, %ebp
testl %r8d, %r8d
sete %al
andl $0x7, %ecx
sete %dl
orb %al, %dl
jne 0x131b3
movl $0x8, %r13d
subl %ecx, %r13d
cmpl %r14d, %r13d
cmovael %r14d, %r13d
leal (%r12,%rbp,2), %eax
leaq (%r15,%rax,8), %rax
movl %ecx, %esi
addq %rax, %rsi
movq %rbx, %rdi
movq %r13, %rdx
callq 0x5590
subl %r13d, %r14d
incl %ebp
addq %r13, %rbx
cmpl $0x8, %r14d
jb 0x131e2
leal (%r12,%rbp,2), %eax
leal -0x8(%r14), %ecx
shrl $0x3, %ecx
addl %ecx, %ebp
incl %ebp
movl %eax, %ecx
movq (%r15,%rcx,8), %rcx
movq %rcx, (%rbx)
addl $-0x8, %r14d
addq $0x8, %rbx
addl $0x2, %eax
cmpl $0x7, %r14d
ja 0x131c8
testl %r14d, %r14d
je 0x13208
leal (%r12,%rbp,2), %eax
leaq (%r15,%rax,8), %rsi
movl %r14d, %edx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x5590
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mjosaarinen[P]brutus/crypto_aead/lakekeyakv2/SandyBridge/KeccakP-1600-times2-SIMD128.c
// Function: KeccakP1600times2_ExtractAndAddBytes
void KeccakP1600times2_ExtractAndAddBytes(const void *states, unsigned int instanceIndex,  const unsigned char *input, unsigned char *output, unsigned int offset, unsigned int length)
{
    unsigned int sizeLeft = length;
    unsigned int lanePosition = offset/SnP_laneLengthInBytes;
    unsigned int offsetInLane = offset%SnP_laneLengthInBytes;
    const unsigned char *curInput = input;
    unsigned char *curOutput = output;
    const UINT64 *statesAsLanes = states;

    if ((sizeLeft > 0) && (offsetInLane != 0)) {
        unsigned int bytesInLane = SnP_laneLengthInBytes - offsetInLane;
        UINT64 lane = statesAsLanes[laneIndex(instanceIndex, lanePosition)] >> (8 * offsetInLane);
        if (bytesInLane > sizeLeft)
            bytesInLane = sizeLeft;
        sizeLeft -= bytesInLane;
        do {
            *(curOutput++) = *(curInput++) ^ (unsigned char)lane;
            lane >>= 8;
        } while ( --bytesInLane != 0);
        lanePosition++;
    }

    while(sizeLeft >= SnP_laneLengthInBytes) {
        *((UINT64*)curOutput) = *((UINT64*)curInput) ^ statesAsLanes[laneIndex(instanceIndex, lanePosition)];
        sizeLeft -= SnP_laneLengthInBytes;
        lanePosition++;
        curInput += SnP_laneLengthInBytes;
        curOutput += SnP_laneLengthInBytes;
    }

    if (sizeLeft != 0) {
        UINT64 lane = statesAsLanes[laneIndex(instanceIndex, lanePosition)];
        do {
            *(curOutput++) = *(curInput++) ^ (unsigned char)lane;
            lane >>= 8;
        } while ( --sizeLeft != 0);
    }
}

// Assembly:
pushq %rbx
movl %r8d, %eax
shrl $0x3, %eax
testl %r9d, %r9d
sete %r10b
andl $0x7, %r8d
sete %r11b
orb %r10b, %r11b
jne 0x1346a
movl $0x8, %r10d
subl %r8d, %r10d
leal (%rsi,%rax,2), %r11d
shll $0x3, %r8d
shrxq %r8, (%rdi,%r11,8), %r8
cmpl %r9d, %r10d
cmovael %r9d, %r10d
movl %r10d, %r11d
movb (%rdx), %bl
xorb %r8b, %bl
incq %rdx
movb %bl, (%rcx)
incq %rcx
shrq $0x8, %r8
decl %r11d
jne 0x1344f
subl %r10d, %r9d
incl %eax
cmpl $0x8, %r9d
jb 0x134a4
leal (%rsi,%rax,2), %r8d
leal -0x8(%r9), %r10d
shrl $0x3, %r10d
addl %r10d, %eax
incl %eax
movl %r8d, %r10d
movq (%rdi,%r10,8), %r10
xorq (%rdx), %r10
movq %r10, (%rcx)
addl $-0x8, %r9d
addq $0x8, %rdx
addq $0x8, %rcx
addl $0x2, %r8d
cmpl $0x7, %r9d
ja 0x13481
testl %r9d, %r9d
je 0x134cb
leal (%rsi,%rax,2), %eax
movq (%rdi,%rax,8), %rax
movl %r9d, %esi
xorl %edi, %edi
movb (%rdx,%rdi), %r8b
xorb %al, %r8b
movb %r8b, (%rcx,%rdi)
shrq $0x8, %rax
incq %rdi
cmpl %edi, %esi
jne 0x134b5
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3_compileoption_used
SQLITE_API int sqlite3_compileoption_used(const char *zOptName){
  int i, n;
  if( sqlite3StrNICmp(zOptName, "SQLITE_", 7)==0 ) zOptName += 7;
  n = sqlite3Strlen30(zOptName);

  /* Since ArraySize(azCompileOpt) is normally in single digits, a
  ** linear search is adequate.  No need for a binary search. */
  for(i=0; i<ArraySize(azCompileOpt); i++){
    if( sqlite3StrNICmp(zOptName, azCompileOpt[i], n)==0
     && sqlite3CtypeMap[(unsigned char)azCompileOpt[i][n]]==0
    ){
      return 1;
    }
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x7(%rdi), %rbx
movl $0x7, %ecx
leaq 0x700a6(%rip), %r8      # 0x79420
xorl %r9d, %r9d
leaq 0x6ccdc(%rip), %rax     # 0x76060
leaq 0x7009c(%rip), %rsi     # 0x79427
movq %r8, %r10
movq %rdi, %rdx
movzbl (%rdx), %r11d
testq %r11, %r11
je 0x93bd
movb (%r11,%rax), %r11b
movzbl (%r10), %r14d
cmpb (%r14,%rax), %r11b
jne 0x93c5
incq %rdx
incq %r9
incq %r10
decq %rcx
jne 0x9391
xorl %ecx, %ecx
movq %rbx, %rdx
jmp 0x93c8
addq %r9, %r8
movq %r8, %rsi
jmp 0x93c8
movq %r10, %rsi
testl %ecx, %ecx
jle 0x93dc
movzbl (%rdx), %ecx
movb (%rcx,%rax), %cl
movzbl (%rsi), %edx
cmpb (%rdx,%rax), %cl
cmovneq %rdi, %rbx
testq %rbx, %rbx
je 0x93fb
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movq %rbx, %rcx
incl %eax
cmpb $0x0, (%rcx)
leaq 0x1(%rcx), %rcx
jne 0x93e9
andl $0x3fffffff, %eax       # imm = 0x3FFFFFFF
jmp 0x93fd
xorl %eax, %eax
movl %eax, %r14d
xorl %r12d, %r12d
leaq 0x89856(%rip), %r13     # 0x92c60
movq (%r12,%r13), %r15
movq %rbx, %rdi
movq %r15, %rsi
movl %r14d, %edx
callq 0x9454
testl %eax, %eax
jne 0x9432
movzbl (%r15,%r14), %eax
leaq 0x6cb34(%rip), %rcx     # 0x75f60
cmpb $0x0, (%rax,%rcx)
je 0x9440
addq $0x8, %r12
cmpq $0x8, %r12
je 0x940a
xorl %eax, %eax
jmp 0x9445
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3_strnicmp
SQLITE_API int sqlite3_strnicmp(const char *zLeft, const char *zRight, int N){
  register unsigned char *a, *b;
  a = (unsigned char *)zLeft;
  b = (unsigned char *)zRight;
  while( N-- > 0 && *a!=0 && UpperToLower[*a]==UpperToLower[*b]){ a++; b++; }
  return N<0 ? 0 : UpperToLower[*a] - UpperToLower[*b];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testl %edx, %edx
jle 0x94ac
movl %edx, %eax
leaq (%rdi,%rax), %rcx
addq %rsi, %rax
leaq 0x6cbf4(%rip), %r8      # 0x76060
movzbl (%rdi), %r9d
testq %r9, %r9
je 0x9499
movb (%r9,%r8), %r9b
movzbl (%rsi), %r10d
cmpb (%r10,%r8), %r9b
jne 0x9499
decl %edx
incq %rdi
incq %rsi
leal 0x1(%rdx), %r9d
cmpl $0x1, %r9d
jg 0x946c
xorl %edx, %edx
jmp 0x949f
movq %rdi, %rcx
movq %rsi, %rax
testl %edx, %edx
setle %dl
movq %rcx, %rdi
movq %rax, %rsi
jmp 0x94ae
movb $0x1, %dl
xorl %eax, %eax
testb %dl, %dl
jne 0x94cb
movzbl (%rdi), %eax
leaq 0x6cba2(%rip), %rcx     # 0x76060
movzbl (%rax,%rcx), %eax
movzbl (%rsi), %edx
movzbl (%rdx,%rcx), %ecx
subl %ecx, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3_status
SQLITE_API int sqlite3_status(int op, int *pCurrent, int *pHighwater, int resetFlag){
  wsdStatInit;
  if( op<0 || op>=ArraySize(wsdStat.nowValue) ){
    return SQLITE_MISUSE_BKPT;
  }
  *pCurrent = wsdStat.nowValue[op];
  *pHighwater = wsdStat.mxValue[op];
  if( resetFlag ){
    wsdStat.mxValue[op] = wsdStat.nowValue[op];
  }
  return SQLITE_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
cmpl $0xa, %edi
jb 0x951a
leaq 0x73ee9(%rip), %rsi     # 0x7d3e4
leaq 0x70037(%rip), %rcx     # 0x79539
movl $0x15, %ebx
movl $0x15, %edi
movl $0x35d6, %edx           # imm = 0x35D6
xorl %eax, %eax
callq 0xb8cc
jmp 0x953b
movl %edi, %eax
leaq 0x8c7bd(%rip), %rdi     # 0x95ce0
movl (%rdi,%rax,4), %r8d
movl %r8d, (%rsi)
movl 0x28(%rdi,%rax,4), %esi
movl %esi, (%rdx)
xorl %ebx, %ebx
testl %ecx, %ecx
je 0x953b
movl %r8d, 0x28(%rdi,%rax,4)
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3DeleteTrigger
SQLITE_PRIVATE void sqlite3DeleteTrigger(sqlite3 *db, Trigger *pTrigger){
  if( pTrigger==0 ) return;
  sqlite3DeleteTriggerStep(db, pTrigger->step_list);
  sqlite3DbFree(db, pTrigger->zName);
  sqlite3DbFree(db, pTrigger->table);
  sqlite3ExprDelete(db, pTrigger->pWhen);
  sqlite3IdListDelete(db, pTrigger->pColumns);
  sqlite3DbFree(db, pTrigger);
}

// Assembly:
testq %rsi, %rsi
je 0x9938
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x38(%rsi), %rsi
callq 0x36f4e
movq (%rbx), %rsi
movq %r14, %rdi
callq 0x9c3a
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x9c3a
movq 0x18(%rbx), %rsi
movq %r14, %rdi
callq 0x34068
movq 0x20(%rbx), %rsi
movq %r14, %rdi
callq 0x3429d
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x9c3a
retq
// File: /workspace/github_c_makefile_star2_O1/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3VdbeClearObject
SQLITE_PRIVATE void sqlite3VdbeClearObject(sqlite3 *db, Vdbe *p){
  SubProgram *pSub, *pNext;
  int i;
  assert( p->db==0 || p->db==db );
  releaseMemArray(p->aVar, p->nVar);
  releaseMemArray(p->aColName, p->nResColumn*COLNAME_N);
  for(pSub=p->pProgram; pSub; pSub=pNext){
    pNext = pSub->pNext;
    vdbeFreeOpArray(db, pSub->aOp, pSub->nOp);
    sqlite3DbFree(db, pSub);
  }
  for(i=p->nzVar-1; i>=0; i--) sqlite3DbFree(db, p->azVar[i]);
  vdbeFreeOpArray(db, p->aOp, p->nOp);
  sqlite3DbFree(db, p->aLabel);
  sqlite3DbFree(db, p->aColName);
  sqlite3DbFree(db, p->zSql);
  sqlite3DbFree(db, p->pFree);
#if defined(SQLITE_ENABLE_TREE_EXPLAIN)
  sqlite3DbFree(db, p->zExplain);
  sqlite3DbFree(db, p->pExplain);
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x78(%rsi), %rdi
movswl 0x88(%rsi), %esi
callq 0x2309b
movq 0x20(%r14), %rdi
movzwl 0x48(%r14), %esi
addl %esi, %esi
callq 0x2309b
movq 0x108(%r14), %r15
testq %r15, %r15
je 0x9bc2
movq 0x20(%r15), %r12
movq (%r15), %rsi
movl 0x8(%r15), %edx
movq %rbx, %rdi
callq 0x23140
movq %rbx, %rdi
movq %r15, %rsi
callq 0x9c3a
movq %r12, %r15
testq %r12, %r12
jne 0x9b9c
movswq 0x8a(%r14), %r15
testq %r15, %r15
jle 0x9bef
incq %r15
movq 0x80(%r14), %rax
movq -0x10(%rax,%r15,8), %rsi
movq %rbx, %rdi
callq 0x9c3a
decq %r15
cmpq $0x1, %r15
jg 0x9bd2
movq 0x8(%r14), %rsi
movl 0x34(%r14), %edx
movq %rbx, %rdi
callq 0x23140
movq 0x40(%r14), %rsi
movq %rbx, %rdi
callq 0x9c3a
movq 0x20(%r14), %rsi
movq %rbx, %rdi
callq 0x9c3a
movq 0xe0(%r14), %rsi
movq %rbx, %rdi
callq 0x9c3a
movq 0xe8(%r14), %rsi
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x9c3a
// File: /workspace/github_c_makefile_star2_O1/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3DbFree
SQLITE_PRIVATE void sqlite3DbFree(sqlite3 *db, void *p){
  assert( db==0 || sqlite3_mutex_held(db->mutex) );
  if( db ){
    if( db->pnBytesFreed ){
      *db->pnBytesFreed += sqlite3DbMallocSize(db, p);
      return;
    }
    if( isLookaside(db, p) ){
      LookasideSlot *pBuf = (LookasideSlot*)p;
#if SQLITE_DEBUG
      /* Trash all content in the buffer being freed */
      memset(p, 0xaa, db->lookaside.sz);
#endif
      pBuf->pNext = db->lookaside.pFree;
      db->lookaside.pFree = pBuf;
      db->lookaside.nOut--;
      return;
    }
  }
  assert( sqlite3MemdebugHasType(p, MEMTYPE_DB) );
  assert( sqlite3MemdebugHasType(p, MEMTYPE_LOOKASIDE|MEMTYPE_HEAP) );
  assert( db!=0 || sqlite3MemdebugNoType(p, MEMTYPE_LOOKASIDE) );
  sqlite3MemdebugSetType(p, MEMTYPE_HEAP);
  sqlite3_free(p);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x9cbb
movq %rdi, %rbx
cmpq $0x0, 0x328(%rdi)
je 0x9c8b
testq %rsi, %rsi
je 0x9c72
cmpq %rsi, 0x170(%rbx)
ja 0x9c72
cmpq %rsi, 0x178(%rbx)
jbe 0x9c72
movzwl 0x150(%rbx), %eax
jmp 0x9c7b
movq %rsi, %rdi
callq *0x8a7bd(%rip)          # 0x94438
movq 0x328(%rbx), %rcx
addl %eax, (%rcx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
testq %rsi, %rsi
je 0x9cbb
cmpq %rsi, 0x170(%rbx)
ja 0x9cbb
cmpq %rsi, 0x178(%rbx)
jbe 0x9cbb
movq 0x168(%rbx), %rax
movq %rax, (%rsi)
movq %rsi, 0x168(%rbx)
decl 0x154(%rbx)
jmp 0x9c84
movq %rsi, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xa2e8
// File: /workspace/github_c_makefile_star2_O1/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3_vfs_find
SQLITE_API sqlite3_vfs *sqlite3_vfs_find(const char *zVfs){
  sqlite3_vfs *pVfs = 0;
#if SQLITE_THREADSAFE
  sqlite3_mutex *mutex;
#endif
#ifndef SQLITE_OMIT_AUTOINIT
  int rc = sqlite3_initialize();
  if( rc ) return 0;
#endif
#if SQLITE_THREADSAFE
  mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER);
#endif
  sqlite3_mutex_enter(mutex);
  for(pVfs = vfsList; pVfs; pVfs=pVfs->pNext){
    if( zVfs==0 ) break;
    if( strcmp(zVfs, pVfs->zName)==0 ) break;
  }
  sqlite3_mutex_leave(mutex);
  return pVfs;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
callq 0x9d1f
testl %eax, %eax
je 0x9ce0
xorl %ebx, %ebx
jmp 0x9cf7
testq %r14, %r14
sete %al
movq 0x8c043(%rip), %rbx     # 0x95d30
testq %rbx, %rbx
sete %cl
orb %al, %cl
je 0x9cff
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq 0x18(%rbx), %rsi
movq %r14, %rdi
callq 0x8530
testl %eax, %eax
je 0x9cf7
movq 0x10(%rbx), %rbx
testq %r14, %r14
je 0x9cf7
testq %rbx, %rbx
jne 0x9cff
jmp 0x9cf7
// File: /workspace/github_c_makefile_star2_O1/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3_vfs_register
SQLITE_API int sqlite3_vfs_register(sqlite3_vfs *pVfs, int makeDflt){
  MUTEX_LOGIC(sqlite3_mutex *mutex;)
#ifndef SQLITE_OMIT_AUTOINIT
  int rc = sqlite3_initialize();
  if( rc ) return rc;
#endif
  MUTEX_LOGIC( mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER); )
  sqlite3_mutex_enter(mutex);
  vfsUnlink(pVfs);
  if( makeDflt || vfsList==0 ){
    pVfs->pNext = vfsList;
    vfsList = pVfs;
  }else{
    pVfs->pNext = vfsList->pNext;
    vfsList->pNext = pVfs;
  }
  assert(vfsList);
  sqlite3_mutex_leave(mutex);
  return SQLITE_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
callq 0x9d1f
testl %eax, %eax
jne 0xa124
movq %rbx, %rdi
callq 0xa129
testl %r14d, %r14d
setne %cl
movq 0x8bc33(%rip), %rax     # 0x95d30
testq %rax, %rax
sete %dl
orb %cl, %dl
je 0xa110
leaq 0x8bc22(%rip), %rcx     # 0x95d30
jmp 0xa11b
movq %rax, %rcx
addq $0x10, %rcx
movq 0x10(%rax), %rax
movq %rax, 0x10(%rbx)
movq %rbx, (%rcx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: vfsUnlink
static void vfsUnlink(sqlite3_vfs *pVfs){
  assert( sqlite3_mutex_held(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER)) );
  if( pVfs==0 ){
    /* No-op */
  }else if( vfsList==pVfs ){
    vfsList = pVfs->pNext;
  }else if( vfsList ){
    sqlite3_vfs *p = vfsList;
    while( p->pNext && p->pNext!=pVfs ){
      p = p->pNext;
    }
    if( p->pNext==pVfs ){
      p->pNext = pVfs->pNext;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0xa16d
movq 0x8bbf7(%rip), %rcx     # 0x95d30
cmpq %rdi, %rcx
je 0xa15f
testq %rcx, %rcx
je 0xa16d
movq %rcx, %rax
movq 0x10(%rcx), %rcx
testq %rcx, %rcx
je 0xa154
cmpq %rdi, %rcx
jne 0xa143
cmpq %rdi, %rcx
jne 0xa16d
addq $0x10, %rax
jmp 0xa166
leaq 0x8bbca(%rip), %rax     # 0x95d30
movq 0x10(%rdi), %rcx
movq %rcx, (%rax)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3_soft_heap_limit64
SQLITE_API sqlite3_int64 sqlite3_soft_heap_limit64(sqlite3_int64 n){
  sqlite3_int64 priorLimit;
  sqlite3_int64 excess;
#ifndef SQLITE_OMIT_AUTOINIT
  int rc = sqlite3_initialize();
  if( rc ) return -1;
#endif
  sqlite3_mutex_enter(mem0.mutex);
  priorLimit = mem0.alarmThreshold;
  sqlite3_mutex_leave(mem0.mutex);
  if( n<0 ) return priorLimit;
  if( n>0 ){
    sqlite3MemoryAlarm(softHeapLimitEnforcer, 0, n);
  }else{
    sqlite3MemoryAlarm(0, 0, 0);
  }
  excess = sqlite3_memory_used() - n;
  if( excess>0 ) sqlite3_release_memory((int)(excess & 0x7fffffff));
  return priorLimit;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x9d1f
movl %eax, %ecx
movq $-0x1, %rax
testl %ecx, %ecx
jne 0xa236
movq 0x8bb5f(%rip), %rax     # 0x95d40
testq %rbx, %rbx
js 0xa236
je 0xa219
leaq 0x4e(%rip), %rcx        # 0xa23d
movq %rcx, 0x8bb52(%rip)     # 0x95d48
movq $0x0, 0x8bb4f(%rip) # 0x95d50
movq %rbx, 0x8bb38(%rip)     # 0x95d40
movslq 0x8bad1(%rip), %rdx     # 0x95ce0
xorl %ecx, %ecx
cmpq %rbx, %rdx
setge %cl
jmp 0xa230
xorps %xmm0, %xmm0
movups %xmm0, 0x8bb1d(%rip)    # 0x95d40
movq $0x0, 0x8bb22(%rip) # 0x95d50
xorl %ecx, %ecx
movl %ecx, 0x8bb36(%rip)     # 0x95d6c
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3_memory_highwater
SQLITE_API sqlite3_int64 sqlite3_memory_highwater(int resetFlag){
  int n, mx;
  sqlite3_int64 res;
  sqlite3_status(SQLITE_STATUS_MEMORY_USED, &n, &mx, resetFlag);
  res = (sqlite3_int64)mx;  /* Work around bug in Borland C. Ticket #3216 */
  return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movslq 0x8ba9c(%rip), %rax     # 0x95d08
testl %edi, %edi
je 0xa27c
movl 0x8ba6a(%rip), %ecx     # 0x95ce0
movl %ecx, 0x8ba8c(%rip)     # 0x95d08
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3Malloc
SQLITE_PRIVATE void *sqlite3Malloc(int n){
  void *p;
  if( n<=0               /* IMP: R-65312-04917 */ 
   || n>=0x7fffff00
  ){
    /* A memory allocation of a number of bytes which is near the maximum
    ** signed integer value might cause an integer overflow inside of the
    ** xMalloc().  Hence we limit the maximum size to 0x7fffff00, giving
    ** 255 bytes of overhead.  SQLite itself will never use anything near
    ** this amount.  The only way to reach the limit is with sqlite3_malloc() */
    p = 0;
  }else if( sqlite3GlobalConfig.bMemstat ){
    sqlite3_mutex_enter(mem0.mutex);
    mallocWithAlarm(n, &p);
    sqlite3_mutex_leave(mem0.mutex);
  }else{
    p = sqlite3GlobalConfig.m.xMalloc(n);
  }
  assert( EIGHT_BYTE_ALIGNMENT(p) );  /* IMP: R-04675-44850 */
  return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x80000100, %eax       # imm = 0x80000100
leal (%rdi,%rax), %ecx
cmpl %eax, %ecx
ja 0xa2c0
movq $0x0, -0x8(%rbp)
jmp 0xa2de
cmpl $0x0, 0x8a139(%rip)     # 0x94400
je 0xa2d4
leaq -0x8(%rbp), %rsi
callq 0x171f3
jmp 0xa2de
callq *0x8a146(%rip)          # 0x94420
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3_free
SQLITE_API void sqlite3_free(void *p){
  if( p==0 ) return;  /* IMP: R-49053-54554 */
  assert( sqlite3MemdebugNoType(p, MEMTYPE_DB) );
  assert( sqlite3MemdebugHasType(p, MEMTYPE_HEAP) );
  if( sqlite3GlobalConfig.bMemstat ){
    sqlite3_mutex_enter(mem0.mutex);
    sqlite3StatusAdd(SQLITE_STATUS_MEMORY_USED, -sqlite3MallocSize(p));
    sqlite3StatusAdd(SQLITE_STATUS_MALLOC_COUNT, -1);
    sqlite3GlobalConfig.m.xFree(p);
    sqlite3_mutex_leave(mem0.mutex);
  }else{
    sqlite3GlobalConfig.m.xFree(p);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xa34f
movq %rdi, %rbx
cmpl $0x0, 0x8a103(%rip)     # 0x94400
je 0xa340
movq %rbx, %rdi
callq *0x8a130(%rip)          # 0x94438
movl 0x8b9d2(%rip), %ecx     # 0x95ce0
subl %eax, %ecx
movl %ecx, 0x8b9ca(%rip)     # 0x95ce0
cmpl 0x8b9ec(%rip), %ecx     # 0x95d08
jle 0xa324
movl %ecx, 0x8b9e4(%rip)     # 0x95d08
movl 0x8b9da(%rip), %eax     # 0x95d04
decl %eax
movl %eax, 0x8b9d2(%rip)     # 0x95d04
cmpl 0x8b9f4(%rip), %eax     # 0x95d2c
jle 0xa340
movl %eax, 0x8b9ec(%rip)     # 0x95d2c
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmpq *0x8a0d9(%rip)          # 0x94428
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3_vmprintf
SQLITE_API char *sqlite3_vmprintf(const char *zFormat, va_list ap){
  char *z;
  char zBase[SQLITE_PRINT_BUF_SIZE];
  StrAccum acc;
#ifndef SQLITE_OMIT_AUTOINIT
  if( sqlite3_initialize() ) return 0;
#endif
  sqlite3StrAccumInit(&acc, zBase, sizeof(zBase), SQLITE_MAX_LENGTH);
  acc.useMalloc = 2;
  sqlite3VXPrintf(&acc, 0, zFormat, ap);
  z = sqlite3StrAccumFinish(&acc);
  return z;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x78, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x9d1f
testl %eax, %eax
je 0xa54b
xorl %eax, %eax
jmp 0xa59a
leaq -0x90(%rbp), %rax
leaq -0x40(%rbp), %r15
movq %rax, 0x8(%r15)
movq %rax, 0x10(%r15)
movq $0x0, (%r15)
movabsq $0x4600000000, %rax     # imm = 0x4600000000
movq %rax, 0x18(%r15)
movl $0x3b9aca00, 0x20(%r15) # imm = 0x3B9ACA00
movw $0x2, 0x24(%r15)
movq %r15, %rdi
xorl %esi, %esi
movq %r14, %rdx
movq %rbx, %rcx
callq 0xa5a5
movq %r15, %rdi
callq 0xb6e7
addq $0x78, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3StrAccumFinish
SQLITE_PRIVATE char *sqlite3StrAccumFinish(StrAccum *p){
  if( p->zText ){
    p->zText[p->nChar] = 0;
    if( p->useMalloc && p->zText==p->zBase ){
      if( p->useMalloc==1 ){
        p->zText = sqlite3DbMallocRaw(p->db, p->nChar+1 );
      }else{
        p->zText = sqlite3_malloc(p->nChar+1);
      }
      if( p->zText ){
        memcpy(p->zText, p->zBase, p->nChar+1);
      }else{
        p->accError = STRACCUM_NOMEM;
      }
    }
  }
  return p->zText;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0xb764
movslq 0x18(%rbx), %rcx
movb $0x0, (%rax,%rcx)
movb 0x24(%rbx), %al
testb %al, %al
je 0xb764
movq 0x10(%rbx), %rcx
cmpq 0x8(%rbx), %rcx
jne 0xb764
cmpb $0x1, %al
jne 0xb726
movq (%rbx), %rdi
movl 0x18(%rbx), %esi
incl %esi
callq 0x115e9
jmp 0xb742
movl 0x18(%rbx), %r14d
callq 0x9d1f
testl %eax, %eax
je 0xb737
xorl %eax, %eax
jmp 0xb742
incl %r14d
movl %r14d, %edi
callq 0xa2a2
movq %rax, 0x10(%rbx)
testq %rax, %rax
je 0xb760
movq 0x8(%rbx), %rsi
movslq 0x18(%rbx), %rdx
incq %rdx
movq %rax, %rdi
callq 0x82f0
jmp 0xb764
movb $0x1, 0x25(%rbx)
movq 0x10(%rbx), %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3_mprintf
SQLITE_API char *sqlite3_mprintf(const char *zFormat, ...){
  va_list ap;
  char *z;
#ifndef SQLITE_OMIT_AUTOINIT
  if( sqlite3_initialize() ) return 0;
#endif
  va_start(ap, zFormat);
  z = sqlite3_vmprintf(zFormat, ap);
  va_end(ap);
  return z;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0xc8, %rsp
movq %rdi, %rbx
movq %rsi, -0xc8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %r8, -0xb0(%rbp)
movq %r9, -0xa8(%rbp)
testb %al, %al
je 0xb7c9
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
callq 0x9d1f
testl %eax, %eax
je 0xb7d6
xorl %eax, %eax
jmp 0xb802
leaq -0xd0(%rbp), %rax
leaq -0x20(%rbp), %rsi
movq %rax, 0x10(%rsi)
leaq 0x10(%rbp), %rax
movq %rax, 0x8(%rsi)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0xa52b
addq $0xc8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3_vsnprintf
SQLITE_API char *sqlite3_vsnprintf(int n, char *zBuf, const char *zFormat, va_list ap){
  StrAccum acc;
  if( n<=0 ) return zBuf;
  sqlite3StrAccumInit(&acc, zBuf, n, 0);
  acc.useMalloc = 0;
  sqlite3VXPrintf(&acc, 0, zFormat, ap);
  return sqlite3StrAccumFinish(&acc);
}

// Assembly:
movq %rsi, %rax
testl %edi, %edi
jle 0xb858
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x28, %rsp
leaq -0x30(%rbp), %rbx
movq %rax, 0x8(%rbx)
movq %rax, 0x10(%rbx)
movq $0x0, (%rbx)
xorl %eax, %eax
movl %eax, 0x18(%rbx)
movl %edi, 0x1c(%rbx)
movl %eax, 0x20(%rbx)
movw $0x0, 0x24(%rbx)
movq %rbx, %rdi
xorl %esi, %esi
callq 0xa5a5
movq %rbx, %rdi
callq 0xb6e7
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3_snprintf
SQLITE_API char *sqlite3_snprintf(int n, char *zBuf, const char *zFormat, ...){
  char *z;
  va_list ap;
  va_start(ap,zFormat);
  z = sqlite3_vsnprintf(n, zBuf, zFormat, ap);
  va_end(ap);
  return z;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
leaq -0xd0(%rbp), %r10
movq %rcx, 0x18(%r10)
movq %r8, 0x20(%r10)
movq %r9, 0x28(%r10)
testb %al, %al
je 0xb8a1
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
leaq -0x20(%rbp), %rcx
movq %r10, 0x10(%rcx)
leaq 0x10(%rbp), %rax
movq %rax, 0x8(%rcx)
movabsq $0x3000000018, %rax     # imm = 0x3000000018
movq %rax, (%rcx)
callq 0xb80c
addq $0xd0, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3_log
SQLITE_API void sqlite3_log(int iErrCode, const char *zFormat, ...){
  va_list ap;                             /* Vararg list */
  if( sqlite3GlobalConfig.xLog ){
    va_start(ap, zFormat);
    renderLogMsg(iErrCode, zFormat, ap);
    va_end(ap);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1d0, %rsp            # imm = 0x1D0
movq %rdx, -0xe0(%rbp)
movq %rcx, -0xd8(%rbp)
movq %r8, -0xd0(%rbp)
movq %r9, -0xc8(%rbp)
testb %al, %al
je 0xb92a
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
cmpq $0x0, 0x88c56(%rip)     # 0x94588
je 0xb9c9
movq %rsi, %r10
movl %edi, %ebx
leaq -0xf0(%rbp), %rax
leaq -0x40(%rbp), %rcx
movq %rax, 0x10(%rcx)
leaq 0x10(%rbp), %rax
movq %rax, 0x8(%rcx)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rcx)
leaq -0x1f0(%rbp), %rax
leaq -0x118(%rbp), %r14
movq %rax, 0x8(%r14)
movq %rax, 0x10(%r14)
movq $0x0, (%r14)
movabsq $0xd200000000, %rax     # imm = 0xD200000000
movq %rax, 0x18(%r14)
movl $0x0, 0x20(%r14)
movw $0x0, 0x24(%r14)
movq %r14, %rdi
xorl %esi, %esi
movq %r10, %rdx
callq 0xa5a5
movq 0x88bd9(%rip), %r12     # 0x94588
movq 0x88bda(%rip), %r15     # 0x94590
movq %r14, %rdi
callq 0xb6e7
movq %r15, %rdi
movl %ebx, %esi
movq %rax, %rdx
callq *%r12
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3_stricmp
SQLITE_API int sqlite3_stricmp(const char *zLeft, const char *zRight){
  register unsigned char *a, *b;
  a = (unsigned char *)zLeft;
  b = (unsigned char *)zRight;
  while( *a!=0 && UpperToLower[*a]==UpperToLower[*b]){ a++; b++; }
  return UpperToLower[*a] - UpperToLower[*b];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb (%rdi), %al
testb %al, %al
je 0xbb33
incq %rdi
leaq 0x6a549(%rip), %rcx     # 0x76060
movzbl %al, %edx
movb (%rdx,%rcx), %dl
movzbl (%rsi), %r8d
cmpb (%r8,%rcx), %dl
jne 0xbb33
incq %rsi
movb (%rdi), %al
incq %rdi
testb %al, %al
jne 0xbb17
movzbl %al, %eax
leaq 0x6a523(%rip), %rcx     # 0x76060
movzbl (%rax,%rcx), %eax
movzbl (%rsi), %edx
movzbl (%rdx,%rcx), %ecx
subl %ecx, %eax
popq %rbp
retq