LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/Openvario[P]sensord/24c16.c
// Function: eeprom_open
int eeprom_open(t_24c16 *eeprom, unsigned char i2c_address)
{
	// local variables
	int fd;
	char s;
	int ret_code = 0;
	char offset = 0x00;

	// try to open I2C Bus
	fd = open("/dev/i2c-1", O_RDWR);

	if (fd < 0) {
		fprintf(stderr, "Error opening file: %s\n", strerror(errno));
		ret_code = 1;
	}

	if (ioctl(fd, I2C_SLAVE, i2c_address) < 0) {
		fprintf(stderr, "ioctl error: %s\n", strerror(errno));
		ret_code = 1;
	}

	// assign file handle to sensor object
	eeprom->fd = fd;
	eeprom->address = i2c_address;

	//write address offset to eeprom
	if ((write(eeprom->fd, (void*)&offset, 1)) != 1) {				// Send register we want to read from
		//fprintf(stderr, "Error writing to i2c slave (%s)\n", __func__);
		ret_code = 1;
	}

	if (read(eeprom->fd, &s, 1) != 1) {		// Read back data into buf[]
		ret_code = 1;
	}

	if (ret_code == 0)
	{
		fprintf(stderr, "Opened 24C16 on 0x%x\n", i2c_address);

	}
	else
	{
		fprintf(stderr, "Opened 24C16 on 0x%x failed !!!\n", i2c_address);
	}
	return (ret_code);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movl $0x0, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
leaq 0x3b88(%rip), %rdi      # 0xb3dc
movl $0x2, %esi
movb $0x0, %al
callq 0x2240
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
jge 0x789f
movq 0x7788(%rip), %rax      # 0xeff8
movq (%rax), %rax
movq %rax, -0x28(%rbp)
callq 0x2030
movl (%rax), %edi
callq 0x22d0
movq -0x28(%rbp), %rdi
movq %rax, %rdx
leaq 0x3b56(%rip), %rsi      # 0xb3e7
movb $0x0, %al
callq 0x21d0
movl $0x1, -0x18(%rbp)
movl -0x10(%rbp), %edi
movzbl -0x9(%rbp), %edx
movl $0x703, %esi            # imm = 0x703
movb $0x0, %al
callq 0x2140
cmpl $0x0, %eax
jge 0x78ed
movq 0x773a(%rip), %rax      # 0xeff8
movq (%rax), %rax
movq %rax, -0x30(%rbp)
callq 0x2030
movl (%rax), %edi
callq 0x22d0
movq -0x30(%rbp), %rdi
movq %rax, %rdx
leaq 0x376d(%rip), %rsi      # 0xb04c
movb $0x0, %al
callq 0x21d0
movl $0x1, -0x18(%rbp)
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movb -0x9(%rbp), %cl
movq -0x8(%rbp), %rax
movb %cl, 0x4(%rax)
movq -0x8(%rbp), %rax
movl (%rax), %edi
leaq -0x19(%rbp), %rsi
movl $0x1, %edx
callq 0x20a0
cmpq $0x1, %rax
je 0x7921
movl $0x1, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %edi
leaq -0x11(%rbp), %rsi
movl $0x1, %edx
callq 0x2180
cmpq $0x1, %rax
je 0x7942
movl $0x1, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jne 0x7966
movq 0x76a9(%rip), %rax      # 0xeff8
movq (%rax), %rdi
movzbl -0x9(%rbp), %edx
leaq 0x4f0f(%rip), %rsi      # 0xc86c
movb $0x0, %al
callq 0x21d0
jmp 0x7982
movq 0x768b(%rip), %rax      # 0xeff8
movq (%rax), %rdi
movzbl -0x9(%rbp), %edx
leaq 0x4f07(%rip), %rsi      # 0xc882
movb $0x0, %al
callq 0x21d0
movl -0x18(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Openvario[P]sensord/24c16.c
// Function: eeprom_write
char eeprom_write(t_24c16 *eeprom, char *s, unsigned char offset, unsigned char count)
{
	unsigned char buf[2];
	int i;

	//memcpy(&buf[1], s, count);

	//write data at offset to eeprom
	buf[0] = offset;														// This is the register we want to read from

	// write byte by byte to EEPROM
	for (i=0; i<count;i++)
	{
		// copy data to write buffer
		buf[1]=*(s);
		//fprintf(stderr, "buf[1]: '%c'\n",buf[1]);
		// Write data to EEPROM
		if ((write(eeprom->fd, &buf[0], 2)) != 2) {				// Send register we want to read from
			fprintf(stderr, "Error writing to i2c slave (%s)\n", __func__);
			return(1);
		}

		// give EEPROM time for write ...
		usleep(10000);
		buf[0]++;
		s++;
	}
	return(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %cl, %al
movb %dl, %cl
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movb %cl, -0x19(%rbp)
movb %al, -0x1a(%rbp)
movb -0x19(%rbp), %al
movb %al, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
movzbl -0x1a(%rbp), %ecx
cmpl %ecx, %eax
jge 0x7a33
movq -0x18(%rbp), %rax
movb (%rax), %al
movb %al, -0x1b(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %edi
leaq -0x1c(%rbp), %rsi
movl $0x2, %edx
callq 0x20a0
cmpq $0x2, %rax
je 0x7a0a
movq 0x760c(%rip), %rax      # 0xeff8
movq (%rax), %rdi
leaq 0x37eb(%rip), %rsi      # 0xb1e1
leaq 0x4ea6(%rip), %rdx      # 0xc8a3
movb $0x0, %al
callq 0x21d0
movb $0x1, -0x1(%rbp)
jmp 0x7a37
movl $0x2710, %edi           # imm = 0x2710
callq 0x2300
movb -0x1c(%rbp), %al
addb $0x1, %al
movb %al, -0x1c(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x79b7
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Openvario[P]sensord/ds2482.c
// Function: ds2482_open
int ds2482_open(t_ds2482 *sensor, unsigned char i2c_address)
{
	// local variables
	int fd;

	// try to open I2C Bus
	fd = open("/dev/i2c-1", O_RDWR);

	if (fd < 0) {
		fprintf(stderr, "Error opening file: %s\n", strerror(errno));
		return 0;
	}
	if (ioctl(fd, I2C_SLAVE, i2c_address) < 0) {
		fprintf(stderr, "ioctl error: %s\n", strerror(errno));
		return 0;
	}

	if (g_debug > 0) fprintf(stderr, "Opened DS2482 on 0x%x\n", i2c_address);
	//assign file handle to sensor object
	sensor->fd = fd;
	sensor->address = i2c_address;
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
leaq 0x3983(%rip), %rdi      # 0xb3dc
movl $0x2, %esi
movb $0x0, %al
callq 0x2240
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jge 0x7aa9
movq 0x7583(%rip), %rax      # 0xeff8
movq (%rax), %rax
movq %rax, -0x20(%rbp)
callq 0x2030
movl (%rax), %edi
callq 0x22d0
movq -0x20(%rbp), %rdi
movq %rax, %rdx
leaq 0x3951(%rip), %rsi      # 0xb3e7
movb $0x0, %al
callq 0x21d0
movl $0x0, -0x4(%rbp)
jmp 0x7b3b
movl -0x18(%rbp), %edi
movzbl -0x11(%rbp), %edx
movl $0x703, %esi            # imm = 0x703
movb $0x0, %al
callq 0x2140
cmpl $0x0, %eax
jge 0x7af9
movq 0x7530(%rip), %rax      # 0xeff8
movq (%rax), %rax
movq %rax, -0x28(%rbp)
callq 0x2030
movl (%rax), %edi
callq 0x22d0
movq -0x28(%rbp), %rdi
movq %rax, %rdx
leaq 0x3563(%rip), %rsi      # 0xb04c
movb $0x0, %al
callq 0x21d0
movl $0x0, -0x4(%rbp)
jmp 0x7b3b
leaq 0x7974(%rip), %rax      # 0xf474
cmpl $0x0, (%rax)
jle 0x7b21
movq 0x74ec(%rip), %rax      # 0xeff8
movq (%rax), %rdi
movzbl -0x11(%rbp), %edx
leaq 0x4dbe(%rip), %rsi      # 0xc8d8
movb $0x0, %al
callq 0x21d0
movl -0x18(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movb -0x11(%rbp), %cl
movq -0x10(%rbp), %rax
movb %cl, 0x4(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Openvario[P]sensord/ds2482.c
// Function: ds2482_reset
int ds2482_reset(t_ds2482 *sensor) {
	//server.log(format("Function: Resetting DS2482 at %i (%#x)", I2CAddr, I2CAddr));

	if (write(sensor->fd, "\xf0", 1)!=1) return 0; //reset DS2482
	sensor->owDeviceAddress[0]=0;
	sensor->owDeviceAddress[1]=0;
	sensor->owTriplet=4;
	sensor->owLastDevice=0;
	sensor->owLastDiscrepancy=0;
	sensor->temp_present=0;
	sensor->temp_valid=0;
	sensor->temperature=23;
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %edi
leaq 0x4d89(%rip), %rsi      # 0xc8f2
movl $0x1, %edx
callq 0x20a0
cmpq $0x1, %rax
je 0x7b82
movl $0x0, -0x4(%rbp)
jmp 0x7be3
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
movl $0x4, 0x18(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x1c(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x20(%rax)
movq -0x10(%rbp), %rax
movb $0x0, 0x2c(%rax)
movq -0x10(%rbp), %rax
movb $0x0, 0x2e(%rax)
movq -0x10(%rbp), %rax
movss 0x4419(%rip), %xmm0     # 0xbff0
movss %xmm0, 0x24(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Openvario[P]sensord/ds2482.c
// Function: OWReset
int OWReset(t_ds2482 *sensor) {
	int i;
	unsigned char data;

	// server.log("Function: I2C Reset");
	if (write(sensor->fd, "\xb4",1)!=1) { // 1-wire reset
		// Device failed to acknowledge reset
		// server.log("I2C Reset Failed");
		return 0;
	}
	for (i=0;i<100;++i) {
		if (read(sensor->fd,&data,1)==0) { // Read the status register
			// server.log("I2C Read Status Failed");
			return 0;
		} else {
			// server.log(format("Read Status Byte = %d", data[0]));
			if (data & 1) { // 1-Wire Busy bit
				struct timespec nstime = {0,1e6};
				while (nanosleep(&nstime,&nstime)) ; // Wait, try again
			} else {
				// server.log("One-Wire bus is idle");
				if (data & 4) { // Short Detected bit
					// server.log("One-Wire Short Detected");
					return 0;
				}
				if (data & 2) { // Presense-Pulse Detect bit
					// server.log("One-Wire Devices Found");
					return 1;
				} else {
					// server.log("No One-Wire Devices Found");
					return 0;
				}
			}
		}
	}
	// server.log("One-Wire busy too long");
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %edi
leaq 0x4ce6(%rip), %rsi      # 0xc8ef
movl $0x1, %edx
callq 0x20a0
cmpq $0x1, %rax
je 0x7c25
movl $0x0, -0x4(%rbp)
jmp 0x7cdf
movl $0x0, -0x14(%rbp)
cmpl $0x64, -0x14(%rbp)
jge 0x7cd8
movq -0x10(%rbp), %rax
movl (%rax), %edi
leaq -0x15(%rbp), %rsi
movl $0x1, %edx
callq 0x2180
cmpq $0x0, %rax
jne 0x7c5c
movl $0x0, -0x4(%rbp)
jmp 0x7cdf
movzbl -0x15(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x7c93
movq 0x4cb9(%rip), %rax      # 0xc928
movq %rax, -0x28(%rbp)
movq 0x4cb6(%rip), %rax      # 0xc930
movq %rax, -0x20(%rbp)
leaq -0x28(%rbp), %rsi
movq %rsi, %rdi
callq 0x2120
cmpl $0x0, %eax
je 0x7c91
jmp 0x7c7e
jmp 0x7cc6
movzbl -0x15(%rbp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x7ca8
movl $0x0, -0x4(%rbp)
jmp 0x7cdf
movzbl -0x15(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x7cbd
movl $0x1, -0x4(%rbp)
jmp 0x7cdf
movl $0x0, -0x4(%rbp)
jmp 0x7cdf
jmp 0x7cc8
jmp 0x7cca
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x7c2c
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Openvario[P]sensord/ds2482.c
// Function: OWTriplet
int OWTriplet(t_ds2482 *sensor) {
	unsigned char data[2]={0x78,0};
	int i;

	// server.log("Function: OneWire Triplet");
	data[1]=sensor->owTriplet<<5;
	if (write(sensor->fd,data,2)!=2) { // Device failed to acknowledge
		// server.log("OneWire Triplet  Failed");
		return 0;
	}
	for (i=0;i<100;++i) {
		if (read(sensor->fd,&data,1)==0) { // Read the status register
			// server.log("I2C Read Status Failed");
			return 0;
		} else {
			// server.log(format("Read Status Byte = %d", data[0]));
			if (data[0] & 1) { // 1-Wire Busy bit
				// server.log("One-Wire bus is busy");
				struct timespec nstime = {0,1e6};
				while (nanosleep(&nstime,&nstime)) ; // Wait, try again
			} else {
				// server.log("One-Wire bus is idle");
				sensor->owTriplet=(data[0]>>5)&7;
				return 1;
			}
		}
	}
	if (i == 100) {
		// server.log("One-Wire busy for too long");
		return 0;
	}
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movw 0x4896(%rip), %ax       # 0xc8f9
movw %ax, -0x12(%rbp)
movq -0x10(%rbp), %rax
movl 0x18(%rax), %eax
shll $0x5, %eax
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %edi
leaq -0x12(%rbp), %rsi
movl $0x2, %edx
callq 0x20a0
cmpq $0x2, %rax
je 0x809a
movl $0x0, -0x4(%rbp)
jmp 0x8147
movl $0x0, -0x18(%rbp)
cmpl $0x64, -0x18(%rbp)
jge 0x8131
movq -0x10(%rbp), %rax
movl (%rax), %edi
leaq -0x12(%rbp), %rsi
movl $0x1, %edx
callq 0x2180
cmpq $0x0, %rax
jne 0x80ce
movl $0x0, -0x4(%rbp)
jmp 0x8147
movzbl -0x12(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x8105
movq 0x4847(%rip), %rax      # 0xc928
movq %rax, -0x28(%rbp)
movq 0x4844(%rip), %rax      # 0xc930
movq %rax, -0x20(%rbp)
leaq -0x28(%rbp), %rsi
movq %rsi, %rdi
callq 0x2120
cmpl $0x0, %eax
je 0x8103
jmp 0x80f0
jmp 0x811f
movzbl -0x12(%rbp), %ecx
sarl $0x5, %ecx
andl $0x7, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x18(%rax)
movl $0x1, -0x4(%rbp)
jmp 0x8147
jmp 0x8121
jmp 0x8123
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x80a1
cmpl $0x64, -0x18(%rbp)
jne 0x8140
movl $0x0, -0x4(%rbp)
jmp 0x8147
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Openvario[P]sensord/ds2482.c
// Function: OWCheckCRC
int OWCheckCRC(t_ds2482 *sensor) {
	int crc, j,i;
	long int da32bit;

	for (i=0;i<2;i++) {
		for (j=0,crc=0,da32bit=sensor->owDeviceAddress[i]; j<4; j++) { // All four bytes
			crc = AddCRC(da32bit & 0xFF, crc);
			// server.log(format("CRC = %.2X", crc));
			da32bit >>= 8; // Shift right 8 bits
		}
	}
	// server.log(format("CRC = %#.2X", crc));
	// server.log(format("DA  = %#.2X", da32bit));
	if ((da32bit & 0xFF) == crc) { // last byte of address should match CRC of other 7 bytes
		// server.log("CRC Passed");
		return 1; // match
	}
	return 0; // bad CRC
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x2, -0x1c(%rbp)
jge 0x8439
movl $0x0, -0x18(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq 0x8(%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
cmpl $0x4, -0x18(%rbp)
jge 0x842c
movq -0x28(%rbp), %rax
andq $0xff, %rax
movl %eax, %edi
movl -0x14(%rbp), %esi
callq 0x8470
movl %eax, -0x14(%rbp)
movq -0x28(%rbp), %rax
sarq $0x8, %rax
movq %rax, -0x28(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x83f8
jmp 0x842e
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x83d3
movq -0x28(%rbp), %rax
andq $0xff, %rax
movslq -0x14(%rbp), %rcx
cmpq %rcx, %rax
jne 0x8455
movl $0x1, -0x4(%rbp)
jmp 0x845c
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Openvario[P]sensord/ds2482.c
// Function: AddCRC
int  AddCRC(int inbyte, int crc) {
	int i;

	for(i=0; i<8; i++) {
		if ((crc ^ inbyte) & 0x01) crc=(crc>>1)^0x8c; else crc>>=1;
		inbyte >>= 1;
	}
	return crc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x8, -0xc(%rbp)
jge 0x84bf
movl -0x8(%rbp), %eax
xorl -0x4(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x84a4
movl -0x8(%rbp), %eax
sarl %eax
xorl $0x8c, %eax
movl %eax, -0x8(%rbp)
jmp 0x84ac
movl -0x8(%rbp), %eax
sarl %eax
movl %eax, -0x8(%rbp)
movl -0x4(%rbp), %eax
sarl %eax
movl %eax, -0x4(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x8481
movl -0x8(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Openvario[P]sensord/ds2482.c
// Function: OWSelect
int OWSelect(t_ds2482 *sensor) {
	// server.log("Selecting device");
	int i,j;

	if (OWWriteByte(sensor, 0x4C)==-1) return 0; // Issue the Match ROM command
	for(i=0; i<2; i++) {
		long int da32bit = sensor->owDeviceAddress[i];
		for(j=0; j<4; j++) {
			// server.log(format("Writing byte: %.2X", da32bit & 0xFF));
			OWWriteByte(sensor, da32bit & 0xff); // Send lowest byte
			da32bit >>=  8; // Shift right 8 bits
		}
	}
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x4c, %esi
callq 0x7cf0
cmpl $-0x1, %eax
jne 0x84f8
movl $0x0, -0x4(%rbp)
jmp 0x8564
movl $0x0, -0x14(%rbp)
cmpl $0x2, -0x14(%rbp)
jge 0x855d
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq 0x8(%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x18(%rbp)
cmpl $0x4, -0x18(%rbp)
jge 0x8550
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
andq $0xff, %rax
movzbl %al, %esi
callq 0x7cf0
movq -0x20(%rbp), %rax
sarq $0x8, %rax
movq %rax, -0x20(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x851d
jmp 0x8552
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x84ff
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Openvario[P]sensord/ds2482.c
// Function: OWConfigureBits
int OWConfigureBits (t_ds2482 *sensor) {
	unsigned char data[4] = {0x4e,0x00,0x00,0x7f};
	int i,j;

	if (OWReset(sensor)==0) return 0;
	if (OWWriteByte(sensor,0xCC)==-1) return 0;
	switch (sensor->databits) {
		case 9  : data[3]=0x1f; sensor->conversion_time = 6; sensor->delta_conversion_time = 5; break;
		case 10 : data[3]=0x3f; sensor->conversion_time = 13; sensor->delta_conversion_time = 5;  break;
		case 11 : data[3]=0x5f; sensor->conversion_time = 28; sensor->delta_conversion_time = 5; break;
		default : sensor->conversion_time = 58; sensor->delta_conversion_time = 5; break;
	}
	for (i=0,j=1;i<4;++i)
		if (OWWriteByte(sensor,data[i])==-1) j=0;
	return j;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl 0x433a(%rip), %eax      # 0xc8bc
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x7bf0
cmpl $0x0, %eax
jne 0x859f
movl $0x0, -0x4(%rbp)
jmp 0x8692
movq -0x10(%rbp), %rdi
movl $0xcc, %esi
callq 0x7cf0
cmpl $-0x1, %eax
jne 0x85be
movl $0x0, -0x4(%rbp)
jmp 0x8692
movq -0x10(%rbp), %rax
movl 0x3c(%rax), %eax
movl %eax, -0x20(%rbp)
subl $0x9, %eax
je 0x85e3
jmp 0x85cf
movl -0x20(%rbp), %eax
subl $0xa, %eax
je 0x85ff
jmp 0x85d9
movl -0x20(%rbp), %eax
subl $0xb, %eax
je 0x861b
jmp 0x8637
movb $0x1f, -0x11(%rbp)
movq -0x10(%rbp), %rax
movl $0x6, 0x34(%rax)
movq -0x10(%rbp), %rax
movl $0x5, 0x38(%rax)
jmp 0x864d
movb $0x3f, -0x11(%rbp)
movq -0x10(%rbp), %rax
movl $0xd, 0x34(%rax)
movq -0x10(%rbp), %rax
movl $0x5, 0x38(%rax)
jmp 0x864d
movb $0x5f, -0x11(%rbp)
movq -0x10(%rbp), %rax
movl $0x1c, 0x34(%rax)
movq -0x10(%rbp), %rax
movl $0x5, 0x38(%rax)
jmp 0x864d
movq -0x10(%rbp), %rax
movl $0x3a, 0x34(%rax)
movq -0x10(%rbp), %rax
movl $0x5, 0x38(%rax)
movl $0x0, -0x18(%rbp)
movl $0x1, -0x1c(%rbp)
cmpl $0x4, -0x18(%rbp)
jge 0x868c
movq -0x10(%rbp), %rdi
movslq -0x18(%rbp), %rax
movzbl -0x14(%rbp,%rax), %esi
callq 0x7cf0
cmpl $-0x1, %eax
jne 0x867f
movl $0x0, -0x1c(%rbp)
jmp 0x8681
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x865b
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Openvario[P]sensord/humidity.c
// Function: si7021_crc_check
int si7021_crc_check(unsigned int value, uint8_t crc)
{
	uint32_t polynom = 0x988000; // x^8 + x^5 + x^4 + 1
	uint32_t msb     = 0x800000;
	uint32_t mask    = 0xFF8000;
	uint32_t result  = (uint32_t)value<<8; // Pad with zeros as specified in spec

	while( msb != 0x80 ) {

		// Check if msb of current value is 1 and apply XOR mask
		if( result & msb )
			result = ((result ^ polynom) & mask) | ( result & ~mask);

		// Shift by one
		msb >>= 1;
		mask >>= 1;
		polynom >>=1;
	}
	if( result == crc ) return 0;
	return 1 ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movl %edi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movl $0x988000, -0x10(%rbp)  # imm = 0x988000
movl $0x800000, -0x14(%rbp)  # imm = 0x800000
movl $0xff8000, -0x18(%rbp)  # imm = 0xFF8000
movl -0x8(%rbp), %eax
shll $0x8, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x80, -0x14(%rbp)
je 0x8922
movl -0x1c(%rbp), %eax
andl -0x14(%rbp), %eax
cmpl $0x0, %eax
je 0x8908
movl -0x1c(%rbp), %eax
xorl -0x10(%rbp), %eax
andl -0x18(%rbp), %eax
movl -0x1c(%rbp), %ecx
movl -0x18(%rbp), %edx
xorl $-0x1, %edx
andl %edx, %ecx
orl %ecx, %eax
movl %eax, -0x1c(%rbp)
movl -0x14(%rbp), %eax
shrl %eax
movl %eax, -0x14(%rbp)
movl -0x18(%rbp), %eax
shrl %eax
movl %eax, -0x18(%rbp)
movl -0x10(%rbp), %eax
shrl %eax
movl %eax, -0x10(%rbp)
jmp 0x88db
movl -0x1c(%rbp), %eax
movzbl -0x9(%rbp), %ecx
cmpl %ecx, %eax
jne 0x8936
movl $0x0, -0x4(%rbp)
jmp 0x893d
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Openvario[P]sensord/humidity.c
// Function: si7021_start_humidity
int si7021_start_humidity (t_ds2482 *sensor) {
	char config[2],lngth=1;

	switch (sensor->sensor_type) {
		case SI7021 :
		case HTU21D : config[0]=0xf5; break;
		case HTU31D : config[0]=sensor->databits; break;
		case SHT4X  : config[0]=0xfd; break;
		case SHT85  : config[0] = 0x24; config[1] = 0x00; lngth=2; break;
		default     : return 2;
	}
	if (write(sensor->fd, &config, lngth)!=lngth) return 1;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movb $0x1, -0x13(%rbp)
movq -0x10(%rbp), %rax
movsbl 0x30(%rax), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x6, %eax
ja 0x95ef
movq -0x20(%rbp), %rax
leaq 0x3398(%rip), %rcx      # 0xc958
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $-0xb, -0x12(%rbp)
jmp 0x95f8
movq -0x10(%rbp), %rax
movl 0x3c(%rax), %eax
movb %al, -0x12(%rbp)
jmp 0x95f8
movb $-0x3, -0x12(%rbp)
jmp 0x95f8
movb $0x24, -0x12(%rbp)
movb $0x0, -0x11(%rbp)
movb $0x2, -0x13(%rbp)
jmp 0x95f8
movl $0x2, -0x4(%rbp)
jmp 0x9626
movq -0x10(%rbp), %rax
movl (%rax), %edi
movsbq -0x13(%rbp), %rdx
leaq -0x12(%rbp), %rsi
callq 0x20a0
movsbq -0x13(%rbp), %rcx
cmpq %rcx, %rax
je 0x961f
movl $0x1, -0x4(%rbp)
jmp 0x9626
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Openvario[P]sensord/humidity.c
// Function: si7021_start_temp
int si7021_start_temp (t_ds2482 *sensor) {

	// This sends a temperature conversion for an HTU21D, a humidity conversion for SI7021 (does both), and a conversion for HTU31D
	char config[2],lngth=1;

	switch (sensor->sensor_type) {
		case SI7021 : config[0]=0xf5; break;
		case HTU21D : config[0]=0xf3; break;
		case HTU31D : config[0]=sensor->databits; break;
		case SHT4X  : config[0]=0xfd; break;
		case SHT85  : config[0]=0x24; config[1]=0x00; lngth=2; break;
		default     : return 2;
	}
	if (write(sensor->fd, &config, lngth)!=lngth) return 1;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movb $0x1, -0x13(%rbp)
movq -0x10(%rbp), %rax
movsbl 0x30(%rax), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x6, %eax
ja 0x9695
movq -0x20(%rbp), %rax
leaq 0x3314(%rip), %rcx      # 0xc974
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $-0xb, -0x12(%rbp)
jmp 0x969e
movb $-0xd, -0x12(%rbp)
jmp 0x969e
movq -0x10(%rbp), %rax
movl 0x3c(%rax), %eax
movb %al, -0x12(%rbp)
jmp 0x969e
movb $-0x3, -0x12(%rbp)
jmp 0x969e
movb $0x24, -0x12(%rbp)
movb $0x0, -0x11(%rbp)
movb $0x2, -0x13(%rbp)
jmp 0x969e
movl $0x2, -0x4(%rbp)
jmp 0x96cc
movq -0x10(%rbp), %rax
movl (%rax), %edi
movsbq -0x13(%rbp), %rdx
leaq -0x12(%rbp), %rsi
callq 0x20a0
movsbq -0x13(%rbp), %rcx
cmpq %rcx, %rax
je 0x96c5
movl $0x1, -0x4(%rbp)
jmp 0x96cc
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Openvario[P]sensord/humidity.c
// Function: si7021_read_temp
int si7021_read_temp (t_ds2482 *sensor) {

	uint8_t data[3];
	double temp;

	switch (sensor->sensor_type) {
		case HTU21D :
			sensor->temp_valid=0;
			if (read(sensor->fd, data, 3) != 3) return 4;
			if (si7021_crc_check((data[0]<<8)|data[1],data[2])>0) return 2;
			temp = (double) ((data[0]<<8)|data[1]) * 175.72/65536.0 - 46.85;
			sensor->temperature = temp;
			sensor->temp_valid = sensor->temp_present;
			break;
		default : si7021_read_humidity (sensor);
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movb 0x30(%rax), %al
subb $0x1, %al
jne 0x97ab
jmp 0x96fd
movq -0x10(%rbp), %rax
movb $0x0, 0x2e(%rax)
movq -0x10(%rbp), %rax
movl (%rax), %edi
leaq -0x13(%rbp), %rsi
movl $0x3, %edx
callq 0x2180
cmpq $0x3, %rax
je 0x972b
movl $0x4, -0x4(%rbp)
jmp 0x97bb
movzbl -0x13(%rbp), %edi
shll $0x8, %edi
movzbl -0x12(%rbp), %eax
orl %eax, %edi
movzbl -0x11(%rbp), %esi
callq 0x88b0
cmpl $0x0, %eax
jle 0x974f
movl $0x2, -0x4(%rbp)
jmp 0x97bb
movzbl -0x13(%rbp), %eax
shll $0x8, %eax
movzbl -0x12(%rbp), %ecx
orl %ecx, %eax
cvtsi2sd %eax, %xmm0
movsd 0x3280(%rip), %xmm1     # 0xc9e8
mulsd %xmm1, %xmm0
movsd 0x326c(%rip), %xmm1     # 0xc9e0
divsd %xmm1, %xmm0
movsd 0x3258(%rip), %xmm1     # 0xc9d8
subsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
cvtsd2ss %xmm0, %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, 0x24(%rax)
movq -0x10(%rbp), %rax
movb 0x2c(%rax), %cl
movq -0x10(%rbp), %rax
movb %cl, 0x2e(%rax)
jmp 0x97b4
movq -0x10(%rbp), %rdi
callq 0x97d0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Openvario[P]sensord/humidity.c
// Function: si7021_configure_heater_value
int si7021_configure_heater_value (t_ds2482 *sensor, int value)
{
	uint8_t data[3] = {0x51,0x00,0x11};

	if (sensor->sensor_type==SI7021) {
		data[1]=value&0xf;				// If SI7021 initialize the heat control register
		if (write(sensor->fd,data,2)!=2) return 2;	// Program it
		if (write(sensor->fd,data+2,1)!=1) return 2;    // Start readback
		if (read(sensor->fd,data,1)!=1) return 2;	// Readback
		if (data[1]!=(value&0xf)) return 2;		// Verify readback matches written value
	} else return 1;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movw 0x2d48(%rip), %ax       # 0xc9ce
movw %ax, -0x17(%rbp)
movb 0x2d40(%rip), %al       # 0xc9d0
movb %al, -0x15(%rbp)
movq -0x10(%rbp), %rax
movsbl 0x30(%rax), %eax
cmpl $0x3, %eax
jne 0x9d33
movl -0x14(%rbp), %eax
andl $0xf, %eax
movb %al, -0x16(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %edi
leaq -0x17(%rbp), %rsi
movl $0x2, %edx
callq 0x20a0
cmpq $0x2, %rax
je 0x9cd0
movl $0x2, -0x4(%rbp)
jmp 0x9d43
movq -0x10(%rbp), %rax
movl (%rax), %edi
leaq -0x17(%rbp), %rsi
addq $0x2, %rsi
movl $0x1, %edx
callq 0x20a0
cmpq $0x1, %rax
je 0x9cf7
movl $0x2, -0x4(%rbp)
jmp 0x9d43
movq -0x10(%rbp), %rax
movl (%rax), %edi
leaq -0x17(%rbp), %rsi
movl $0x1, %edx
callq 0x2180
cmpq $0x1, %rax
je 0x9d1a
movl $0x2, -0x4(%rbp)
jmp 0x9d43
movzbl -0x16(%rbp), %eax
movl -0x14(%rbp), %ecx
andl $0xf, %ecx
cmpl %ecx, %eax
je 0x9d31
movl $0x2, -0x4(%rbp)
jmp 0x9d43
jmp 0x9d3c
movl $0x1, -0x4(%rbp)
jmp 0x9d43
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Openvario[P]sensord/humidity.c
// Function: am2321_open
int am2321_open (t_ds2482 *sensor, unsigned char i2c_address) {

	sensor->fd = open(I2C_DEVICE, O_RDWR);
	if (sensor->fd < 0) {
		fprintf(stderr, "Error opening file: %s\n", strerror(errno));
		return 1;
	}
	if (ioctl(sensor->fd, I2C_SLAVE, i2c_address) < 0) {
		fprintf(stderr, "ioctl error: %s\n", strerror(errno));
		return 1;
	}

	if (am2321_read(sensor)>0) return 1;
	if (g_debug > 0) fprintf(stderr, "Opened AM2321 on 0x%x\n", i2c_address);

	// assign file handle to sensor object
	sensor->address = i2c_address;
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
leaq 0x1393(%rip), %rdi      # 0xb3dc
movl $0x2, %esi
movb $0x0, %al
callq 0x2240
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
jge 0xa0a1
movq 0x4f8b(%rip), %rax      # 0xeff8
movq (%rax), %rax
movq %rax, -0x20(%rbp)
callq 0x2030
movl (%rax), %edi
callq 0x22d0
movq -0x20(%rbp), %rdi
movq %rax, %rdx
leaq 0x1359(%rip), %rsi      # 0xb3e7
movb $0x0, %al
callq 0x21d0
movl $0x1, -0x4(%rbp)
jmp 0xa144
movq -0x10(%rbp), %rax
movl (%rax), %edi
movzbl -0x11(%rbp), %edx
movl $0x703, %esi            # imm = 0x703
movb $0x0, %al
callq 0x2140
cmpl $0x0, %eax
jge 0xa0f4
movq 0x4f35(%rip), %rax      # 0xeff8
movq (%rax), %rax
movq %rax, -0x28(%rbp)
callq 0x2030
movl (%rax), %edi
callq 0x22d0
movq -0x28(%rbp), %rdi
movq %rax, %rdx
leaq 0xf68(%rip), %rsi       # 0xb04c
movb $0x0, %al
callq 0x21d0
movl $0x1, -0x4(%rbp)
jmp 0xa144
movq -0x10(%rbp), %rdi
callq 0xa150
cmpl $0x0, %eax
jle 0xa10b
movl $0x1, -0x4(%rbp)
jmp 0xa144
leaq 0x5362(%rip), %rax      # 0xf474
cmpl $0x0, (%rax)
jle 0xa133
movq 0x4eda(%rip), %rax      # 0xeff8
movq (%rax), %rdi
movzbl -0x11(%rbp), %edx
leaq 0x2b22(%rip), %rsi      # 0xcc4e
movb $0x0, %al
callq 0x21d0
movb -0x11(%rbp), %cl
movq -0x10(%rbp), %rax
movb %cl, 0x4(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Openvario[P]sensord/humidity.c
// Function: am2321_wakeup
int am2321_wakeup (t_ds2482 *sensor) {

	//  wake AM2320 up, goes to sleep to not warm up and affect the humidity sensor

	if (write(sensor->fd, NULL, 0)<0) return 3;
	struct timespec nstime = {0,1.0e6};
	while (nanosleep (&nstime,&nstime)) ; /* Wait atleast 1.5ms */
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %edi
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x20a0
cmpq $0x0, %rax
jge 0xa36d
movl $0x3, -0x4(%rbp)
jmp 0xa39d
movq 0x25b4(%rip), %rax      # 0xc928
movq %rax, -0x20(%rbp)
movq 0x25b1(%rip), %rax      # 0xc930
movq %rax, -0x18(%rbp)
leaq -0x20(%rbp), %rsi
movq %rsi, %rdi
callq 0x2120
cmpl $0x0, %eax
je 0xa396
jmp 0xa383
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Openvario[P]sensord/humidity.c
// Function: calc_crc16
static uint16_t _calc_crc16(const uint8_t *buf, size_t len) {
	uint16_t crc = 0xFFFF;

	while(len--) {
		crc ^= (uint16_t) *buf++;
		for (unsigned i = 0; i < 8; i++)
			if (crc & 0x0001) crc = (crc>>1) ^ 0xa001; else crc >>= 1;
	}
	return crc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movw $0xffff, -0x12(%rbp)    # imm = 0xFFFF
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x10(%rbp)
cmpq $0x0, %rax
je 0xa439
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movzbl (%rax), %eax
movzwl %ax, %ecx
movzwl -0x12(%rbp), %eax
xorl %ecx, %eax
movw %ax, -0x12(%rbp)
movl $0x0, -0x18(%rbp)
cmpl $0x8, -0x18(%rbp)
jae 0xa437
movzwl -0x12(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0xa420
movzwl -0x12(%rbp), %eax
sarl %eax
xorl $0xa001, %eax           # imm = 0xA001
movw %ax, -0x12(%rbp)
jmp 0xa42a
movzwl -0x12(%rbp), %eax
sarl %eax
movw %ax, -0x12(%rbp)
jmp 0xa42c
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xa3fd
jmp 0xa3c2
movw -0x12(%rbp), %ax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/marcespie[P]unix-samples/chapter1/fork3bad.c
// Function: perform_computation
void
perform_computation(int i)
{
	printf("Square of %d is %d\n", i, i * i);
	if (i % 17 == 0)
		exit(1);
	if (i % 25 == 0)
		kill(getpid(), SIGINT);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %esi
movl -0x4(%rbp), %edx
imull -0x4(%rbp), %edx
leaq 0xe18(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1050
movl -0x4(%rbp), %eax
movl $0x11, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x120d
movl $0x1, %edi
callq 0x10a0
movl -0x4(%rbp), %eax
movl $0x19, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x122e
callq 0x1040
movl %eax, %edi
movl $0x2, %esi
callq 0x1070
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/marcespie[P]unix-samples/chapter1/fork3bad.c
// Function: bad_status
bool 
bad_status(int status)
{
	if (WIFEXITED(status)) {
		int rc = WEXITSTATUS(status);
		if (rc == 0)
			return false;
		else
			fprintf(stderr, "Child exited with exit(%d)\n", rc);
	} else if (WIFSIGNALED(status)) {
		int sig = WTERMSIG(status);
		fprintf(stderr, "Child exited with signal %d (%s)\n", 
		    sig, strsignal(sig));
	} else
		fprintf(stderr, "This should never happen: %d\n", status);
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
andl $0x7f, %eax
cmpl $0x0, %eax
jne 0x1290
movl -0x8(%rbp), %eax
andl $0xff00, %eax           # imm = 0xFF00
sarl $0x8, %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x1273
movb $0x0, -0x1(%rbp)
jmp 0x1303
movq 0x2d7e(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movl -0xc(%rbp), %edx
leaq 0xd91(%rip), %rsi       # 0x2018
movb $0x0, %al
callq 0x1060
jmp 0x12ff
movl -0x8(%rbp), %eax
andl $0x7f, %eax
addl $0x1, %eax
movsbl %al, %eax
sarl %eax
cmpl $0x0, %eax
jle 0x12e2
movl -0x8(%rbp), %eax
andl $0x7f, %eax
movl %eax, -0x10(%rbp)
movq 0x2d45(%rip), %rax      # 0x3ff8
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x10(%rbp), %edi
callq 0x1090
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %edx
movq %rax, %rcx
leaq 0xd5b(%rip), %rsi       # 0x2034
movb $0x0, %al
callq 0x1060
jmp 0x12fd
movq 0x2d0f(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movl -0x8(%rbp), %edx
leaq 0xd60(%rip), %rsi       # 0x2056
movb $0x0, %al
callq 0x1060
jmp 0x12ff
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/marcespie[P]unix-samples/chapter1/fork3bad.c
// Function: main
int
main()
{

	for (int i = 15; i < 550; i += 2) {
		int pid = fork();
		switch(pid) {
		case -1: 
			err(1, "fork");
		case 0:
			perform_computation(i);
			exit(0);
		}
	}

	// parent
	int rc = 0; // by default we succeed

	int status, r;
	while ((r = wait(&status)) != -1)
		if (bad_status(status))
			rc = 1;
	// this normally exits with ECHILD, when we reaped every child
	if (errno != ECHILD)
		err(1, "wait");

	exit(rc);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl $0xf, -0x8(%rbp)
cmpl $0x226, -0x8(%rbp)      # imm = 0x226
jge 0x137c
callq 0x10c0
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
subl $-0x1, %eax
je 0x134d
jmp 0x1344
movl -0x1c(%rbp), %eax
testl %eax, %eax
je 0x1360
jmp 0x136f
movl $0x1, %edi
leaq 0xd1b(%rip), %rsi       # 0x2074
movb $0x0, %al
callq 0x1080
movl -0x8(%rbp), %edi
callq 0x11d0
xorl %edi, %edi
callq 0x10a0
jmp 0x1371
movl -0x8(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x8(%rbp)
jmp 0x1326
movl $0x0, -0x10(%rbp)
leaq -0x14(%rbp), %rdi
callq 0x10b0
movl %eax, -0x18(%rbp)
cmpl $-0x1, %eax
je 0x13ab
movl -0x14(%rbp), %edi
callq 0x1240
testb $0x1, %al
jne 0x13a2
jmp 0x13a9
movl $0x1, -0x10(%rbp)
jmp 0x1383
callq 0x1030
cmpl $0xa, (%rax)
je 0x13c8
movl $0x1, %edi
leaq 0xcb8(%rip), %rsi       # 0x2079
movb $0x0, %al
callq 0x1080
movl -0x10(%rbp), %edi
callq 0x10a0
// File: /workspace/github_c_makefile_star2_O0/johanDa9u[P]MiniShell/src/boucle.c
// Function: main
int main(){
    int x = 0;
   while(1){
       printf("%d\n",x++);
       sleep(1);
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
leaq 0x298c(%rip), %rdi      # 0x5004
movb $0x0, %al
callq 0x2140
movl $0x1, %edi
callq 0x24d0
jmp 0x2666
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_5/exercise_5_12/detab.c
// Function: is_arg_list_valid
int is_arg_list_valid(int argc, char *argv[])
{
  for (size_t i = 1; i < argc; ++i)
  {
    if (argv[i][0] == '-' || argv[i][0] == '+')
    {
      if (argc > 3 || !is_str_uint(argv[i] + 1))
      {
        return 0;
      }
      continue;
    }

    if (!is_str_uint(argv[i]) || (i > 1 && atoi(argv[i - 1]) > atoi(argv[i])))
    {
      return 0;
    }
  }
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x1, -0x18(%rbp)
movq -0x18(%rbp), %rax
movslq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jae 0x14d6
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
je 0x1440
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsbl (%rax), %eax
cmpl $0x2b, %eax
jne 0x146b
cmpl $0x3, -0x8(%rbp)
jg 0x1460
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
addq $0x1, %rdi
callq 0x14f0
cmpl $0x0, %eax
jne 0x1469
movl $0x0, -0x4(%rbp)
jmp 0x14dd
jmp 0x14c5
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x14f0
cmpl $0x0, %eax
je 0x14ba
cmpq $0x1, -0x18(%rbp)
jbe 0x14c3
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1070
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1070
movl %eax, %ecx
movl -0x1c(%rbp), %eax
cmpl %ecx, %eax
jle 0x14c3
movl $0x0, -0x4(%rbp)
jmp 0x14dd
jmp 0x14c5
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x1407
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_5/exercise_5_12/detab.c
// Function: is_str_uint
int is_str_uint(char *str)
{
  for (size_t i = 0; i < strlen(str); ++i)
  {
    if (!isdigit(str[i]))
    {
      return 0;
    }
  }
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1050
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jae 0x155f
callq 0x1080
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
jne 0x154f
movl $0x0, -0x4(%rbp)
jmp 0x1566
jmp 0x1551
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x1504
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/phluid61[P]hsf/src/item.c
// Function: SH_Item__init
SH_Item*
SH_Item__init(SH_BareItem* item, SH_dict* params, int* err) {
	SH_Item* obj;

	__cascade(err, (SH_Item*)0);

	obj = (SH_Item*)malloc(sizeof(SH_Item));
	if ((SH_Item*)0 == obj) {
		__raise(err, SH_E_MALLOC_ERROR);
		return (SH_Item*)0;
	}

	if ((SH_dict*)0 == params) {
		params = SH_dict__init(err);
		if (__catch(err)) {
			free(obj);
			return (SH_Item*)0;
		}
	}

	obj->item = item;
	obj->params = params;

	__clear(err);
	return obj;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
xorl %eax, %eax
cmpq -0x20(%rbp), %rax
je 0x1233
movq -0x20(%rbp), %rcx
xorl %eax, %eax
cmpl (%rcx), %eax
je 0x1233
movq $0x0, -0x8(%rbp)
jmp 0x12d2
movl $0x10, %edi
callq 0x10d0
movq %rax, -0x28(%rbp)
xorl %eax, %eax
cmpq -0x28(%rbp), %rax
jne 0x1265
xorl %eax, %eax
cmpq -0x20(%rbp), %rax
je 0x125b
movq -0x20(%rbp), %rax
movl $0x80000001, (%rax)     # imm = 0x80000001
movq $0x0, -0x8(%rbp)
jmp 0x12d2
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
jne 0x12a1
movq -0x20(%rbp), %rdi
callq 0x1050
movq %rax, -0x18(%rbp)
xorl %eax, %eax
cmpq -0x20(%rbp), %rax
je 0x129f
movq -0x20(%rbp), %rcx
xorl %eax, %eax
cmpl (%rcx), %eax
je 0x129f
movq -0x28(%rbp), %rdi
callq 0x1040
movq $0x0, -0x8(%rbp)
jmp 0x12d2
jmp 0x12a1
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
xorl %eax, %eax
cmpq -0x20(%rbp), %rax
je 0x12ca
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/phluid61[P]hsf/src/item.c
// Function: SH_Item__destroy
void
SH_Item__destroy(SH_Item *obj, sh_bool_t recursive, int* err) {
	int local_err1 = SH_E_NO_ERROR;
	int local_err2 = SH_E_NO_ERROR;
	__cascade(err,);
	if (recursive) {
		SH_BareItem__destroy(obj->item, recursive, &local_err1);
		SH_dict__destroy(obj->params, recursive, &local_err2);
		free(obj);
		__raise(err, (SH_E_NO_ERROR == local_err1) ? local_err2 : local_err1);
	} else {
		free(obj);
		__clear(err);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
je 0x1318
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpl (%rcx), %eax
je 0x1318
jmp 0x1395
cmpb $0x0, -0x9(%rbp)
je 0x1378
movq -0x8(%rbp), %rax
movq (%rax), %rdi
leaq -0x1c(%rbp), %rdx
movzbl -0x9(%rbp), %esi
callq 0x1100
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
leaq -0x20(%rbp), %rdx
movzbl -0x9(%rbp), %esi
callq 0x10e0
movq -0x8(%rbp), %rdi
callq 0x1040
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
je 0x1376
xorl %eax, %eax
cmpl -0x1c(%rbp), %eax
jne 0x1367
movl -0x20(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0x136d
movl -0x1c(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
jmp 0x1395
movq -0x8(%rbp), %rdi
callq 0x1040
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
je 0x1393
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
jmp 0x1395
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/phluid61[P]hsf/src/item.c
// Function: SH_Item__add_param
void
SH_Item__add_param(SH_Item* obj, SH_Key* key, SH_Item* item, int* err) {
	if (SH_dict__count(obj->params, 0) >= 256) { /* FIXME: magic numer, RFC 8941, 3.1.2 */
		__raise(err, SH_E_PARAMETERS_OVERFLOW);
		return;
	}
	SH_dict__add(obj->params, key, item, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1060
cmpq $0x100, %rax            # imm = 0x100
jb 0x1485
xorl %eax, %eax
cmpq -0x20(%rbp), %rax
je 0x1483
movq -0x20(%rbp), %rax
movl $0x100002, (%rax)       # imm = 0x100002
jmp 0x149e
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x10b0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonassimp/src/additional.c
// Function: Textureflags
static int Textureflags(lua_State *L)
    {
    if(lua_type(L, 1) == LUA_TNUMBER)
        return pushtextureflags(L, luaL_checkinteger(L, 1), 0);
    lua_pushinteger(L, checktextureflags(L, 1));
    return 1;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x68e0
cmpl $0x3, %eax
jne 0x6b1a
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x6440
movq 0x10(%rsp), %rdi
movl %eax, %esi
xorl %edx, %edx
callq 0x6200
movl %eax, 0x24(%rsp)
jmp 0x6b49
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x60f0
movq 0x8(%rsp), %rdi
movl %eax, %eax
movl %eax, %esi
callq 0x6310
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonassimp/src/additional.c
// Function: Primtypes
static int Primtypes(lua_State *L)
    {
    if(lua_type(L, 1) == LUA_TNUMBER)
        return pushprimitivetype(L, luaL_checkinteger(L, 1), 0);
    lua_pushinteger(L, checkprimitivetype(L, 1));
    return 1;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x68e0
cmpl $0x3, %eax
jne 0x6baa
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x6440
movq 0x10(%rsp), %rdi
movl %eax, %esi
xorl %edx, %edx
callq 0x66b0
movl %eax, 0x24(%rsp)
jmp 0x6bd9
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x6410
movq 0x8(%rsp), %rdi
movl %eax, %eax
movl %eax, %esi
callq 0x6310
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonassimp/src/additional.c
// Function: Postprocessflags
static int Postprocessflags(lua_State *L)
    {
    if(lua_type(L, 1) == LUA_TNUMBER)
        return pushpostprocessflags(L, luaL_checkinteger(L, 1), 0);
    lua_pushinteger(L, checkpostprocessflags(L, 1));
    return 1;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x68e0
cmpl $0x3, %eax
jne 0x6c3a
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x6440
movq 0x10(%rsp), %rdi
movl %eax, %esi
xorl %edx, %edx
callq 0x6210
movl %eax, 0x24(%rsp)
jmp 0x6c69
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x6260
movq 0x8(%rsp), %rdi
movl %eax, %eax
movl %eax, %esi
callq 0x6310
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonassimp/src/additional.c
// Function: Sceneflags
static int Sceneflags(lua_State *L)
    {
    if(lua_type(L, 1) == LUA_TNUMBER)
        return pushsceneflags(L, luaL_checkinteger(L, 1), 0);
    lua_pushinteger(L, checksceneflags(L, 1));
    return 1;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x68e0
cmpl $0x3, %eax
jne 0x6cca
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x6440
movq 0x10(%rsp), %rdi
movl %eax, %esi
xorl %edx, %edx
callq 0x65b0
movl %eax, 0x24(%rsp)
jmp 0x6cf9
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x6670
movq 0x8(%rsp), %rdi
movl %eax, %eax
movl %eax, %esi
callq 0x6310
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonassimp/src/animation.c
// Function: moonassimp_newanimation
int newanimation(lua_State *L, scene_t *scene, animation_t *animation)
    {
    unsigned int i;
    ud_t *ud;
    TRACE_CREATE(animation, "animation");
    if(animation->mChannels != NULL && animation->mNumChannels > 0)
        {
        for(i = 0; i < animation->mNumChannels; i++)
            { newnodeanim(L, scene, animation, animation->mChannels[i]); lua_pop(L, 1); }
        TRACE_CREATE_N(i, "nodeanims");
        }
    if(animation->mMeshChannels != NULL && animation->mNumMeshChannels > 0)
        {
        for(i = 0; i < animation->mNumMeshChannels; i++)
            { newmeshanim(L, scene, animation, animation->mMeshChannels[i]); lua_pop(L, 1); }
        TRACE_CREATE_N(i, "meshanims");
        }
    ud = newuserdata(L, (void*)animation, ANIMATION_MT);
    ud->scene = scene;
    return 1;   
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x10(%rsp), %rsi
leaq 0xf304(%rip), %rdi      # 0x16033
movb $0x0, %al
callq 0x6720
movq 0x10(%rsp), %rax
cmpq $0x0, 0x420(%rax)
je 0x6dca
movq 0x10(%rsp), %rax
cmpl $0x0, 0x418(%rax)
jbe 0x6dca
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl 0x418(%rcx), %eax
jae 0x6db4
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x10(%rsp), %rax
movq 0x420(%rax), %rax
movl 0xc(%rsp), %ecx
movq (%rax,%rcx,8), %rcx
callq 0x6100
movq 0x20(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x60c0
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x6d5f
jmp 0x6db6
movl 0xc(%rsp), %esi
leaq 0xf289(%rip), %rdi      # 0x1604a
movb $0x0, %al
callq 0x6720
jmp 0x6dca
movq 0x10(%rsp), %rax
cmpq $0x0, 0x430(%rax)
je 0x6e5e
movq 0x10(%rsp), %rax
cmpl $0x0, 0x428(%rax)
jbe 0x6e5e
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl 0x428(%rcx), %eax
jae 0x6e48
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x10(%rsp), %rax
movq 0x430(%rax), %rax
movl 0xc(%rsp), %ecx
movq (%rax,%rcx,8), %rcx
callq 0x6490
movq 0x20(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x60c0
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x6df3
jmp 0x6e4a
movl 0xc(%rsp), %esi
leaq 0xf20a(%rip), %rdi      # 0x1605f
movb $0x0, %al
callq 0x6720
jmp 0x6e5e
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
leaq 0xf205(%rip), %rdx      # 0x16074
callq 0x68d0
movq %rax, (%rsp)
movq 0x18(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
movl $0x1, %eax
addq $0x28, %rsp
retq
nop