LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/BU-DiSC[P]BF-Shared-Hashing/hash/murmurhash.cc
// Function: MurmurHash64A(void const*, int, unsigned int)
uint64_t MurmurHash64A ( const void * key, int len, unsigned int seed )
{
    const uint64_t m = 0xc6a4a7935bd1e995;
    const int r = 47;

    uint64_t h = seed ^ (len * m);

    const uint64_t * data = (const uint64_t *)key;
    const uint64_t * end = data + (len/8);

    while(data != end)
    {
        uint64_t k = *data++;

        k *= m;
        k ^= k >> r;
        k *= m;

        h ^= k;
        h *= m;
    }

    const unsigned char * data2 = (const unsigned char*)data;

    switch(len & 7)
    {
    case 7: h ^= ((uint64_t)data2[6]) << 48;
    case 6: h ^= ((uint64_t)data2[5]) << 40;
    case 5: h ^= ((uint64_t)data2[4]) << 32;
    case 4: h ^= ((uint64_t)data2[3]) << 24;
    case 3: h ^= ((uint64_t)data2[2]) << 16;
    case 2: h ^= ((uint64_t)data2[1]) << 8; 
    case 1: h ^= ((uint64_t)data2[0]);
        h *= m;
    };

    h ^= h >> r;
    h *= m;
    h ^= h >> r;

    return h;
}

// Assembly:
movabsq $-0x395b586ca42e166b, %rax # imm = 0xC6A4A7935BD1E995
movl %edx, %ecx
movslq %esi, %r8
movq %r8, %rdx
imulq %rax, %rdx
xorq %rcx, %rdx
leal 0x7(%r8), %r9d
testl %r8d, %r8d
movl %esi, %ecx
cmovsl %r9d, %ecx
cmpl $0xf, %r9d
jae 0x23f09
movq %rdx, %rcx
jmp 0x23f3c
sarl $0x3, %ecx
movslq %ecx, %r8
shlq $0x3, %r8
movq (%rdi), %r9
imulq %rax, %r9
addq $0x8, %rdi
movq %r9, %rcx
shrq $0x2f, %rcx
xorq %r9, %rcx
imulq %rax, %rcx
xorq %rdx, %rcx
imulq %rax, %rcx
movq %rcx, %rdx
addq $-0x8, %r8
jne 0x23f13
andl $0x7, %esi
leaq 0x64ea(%rip), %rdx      # 0x2a430
movslq (%rdx,%rsi,4), %rsi
addq %rdx, %rsi
jmpq *%rsi
movzbl 0x6(%rdi), %edx
shlq $0x30, %rdx
xorq %rdx, %rcx
movzbl 0x5(%rdi), %edx
shlq $0x28, %rdx
xorq %rdx, %rcx
movzbl 0x4(%rdi), %edx
shlq $0x20, %rdx
xorq %rdx, %rcx
movzbl 0x3(%rdi), %edx
shll $0x18, %edx
xorq %rdx, %rcx
movzbl 0x2(%rdi), %edx
shll $0x10, %edx
xorq %rdx, %rcx
movzbl 0x1(%rdi), %edx
shll $0x8, %edx
xorq %rdx, %rcx
movzbl (%rdi), %edx
xorq %rcx, %rdx
imulq %rax, %rdx
movq %rdx, %rcx
movq %rcx, %rdx
shrq $0x2f, %rdx
xorq %rcx, %rdx
imulq %rax, %rdx
movq %rdx, %rax
shrq $0x2f, %rax
xorq %rdx, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O1/BU-DiSC[P]BF-Shared-Hashing/hash/xxhash.cc
// Function: ROCKSDB_XXH32
XXH_PUBLIC_API XXH32_hash_t XXH32 (const void* input, size_t len, XXH32_hash_t seed)
{
#if 0
    /* Simple version, good for code maintenance, but unfortunately slow for small inputs */
    XXH32_state_t state;
    XXH32_reset(&state, seed);
    XXH32_update(&state, (const xxh_u8*)input, len);
    return XXH32_digest(&state);

#else

    if (XXH_FORCE_ALIGN_CHECK) {
        if ((((size_t)input) & 3) == 0) {   /* Input is 4-bytes aligned, leverage the speed benefit */
            return XXH32_endian_align((const xxh_u8*)input, len, seed, XXH_aligned);
    }   }

    return XXH32_endian_align((const xxh_u8*)input, len, seed, XXH_unaligned);
#endif
}

// Assembly:
movl %edx, %eax
movq %rsi, %rdx
movq %rdi, %rsi
cmpq $0x10, %rdx
jb 0x244c5
pushq %rbx
leaq (%rsi,%rdx), %rcx
addq $-0xf, %rcx
leal 0x24234428(%rax), %r9d
leal -0x7a143589(%rax), %r8d
leal 0x61c8864f(%rax), %edi
imull $0x85ebca77, (%rsi), %r10d # imm = 0x85EBCA77
addl %r9d, %r10d
roll $0xd, %r10d
imull $0x85ebca77, 0x4(%rsi), %r11d # imm = 0x85EBCA77
addl %r8d, %r11d
roll $0xd, %r11d
imull $0x9e3779b1, %r10d, %r9d # imm = 0x9E3779B1
imull $0x85ebca77, 0x8(%rsi), %r10d # imm = 0x85EBCA77
addl %eax, %r10d
roll $0xd, %r10d
imull $0x85ebca77, 0xc(%rsi), %ebx # imm = 0x85EBCA77
imull $0x9e3779b1, %r11d, %r8d # imm = 0x9E3779B1
addl %edi, %ebx
roll $0xd, %ebx
imull $0x9e3779b1, %r10d, %eax # imm = 0x9E3779B1
imull $0x9e3779b1, %ebx, %edi # imm = 0x9E3779B1
addq $0x10, %rsi
cmpq %rcx, %rsi
jb 0x24451
roll %r9d
roll $0x7, %r8d
addl %r9d, %r8d
roll $0xc, %eax
roll $0x12, %edi
addl %eax, %edi
addl %r8d, %edi
popq %rbx
jmp 0x244cc
addl $0x165667b1, %eax       # imm = 0x165667B1
movl %eax, %edi
addl %edx, %edi
andl $0xf, %edx
jmp 0x24760
// File: /workspace/github_cpp_makefile_star2_O1/BU-DiSC[P]BF-Shared-Hashing/hash/xxhash.cc
// Function: ROCKSDB_XXH32_digest
XXH_PUBLIC_API XXH32_hash_t XXH32_digest (const XXH32_state_t* state)
{
    xxh_u32 h32;

    if (state->large_len) {
        h32 = XXH_rotl32(state->v1, 1)
            + XXH_rotl32(state->v2, 7)
            + XXH_rotl32(state->v3, 12)
            + XXH_rotl32(state->v4, 18);
    } else {
        h32 = state->v3 /* == seed */ + PRIME32_5;
    }

    h32 += state->total_len_32;

    return XXH32_finalize(h32, (const xxh_u8*)state->mem32, state->memsize, XXH_aligned);
}

