LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/jalalium[P]graph_algorithms_task/src_ranking/vector.c
// Function: push_back
void	push_back(t_vect *v, int val)
{
	size_t pos = v->used;
	size_t size = v->size;

	if (pos + 1 == size)
		extend_vector(v, val);
	v->tab[pos] = val;
	v->used++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
cmpq -0x20(%rbp), %rax
jne 0x2731
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x2620
movl -0xc(%rbp), %edx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/salextpuru[P]speccy-toochain/src/hex2bin/mot2bin.c
// Function: NoFailMalloc
void *NoFailMalloc (size_t size)
{
void *result;

	if ((result = malloc (size)) == NULL)
	{
		fprintf (stderr,"Can't allocate memory.\n");
		exit(1);
	}
	return (result);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x10d0
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
jne 0x12c0
movq 0x3d3b(%rip), %rax      # 0x4fe0
movq (%rax), %rdi
leaq 0x1fb7(%rip), %rsi      # 0x3266
movb $0x0, %al
callq 0x10f0
movl $0x1, %edi
callq 0x10c0
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/salextpuru[P]speccy-toochain/src/hex2bin/mot2bin.c
// Function: NoFailOpenInputFile
void NoFailOpenInputFile (char *Flnm)
{
    while ((Filin = fopen(Flnm,"r")) == NULL)
    {
        fprintf (stderr,"Input file %s cannot be opened. Enter new filename: ",Flnm);
        fgets (Flnm,MAX_FILE_NAME_SIZE,stdin);
        if (Flnm[0] == '\0') exit(1);
    }

#ifdef USE_FILE_BUFFERS
    FilinBuf = (char *) NoFailMalloc (BUFFSZ);
    setvbuf(Filin, FilinBuf, _IOFBF, BUFFSZ);
#endif
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
leaq 0x1f9e(%rip), %rsi      # 0x327e
callq 0x10a0
movq %rax, 0x3de4(%rip)      # 0x50d0
cmpq $0x0, %rax
jne 0x133e
movq 0x3ce7(%rip), %rax      # 0x4fe0
movq (%rax), %rdi
movq (%rsp), %rdx
leaq 0x1f79(%rip), %rsi      # 0x3280
movb $0x0, %al
callq 0x10f0
movq (%rsp), %rdi
movq 0x3cbf(%rip), %rax      # 0x4fd8
movq (%rax), %rdx
movl $0x51, %esi
callq 0x1120
movq (%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x133c
movl $0x1, %edi
callq 0x10c0
jmp 0x12d5
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O0/salextpuru[P]speccy-toochain/src/hex2bin/mot2bin.c
// Function: NoFailOpenOutputFile
void NoFailOpenOutputFile (char *Flnm)
{
    while ((Filout = fopen(Flnm,"wb")) == NULL)
    {
        /* Failure to open the output file may be
        simply due to an insufficiant permission setting. */

        fprintf(stderr,"Output file %s cannot be opened. Enter new file name: ", Flnm);
        fgets(Flnm,MAX_FILE_NAME_SIZE,stdin);
        if (Flnm[0] == '\0') exit(1);
    }
#ifdef USE_FILE_BUFFERS
    FiloutBuf = (char *) NoFailMalloc (BUFFSZ);
    setvbuf(Filout, FiloutBuf, _IOFBF, BUFFSZ);
#endif

}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
leaq 0x1f65(%rip), %rsi      # 0x32b5
callq 0x10a0
movq %rax, 0x3d7c(%rip)      # 0x50d8
cmpq $0x0, %rax
jne 0x13ae
movq 0x3c77(%rip), %rax      # 0x4fe0
movq (%rax), %rdi
movq (%rsp), %rdx
leaq 0x1f41(%rip), %rsi      # 0x32b8
movb $0x0, %al
callq 0x10f0
movq (%rsp), %rdi
movq 0x3c4f(%rip), %rax      # 0x4fd8
movq (%rax), %rdx
movl $0x51, %esi
callq 0x1120
movq (%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x13ac
movl $0x1, %edi
callq 0x10c0
jmp 0x1345
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O0/salextpuru[P]speccy-toochain/src/hex2bin/mot2bin.c
// Function: PutExtension
void PutExtension(char *Flnm, char *Extension)
{
char        *Period;        /* location of period in file name */
boolean     Samename;

    /* This assumes DOS like file names */
    /* Don't use strchr(): consider the following filename:
    	../my.dir/file.hex
    */
    if ((Period = strrchr(Flnm,'.')) != NULL)
        *(Period) = '\0';

    Samename = FALSE;
    if (strcmp(Extension, Period+1)== 0)
        Samename = TRUE;

    strcat(Flnm,".");
    strcat(Flnm, Extension);
    if (Samename)
    {
        fprintf (stderr,"Input and output filenames (%s) are the same.", Flnm);
        exit(1);
    }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movl $0x2e, %esi
callq 0x1090
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x13e0
movq 0x10(%rsp), %rax
movb $0x0, (%rax)
movl $0x0, 0xc(%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
addq $0x1, %rsi
callq 0x10e0
cmpl $0x0, %eax
jne 0x1408
movl $0x1, 0xc(%rsp)
movq 0x20(%rsp), %rdi
leaq 0x1f07(%rip), %rsi      # 0x331b
callq 0x1130
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x1130
cmpl $0x0, 0xc(%rsp)
je 0x1456
movq 0x3baa(%rip), %rax      # 0x4fe0
movq (%rax), %rdi
movq 0x20(%rsp), %rdx
leaq 0x1eaa(%rip), %rsi      # 0x32ef
movb $0x0, %al
callq 0x10f0
movl $0x1, %edi
callq 0x10c0
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zpole[P]IICV/src/test_sqrti.c
// Function: main
int
main (int argc VL_UNUSED, char** argv VL_UNUSED)
{
  vl_index i ;
  for (i = 0 ; i < 0xff ; ++i) {
    vl_uint8 x = (vl_uint8)i ;
    vl_uint8 r = vl_fast_sqrt_ui8(x) ;
    vl_uint8 r_ = (vl_uint8) floor(sqrt((double)x)) ;
    if (r != r_) abort() ;
    /* printf("sqrt(%5d) = %5d -- %5d\n", i, r, r_) ; */
  }

  for (i = 0 ; i < 0xffffffff ; ++i) {
    vl_uint16 x = (vl_uint16)i ;
    vl_uint16 r = vl_fast_sqrt_ui16(x) ;
    vl_uint16 r_ = (vl_uint8) floor(sqrt((double)x)) ;
    if (r != r_) abort() ;
    /* printf("sqrt(%5d) = %5d -- %5d\n", i, r, r_) ; */
  }

  return 0 ;
}

// Assembly:
subq $0x28, %rsp
movl $0x0, 0x24(%rsp)
movl %edi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
cmpq $0xff, 0x10(%rsp)
jge 0x11df
movb 0x10(%rsp), %al
movb %al, 0xf(%rsp)
movzbl 0xf(%rsp), %edi
callq 0x1260
movb %al, 0xe(%rsp)
movzbl 0xf(%rsp), %eax
cvtsi2sd %eax, %xmm0
callq 0x1050
callq 0x1040
cvttsd2si %xmm0, %eax
movb %al, 0xd(%rsp)
movzbl 0xe(%rsp), %eax
movzbl 0xd(%rsp), %ecx
cmpl %ecx, %eax
je 0x11cd
callq 0x1030
jmp 0x11cf
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x117e
movq $0x0, 0x10(%rsp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rax, 0x10(%rsp)
jge 0x1251
movw 0x10(%rsp), %ax
movw %ax, 0xa(%rsp)
movzwl 0xa(%rsp), %edi
callq 0x12e0
movw %ax, 0x8(%rsp)
movzwl 0xa(%rsp), %eax
cvtsi2sd %eax, %xmm0
callq 0x1050
callq 0x1040
cvttsd2si %xmm0, %eax
movzbl %al, %eax
movw %ax, 0x6(%rsp)
movzwl 0x8(%rsp), %eax
movzwl 0x6(%rsp), %ecx
cmpl %ecx, %eax
je 0x123f
callq 0x1030
jmp 0x1241
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x11e8
xorl %eax, %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/lunarkeyakv2/compact/KeccakP-1600-compact64.c
// Function: KeccakP1600_AddBytesInLane
void KeccakP1600_AddBytesInLane(void *argState, unsigned int lanePosition, const unsigned char *data, unsigned int offset, unsigned int length)
{
    unsigned int i;
    #if (PLATFORM_BYTE_ORDER == IS_LITTLE_ENDIAN)
    unsigned char * state = (unsigned char*)argState + lanePosition * sizeof(tKeccakLane) + offset;
    for(i=0; i<length; i++)
        ((unsigned char *)state)[i] ^= data[i];
    #else
    tKeccakLane lane = 0;
    for(i=0; i<length; i++)
        lane |= ((tKeccakLane)data[i]) << ((i+offset)*8);
    ((tKeccakLane*)argState)[lanePosition] ^= lane;
    #endif
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movq %rdx, -0x18(%rsp)
movl %ecx, -0x1c(%rsp)
movl %r8d, -0x20(%rsp)
movq -0x8(%rsp), %rax
movl -0xc(%rsp), %ecx
shlq $0x3, %rcx
addq %rcx, %rax
movl -0x1c(%rsp), %ecx
addq %rcx, %rax
movq %rax, -0x30(%rsp)
movl $0x0, -0x24(%rsp)
movl -0x24(%rsp), %eax
cmpl -0x20(%rsp), %eax
jae 0x5891
movq -0x18(%rsp), %rax
movl -0x24(%rsp), %ecx
movzbl (%rax,%rcx), %esi
movq -0x30(%rsp), %rax
movl -0x24(%rsp), %ecx
movzbl (%rax,%rcx), %edx
xorl %esi, %edx
movb %dl, (%rax,%rcx)
movl -0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rsp)
jmp 0x585b
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/lunarkeyakv2/compact/KeccakP-1600-compact64.c
// Function: KeccakP1600_AddLanes
void KeccakP1600_AddLanes(void *state, const unsigned char *data, unsigned int laneCount)
{
#if (PLATFORM_BYTE_ORDER == IS_LITTLE_ENDIAN)
    tSmallUInt i;
    laneCount *= sizeof(tKeccakLane);
    for( i = 0; i < laneCount; ++i) {
        ((unsigned char*)state)[i] ^= data[i];
    }
#else
    tSmallUInt i;
    const UINT8 *curData = data;
    for(i=0; i<laneCount; i++, curData+=8) {
        tKeccakLane lane = (tKeccakLane)curData[0]
            | ((tKeccakLane)curData[1] << 8)
            | ((tKeccakLane)curData[2] << 16)
            | ((tKeccakLane)curData[3] << 24)
            | ((tKeccakLane)curData[4] << 32)
            | ((tKeccakLane)curData[5] << 40)
            | ((tKeccakLane)curData[6] << 48)
            | ((tKeccakLane)curData[7] << 56);
        ((tKeccakLane*)state)[i] ^= lane;
    }
#endif
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl %edx, -0x14(%rsp)
movl -0x14(%rsp), %eax
shlq $0x3, %rax
movl %eax, -0x14(%rsp)
movl $0x0, -0x18(%rsp)
movl -0x18(%rsp), %eax
cmpl -0x14(%rsp), %eax
jae 0x58f8
movq -0x10(%rsp), %rax
movl -0x18(%rsp), %ecx
movzbl (%rax,%rcx), %esi
movq -0x8(%rsp), %rax
movl -0x18(%rsp), %ecx
movzbl (%rax,%rcx), %edx
xorl %esi, %edx
movb %dl, (%rax,%rcx)
movl -0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rsp)
jmp 0x58c2
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/lunarkeyakv2/compact/KeccakP-1600-compact64.c
// Function: KeccakF1600_GetNextRoundConstant
static tKeccakLane KeccakF1600_GetNextRoundConstant( UINT8 *LFSR )
{
    tSmallUInt i;
    tKeccakLane    roundConstant;
    tSmallUInt doXOR;
    tSmallUInt tempLSFR;

    roundConstant = 0;
    tempLSFR = *LFSR;
    for(i=1; i<128; i <<= 1)
    {
        doXOR = tempLSFR & 1;
        if ((tempLSFR & 0x80) != 0)
            /* Primitive polynomial over GF(2): x^8+x^6+x^5+x^4+1 */
            tempLSFR = (tempLSFR << 1) ^ 0x71;
        else
            tempLSFR <<= 1;

        if ( doXOR != 0 )
            roundConstant ^= (tKeccakLane)1ULL << (i - 1);
    }
    *LFSR = (UINT8)tempLSFR;
    return ( roundConstant );
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq $0x0, -0x18(%rsp)
movq -0x8(%rsp), %rax
movzbl (%rax), %eax
movl %eax, -0x20(%rsp)
movl $0x1, -0xc(%rsp)
cmpl $0x80, -0xc(%rsp)
jae 0x6020
movl -0x20(%rsp), %eax
andl $0x1, %eax
movl %eax, -0x1c(%rsp)
movl -0x20(%rsp), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0x5fe4
movl -0x20(%rsp), %eax
shll %eax
xorl $0x71, %eax
movl %eax, -0x20(%rsp)
jmp 0x5fee
movl -0x20(%rsp), %eax
shll %eax
movl %eax, -0x20(%rsp)
cmpl $0x0, -0x1c(%rsp)
je 0x6012
movl -0xc(%rsp), %eax
subl $0x1, %eax
movl %eax, %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
xorq -0x18(%rsp), %rax
movq %rax, -0x18(%rsp)
jmp 0x6014
movl -0xc(%rsp), %eax
shll %eax
movl %eax, -0xc(%rsp)
jmp 0x5fb2
movl -0x20(%rsp), %eax
movb %al, %cl
movq -0x8(%rsp), %rax
movb %cl, (%rax)
movq -0x18(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/lunarkeyakv2/compact/KeccakP-1600-compact64.c
// Function: KeccakP1600_ExtractAndAddBytesInLane
void KeccakP1600_ExtractAndAddBytesInLane(const void *state, unsigned int lanePosition, const unsigned char *input, unsigned char *output, unsigned int offset, unsigned int length)
{
    tSmallUInt i;
    tKeccakLane lane = ((tKeccakLane*)state)[lanePosition];
    lane >>= offset*8;
    for(i=0; i<length; i++) {
        output[i] = input[i] ^ (lane & 0xFF);
        lane >>= 8;
    }
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movq %rdx, -0x18(%rsp)
movq %rcx, -0x20(%rsp)
movl %r8d, -0x24(%rsp)
movl %r9d, -0x28(%rsp)
movq -0x8(%rsp), %rax
movl -0xc(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x38(%rsp)
movl -0x24(%rsp), %ecx
shll $0x3, %ecx
movq -0x38(%rsp), %rax
movl %ecx, %ecx
shrq %cl, %rax
movq %rax, -0x38(%rsp)
movl $0x0, -0x2c(%rsp)
movl -0x2c(%rsp), %eax
cmpl -0x28(%rsp), %eax
jae 0x62bc
movq -0x18(%rsp), %rax
movl -0x2c(%rsp), %ecx
movzbl (%rax,%rcx), %eax
movq -0x38(%rsp), %rcx
andq $0xff, %rcx
xorq %rcx, %rax
movb %al, %dl
movq -0x20(%rsp), %rax
movl -0x2c(%rsp), %ecx
movb %dl, (%rax,%rcx)
movq -0x38(%rsp), %rax
shrq $0x8, %rax
movq %rax, -0x38(%rsp)
movl -0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rsp)
jmp 0x626d
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/lunarkeyakv2/compact/KeccakP-200-compact.c
// Function: KeccakP200_AddBytes
void KeccakP200_AddBytes(void *argState, const unsigned char *data, unsigned int offset, unsigned int length)
{
    tSmallUInt i;
    tKeccakLane * state = (tKeccakLane*)argState + offset;
    for(i=0; i<length; i++)
        state[i] ^= data[i];
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl %edx, -0x14(%rsp)
movl %ecx, -0x18(%rsp)
movq -0x8(%rsp), %rax
movl -0x14(%rsp), %ecx
addq %rcx, %rax
movq %rax, -0x28(%rsp)
movl $0x0, -0x1c(%rsp)
movl -0x1c(%rsp), %eax
cmpl -0x18(%rsp), %eax
jae 0x73d1
movq -0x10(%rsp), %rax
movl -0x1c(%rsp), %ecx
movzbl (%rax,%rcx), %esi
movq -0x28(%rsp), %rax
movl -0x1c(%rsp), %ecx
movzbl (%rax,%rcx), %edx
xorl %esi, %edx
movb %dl, (%rax,%rcx)
movl -0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rsp)
jmp 0x739b
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/lunarkeyakv2/compact/KeccakP-200-compact.c
// Function: KeccakP200_ExtractAndAddBytes
void KeccakP200_ExtractAndAddBytes(const void *argState, const unsigned char *input, unsigned char *output, unsigned int offset, unsigned int length)
{
    unsigned int i;
    tKeccakLane * state = (tKeccakLane*)argState + offset;
    for(i=0; i<length; i++)
        output[i] = input[i] ^ state[i];
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movl %ecx, -0x1c(%rsp)
movl %r8d, -0x20(%rsp)
movq -0x8(%rsp), %rax
movl -0x1c(%rsp), %ecx
addq %rcx, %rax
movq %rax, -0x30(%rsp)
movl $0x0, -0x24(%rsp)
movl -0x24(%rsp), %eax
cmpl -0x20(%rsp), %eax
jae 0x7882
movq -0x10(%rsp), %rax
movl -0x24(%rsp), %ecx
movzbl (%rax,%rcx), %eax
movq -0x30(%rsp), %rcx
movl -0x24(%rsp), %edx
movzbl (%rcx,%rdx), %ecx
xorl %ecx, %eax
movb %al, %dl
movq -0x18(%rsp), %rax
movl -0x24(%rsp), %ecx
movb %dl, (%rax,%rcx)
movl -0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rsp)
jmp 0x7841
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/lunarkeyakv2/compact/KeccakP-800-compact.c
// Function: KeccakP800_AddBytes
void KeccakP800_AddBytes(void *argState, const unsigned char *data, unsigned int offset, unsigned int length)
{
    tSmallUInt i;
    unsigned char * state = (unsigned char*)argState + offset;

    for(i=0; i<length; i++)
        ((unsigned char *)state)[i] ^= data[i];
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl %edx, -0x14(%rsp)
movl %ecx, -0x18(%rsp)
movq -0x8(%rsp), %rax
movl -0x14(%rsp), %ecx
addq %rcx, %rax
movq %rax, -0x28(%rsp)
movl $0x0, -0x1c(%rsp)
movl -0x1c(%rsp), %eax
cmpl -0x18(%rsp), %eax
jae 0x8651
movq -0x10(%rsp), %rax
movl -0x1c(%rsp), %ecx
movzbl (%rax,%rcx), %esi
movq -0x28(%rsp), %rax
movl -0x1c(%rsp), %ecx
movzbl (%rax,%rcx), %edx
xorl %esi, %edx
movb %dl, (%rax,%rcx)
movl -0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rsp)
jmp 0x861b
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/lunarkeyakv2/compact/KeccakP-800-compact.c
// Function: KeccakP800_ExtractAndAddBytes
void KeccakP800_ExtractAndAddBytes(const void *argState, const unsigned char *input, unsigned char *output, unsigned int offset, unsigned int length)
{
    tSmallUInt i;
    const unsigned char * state = (const unsigned char*)argState + offset;

    for(i=0; i<length; i++)
        output[i] = input[i] ^ state[i];
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movl %ecx, -0x1c(%rsp)
movl %r8d, -0x20(%rsp)
movq -0x8(%rsp), %rax
movl -0x1c(%rsp), %ecx
addq %rcx, %rax
movq %rax, -0x30(%rsp)
movl $0x0, -0x24(%rsp)
movl -0x24(%rsp), %eax
cmpl -0x20(%rsp), %eax
jae 0x8bb2
movq -0x10(%rsp), %rax
movl -0x24(%rsp), %ecx
movzbl (%rax,%rcx), %eax
movq -0x30(%rsp), %rcx
movl -0x24(%rsp), %edx
movzbl (%rcx,%rdx), %ecx
xorl %ecx, %eax
movb %al, %dl
movq -0x18(%rsp), %rax
movl -0x24(%rsp), %ecx
movb %dl, (%rax,%rcx)
movl -0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rsp)
jmp 0x8b71
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/lunarkeyakv2/compact/encrypt.c
// Function: crypto_aead_encrypt
int crypto_aead_encrypt(
    unsigned char *c,unsigned long long *clen,
    const unsigned char *m,unsigned long long mlen,
    const unsigned char *ad,unsigned long long adlen,
    const unsigned char *nsec,
    const unsigned char *npub,
    const unsigned char *k
    )
{
    LunarKeyak_Instance instance;

    LunarKeyak_Initialize( &instance, k, 16, npub, 150, 0, 0, 0, 0 );
    LunarKeyak_Wrap( &instance, m, c, (size_t)mlen, ad, (size_t)adlen, c+mlen, 0, 0 );
    *clen = mlen + 16;
    return 0;
}

// Assembly:
subq $0x6a8, %rsp            # imm = 0x6A8
movq 0x6c0(%rsp), %rax
movq 0x6b8(%rsp), %rax
movq 0x6b0(%rsp), %rax
movq %rdi, 0x6a0(%rsp)
movq %rsi, 0x698(%rsp)
movq %rdx, 0x690(%rsp)
movq %rcx, 0x688(%rsp)
movq %r8, 0x680(%rsp)
movq %r9, 0x678(%rsp)
movq 0x6c0(%rsp), %rsi
movq 0x6b8(%rsp), %rcx
leaq 0x20(%rsp), %rdi
movl $0x10, %edx
movl $0x96, %r8d
xorl %r9d, %r9d
xorl %eax, %eax
movq $0x0, (%rsp)
movl $0x0, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
callq 0x5210
movq 0x690(%rsp), %rsi
movq 0x6a0(%rsp), %rdx
movq 0x688(%rsp), %rcx
movq 0x680(%rsp), %r8
movq 0x678(%rsp), %r9
movq 0x6a0(%rsp), %rax
addq 0x688(%rsp), %rax
leaq 0x20(%rsp), %rdi
xorl %r10d, %r10d
movq %rax, (%rsp)
movl $0x0, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
callq 0x5510
movq 0x688(%rsp), %rcx
addq $0x10, %rcx
movq 0x698(%rsp), %rax
movq %rcx, (%rax)
xorl %eax, %eax
addq $0x6a8, %rsp            # imm = 0x6A8
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/lunarkeyakv2/compact/encrypt.c
// Function: crypto_aead_decrypt
int crypto_aead_decrypt(
    unsigned char *m,unsigned long long *mlen,
    unsigned char *nsec,
    const unsigned char *c,unsigned long long clen,
    const unsigned char *ad,unsigned long long adlen,
    const unsigned char *npub,
    const unsigned char *k
    )
{
    LunarKeyak_Instance instance;
    unsigned long long mlen_;

    if (clen < 16)
        return -1;
    LunarKeyak_Initialize( &instance, k, 16, npub, 150, 0, 0, 1, 0 );
    mlen_ = clen - 16;
    *mlen = mlen_;
    if ( LunarKeyak_Wrap( &instance, c, m, (size_t)mlen_, ad, (size_t)adlen, (unsigned char*)c+mlen_, 1, 0 ) == 1 )
        return 0;
    return -1;
}

// Assembly:
subq $0x6b8, %rsp            # imm = 0x6B8
movq 0x6d0(%rsp), %rax
movq 0x6c8(%rsp), %rax
movq 0x6c0(%rsp), %rax
movq %rdi, 0x6a8(%rsp)
movq %rsi, 0x6a0(%rsp)
movq %rdx, 0x698(%rsp)
movq %rcx, 0x690(%rsp)
movq %r8, 0x688(%rsp)
movq %r9, 0x680(%rsp)
cmpq $0x10, 0x688(%rsp)
jae 0x1423a
movl $0xffffffff, 0x6b4(%rsp) # imm = 0xFFFFFFFF
jmp 0x1430d
movq 0x6d0(%rsp), %rsi
movq 0x6c8(%rsp), %rcx
leaq 0x28(%rsp), %rdi
movl $0x10, %edx
movl $0x96, %r8d
xorl %r9d, %r9d
xorl %eax, %eax
movq $0x0, (%rsp)
movl $0x1, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
callq 0x5210
movq 0x688(%rsp), %rax
subq $0x10, %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rcx
movq 0x6a0(%rsp), %rax
movq %rcx, (%rax)
movq 0x690(%rsp), %rsi
movq 0x6a8(%rsp), %rdx
movq 0x20(%rsp), %rcx
movq 0x680(%rsp), %r8
movq 0x6c0(%rsp), %r9
movq 0x690(%rsp), %rax
addq 0x20(%rsp), %rax
leaq 0x28(%rsp), %rdi
xorl %r10d, %r10d
movq %rax, (%rsp)
movl $0x1, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
callq 0x5510
cmpl $0x1, %eax
jne 0x14302
movl $0x0, 0x6b4(%rsp)
jmp 0x1430d
movl $0xffffffff, 0x6b4(%rsp) # imm = 0xFFFFFFFF
movl 0x6b4(%rsp), %eax
addq $0x6b8, %rsp            # imm = 0x6B8
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]spiped/tests/valgrind/potential-memleaks.c
// Function: main
int
main(int argc, char * argv[])
{
	int i;

	if (argc == 2) {
		/* Run the relevant function. */
		for (i = 0; i < num_tests; i++) {
			if ((strcmp(argv[1], tests[i].name)) == 0) {
				tests[i].func();
				goto success;
			}
		}

		/* We didn't find the desired function name. */
		goto err0;
	} else {
		/* Print test names. */
		for (i = 0; i < num_tests; i++)
			printf("%s\n", tests[i].name);
	}

success:
	/* Success! */
	exit(0);

err0:
	/* Failure! */
	exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x2, -0x8(%rbp)
jne 0x1279
movl $0x0, -0x14(%rbp)
cmpl $0x7, -0x14(%rbp)
jge 0x1277
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movslq -0x14(%rbp), %rcx
leaq 0x2b24(%rip), %rax      # 0x3d60
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rsi
callq 0x10b0
cmpl $0x0, %eax
jne 0x126a
movslq -0x14(%rbp), %rcx
leaq 0x2b05(%rip), %rax      # 0x3d60
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
callq *%rax
jmp 0x12b8
jmp 0x126c
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1223
jmp 0x12bf
movl $0x0, -0x14(%rbp)
cmpl $0x7, -0x14(%rbp)
jge 0x12b4
movslq -0x14(%rbp), %rcx
leaq 0x2acf(%rip), %rax      # 0x3d60
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rsi
leaq 0xd62(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1040
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1280
jmp 0x12b6
jmp 0x12b8
xorl %edi, %edi
callq 0x1060
movl $0x1, %edi
callq 0x1060
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]spiped/tests/valgrind/potential-memleaks.c
// Function: pl_freebsd_strlen
static void
pl_freebsd_strlen(void)
{
	/* More than 8 bytes, and not a multiple of 8. */
	char problem[] = {1, 2, 3, 4, 5, 6, 7, 8, 0};

	/* Play games to avoid the compiler optimizing away strlen(). */
	size_t (* const volatile strlen_func)(const char *) = strlen;
	volatile size_t len = strlen_func(problem);
	(void)len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq 0xdd7(%rip), %rax       # 0x20c6
movq %rax, -0x9(%rbp)
movb 0xdd5(%rip), %al        # 0x20ce
movb %al, -0x1(%rbp)
movq 0x2ccd(%rip), %rax      # 0x3fd0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
leaq -0x9(%rbp), %rdi
callq *%rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]spiped/tests/valgrind/potential-memleaks.c
// Function: pl_freebsd_pthread_nothing
static void
pl_freebsd_pthread_nothing(void)
{
	pthread_t thr;
	int rc;

	if ((rc = pthread_create(&thr, NULL, pl_workthread_nothing, NULL)))
		fprintf(stderr, "pthread_create: %s", strerror(rc));
	if ((rc = pthread_join(thr, NULL)))
		fprintf(stderr, "pthread_join: %s", strerror(rc));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %ecx
leaq 0x1c9(%rip), %rdx       # 0x1540
movq %rcx, %rsi
callq 0x1080
movl %eax, -0xc(%rbp)
cmpl $0x0, %eax
je 0x13b2
movq 0x2c5a(%rip), %rax      # 0x3fe8
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %edi
callq 0x10a0
movq -0x18(%rbp), %rdi
movq %rax, %rdx
leaq 0xd29(%rip), %rsi       # 0x20d4
movb $0x0, %al
callq 0x10e0
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1030
movl %eax, -0xc(%rbp)
cmpl $0x0, %eax
je 0x13f2
movq 0x2c1a(%rip), %rax      # 0x3fe8
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %edi
callq 0x10a0
movq -0x20(%rbp), %rdi
movq %rax, %rdx
leaq 0xcfc(%rip), %rsi       # 0x20e7
movb $0x0, %al
callq 0x10e0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]spiped/tests/valgrind/potential-memleaks.c
// Function: pl_freebsd_pthread_strerror_localtime
static void
pl_freebsd_pthread_strerror_localtime(void)
{
	pthread_t thr;
	int rc;

	if ((rc = pthread_create(&thr, NULL,
	    pl_workthread_strerror_localtime, NULL)))
		fprintf(stderr, "pthread_create: %s", strerror(rc));
	if ((rc = pthread_join(thr, NULL)))
		fprintf(stderr, "pthread_join: %s", strerror(rc));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %ecx
leaq 0x139(%rip), %rdx       # 0x1550
movq %rcx, %rsi
callq 0x1080
movl %eax, -0xc(%rbp)
cmpl $0x0, %eax
je 0x1452
movq 0x2bba(%rip), %rax      # 0x3fe8
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %edi
callq 0x10a0
movq -0x18(%rbp), %rdi
movq %rax, %rdx
leaq 0xc89(%rip), %rsi       # 0x20d4
movb $0x0, %al
callq 0x10e0
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1030
movl %eax, -0xc(%rbp)
cmpl $0x0, %eax
je 0x1492
movq 0x2b7a(%rip), %rax      # 0x3fe8
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %edi
callq 0x10a0
movq -0x20(%rbp), %rdi
movq %rax, %rdx
leaq 0xc5c(%rip), %rsi       # 0x20e7
movb $0x0, %al
callq 0x10e0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]spiped/tests/valgrind/potential-memleaks.c
// Function: pl_freebsd_pthread_getaddrinfo
static void
pl_freebsd_pthread_getaddrinfo(void)
{
	pthread_t thr;
	int rc;

	if ((rc = pthread_create(&thr, NULL,
	    pl_workthread_getaddrinfo, NULL)))
		fprintf(stderr, "pthread_create: %s", strerror(rc));
	if ((rc = pthread_join(thr, NULL)))
		fprintf(stderr, "pthread_join: %s", strerror(rc));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %ecx
leaq 0xd9(%rip), %rdx        # 0x1590
movq %rcx, %rsi
callq 0x1080
movl %eax, -0xc(%rbp)
cmpl $0x0, %eax
je 0x14f2
movq 0x2b1a(%rip), %rax      # 0x3fe8
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %edi
callq 0x10a0
movq -0x18(%rbp), %rdi
movq %rax, %rdx
leaq 0xbe9(%rip), %rsi       # 0x20d4
movb $0x0, %al
callq 0x10e0
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1030
movl %eax, -0xc(%rbp)
cmpl $0x0, %eax
je 0x1532
movq 0x2ada(%rip), %rax      # 0x3fe8
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %edi
callq 0x10a0
movq -0x20(%rbp), %rdi
movq %rax, %rdx
leaq 0xbbc(%rip), %rsi       # 0x20e7
movb $0x0, %al
callq 0x10e0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]spiped/tests/valgrind/potential-memleaks.c
// Function: pl_workthread_strerror_localtime
static void *
pl_workthread_strerror_localtime(void * cookie)
{
	char * str = strerror(1);
	time_t now;
	struct tm tm;

	(void)cookie; /* UNUSED */
	(void)str; /* UNUSED */

	time(&now);
	localtime_r(&now, &tm);

	return (NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl $0x1, %edi
callq 0x10a0
movq %rax, -0x10(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x10f0
leaq -0x18(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x10c0
xorl %eax, %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]spiped/tests/valgrind/potential-memleaks.c
// Function: pl_getaddrinfo
static void
pl_getaddrinfo(const char * addr)
{
	struct addrinfo hints;
	struct addrinfo * res;
	const char * ports = "80";
	int error;

	/* Create hints structure. */
	memset(&hints, 0, sizeof(hints));
	hints.ai_family = AF_UNSPEC;
	hints.ai_socktype = SOCK_STREAM;
	hints.ai_protocol = IPPROTO_TCP;

	/* Perform DNS lookup. */
	if ((error = getaddrinfo(addr, ports, &hints, &res)) != 0) {
		/* Only print an error if we're online. */
		if (error != EAI_AGAIN) {
			fprintf(stderr, "Error looking up %s: %s", addr,
			    gai_strerror(error));
		}
		return;
	}

	/* Clean up. */
	freeaddrinfo(res);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
leaq 0xb3f(%rip), %rax       # 0x2102
movq %rax, -0x48(%rbp)
leaq -0x38(%rbp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x1050
movl $0x0, -0x34(%rbp)
movl $0x1, -0x30(%rbp)
movl $0x6, -0x2c(%rbp)
movq -0x8(%rbp), %rdi
movq -0x48(%rbp), %rsi
leaq -0x38(%rbp), %rdx
leaq -0x40(%rbp), %rcx
callq 0x1070
movl %eax, -0x4c(%rbp)
cmpl $0x0, %eax
je 0x1648
cmpl $-0x3, -0x4c(%rbp)
je 0x1646
movq 0x29d2(%rip), %rax      # 0x3fe8
movq (%rax), %rax
movq %rax, -0x60(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movl -0x4c(%rbp), %edi
callq 0x10d0
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rdx
movq %rax, %rcx
leaq 0xac6(%rip), %rsi       # 0x2105
movb $0x0, %al
callq 0x10e0
jmp 0x1651
movq -0x40(%rbp), %rdi
callq 0x1090
addq $0x60, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/antonblanchard[P]will-it-scale/tests/pthread_mutex4.c
// Function: testcase
void testcase(unsigned long long *iterations, unsigned long nr)
{
	// alloca() because plain "unsigned long val" gets optimized away.
	unsigned long *val = alloca(sizeof(unsigned long));
	*(val) = 0;

	while (1) {
		pthread_mutex_lock(&mutex);
		(*val)++;
		pthread_mutex_unlock(&mutex);

		(*iterations)++;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
leaq 0xb156(%rip), %rdi      # 0xd1a0
callq 0x1280
movq -0x18(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
leaq 0xb13c(%rip), %rdi      # 0xd1a0
callq 0x11a0
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x2043
// File: /workspace/github_c_makefile_star2_O0/unixlab[P]cloudflare-udp-ping/./stddev.h
// Function: stddev_add
static inline void stddev_add(struct stddev *sd, int value)
{
	sd->count++;
	sd->sum += value;
	sd->sum_sq += value * value;
	if (value < sd->min) {
		sd->min = value;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x18(%rax)
movslq -0xc(%rbp), %rcx
movq -0x8(%rbp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movl -0xc(%rbp), %eax
imull -0xc(%rbp), %eax
movslq %eax, %rcx
movq -0x8(%rbp), %rax
addq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x401d25
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/unixlab[P]cloudflare-udp-ping/./stddev.h
// Function: stddev_get
static inline void stddev_get(struct stddev *sd, uint64_t *counter_ptr,
			      double *avg_ptr, double *stddev_ptr)
{
	double avg = 0.0, dev = 0.0;
	double sum = (double)sd->sum, sum_sq = (double)sd->sum_sq,
	       count = (double)sd->count;

	if (avg_ptr) {
		if (sd->count != 0) {
			avg = sum / count;
		}
	}

	if (stddev_ptr) {
		if (sd->count > 2) {
			double variance =
				(sum_sq - (sum * (sum / count))) / count;
			dev = sqrt(fabs(variance));
		}
	}
	if (counter_ptr) {
		*counter_ptr = sd->count;
	}
	if (avg_ptr) {
		*avg_ptr = avg;
	}
	if (stddev_ptr) {
		*stddev_ptr = dev;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x8(%rbp), %rax
cvtsi2sdq 0x8(%rax), %xmm0
movsd %xmm0, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %xmm0
movaps 0xb2e39(%rip), %xmm2    # 0x4b5060
punpckldq %xmm2, %xmm0    # xmm0 = xmm0[0],xmm2[0],xmm0[1],xmm2[1]
movapd 0xb2e3d(%rip), %xmm1    # 0x4b5070
subpd %xmm1, %xmm0
movaps %xmm0, %xmm3
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm3, %xmm0
movsd %xmm0, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %xmm0
punpckldq %xmm2, %xmm0    # xmm0 = xmm0[0],xmm2[0],xmm0[1],xmm2[1]
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd %xmm0, -0x48(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x40228b
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x402289
movsd -0x38(%rbp), %xmm0
divsd -0x48(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
jmp 0x40228b
cmpq $0x0, -0x20(%rbp)
je 0x4022f6
movq -0x8(%rbp), %rax
cmpq $0x2, 0x18(%rax)
jbe 0x4022f4
movsd -0x40(%rbp), %xmm1
movsd -0x38(%rbp), %xmm0
movsd -0x38(%rbp), %xmm2
divsd -0x48(%rbp), %xmm2
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
divsd -0x48(%rbp), %xmm0
movsd %xmm0, -0x50(%rbp)
movsd -0x50(%rbp), %xmm0
movaps 0xb2d9a(%rip), %xmm1    # 0x4b5080
pand %xmm1, %xmm0
callq 0x403a90
movsd %xmm0, -0x30(%rbp)
jmp 0x4022f6
cmpq $0x0, -0x10(%rbp)
je 0x40230c
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
cmpq $0x0, -0x18(%rbp)
je 0x402320
movsd -0x28(%rbp), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, (%rax)
cmpq $0x0, -0x20(%rbp)
je 0x402334
movsd -0x30(%rbp), %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, (%rax)
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/unixlab[P]cloudflare-udp-ping/./stddev.h
// Function: stddev_init
static inline struct stddev *stddev_init(struct stddev *sd)
{
	sd->min = INT_MAX;
	sd->sum = 0;
	sd->sum_sq = 0;
	sd->count = 0;
	return sd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x7fffffff, (%rax)     # imm = 0x7FFFFFFF
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/unixlab[P]cloudflare-udp-ping/net.c
// Function: str_quote
const char *str_quote(const char *s)
{
	static char buf[1024];
	int r = snprintf(buf, sizeof(buf), "\"%.*s\"", (int)sizeof(buf) - 4, s);
	if (r >= (int)sizeof(buf)) {
		buf[sizeof(buf) - 1] = 0;
	}
	return buf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %r8
leaq 0xe80d9(%rip), %rdi     # 0x4ea470
movl $0x400, %esi            # imm = 0x400
leaq 0xb2f0c(%rip), %rdx     # 0x4b52af
movl $0x3fc, %ecx            # imm = 0x3FC
movb $0x0, %al
callq 0x40e0a0
movl %eax, -0xc(%rbp)
cmpl $0x400, -0xc(%rbp)      # imm = 0x400
jl 0x4023c2
movb $0x0, 0xe84ad(%rip)     # 0x4ea86f
leaq 0xe80a7(%rip), %rax     # 0x4ea470
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/unixlab[P]cloudflare-udp-ping/net.c
// Function: net_set_buffer_size
void net_set_buffer_size(int cd, int max, int send)
{
	int i, flag;

	if (send) {
		flag = SO_SNDBUF;
	} else {
		flag = SO_RCVBUF;
	}

	int size = 0;

	for (i = 0; i < 10 && size; i++) {
		int bef;
		socklen_t size = sizeof(bef);
		if (getsockopt(cd, SOL_SOCKET, flag, &bef, &size) < 0) {
			PFATAL("getsockopt(SOL_SOCKET)");
			break;
		}
		if (bef >= max) {
			break;
		}

		size = bef * 2;
		if (setsockopt(cd, SOL_SOCKET, flag, &size, sizeof(size)) < 0) {
			// don't log error, just break
			break;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x4023f0
movl $0x7, -0x14(%rbp)
jmp 0x4023f7
movl $0x8, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x10(%rbp)
xorl %eax, %eax
cmpl $0xa, -0x10(%rbp)
movb %al, -0x21(%rbp)
jge 0x40241a
cmpl $0x0, -0x18(%rbp)
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x402426
jmp 0x402501
movl $0x4, -0x20(%rbp)
movl -0x4(%rbp), %edi
movl -0x14(%rbp), %edx
movl $0x1, %esi
leaq -0x1c(%rbp), %rcx
leaq -0x20(%rbp), %r8
callq 0x45fe80
cmpl $0x0, %eax
jge 0x4024be
jmp 0x40244c
movq $0x4e87a8, %rax         # imm = 0x4E87A8
movq (%rax), %rdi
leaq 0xb2e59(%rip), %rsi     # 0x4b52b6
movb $0x0, %al
callq 0x40df10
movq $0x4e87a8, %rax         # imm = 0x4E87A8
movq (%rax), %rdi
leaq 0xb2c56(%rip), %rsi     # 0x4b50cb
leaq 0xb2e64(%rip), %rdx     # 0x4b52e0
leaq 0xb2e71(%rip), %rcx     # 0x4b52f4
movl $0x2a, %r8d
movb $0x0, %al
callq 0x40df10
leaq 0xb2c66(%rip), %rdi     # 0x4b50fd
callq 0x40e2c0
movq $0x4e87a8, %rax         # imm = 0x4E87A8
movq (%rax), %rdi
leaq 0xb365d(%rip), %rsi     # 0x4b5b0a
movb $0x0, %al
callq 0x40df10
movl $0x1, %edi
callq 0x40ce70
movl -0x1c(%rbp), %eax
cmpl -0x8(%rbp), %eax
jl 0x4024c8
jmp 0x402501
movl -0x1c(%rbp), %eax
shll %eax
movl %eax, -0x20(%rbp)
movl -0x4(%rbp), %edi
movl -0x14(%rbp), %edx
movl $0x1, %esi
leaq -0x20(%rbp), %rcx
movl $0x4, %r8d
callq 0x460040
cmpl $0x0, %eax
jge 0x4024f1
jmp 0x402501
jmp 0x4024f3
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x402405
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/unixlab[P]cloudflare-udp-ping/net.c
// Function: parse_addr
void parse_addr(struct net_addr *netaddr, const char *addr)
{
	char *colon = strrchr(addr, ':');
	if (colon == NULL) {
		FATAL("You forgot to specify port");
	}
	int port = atoi(colon + 1);
	if (port < 0 || port > 65535) {
		FATAL("Invalid port number %d", port);
	}
	char host[255];
	int addr_len = colon - addr > 254 ? 254 : colon - addr;
	strncpy(host, addr, addr_len);
	host[addr_len] = '\0';
	net_gethostbyname(netaddr, host, port);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x3a, %esi
callq 0x401058
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x40258c
jmp 0x40253e
movq $0x4e87a8, %rax         # imm = 0x4E87A8
movq (%rax), %rdi
leaq 0xb2dab(%rip), %rsi     # 0x4b52fa
movb $0x0, %al
callq 0x40df10
movq $0x4e87a8, %rax         # imm = 0x4E87A8
movq (%rax), %rdi
leaq 0xb2c4f(%rip), %rsi     # 0x4b51b6
leaq 0xb2dbb(%rip), %rdx     # 0x4b5329
leaq 0xb2d7f(%rip), %rcx     # 0x4b52f4
movl $0x3d, %r8d
movb $0x0, %al
callq 0x40df10
movl $0x1, %edi
callq 0x40ce70
movq -0x18(%rbp), %rdi
addq $0x1, %rdi
callq 0x40c2f0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jl 0x4025ab
cmpl $0xffff, -0x1c(%rbp)    # imm = 0xFFFF
jle 0x4025fe
jmp 0x4025ad
movq $0x4e87a8, %rax         # imm = 0x4E87A8
movq (%rax), %rdi
movl -0x1c(%rbp), %edx
leaq 0xb2d73(%rip), %rsi     # 0x4b5334
movb $0x0, %al
callq 0x40df10
movq $0x4e87a8, %rax         # imm = 0x4E87A8
movq (%rax), %rdi
leaq 0xb2bdd(%rip), %rsi     # 0x4b51b6
leaq 0xb2d49(%rip), %rdx     # 0x4b5329
leaq 0xb2d0d(%rip), %rcx     # 0x4b52f4
movl $0x41, %r8d
movb $0x0, %al
callq 0x40df10
movl $0x1, %edi
callq 0x40ce70
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
cmpq $0xfe, %rax
jle 0x40261f
movl $0xfe, %eax
movq %rax, -0x130(%rbp)
jmp 0x402631
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x130(%rbp)
movq -0x130(%rbp), %rax
movl %eax, -0x124(%rbp)
leaq -0x120(%rbp), %rdi
movq -0x10(%rbp), %rsi
movslq -0x124(%rbp), %rdx
callq 0x401088
movslq -0x124(%rbp), %rax
movb $0x0, -0x120(%rbp,%rax)
movq -0x8(%rbp), %rdi
leaq -0x120(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x402680
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/unixlab[P]cloudflare-udp-ping/net.c
// Function: net_gethostbyname
void net_gethostbyname(struct net_addr *shost, const char *host, int port)
{
	memset(shost, 0, sizeof(struct net_addr));

	struct in_addr in_addr;
	struct in6_addr in6_addr;

	/* Try ipv4 address first */
	if (inet_pton(AF_INET, host, &in_addr) == 1) {
		goto got_ipv4;
	}

	/* Then ipv6 */
	if (inet_pton(AF_INET6, host, &in6_addr) == 1) {
		goto got_ipv6;
	}

	FATAL("inet_pton(%s)", str_quote(host));
	return;

got_ipv4:
	shost->ipver = 4;
	shost->sockaddr = (struct sockaddr *)&shost->sin4;
	shost->sockaddr_len = sizeof(shost->sin4);
	shost->sin4.sin_family = AF_INET;
	shost->sin4.sin_port = htons(port);
	shost->sin4.sin_addr = in_addr;
	return;

got_ipv6:
	shost->ipver = 6;
	shost->sockaddr = (struct sockaddr *)&shost->sin6;
	shost->sockaddr_len = sizeof(shost->sin4);
	shost->sin6.sin6_family = AF_INET6;
	shost->sin6.sin6_port = htons(port);
	shost->sin6.sin6_addr = in6_addr;
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0x4010a8
movq -0x10(%rbp), %rsi
movl $0x2, %edi
leaq -0x18(%rbp), %rdx
callq 0x460fb0
cmpl $0x1, %eax
jne 0x4026bf
jmp 0x40273f
movq -0x10(%rbp), %rsi
movl $0xa, %edi
leaq -0x28(%rbp), %rdx
callq 0x460fb0
cmpl $0x1, %eax
jne 0x4026db
jmp 0x402790
jmp 0x4026dd
movq $0x4e87a8, %rax         # imm = 0x4E87A8
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x402380
movq -0x30(%rbp), %rdi
movq %rax, %rdx
leaq 0xb2c5d(%rip), %rsi     # 0x4b535f
movb $0x0, %al
callq 0x40df10
movq $0x4e87a8, %rax         # imm = 0x4E87A8
movq (%rax), %rdi
leaq 0xb2a9c(%rip), %rsi     # 0x4b51b6
leaq 0xb2c60(%rip), %rdx     # 0x4b5381
leaq 0xb2bcc(%rip), %rcx     # 0x4b52f4
movl $0x5b, %r8d
movb $0x0, %al
callq 0x40df10
movl $0x1, %edi
callq 0x40ce70
movq -0x8(%rbp), %rax
movl $0x4, (%rax)
movq -0x8(%rbp), %rcx
addq $0x4, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x8(%rbp), %rax
movl $0x10, 0x38(%rax)
movq -0x8(%rbp), %rax
movw $0x2, 0x4(%rax)
movl -0x14(%rbp), %eax
movzwl %ax, %edi
callq 0x460460
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, 0x6(%rax)
movq -0x8(%rbp), %rax
movl -0x18(%rbp), %ecx
movl %ecx, 0x8(%rax)
jmp 0x4027e9
movq -0x8(%rbp), %rax
movl $0x6, (%rax)
movq -0x8(%rbp), %rcx
addq $0x14, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x8(%rbp), %rax
movl $0x10, 0x38(%rax)
movq -0x8(%rbp), %rax
movw $0xa, 0x14(%rax)
movl -0x14(%rbp), %eax
movzwl %ax, %edi
callq 0x460460
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, 0x16(%rax)
movq -0x8(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, 0x1c(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x24(%rax)
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/unixlab[P]cloudflare-udp-ping/net.c
// Function: addr_to_str
const char *addr_to_str(struct net_addr *addr)
{
	char dst[INET6_ADDRSTRLEN + 1];
	int port = 0;

	switch (addr->ipver) {
	case 4: {
		inet_ntop(AF_INET, &addr->sin4.sin_addr, dst, INET6_ADDRSTRLEN);
		port = ntohs(addr->sin4.sin_port);
	} break;
	case 16: {
		inet_ntop(AF_INET6, &addr->sin6.sin6_addr, dst,
			  INET6_ADDRSTRLEN);
		port = ntohs(addr->sin6.sin6_port);
	} break;
	default:
		dst[0] = '?';
		dst[1] = 0x00;
	}

	static char buf[255];
	snprintf(buf, sizeof(buf), "%s:%i", dst, port);
	return buf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x44(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x48(%rbp)
subl $0x4, %eax
je 0x40281d
jmp 0x402813
movl -0x48(%rbp), %eax
subl $0x10, %eax
je 0x402851
jmp 0x402885
movq -0x8(%rbp), %rsi
addq $0x4, %rsi
addq $0x4, %rsi
leaq -0x40(%rbp), %rdx
movl $0x2, %edi
movl $0x2e, %ecx
callq 0x460470
movq -0x8(%rbp), %rax
movzwl 0x6(%rax), %edi
callq 0x460460
movzwl %ax, %eax
movl %eax, -0x44(%rbp)
jmp 0x40288d
movq -0x8(%rbp), %rsi
addq $0x14, %rsi
addq $0x8, %rsi
leaq -0x40(%rbp), %rdx
movl $0xa, %edi
movl $0x2e, %ecx
callq 0x460470
movq -0x8(%rbp), %rax
movzwl 0x16(%rax), %edi
callq 0x460460
movzwl %ax, %eax
movl %eax, -0x44(%rbp)
jmp 0x40288d
movb $0x3f, -0x40(%rbp)
movb $0x0, -0x3f(%rbp)
leaq -0x40(%rbp), %rcx
movl -0x44(%rbp), %r8d
leaq 0xe7fd4(%rip), %rdi     # 0x4ea870
movl $0xff, %esi
leaq 0xb2aeb(%rip), %rdx     # 0x4b5393
movb $0x0, %al
callq 0x40e0a0
leaq 0xe7fba(%rip), %rax     # 0x4ea870
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/unixlab[P]cloudflare-udp-ping/net.c
// Function: thread_spawn
struct thread *thread_spawn(void (*callback)(void *), void *userdata)
{
	struct thread *thread = calloc(1, sizeof(struct thread));
	thread->callback = callback;
	thread->userdata = userdata;
	int r = pthread_create(&thread->thread_id, NULL, _thread_start, thread);
	if (r != 0) {
		PFATAL("pthread_create()");
	}
	return thread;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, %edi
movl $0x18, %esi
callq 0x427390
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rdi
movq -0x18(%rbp), %rcx
xorl %eax, %eax
movl %eax, %esi
leaq 0x92(%rip), %rdx        # 0x403090
callq 0x41de30
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x403080
jmp 0x40300e
movq $0x4e87a8, %rax         # imm = 0x4E87A8
movq (%rax), %rdi
leaq 0xb2494(%rip), %rsi     # 0x4b54b3
movb $0x0, %al
callq 0x40df10
movq $0x4e87a8, %rax         # imm = 0x4E87A8
movq (%rax), %rdi
leaq 0xb2094(%rip), %rsi     # 0x4b50cb
leaq 0xb2499(%rip), %rdx     # 0x4b54d7
leaq 0xb22af(%rip), %rcx     # 0x4b52f4
movl $0xf8, %r8d
movb $0x0, %al
callq 0x40df10
leaq 0xb20a4(%rip), %rdi     # 0x4b50fd
callq 0x40e2c0
movq $0x4e87a8, %rax         # imm = 0x4E87A8
movq (%rax), %rdi
leaq 0xb2a9b(%rip), %rsi     # 0x4b5b0a
movb $0x0, %al
callq 0x40df10
movl $0x1, %edi
callq 0x40ce70
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/unixlab[P]cloudflare-udp-ping/net.c
// Function: thread_start
static void *_thread_start(void *userdata)
{
	struct thread *thread = userdata;

	/* Direct all signals to main thread. */
	sigset_t set;
	sigfillset(&set);
	int r = pthread_sigmask(SIG_SETMASK, &set, NULL);
	if (r != 0) {
		PFATAL("pthread_sigmask()");
	}

	thread->callback(thread->userdata);
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x40c2c0
movl $0x2, %edi
leaq -0x90(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x4213f0
movl %eax, -0x94(%rbp)
cmpl $0x0, -0x94(%rbp)
je 0x40314b
jmp 0x4030d9
movq $0x4e87a8, %rax         # imm = 0x4E87A8
movq (%rax), %rdi
leaq 0xb2470(%rip), %rsi     # 0x4b555a
movb $0x0, %al
callq 0x40df10
movq $0x4e87a8, %rax         # imm = 0x4E87A8
movq (%rax), %rdi
leaq 0xb1fc9(%rip), %rsi     # 0x4b50cb
leaq 0xb2476(%rip), %rdx     # 0x4b557f
leaq 0xb21e4(%rip), %rcx     # 0x4b52f4
movl $0xea, %r8d
movb $0x0, %al
callq 0x40df10
leaq 0xb1fd9(%rip), %rdi     # 0x4b50fd
callq 0x40e2c0
movq $0x4e87a8, %rax         # imm = 0x4E87A8
movq (%rax), %rdi
leaq 0xb29d0(%rip), %rsi     # 0x4b5b0a
movb $0x0, %al
callq 0x40df10
movl $0x1, %edi
callq 0x40ce70
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rdi
callq *%rax
xorl %eax, %eax
addq $0xa0, %rsp
popq %rbp
retq
nopl (%rax,%rax)