// Assembly:
movq %rdi, %rsi
cmpl $0x0, 0x4(%rdi)
je 0x2474d
movdqu 0x8(%rsi), %xmm0
movdqa 0x5e8d(%rip), %xmm1     # 0x2a590
pshufd $0xf5, %xmm0, %xmm2     # xmm2 = xmm0[1,1,3,3]
pmuludq %xmm1, %xmm0
pshufd $0xed, %xmm0, %xmm3     # xmm3 = xmm0[1,3,2,3]
pshufd $0xf5, %xmm1, %xmm1     # xmm1 = xmm1[1,1,3,3]
pmuludq %xmm2, %xmm1
pshufd $0xed, %xmm1, %xmm2     # xmm2 = xmm1[1,3,2,3]
punpckldq %xmm2, %xmm3    # xmm3 = xmm3[0],xmm2[0],xmm3[1],xmm2[1]
pshufd $0xe8, %xmm0, %xmm0     # xmm0 = xmm0[0,2,2,3]
pshufd $0xe8, %xmm1, %xmm1     # xmm1 = xmm1[0,2,2,3]
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
por %xmm3, %xmm0
pshufd $0xee, %xmm0, %xmm1     # xmm1 = xmm0[2,3,2,3]
paddd %xmm0, %xmm1
pshufd $0x55, %xmm1, %xmm0     # xmm0 = xmm1[1,1,1,1]
paddd %xmm1, %xmm0
movd %xmm0, %edi
jmp 0x24755
movl $0x165667b1, %edi       # imm = 0x165667B1
addl 0x10(%rsi), %edi
addl (%rsi), %edi
movl 0x28(%rsi), %edx
addq $0x18, %rsi
jmp 0x24760
// File: /workspace/github_cpp_makefile_star2_O1/BU-DiSC[P]BF-Shared-Hashing/hash/Crc32.cpp
// Function: crc32_halfbyte(void const*, unsigned long, unsigned int)
uint32_t crc32_halfbyte(const void* data, size_t length, uint32_t previousCrc32)
{
  uint32_t crc = ~previousCrc32; // same as previousCrc32 ^ 0xFFFFFFFF
  const uint8_t* current = (const uint8_t*) data;

  /// look-up table for half-byte, same as crc32Lookup[0][16*i]
  static const uint32_t Crc32Lookup16[16] =
  {
    0x00000000,0x1DB71064,0x3B6E20C8,0x26D930AC,0x76DC4190,0x6B6B51F4,0x4DB26158,0x5005713C,
    0xEDB88320,0xF00F9344,0xD6D6A3E8,0xCB61B38C,0x9B64C2B0,0x86D3D2D4,0xA00AE278,0xBDBDF21C
  };

  while (length-- != 0)
  {
    crc = Crc32Lookup16[(crc ^  *current      ) & 0x0F] ^ (crc >> 4);
    crc = Crc32Lookup16[(crc ^ (*current >> 4)) & 0x0F] ^ (crc >> 4);
    current++;
  }

  return ~crc; // same as crc ^ 0xFFFFFFFF
}

// Assembly:
movl %edx, %eax
testq %rsi, %rsi
je 0x275b4
notl %eax
xorl %ecx, %ecx
leaq 0x3191(%rip), %rdx      # 0x2a710
movzbl (%rdi,%rcx), %r8d
movl %eax, %r9d
xorl %r8d, %r9d
andl $0xf, %r9d
shrl $0x4, %eax
xorl (%rdx,%r9,4), %eax
shrl $0x4, %r8d
movl %eax, %r9d
andl $0xf, %r9d
xorl %r8d, %r9d
shrl $0x4, %eax
xorl (%rdx,%r9,4), %eax
incq %rcx
cmpq %rcx, %rsi
jne 0x2757f
notl %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/BU-DiSC[P]BF-Shared-Hashing/hash/Crc32.cpp
// Function: crc32_1byte(void const*, unsigned long, unsigned int)
uint32_t crc32_1byte(const void* data, size_t length, uint32_t previousCrc32)
{
  uint32_t crc = ~previousCrc32; // same as previousCrc32 ^ 0xFFFFFFFF
  const uint8_t* current = (const uint8_t*) data;

  while (length-- != 0)
    crc = (crc >> 8) ^ Crc32Lookup[0][(crc & 0xFF) ^ *current++];

  return ~crc; // same as crc ^ 0xFFFFFFFF
}

// Assembly:
movl %edx, %eax
testq %rsi, %rsi
je 0x275e4
notl %eax
xorl %ecx, %ecx
leaq 0x3189(%rip), %rdx      # 0x2a750
movzbl %al, %r8d
shrl $0x8, %eax
movzbl (%rdi,%rcx), %r9d
xorl %r8d, %r9d
xorl (%rdx,%r9,4), %eax
incq %rcx
cmpq %rcx, %rsi
jne 0x275c7
notl %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/BU-DiSC[P]BF-Shared-Hashing/hash/Crc32.cpp
// Function: crc32_1byte_tableless2(void const*, unsigned long, unsigned int)
uint32_t crc32_1byte_tableless2(const void* data, size_t length, uint32_t previousCrc32)
{
  int32_t crc = ~previousCrc32; // note: signed integer, right shift distributes sign bit into lower bits
  const uint8_t* current = (const uint8_t*) data;

  while (length-- != 0)
  {
    crc = crc ^ *current++;

    uint32_t c = (((crc << 31) >> 31) & ((Polynomial >> 7)  ^ (Polynomial >> 1))) ^
                 (((crc << 30) >> 31) & ((Polynomial >> 6)  ^  Polynomial)) ^
                 (((crc << 29) >> 31) &  (Polynomial >> 5)) ^
                 (((crc << 28) >> 31) &  (Polynomial >> 4)) ^
                 (((crc << 27) >> 31) &  (Polynomial >> 3)) ^
                 (((crc << 26) >> 31) &  (Polynomial >> 2)) ^
                 (((crc << 25) >> 31) &  (Polynomial >> 1)) ^
                 (((crc << 24) >> 31) &   Polynomial);

    crc = ((uint32_t)crc >> 8) ^ c; // convert to unsigned integer before right shift
  }

  return ~crc; // same as crc ^ 0xFFFFFFFF
}

// Assembly:
movl %edx, %eax
testq %rsi, %rsi
je 0x276d7
notl %eax
xorl %ecx, %ecx
movdqa 0x3057(%rip), %xmm0     # 0x2a6c0
movdqa 0x305f(%rip), %xmm1     # 0x2a6d0
movdqa 0x3067(%rip), %xmm2     # 0x2a6e0
movdqa 0x306f(%rip), %xmm3     # 0x2a6f0
movzbl (%rdi,%rcx), %edx
xorl %eax, %edx
movd %edx, %xmm4
pshufd $0x0, %xmm4, %xmm4      # xmm4 = xmm4[0,0,0,0]
movdqa %xmm4, %xmm5
pand %xmm0, %xmm5
pand %xmm1, %xmm4
pcmpeqd %xmm1, %xmm4
pand %xmm2, %xmm4
pcmpeqd %xmm0, %xmm5
pand %xmm3, %xmm5
pxor %xmm4, %xmm5
movl %eax, %edx
shrl $0x8, %edx
pshufd $0xee, %xmm5, %xmm4     # xmm4 = xmm5[2,3,2,3]
pxor %xmm5, %xmm4
pshufd $0x55, %xmm4, %xmm5     # xmm5 = xmm4[1,1,1,1]
pxor %xmm4, %xmm5
movd %xmm5, %eax
xorl %edx, %eax
incq %rcx
cmpq %rcx, %rsi
jne 0x27681
notl %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/BU-DiSC[P]BF-Shared-Hashing/hash/Crc32.cpp
// Function: crc32_4bytes(void const*, unsigned long, unsigned int)
uint32_t crc32_4bytes(const void* data, size_t length, uint32_t previousCrc32)
{
  uint32_t  crc = ~previousCrc32; // same as previousCrc32 ^ 0xFFFFFFFF
  const uint32_t* current = (const uint32_t*) data;

  // process four bytes at once (Slicing-by-4)
  while (length >= 4)
  {
#if __BYTE_ORDER == __BIG_ENDIAN
    uint32_t one = *current++ ^ swap(crc);
    crc = Crc32Lookup[0][ one      & 0xFF] ^
          Crc32Lookup[1][(one>> 8) & 0xFF] ^
          Crc32Lookup[2][(one>>16) & 0xFF] ^
          Crc32Lookup[3][(one>>24) & 0xFF];
#else
    uint32_t one = *current++ ^ crc;
    crc = Crc32Lookup[0][(one>>24) & 0xFF] ^
          Crc32Lookup[1][(one>>16) & 0xFF] ^
          Crc32Lookup[2][(one>> 8) & 0xFF] ^
          Crc32Lookup[3][ one      & 0xFF];
#endif

    length -= 4;
  }

  const uint8_t* currentChar = (const uint8_t*) current;
  // remaining 1 to 3 bytes (standard algorithm)
  while (length-- != 0)
    crc = (crc >> 8) ^ Crc32Lookup[0][(crc & 0xFF) ^ *currentChar++];

  return ~crc; // same as crc ^ 0xFFFFFFFF
}

// Assembly:
notl %edx
cmpq $0x4, %rsi
jb 0x2773a
leaq 0x3069(%rip), %rax      # 0x2a750
movl $0xff, %r8d
xorl (%rdi), %edx
movl %edx, %r9d
shrl $0x18, %r9d
movl %edx, %ecx
shrl $0xe, %ecx
andl $0x3fc, %ecx            # imm = 0x3FC
movl 0x400(%rcx,%rax), %ecx
xorl (%rax,%r9,4), %ecx
movl %edx, %r9d
shrl $0x8, %r9d
andl %r8d, %r9d
xorl 0x800(%rax,%r9,4), %ecx
andl %r8d, %edx
xorl 0xc00(%rax,%rdx,4), %ecx
addq $0x4, %rdi
addq $-0x4, %rsi
movl %ecx, %edx
cmpq $0x3, %rsi
ja 0x276ed
jmp 0x2773c
movl %edx, %ecx
testq %rsi, %rsi
je 0x2776a
xorl %edx, %edx
leaq 0x3006(%rip), %r8       # 0x2a750
movl %ecx, %eax
shrl $0x8, %eax
movzbl %cl, %ecx
movzbl (%rdi,%rdx), %r9d
xorl %ecx, %r9d
xorl (%r8,%r9,4), %eax
incq %rdx
movl %eax, %ecx
cmpq %rdx, %rsi
jne 0x2774c
jmp 0x2776c
movl %ecx, %eax
notl %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/BU-DiSC[P]BF-Shared-Hashing/hash/Crc32.cpp
// Function: crc32_8bytes(void const*, unsigned long, unsigned int)
uint32_t crc32_8bytes(const void* data, size_t length, uint32_t previousCrc32)
{
  uint32_t crc = ~previousCrc32; // same as previousCrc32 ^ 0xFFFFFFFF
  const uint32_t* current = (const uint32_t*) data;

  // process eight bytes at once (Slicing-by-8)
  while (length >= 8)
  {
#if __BYTE_ORDER == __BIG_ENDIAN
    uint32_t one = *current++ ^ swap(crc);
    uint32_t two = *current++;
    crc = Crc32Lookup[0][ two      & 0xFF] ^
          Crc32Lookup[1][(two>> 8) & 0xFF] ^
          Crc32Lookup[2][(two>>16) & 0xFF] ^
          Crc32Lookup[3][(two>>24) & 0xFF] ^
          Crc32Lookup[4][ one      & 0xFF] ^
          Crc32Lookup[5][(one>> 8) & 0xFF] ^
          Crc32Lookup[6][(one>>16) & 0xFF] ^
          Crc32Lookup[7][(one>>24) & 0xFF];
#else
    uint32_t one = *current++ ^ crc;
    uint32_t two = *current++;
    crc = Crc32Lookup[0][(two>>24) & 0xFF] ^
          Crc32Lookup[1][(two>>16) & 0xFF] ^
          Crc32Lookup[2][(two>> 8) & 0xFF] ^
          Crc32Lookup[3][ two      & 0xFF] ^
          Crc32Lookup[4][(one>>24) & 0xFF] ^
          Crc32Lookup[5][(one>>16) & 0xFF] ^
          Crc32Lookup[6][(one>> 8) & 0xFF] ^
          Crc32Lookup[7][ one      & 0xFF];
#endif

    length -= 8;
  }

  const uint8_t* currentChar = (const uint8_t*) current;
  // remaining 1 to 7 bytes (standard algorithm)
  while (length-- != 0)
    crc = (crc >> 8) ^ Crc32Lookup[0][(crc & 0xFF) ^ *currentChar++];

  return ~crc; // same as crc ^ 0xFFFFFFFF
}

// Assembly:
pushq %rbx
notl %edx
cmpq $0x8, %rsi
jb 0x27821
leaq 0x2fcd(%rip), %rax      # 0x2a750
movl $0x3fc, %ecx            # imm = 0x3FC
movl $0xff, %r8d
xorl (%rdi), %edx
movl 0x4(%rdi), %r9d
movl %r9d, %r11d
shrl $0x18, %r11d
movl %r9d, %r10d
shrl $0xe, %r10d
andl %ecx, %r10d
movl %edx, %ebx
movl 0x400(%r10,%rax), %r10d
xorl (%rax,%r11,4), %r10d
movl %r9d, %r11d
shrl $0x8, %r11d
andl %r8d, %r11d
xorl 0x800(%rax,%r11,4), %r10d
movl %edx, %r11d
andl %r8d, %r9d
xorl 0xc00(%rax,%r9,4), %r10d
movl %edx, %r9d
shrl $0x18, %r9d
xorl 0x1000(%rax,%r9,4), %r10d
movl %edx, %r9d
addq $0x8, %rdi
shrl $0xe, %ebx
andl %ecx, %ebx
xorl 0x1400(%rbx,%rax), %r10d
shrl $0x8, %r11d
andl %r8d, %r11d
xorl 0x1800(%rax,%r11,4), %r10d
andl %r8d, %r9d
movl %r10d, %edx
xorl 0x1c00(%rax,%r9,4), %edx
addq $-0x8, %rsi
cmpq $0x7, %rsi
ja 0x2778e
testq %rsi, %rsi
je 0x2784f
xorl %ecx, %ecx
leaq 0x2f21(%rip), %r8       # 0x2a750
movl %edx, %eax
shrl $0x8, %eax
movzbl %dl, %edx
movzbl (%rdi,%rcx), %r9d
xorl %edx, %r9d
xorl (%r8,%r9,4), %eax
incq %rcx
movl %eax, %edx
cmpq %rcx, %rsi
jne 0x27831
jmp 0x27851
movl %edx, %eax
notl %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/BU-DiSC[P]BF-Shared-Hashing/hash/Crc32.cpp
// Function: crc32_4x8bytes(void const*, unsigned long, unsigned int)
uint32_t crc32_4x8bytes(const void* data, size_t length, uint32_t previousCrc32)
{
  uint32_t crc = ~previousCrc32; // same as previousCrc32 ^ 0xFFFFFFFF
  const uint32_t* current = (const uint32_t*) data;

  // enabling optimization (at least -O2) automatically unrolls the inner for-loop
  const size_t Unroll = 4;
  const size_t BytesAtOnce = 8 * Unroll;

  // process 4x eight bytes at once (Slicing-by-8)
  while (length >= BytesAtOnce)
  {
    for (size_t unrolling = 0; unrolling < Unroll; unrolling++)
    {
#if __BYTE_ORDER == __BIG_ENDIAN
      uint32_t one = *current++ ^ swap(crc);
      uint32_t two = *current++;
      crc = Crc32Lookup[0][ two      & 0xFF] ^
            Crc32Lookup[1][(two>> 8) & 0xFF] ^
            Crc32Lookup[2][(two>>16) & 0xFF] ^
            Crc32Lookup[3][(two>>24) & 0xFF] ^
            Crc32Lookup[4][ one      & 0xFF] ^
            Crc32Lookup[5][(one>> 8) & 0xFF] ^
            Crc32Lookup[6][(one>>16) & 0xFF] ^
            Crc32Lookup[7][(one>>24) & 0xFF];
#else
      uint32_t one = *current++ ^ crc;
      uint32_t two = *current++;
      crc = Crc32Lookup[0][(two>>24) & 0xFF] ^
            Crc32Lookup[1][(two>>16) & 0xFF] ^
            Crc32Lookup[2][(two>> 8) & 0xFF] ^
            Crc32Lookup[3][ two      & 0xFF] ^
            Crc32Lookup[4][(one>>24) & 0xFF] ^
            Crc32Lookup[5][(one>>16) & 0xFF] ^
            Crc32Lookup[6][(one>> 8) & 0xFF] ^
            Crc32Lookup[7][ one      & 0xFF];
#endif

    }

    length -= BytesAtOnce;
  }

  const uint8_t* currentChar = (const uint8_t*) current;
  // remaining 1 to 31 bytes (standard algorithm)
  while (length-- != 0)
    crc = (crc >> 8) ^ Crc32Lookup[0][(crc & 0xFF) ^ *currentChar++];

  return ~crc; // same as crc ^ 0xFFFFFFFF
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
notl %edx
leaq 0x2eeb(%rip), %rcx      # 0x2a750
cmpq $0x20, %rsi
jb 0x2791a
movl $0x3fc, %eax            # imm = 0x3FC
movl $0xff, %r8d
xorl %r9d, %r9d
xorl (%rdi,%r9,8), %edx
movl 0x4(%rdi,%r9,8), %r10d
movl %r10d, %r11d
shrl $0x18, %r11d
movl %r10d, %ebx
shrl $0xe, %ebx
andl %eax, %ebx
movl %edx, %r14d
movl %edx, %r15d
movl %edx, %r12d
movl 0x400(%rbx,%rcx), %ebx
xorl (%rcx,%r11,4), %ebx
movl %r10d, %r11d
shrl $0x8, %r11d
andl %r8d, %r11d
xorl 0x800(%rcx,%r11,4), %ebx
andl %r8d, %r10d
xorl 0xc00(%rcx,%r10,4), %ebx
shrl $0x18, %edx
xorl 0x1000(%rcx,%rdx,4), %ebx
shrl $0xe, %r14d
andl %eax, %r14d
xorl 0x1400(%r14,%rcx), %ebx
shrl $0x8, %r15d
andl %r8d, %r15d
xorl 0x1800(%rcx,%r15,4), %ebx
andl %r8d, %r12d
movl %ebx, %edx
xorl 0x1c00(%rcx,%r12,4), %edx
incq %r9
cmpq $0x4, %r9
jne 0x2787d
addq $0x20, %rdi
addq $-0x20, %rsi
cmpq $0x1f, %rsi
ja 0x2787a
testq %rsi, %rsi
je 0x27942
xorl %r8d, %r8d
movl %edx, %eax
shrl $0x8, %eax
movzbl %dl, %edx
movzbl (%rdi,%r8), %r9d
xorl %edx, %r9d
xorl (%rcx,%r9,4), %eax
incq %r8
movl %eax, %edx
cmpq %r8, %rsi
jne 0x27924
jmp 0x27944
movl %edx, %eax
notl %eax
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/BU-DiSC[P]BF-Shared-Hashing/hash/city.cc
// Function: HashLen0to16(char const*, unsigned long)
static uint64 HashLen0to16(const char *s, size_t len) {
  if (len >= 8) {
    uint64 mul = k2 + len * 2;
    uint64 a = Fetch64(s) + k2;
    uint64 b = Fetch64(s + len - 8);
    uint64 c = Rotate(b, 37) * mul + a;
    uint64 d = (Rotate(a, 25) + b) * mul;
    return HashLen16(c, d, mul);
  }
  if (len >= 4) {
    uint64 mul = k2 + len * 2;
    uint64 a = Fetch32(s);
    return HashLen16(len + (a << 3), Fetch32(s + len - 4), mul);
  }
  if (len > 0) {
    uint8 a = s[0];
    uint8 b = s[len >> 1];
    uint8 c = s[len - 1];
    uint32 y = static_cast<uint32>(a) + (static_cast<uint32>(b) << 8);
    uint32 z = len + (static_cast<uint32>(c) << 2);
    return ShiftMix(y * k2 ^ z * k0) * k2;
  }
  return k2;
}

// Assembly:
movabsq $-0x651e95c4d06fbfb1, %rax # imm = 0x9AE16A3B2F90404F
cmpq $0x8, %rsi
jb 0x2869e
leaq (%rax,%rsi,2), %rcx
addq (%rdi), %rax
movq -0x8(%rdi,%rsi), %rdx
movq %rdx, %rsi
rolq $0x1b, %rsi
imulq %rcx, %rsi
addq %rax, %rsi
rolq $0x27, %rax
addq %rdx, %rax
imulq %rcx, %rax
xorq %rax, %rsi
imulq %rcx, %rsi
xorq %rsi, %rax
shrq $0x2f, %rsi
xorq %rax, %rsi
imulq %rcx, %rsi
movq %rsi, %rax
shrq $0x2f, %rax
xorq %rsi, %rax
jmp 0x286d1
cmpq $0x4, %rsi
jb 0x286d6
leaq (%rax,%rsi,2), %rcx
movl (%rdi), %eax
leaq (%rsi,%rax,8), %rdx
movl -0x4(%rdi,%rsi), %eax
xorq %rax, %rdx
imulq %rcx, %rdx
xorq %rdx, %rax
shrq $0x2f, %rdx
xorq %rax, %rdx
imulq %rcx, %rdx
movq %rdx, %rax
shrq $0x2f, %rax
xorq %rdx, %rax
imulq %rcx, %rax
retq
testq %rsi, %rsi
je 0x2871c
movzbl (%rdi), %ecx
movq %rsi, %rdx
shrq %rdx
movzbl (%rdi,%rdx), %edx
movzbl -0x1(%rdi,%rsi), %edi
shll $0x8, %edx
orq %rcx, %rdx
shll $0x2, %edi
orq %rsi, %rdi
imulq %rax, %rdx
movabsq $-0x3c5a37a36834ced9, %rcx # imm = 0xC3A5C85C97CB3127
imulq %rdi, %rcx
xorq %rdx, %rcx
movq %rcx, %rdx
shrq $0x2f, %rdx
xorq %rcx, %rdx
imulq %rdx, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O1/BU-DiSC[P]BF-Shared-Hashing/hash/city.cc
// Function: CityHash128(char const*, unsigned long)
uint128 CityHash128(const char *s, size_t len) {
  return len >= 16 ?
      CityHash128WithSeed(s + 16, len - 16,
                          uint128(Fetch64(s), Fetch64(s + 8) + k0)) :
      CityHash128WithSeed(s, len, uint128(k0, k1));
}

// Assembly:
movabsq $-0x3c5a37a36834ced9, %rcx # imm = 0xC3A5C85C97CB3127
cmpq $0x10, %rsi
jb 0x28c80
leaq 0x10(%rdi), %rax
addq $-0x10, %rsi
movq (%rdi), %rdx
addq 0x8(%rdi), %rcx
movq %rax, %rdi
jmp 0x287a9
movabsq $-0x4b6d499041670d8d, %rax # imm = 0xB492B66FBE98F273
movq %rcx, %rdx
movq %rax, %rcx
jmp 0x287a9
// File: /workspace/github_cpp_makefile_star2_O1/lvandeve[P]lodepng/lodepng_benchmark.cpp
// Function: assertTrue(bool, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void assertTrue(bool value, const std::string& message = "") {
  if(!value) {
    std::cout << "Error: expected true." << std::endl;
    std::cout << "Message: " << message << std::endl;
    std::exit(1);
  }
}

// Assembly:
testl %edi, %edi
je 0x10dc4
retq
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0xc206(%rip), %r14      # 0x1cfd8
leaq 0x6e77(%rip), %rsi      # 0x17c50
movq %r14, %rdi
callq 0x2190
movq %rax, %rdi
callq 0x20c0
leaq 0x6e76(%rip), %rsi      # 0x17c66
movq %r14, %rdi
callq 0x2190
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2160
movq %rax, %rdi
callq 0x20c0
movl $0x1, %edi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O1/lvandeve[P]lodepng/lodepng_benchmark.cpp
// Function: getFilePart(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string getFilePart(const std::string& path) {
  if(path.empty()) return "";
  int slash = path.size() - 1;
  while(slash >= 0 && path[(size_t)slash] != '/') slash--;
  return path.substr((size_t)(slash + 1));
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rsi), %rax
testq %rax, %rax
je 0x1170c
movq (%rsi), %rcx
leal -0x1(%rax), %edi
cmpl $-0x1, %edi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
cmovll %edi, %edx
movl %eax, %edi
incl %edx
incl %eax
decq %rdi
testl %edi, %edi
js 0x11727
movl %edi, %r8d
andl $0x7fffffff, %r8d       # imm = 0x7FFFFFFF
decl %eax
decq %rdi
cmpb $0x2f, (%rcx,%r8)
jne 0x116f0
jmp 0x11729
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x694c(%rip), %rdx      # 0x18066
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x130da
jmp 0x1173b
movl %edx, %eax
movslq %eax, %rdx
movq %rbx, %rdi
movq $-0x1, %rcx
callq 0x21d0
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/lvandeve[P]lodepng/lodepng_benchmark.cpp
// Function: void assertEquals<int, unsigned int>(int const&, unsigned int const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void assertEquals(const T& expected, const U& actual, const std::string& message = "") {
  if(expected != (T)actual) {
    std::cout << "Error: Not equal! Expected " << expected << " got " << actual << "." << std::endl;
    std::cout << "Message: " << message << std::endl;
    std::exit(1);
  }
}

// Assembly:
movl (%rdi), %eax
cmpl (%rsi), %eax
jne 0x12d85
retq
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
movq 0xa23b(%rip), %r14      # 0x1cfd8
leaq 0x531d(%rip), %rsi      # 0x180c1
movq %r14, %rdi
callq 0x2190
movl (%r12), %esi
movq %rax, %rdi
callq 0x22e0
leaq 0x531e(%rip), %rsi      # 0x180dd
movq %rax, %rdi
callq 0x2190
movl (%r15), %esi
movq %rax, %rdi
callq 0x2240
leaq 0x4e8b(%rip), %rsi      # 0x17c64
movq %rax, %rdi
callq 0x2190
movq %rax, %rdi
callq 0x20c0
leaq 0x4e76(%rip), %rsi      # 0x17c66
movq %r14, %rdi
callq 0x2190
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2160
movq %rax, %rdi
callq 0x20c0
movl $0x1, %edi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O1/wenleix[P]EdgePPR/src/ParamPPR.cpp
// Function: WorkerThread(void*)
void *WorkerThread(void *__conf) {
	ThreadConfig* conf = (ThreadConfig*)__conf;

	fprintf(stdout, "INFO: Thread %d start!\n", conf->threadId);

	double *value = new double[conf->g->numVertex];
	for (int i = conf->start; i < conf->end; i++) {
		int paramId = conf->paramIdx[i];
		double *curParam = conf->params + ParamGraph_NumEdgeTypes * paramId;
		fprintf(stderr, "DEBUG: Param:");
		for (int j = 0; j < ParamGraph_NumEdgeTypes; j++)
			fprintf(stderr, " %.2lf", curParam[j]);
		fprintf(stderr, "\n");

		ParamJacobiSolver(conf->g, conf->pref, value, curParam);

		//	Print out the useful vertices
		char filenameBuf[1000];
		sprintf(filenameBuf, "%s-%d", conf->outputPrefix, paramId);
		WriteVector(value, conf->g->numVertex, filenameBuf, conf->outputFormat);
		fprintf(stderr, "DEBUG: Thread %d finished param %d!\n", conf->threadId, paramId);
	}

	fprintf(stdout, "INFO: Thread %d done!\n", conf->threadId);
	pthread_exit(NULL);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x3f8, %rsp            # imm = 0x3F8
movq %rdi, %rbx
movq 0x5661(%rip), %rax      # 0x7fc8
movq (%rax), %rdi
movl (%rbx), %edx
leaq 0x269d(%rip), %rsi      # 0x5010
xorl %eax, %eax
callq 0x21e0
movq 0x40(%rbx), %rax
movslq (%rax), %rax
leaq (,%rax,8), %rcx
testq %rax, %rax
movq $-0x1, %rdi
cmovnsq %rcx, %rdi
callq 0x2030
movq %rax, (%rsp)
movslq 0x10(%rbx), %rbp
cmpl 0x14(%rbx), %ebp
jge 0x2a9b
movq 0x562c(%rip), %r14      # 0x7fe0
leaq 0x267b(%rip), %r12      # 0x5036
movq 0x30(%rbx), %rax
movl (%rax,%rbp,4), %ecx
leal (,%rcx,8), %eax
movq %rcx, 0x8(%rsp)
subl %ecx, %eax
movslq %eax, %r15
shlq $0x3, %r15
addq 0x8(%rbx), %r15
movq (%r14), %rcx
movl $0xd, %esi
movl $0x1, %edx
leaq 0x2639(%rip), %rdi      # 0x5028
callq 0x2290
xorl %r13d, %r13d
movq (%r14), %rdi
movsd (%r15,%r13,8), %xmm0
movq %r12, %rsi
movb $0x1, %al
callq 0x21e0
incq %r13
cmpq $0x7, %r13
jne 0x29f7
movq (%r14), %rsi
movl $0xa, %edi
callq 0x21b0
movq 0x28(%rbx), %rsi
movq 0x40(%rbx), %rdi
movq (%rsp), %r13
movq %r13, %rdx
movq %r15, %rcx
movsd 0x25ce(%rip), %xmm0     # 0x5008
callq 0x2571
movq 0x20(%rbx), %rdx
leaq 0x10(%rsp), %rdi
leaq 0x25ee(%rip), %rsi      # 0x503d
movq 0x8(%rsp), %r15
movl %r15d, %ecx
xorl %eax, %eax
callq 0x2050
movq 0x38(%rbx), %rcx
movq 0x40(%rbx), %rax
movl (%rax), %esi
movq %r13, %rdi
leaq 0x10(%rsp), %rdx
callq 0x393e
movq (%r14), %rdi
movl (%rbx), %edx
leaq 0x25c2(%rip), %rsi      # 0x5043
movl %r15d, %ecx
xorl %eax, %eax
callq 0x21e0
incq %rbp
movslq 0x14(%rbx), %rax
cmpq %rax, %rbp
jl 0x29bb
movq 0x5526(%rip), %rax      # 0x7fc8
movq (%rax), %rdi
movl (%rbx), %edx
leaq 0x25ba(%rip), %rsi      # 0x5068
xorl %eax, %eax
callq 0x21e0
xorl %edi, %edi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O1/wenleix[P]EdgePPR/src/ParamGraph.cpp
// Function: ParamGraph::SetWeight(double*)
void ParamGraph::SetWeight(double param[7]) {
	for (int i = 0; i < numVertex; i++) {
		ParamVertex *v = GetVertex(i);
		for (int j = 0; j < v->outDeg; j++) {
			ParamEdge *e = &(v->outEdge[j]);
			int etype = e->GetIntEType();
			e->weight = param[etype] / v->outEdgeTypeCount[etype];
		}
	}
}

// Assembly:
movslq (%rdi), %rax
testq %rax, %rax
jle 0x362b
movq 0x8(%rdi), %rcx
xorl %edx, %edx
leaq (%rdx,%rdx,2), %rdi
shlq $0x5, %rdi
movslq 0x30(%rcx,%rdi), %r8
testq %r8, %r8
jle 0x3623
addq %rcx, %rdi
movq 0x38(%rdi), %r9
shlq $0x4, %r8
xorl %r10d, %r10d
movslq 0x4(%r9,%r10), %r11
movsd (%rsi,%r11,8), %xmm0
xorps %xmm1, %xmm1
cvtsi2sdl 0x40(%rdi,%r11,4), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x8(%r9,%r10)
addq $0x10, %r10
cmpq %r10, %r8
jne 0x35fa
incq %rdx
cmpq %rax, %rdx
jne 0x35da
retq
// File: /workspace/github_cpp_makefile_star2_O1/wenleix[P]EdgePPR/src/PPRCommon.cpp
// Function: WriteVector(double*, int, char*, char*)
void WriteVector(double *pprValue, int size, char* filename, char* suffix) {
	char fullname[1000];
	sprintf(fullname, "%s.%s", filename, suffix);

	if (strcmp(suffix, "txt") == 0) {
		FILE *f = fopen(fullname, "w");
		fprintf(f, "%d\n", size);
		for (int i = 0; i < size; i++)
			fprintf(f, "%.8lf\n", pprValue[i]);
		fclose(f);
	} else if (strcmp(suffix, "bin") == 0) {
		FILE *f = fopen(fullname, "wb");
		fwrite(&size, sizeof(int), 1, f);
		fwrite(pprValue, sizeof(double), size, f);
		fclose(f);
	} else {
		assert(false);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x3f8, %rsp            # imm = 0x3F8
movq %rcx, %r14
movl %esi, %ebp
movq %rdi, %rbx
movl %esi, 0xc(%rsp)
leaq 0x1b6a(%rip), %rsi      # 0x54cc
leaq 0x10(%rsp), %rdi
xorl %eax, %eax
callq 0x2050
leaq 0x1778(%rip), %rsi      # 0x50ed
movq %r14, %rdi
callq 0x21d0
testl %eax, %eax
je 0x39db
leaq 0x1761(%rip), %rsi      # 0x50e9
movq %r14, %rdi
callq 0x21d0
testl %eax, %eax
jne 0x3a47
leaq 0x1be3(%rip), %rsi      # 0x5582
leaq 0x10(%rsp), %rdi
callq 0x2190
movq %rax, %r14
leaq 0xc(%rsp), %r15
movl $0x4, %esi
movl $0x1, %edx
movq %r15, %rdi
movq %rax, %rcx
callq 0x2290
movslq (%r15), %rdx
movl $0x8, %esi
movq %rbx, %rdi
movq %r14, %rcx
callq 0x2290
jmp 0x3a2e
leaq 0x1b97(%rip), %rsi      # 0x5579
leaq 0x10(%rsp), %rdi
callq 0x2190
movq %rax, %r14
leaq 0x1a82(%rip), %rsi      # 0x5478
movq %rax, %rdi
movl %ebp, %edx
xorl %eax, %eax
callq 0x21e0
testl %ebp, %ebp
jle 0x3a2e
movl %ebp, %r12d
xorl %r13d, %r13d
leaq 0x1b68(%rip), %r15      # 0x557b
movsd (%rbx,%r13,8), %xmm0
movq %r14, %rdi
movq %r15, %rsi
movb $0x1, %al
callq 0x21e0
incq %r13
cmpq %r13, %r12
jne 0x3a13
movq %r14, %rdi
addq $0x3f8, %rsp            # imm = 0x3F8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2130
leaq 0x1b25(%rip), %rdi      # 0x5573
leaq 0x1a9f(%rip), %rsi      # 0x54f4
leaq 0x1b29(%rip), %rcx      # 0x5585
movl $0xc5, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O1/wenleix[P]EdgePPR/src/PPRCommon.cpp
// Function: L1(double*, double*, int)
double L1(double *trueprv, double *estprv, int n) {
	double diff = 0.0, sum = 0.0;
	for (int i = 0; i < n; i++) {
		diff += fabs(trueprv[i] - estprv[i]);
		sum += trueprv[i];
	}

	return diff / sum;
}

// Assembly:
testl %edx, %edx
jle 0x3aa1
movl %edx, %eax
xorpd %xmm1, %xmm1
xorl %ecx, %ecx
movapd 0x1976(%rip), %xmm2     # 0x53f0
xorpd %xmm0, %xmm0
movsd (%rdi,%rcx,8), %xmm3
addsd %xmm3, %xmm1
subsd (%rsi,%rcx,8), %xmm3
andpd %xmm2, %xmm3
addsd %xmm3, %xmm0
incq %rcx
cmpq %rcx, %rax
jne 0x3a7e
divsd %xmm1, %xmm0
retq
movsd 0x1937(%rip), %xmm0     # 0x53e0
retq
// File: /workspace/github_cpp_makefile_star2_O1/lhydave[P]SysYCompilerLab/front/symtab.cpp
// Function: sysY_AST::inc_blk()
void inc_blk()
{
	if (create)
	{
		blk_id++;
		var_stack.push_back(var_table_t());
	}
	create = true;
}

// Assembly:
pushq %rbx
subq $0x40, %rsp
cmpb $0x1, 0x20940(%rip)     # 0x352b4
jne 0x149c5
incl 0x20a5c(%rip)           # 0x353d8
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %rax
movaps %xmm0, -0x30(%rax)
movaps %xmm0, -0x10(%rax)
movaps %xmm0, -0x20(%rax)
movq $0x0, (%rax)
movq %rax, -0x30(%rax)
movq $0x1, -0x28(%rax)
movl $0x3f800000, -0x10(%rax) # imm = 0x3F800000
movups %xmm0, -0x8(%rax)
leaq 0x209b3(%rip), %rdi     # 0x35368
movq %rsp, %rsi
callq 0x1595a
movq %rsp, %rdi
callq 0x15450
movb $0x1, 0x208e8(%rip)     # 0x352b4
addq $0x40, %rsp
popq %rbx
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x15450
movq %rbx, %rdi
callq 0x54c0
// File: /workspace/github_cpp_makefile_star2_O1/lhydave[P]SysYCompilerLab/front/node.cpp
// Function: yyerror(char const*, int)
void yyerror(const char *msg, int lineno)
{
	has_err = true;
	++err_cnt;
	if (err_cnt > err_max)
	{
		fprintf(stderr, "Too many errors, aborted.\n");
		exit(1);
	}
	fprintf(stderr, "error happens near line %d: %s\n", lineno, msg);
}

// Assembly:
movl %esi, %edx
movq %rdi, %rcx
leaq 0x2d208(%rip), %rax     # 0x353f0
movb $0x1, (%rax)
movl 0x2d14f(%rip), %eax     # 0x35340
leal 0x1(%rax), %esi
movl %esi, 0x2d146(%rip)     # 0x35340
movq 0x2cdd7(%rip), %rsi     # 0x34fd8
movq (%rsi), %rdi
cmpl $0x28, %eax
jge 0x8217
leaq 0x20694(%rip), %rsi     # 0x288a4
xorl %eax, %eax
jmp 0x53a0
pushq %rax
callq 0x5540
// File: /workspace/github_cpp_makefile_star2_O1/lhydave[P]SysYCompilerLab/front/node.cpp
// Function: sysY_AST::str2op(char const*)
op_t str2op(const char *s)
{
	switch (s[0])
	{
	case '+': return ADD;
	case '-': return SUB;
	case '*': return MUL;
	case '/': return DIV;
	case '%': return MOD;
	case '&': return AND;
	case '|': return OR;
	case '<':
		if (s[1] == '=')
			return LE;
		return L;
	case '>':
		if (s[1] == '=')
			return GE;
		return G;
	case '!':
		if (s[1] == '=')
			return NE;
		return NOT;
	default: return NONE;
	}
}

// Assembly:
movzbl (%rdi), %eax
cmpl $0x3b, %eax
jg 0x826d
addl $-0x21, %eax
cmpl $0xe, %eax
ja 0x82c8
leaq 0x20416(%rip), %rcx     # 0x28668
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cmpb $0x3d, 0x1(%rdi)
movl $0x2, %ecx
movl $0xf, %eax
cmovel %ecx, %eax
retq
cmpl $0x3c, %eax
je 0x82a6
cmpl $0x3e, %eax
je 0x82b7
cmpl $0x7c, %eax
jne 0x82c8
movl $0xe, %eax
retq
movl $0xb, %eax
retq
movl $0xa, %eax
retq
movl $0x8, %eax
retq
movl $0xd, %eax
retq
movl $0xc, %eax
retq
movl $0x7, %eax
retq
xorl %eax, %eax
cmpb $0x3d, 0x1(%rdi)
setne %al
leal 0x4(,%rax,2), %eax
retq
xorl %eax, %eax
cmpb $0x3d, 0x1(%rdi)
setne %al
leal 0x3(,%rax,2), %eax
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/lhydave[P]SysYCompilerLab/front/node.cpp
// Function: sysY_AST::str2num(char const*, int)
int str2num(const char *s, int base)
{
	int len = strlen(s);
	int val = 0;
	for (int i = 0; i < len; i++)
	{
		if (s[i] >= '0' && s[i] <= '9')
			val = val * base + (s[i] - '0');
		else if (s[i] >= 'a' && s[i] <= 'f')
			val = val * base + (s[i] - 'a') + 10;
		else if (s[i] >= 'A' && s[i] <= 'F')
			val = val * base + (s[i] - 'A') + 10;
		else
			return -1;
	}
	return val;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
callq 0x5110
testl %eax, %eax
jle 0x8365
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
xorl %edx, %edx
xorl %ecx, %ecx
movsbl (%r14,%rdx), %esi
leal -0x30(%rsi), %edi
cmpb $0x9, %dil
ja 0x8337
imull %ebx, %ecx
addb $-0x30, %sil
movzbl %sil, %esi
addl %esi, %ecx
jmp 0x835b
leal -0x61(%rsi), %edi
cmpb $0x5, %dil
ja 0x834a
imull %ebx, %ecx
addl %esi, %ecx
addl $-0x57, %ecx
jmp 0x835b
leal -0x41(%rsi), %edi
cmpb $0x5, %dil
ja 0x8369
imull %ebx, %ecx
addl %esi, %ecx
addl $-0x37, %ecx
incq %rdx
cmpq %rdx, %rax
jne 0x831a
jmp 0x836e
xorl %ecx, %ecx
jmp 0x836e
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/lhydave[P]SysYCompilerLab/front/node.cpp
// Function: sysY_AST::vardef_node::set_shape(sysY_AST::exp_node*)
void vardef_node::set_shape(exp_node *first_dim)
{
	size = 1;
	if (is_pt)
		dim.push_back(0);
	while (first_dim)
	{
		first_dim->reduce();
		size_t temp = first_dim->num;
		if (first_dim->exp_type != EXP_NUM || first_dim->num <= 0)
		{
			yyerror("array size in delaration must be a positive constant int");
			temp = 1;
		}
		size *= temp;
		dim.push_back(temp);
		first_dim = first_dim->next;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x1, 0xa4(%rdi)
cmpb $0x1, 0xa0(%rdi)
jne 0x8811
movl $0x0, 0x4(%rsp)
movq 0x78(%r14), %rsi
cmpq 0x80(%r14), %rsi
je 0x8803
movl $0x0, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x78(%r14)
jmp 0x8811
leaq 0x70(%r14), %rdi
leaq 0x4(%rsp), %rdx
callq 0x1287c
testq %rbx, %rbx
je 0x889c
leaq 0x70(%r14), %r15
leaq 0x2ca8b(%rip), %rbp     # 0x352b0
leaq 0x200c5(%rip), %r12     # 0x288f1
movq %rsp, %r13
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
cmpl $0x2, 0x98(%rbx)
jne 0x884b
movl 0x94(%rbx), %eax
testl %eax, %eax
jg 0x885b
movl (%rbp), %esi
movq %r12, %rdi
callq 0x81dc
movl $0x1, %eax
movl 0xa4(%r14), %ecx
imull %eax, %ecx
movl %ecx, 0xa4(%r14)
movl %eax, (%rsp)
movq 0x78(%r14), %rsi
cmpq 0x80(%r14), %rsi
je 0x8888
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x78(%r14)
jmp 0x8893
movq %r15, %rdi
movq %r13, %rdx
callq 0x1287c
movq 0x40(%rbx), %rbx
testq %rbx, %rbx
jne 0x882f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/lhydave[P]SysYCompilerLab/front/node.cpp
// Function: sysY_AST::funcdef_node::funcdef_node(char const*, sysY_AST::data_t, sysY_AST::node_basic*)
funcdef_node::funcdef_node(
	const char *_name, data_t _ret_type, node_basic *_blk)
{
	blk = _blk;
	name = string(_name);
	dbg_printf("def a func named %s\n", _name);
	ret_type = _ret_type;
	add_ret(blk != nullptr);
	gen_code();
	temp_id = 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebp
movq %rdi, %rbx
leaq 0x2a788(%rip), %rax     # 0x345d8
movq %rax, (%rdi)
leaq 0x28(%rdi), %r12
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movq %r12, 0x18(%rdi)
xorl %eax, %eax
movq %rax, 0x20(%rdi)
movb %al, 0x28(%rdi)
leaq 0x2b43e(%rip), %rdx     # 0x352b0
movl (%rdx), %edx
movl %edx, 0x38(%rdi)
leaq 0x2a562(%rip), %rdx     # 0x343e0
movq %rdx, (%rdi)
leaq 0x40(%rdi), %r14
leaq 0x50(%rdi), %r13
movq %r13, 0x40(%rdi)
movq %rax, 0x48(%rdi)
movb %al, 0x50(%rdi)
movups %xmm0, 0x70(%rdi)
movq %rax, 0x80(%rdi)
movq %rcx, 0x68(%rdi)
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x6eb8
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x5310
movq (%r15), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x9edc
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5240
movl %ebp, 0x60(%rbx)
xorl %esi, %esi
cmpq $0x0, 0x68(%rbx)
setne %sil
movq %rbx, %rdi
callq 0x9f6e
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
movl $0x0, 0x2b444(%rip)     # 0x35348
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x9f15
movq %rax, %r15
leaq 0x70(%rbx), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x9f33
movq 0x80(%rbx), %rsi
subq %rdi, %rsi
callq 0x5240
movq (%r14), %rdi
cmpq %r13, %rdi
je 0x9f47
movq (%r13), %rsi
incq %rsi
callq 0x5240
leaq 0x2a68a(%rip), %rax     # 0x345d8
movq %rax, (%rbx)
movq 0x18(%rbx), %rdi
cmpq %r12, %rdi
je 0x9f66
movq (%r12), %rsi
incq %rsi
callq 0x5240
movq %r15, %rdi
callq 0x54c0
// File: /workspace/github_cpp_makefile_star2_O1/lhydave[P]SysYCompilerLab/front/node.cpp
// Function: sysY_AST::funcdef_node::add_ret(bool)
void funcdef_node::add_ret(bool is_append)
{
	dbg_printf("add ret is_append: %d\n", is_append);
	now_func_name = name;
	auto has_ret_val = (func_table[name].ret_type == INT);
	ret_stmt_node *ret_stmt;
	if (has_ret_val)
		ret_stmt = new ret_stmt_node(new exp_node(EXP_NUM, "", 0));
	else
		ret_stmt = new ret_stmt_node(nullptr);
	if (is_append)
		blk->code += ret_stmt->code;
	else
		blk = ret_stmt;
	now_func_name = "";
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebp
movq %rdi, %r15
leaq 0x40(%rdi), %rbx
leaq 0x2b42c(%rip), %r14     # 0x353b8
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5140
leaq 0x2b3e2(%rip), %rdi     # 0x35380
movq %rbx, %rsi
callq 0x12e54
movl 0x50(%rax), %r12d
movl $0x48, %edi
callq 0x5220
movq %rax, %rbx
cmpl $0x1, %r12d
jne 0xa030
movl $0xa0, %edi
callq 0x5220
movq %rax, %r12
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x1f8ff(%rip), %rdx     # 0x298d9
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0x6ef6
movb $0x1, %r13b
leaq 0x8(%rsp), %rdx
movq %r12, %rdi
movl $0x2, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0xe4d0
xorl %r13d, %r13d
movq %rbx, %rdi
movq %r12, %rsi
callq 0xe044
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xa03a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5240
jmp 0xa03a
movq %rbx, %rdi
xorl %esi, %esi
callq 0xe044
testb %bpl, %bpl
je 0xa056
movq 0x68(%r15), %rdi
addq $0x18, %rdi
movq 0x18(%rbx), %rsi
movq 0x20(%rbx), %rdx
callq 0x50c0
jmp 0xa05a
movq %rbx, 0x68(%r15)
movq 0x8(%r14), %rdx
leaq 0x1f874(%rip), %rcx     # 0x298d9
movq %r14, %rdi
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x53f0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movb $0x1, %r13b
jmp 0xa0af
jmp 0xa08b
movq %rax, %r14
jmp 0xa0c1
movq %rax, %r14
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xa0af
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5240
testb %r13b, %r13b
je 0xa0c1
movl $0xa0, %esi
movq %r12, %rdi
callq 0x5240
movl $0x48, %esi
movq %rbx, %rdi
callq 0x5240
movq %r14, %rdi
callq 0x54c0
// File: /workspace/github_cpp_makefile_star2_O1/lhydave[P]SysYCompilerLab/front/node.cpp
// Function: sysY_AST::stmt_node::stmt_node(sysY_AST::node_basic*)
stmt_node::stmt_node(node_basic *_child)
{
	child = _child;
	if (blk_id == 1) // in the function
		last_stmt = this;
	gen_code();
	dbg_printf("create a stmt_node...\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x29240(%rip), %r12     # 0x345d8
movq %r12, (%rdi)
leaq 0x28(%rdi), %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movq %r15, 0x18(%rdi)
movq $0x0, 0x20(%rdi)
movb $0x0, 0x28(%rdi)
leaq 0x29ef3(%rip), %rax     # 0x352b0
movl (%rax), %eax
movl %eax, 0x38(%rdi)
leaq 0x29037(%rip), %rax     # 0x34400
movq %rax, (%rdi)
movq %rsi, 0x10(%rdi)
leaq 0x2a001(%rip), %rax     # 0x353d8
cmpl $0x1, (%rax)
jne 0xb3e3
movq %rbx, 0x29f6d(%rip)     # 0x35350
testq %rsi, %rsi
je 0xb3fc
leaq 0x18(%rbx), %rdi
movq 0x18(%rsi), %rax
movq 0x20(%rsi), %rdx
movq %rax, %rsi
callq 0x50c0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq %r12, (%rbx)
movq 0x18(%rbx), %rdi
cmpq %r15, %rdi
je 0xb422
movq (%r15), %rsi
incq %rsi
callq 0x5240
movq %r14, %rdi
callq 0x54c0
// File: /workspace/github_cpp_makefile_star2_O1/lhydave[P]SysYCompilerLab/front/node.cpp
// Function: sysY_AST::assign_stmt_node::assign_stmt_node(sysY_AST::exp_node*, sysY_AST::exp_node*)
assign_stmt_node::assign_stmt_node(exp_node *_lval, exp_node *_assign_exp)
{
	lval = _lval;
	assign_exp = _assign_exp;
	if (lval->exp_type != EXP_ARRAY && lval->exp_type != EXP_VAR)
		yyerror("expression is not assignable");

	assign_exp->reduce();
	if (lval->exp_type == EXP_ARRAY)
		assign_exp->new_temp();
	gen_code();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x2916e(%rip), %r12     # 0x345d8
movq %r12, (%rdi)
leaq 0x28(%rdi), %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movq %r15, 0x18(%rdi)
xorl %ecx, %ecx
movq %rcx, 0x20(%rdi)
movb $0x0, 0x28(%rdi)
leaq 0x29e23(%rip), %rax     # 0x352b0
movl (%rax), %eax
movl %eax, 0x38(%rdi)
leaq 0x28f67(%rip), %rdi     # 0x34400
movq %rdi, (%rbx)
movq %rcx, 0x10(%rbx)
leaq 0x29f31(%rip), %rcx     # 0x353d8
cmpl $0x1, (%rcx)
jne 0xb4b3
movq %rbx, 0x29e9d(%rip)     # 0x35350
leaq 0x28f6e(%rip), %rcx     # 0x34428
movq %rcx, (%rbx)
movq %rsi, 0x40(%rbx)
movq %rdx, 0x48(%rbx)
movl 0x98(%rsi), %ecx
cmpl $0x1, %ecx
je 0xb4e3
cmpl $0x4, %ecx
je 0xb4e3
leaq 0x1d502(%rip), %rdi     # 0x289de
movl %eax, %esi
callq 0x81dc
movq 0x48(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x40(%rbx), %rax
cmpl $0x4, 0x98(%rax)
jne 0xb504
movq 0x48(%rbx), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq %r12, (%rbx)
movq 0x18(%rbx), %rdi
cmpq %r15, %rdi
je 0xb532
movq (%r15), %rsi
incq %rsi
callq 0x5240
movq %r14, %rdi
callq 0x54c0
// File: /workspace/github_cpp_makefile_star2_O1/lhydave[P]SysYCompilerLab/front/node.cpp
// Function: sysY_AST::exp_stmt_node::gen_code()
void exp_stmt_node::gen_code()
{
	if (exp_stmt->exp_type == EXP_FUNC_CALL)
	{
		auto func_exp_stmt = static_cast<func_call_exp_node *>(exp_stmt);
		func_entry query;
		find_func(func_exp_stmt->sysy_func_name, query);
		if (query.ret_type == INT)
		{
			exp_stmt->new_temp();
			code = exp_stmt->code;
		}
		else
		{
			code = exp_stmt->code;
			code += "\t" + exp_stmt->eeyore_name + "\n";
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xa0, %rsp
movq %rdi, %r14
movq 0x40(%rdi), %rdi
cmpl $0x3, 0x98(%rdi)
jne 0xb9d3
leaq 0x58(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r15)
movups %xmm0, 0x20(%r15)
movups %xmm0, 0x30(%r15)
addq $0xb8, %rdi
leaq 0x48(%rsp), %rsi
callq 0x150b3
cmpl $0x1, 0x98(%rsp)
movq 0x40(%r14), %rsi
jne 0xb8dc
movq (%rsi), %rax
movq %rsi, %rdi
callq *0x10(%rax)
movq 0x40(%r14), %rsi
addq $0x18, %rsi
addq $0x18, %r14
movq %r14, %rdi
callq 0x5140
jmp 0xb9a0
addq $0x18, %rsi
leaq 0x18(%r14), %rbx
movq %rbx, %rdi
callq 0x5140
movq 0x40(%r14), %rdx
addq $0x70, %rdx
leaq 0x1dfdd(%rip), %rsi     # 0x298d8
leaq 0x28(%rsp), %rdi
callq 0x11eb4
leaq 0x1d0d0(%rip), %rsi     # 0x289dc
leaq 0x28(%rsp), %rdi
callq 0x5510
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0xb93d
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
jmp 0xb944
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movq 0x8(%rax), %rdx
movq %rdx, 0x10(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x50c0
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0xb985
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5240
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb9a0
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x5240
leaq 0x68(%rsp), %rbx
leaq 0x80(%rsp), %r14
movq %r14, %rdi
callq 0x123f6
movq %rbx, %rdi
callq 0x123f6
movq -0x38(%r14), %rdi
cmpq %r15, %rdi
je 0xb9d3
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x5240
addq $0xa0, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0xb9ff
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5240
jmp 0xb9ff
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xba21
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x5240
jmp 0xba21
jmp 0xba1e
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x12222
movq %rbx, %rdi
callq 0x54c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/lhydave[P]SysYCompilerLab/front/node.cpp
// Function: sysY_AST::if_stmt_node::update(sysY_AST::cond_exp_node*, sysY_AST::node_basic*, sysY_AST::node_basic*)
void if_stmt_node::update(
	cond_exp_node *_cond, node_basic *_true_stmt, node_basic *_false_stmt)
{
	cond = _cond;
	true_stmt = _true_stmt;
	false_stmt = _false_stmt;
	has_else = (false_stmt != nullptr);
	if (!has_else)
	{
		cond->true_label = true_label = fall_label;
		cond->false_label = false_label = new_label();
	}
	else
	{
		cond->true_label = true_label = new_label();
		cond->false_label = false_label = new_label();
	}
	cond->traverse();
	gen_code();
	fall_label = old_fall_label;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq %rsi, 0x40(%rdi)
movq %rdx, 0x48(%rdi)
movq %rcx, 0x50(%rdi)
testq %rcx, %rcx
setne 0x64(%rdi)
je 0xbae4
movl 0x2988b(%rip), %ecx     # 0x35358
leal 0x1(%rcx), %eax
movl %eax, 0x29882(%rip)     # 0x35358
movl %ecx, 0x58(%rbx)
movl %ecx, 0xb0(%rsi)
addl $0x2, %ecx
jmp 0xbafc
movl 0x29872(%rip), %eax     # 0x3535c
movl %eax, 0x58(%rbx)
movl %eax, 0xb0(%rsi)
movl 0x2985f(%rip), %eax     # 0x35358
leal 0x1(%rax), %ecx
movl %ecx, 0x29856(%rip)     # 0x35358
movl %eax, 0x5c(%rbx)
movl %eax, 0xb4(%rsi)
movq %rsi, %rdi
callq 0xbb26
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
movl 0x60(%rbx), %eax
movl %eax, 0x29838(%rip)     # 0x3535c
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/lhydave[P]SysYCompilerLab/front/node.cpp
// Function: sysY_AST::while_stmt_node::update(sysY_AST::cond_exp_node*, sysY_AST::node_basic*, sysY_AST::node_basic*)
void while_stmt_node::update(
	cond_exp_node *_cond, node_basic *_true_stmt, node_basic *_next_stmt)
{
	cond = _cond;
	true_stmt = _true_stmt;
	cond->true_label = true_label = fall_label;
	cond->false_label = while_next_label;
	cond->traverse();
	gen_code();
	fall_label = old_fall_label;
	while_start_label = old_start_label;
	while_next_label = old_next_label;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq %rsi, 0x40(%rdi)
movq %rdx, 0x48(%rdi)
movl 0x27eb4(%rip), %eax     # 0x3535c
movl %eax, 0x50(%rdi)
movl %eax, 0xb0(%rsi)
movl 0x27ead(%rip), %eax     # 0x35364
movl %eax, 0xb4(%rsi)
movq %rsi, %rdi
callq 0xbb26
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
movl 0x54(%rbx), %eax
movl %eax, 0x27e86(%rip)     # 0x3535c
movl 0x5c(%rbx), %eax
movl %eax, 0x27e81(%rip)     # 0x35360
movl 0x58(%rbx), %eax
movl %eax, 0x27e7c(%rip)     # 0x35364
popq %rbx
retq