LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/alan0201tw[P]RayTracer/include/stb_image.h
// Function: stbi__png_info_raw(stbi__png*, int*, int*, int*)
static int stbi__png_info_raw(stbi__png *p, int *x, int *y, int *comp)
{
   if (!stbi__parse_png_file(p, STBI__SCAN_header, 0)) {
      stbi__rewind( p->s );
      return 0;
   }
   if (x) *x = p->s->img_x;
   if (y) *y = p->s->img_y;
   if (comp) *comp = p->s->img_n;
   return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
pushq $0x2
popq %rsi
xorl %ebp, %ebp
xorl %edx, %edx
callq 0x295ba
testl %eax, %eax
je 0x2cd9c
testq %r12, %r12
je 0x2cd7c
movq (%r14), %rax
movl (%rax), %eax
movl %eax, (%r12)
testq %r15, %r15
je 0x2cd8a
movq (%r14), %rax
movl 0x4(%rax), %eax
movl %eax, (%r15)
pushq $0x1
popq %rbp
testq %rbx, %rbx
je 0x2cdad
movq (%r14), %rax
movl 0x8(%rax), %eax
movl %eax, (%rbx)
jmp 0x2cdad
movq (%r14), %rax
movups 0xc8(%rax), %xmm0
movups %xmm0, 0xb8(%rax)
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/alan0201tw[P]RayTracer/include/stb_image_write.h
// Function: stbiw__write_pixel(stbi__write_context*, int, int, int, int, unsigned char*)
static void stbiw__write_pixel(stbi__write_context *s, int rgb_dir, int comp, int write_alpha, int expand_mono, unsigned char *d)
{
   unsigned char bg[3] = { 255, 0, 255}, px[3];
   int k;

   if (write_alpha < 0)
      s->func(s->context, &d[comp - 1], 1);

   switch (comp) {
      case 2: // 2 pixels = mono + alpha, alpha is written separately, so same as 1-channel case
      case 1:
         if (expand_mono)
            stbiw__write3(s, d[0], d[0], d[0]); // monochrome bmp
         else
            s->func(s->context, d, 1);  // monochrome TGA
         break;
      case 4:
         if (!write_alpha) {
            // composite against pink background
            for (k = 0; k < 3; ++k)
               px[k] = bg[k] + ((d[k] - bg[k]) * d[3]) / 255;
            stbiw__write3(s, px[1 - rgb_dir], px[1], px[1 + rgb_dir]);
            break;
         }
         /* FALLTHROUGH */
      case 3:
         stbiw__write3(s, d[1 - rgb_dir], d[1], d[1 + rgb_dir]);
         break;
   }
   if (write_alpha > 0)
      s->func(s->context, &d[comp - 1], 1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %r8, %r14
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %rbx
leal -0x1(%r15), %eax
cmpl $0x2, %eax
jb 0x2d0be
cmpl $0x3, %r15d
je 0x2d0a4
cmpl $0x4, %r15d
jne 0x2d0db
testl %ebp, %ebp
je 0x2d109
movb 0x2(%r14), %al
movb (%r14), %cl
movb 0x1(%r14), %dl
leaq 0x15(%rsp), %rsi
movb %al, (%rsi)
movb %dl, 0x1(%rsi)
movb %cl, 0x2(%rsi)
jmp 0x2d0d2
testl %ecx, %ecx
je 0x2d0fd
movb (%r14), %al
leaq 0xf(%rsp), %rsi
movb %al, (%rsi)
movb %al, 0x1(%rsi)
movb %al, 0x2(%rsi)
movq 0x8(%rbx), %rdi
pushq $0x3
popq %rdx
callq *(%rbx)
testl %ebp, %ebp
jle 0x2d0f2
movq 0x8(%rbx), %rdi
movslq %r15d, %rax
leaq (%r14,%rax), %rsi
decq %rsi
pushq $0x1
popq %rdx
callq *(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%rbx), %rdi
pushq $0x1
popq %rdx
movq %r14, %rsi
jmp 0x2d0d9
movzbl 0x3(%r14), %ecx
xorl %esi, %esi
leaq 0x4c09(%rip), %rdi      # 0x31d20
movl $0xff, %r8d
cmpq $0x3, %rsi
je 0x2d143
movzbl (%rsi,%rdi), %r9d
movzbl (%r14,%rsi), %eax
subl %r9d, %eax
imull %ecx, %eax
cltd
idivl %r8d
addb %r9b, %al
movb %al, 0xc(%rsp,%rsi)
incq %rsi
jmp 0x2d11d
movb 0xe(%rsp), %al
movb 0xc(%rsp), %cl
movb 0xd(%rsp), %dl
leaq 0x12(%rsp), %rsi
jmp 0x2d0b4
// File: /workspace/github_cpp_makefile_star2_O2/alan0201tw[P]RayTracer/include/stb_image_write.h
// Function: stbiw__jpg_writeBits(stbi__write_context*, int*, int*, unsigned short const*)
static void stbiw__jpg_writeBits(stbi__write_context *s, int *bitBufP, int *bitCntP, const unsigned short *bs) {
   int bitBuf = *bitBufP, bitCnt = *bitCntP;
   bitCnt += bs[1];
   bitBuf |= bs[0] << (24 - bitCnt);
   while(bitCnt >= 8) {
      unsigned char c = (bitBuf >> 16) & 255;
      stbiw__putc(s, c);
      if(c == 255) {
         stbiw__putc(s, 0);
      }
      bitBuf <<= 8;
      bitCnt -= 8;
   }
   *bitBufP = bitBuf;
   *bitCntP = bitCnt;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movzwl 0x2(%rcx), %ebx
movq %rdx, 0x10(%rsp)
addl (%rdx), %ebx
movzwl (%rcx), %r14d
movb $0x18, %cl
subb %bl, %cl
shll %cl, %r14d
movq %rsi, 0x8(%rsp)
orl (%rsi), %r14d
movq %rdi, %r15
leaq 0x6(%rsp), %r12
pushq $0x1
popq %rbp
leaq 0x7(%rsp), %r13
cmpl $0x8, %ebx
jl 0x2d609
movl %r14d, %eax
shrl $0x10, %eax
movb %al, 0x6(%rsp)
movq 0x8(%r15), %rdi
movq %r12, %rsi
movl %ebp, %edx
callq *(%r15)
movl %r14d, %eax
notl %eax
testl $0xff0000, %eax         # imm = 0xFF0000
jne 0x2d600
movb $0x0, 0x7(%rsp)
movq 0x8(%r15), %rdi
movq %r13, %rsi
movl %ebp, %edx
callq *(%r15)
shll $0x8, %r14d
addl $-0x8, %ebx
jmp 0x2d5c8
movq 0x8(%rsp), %rax
movl %r14d, (%rax)
movq 0x10(%rsp), %rax
movl %ebx, (%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/alan0201tw[P]RayTracer/include/stb_image_write.h
// Function: stbiw__jpg_DCT(float*, float*, float*, float*, float*, float*, float*, float*)
static void stbiw__jpg_DCT(float *d0p, float *d1p, float *d2p, float *d3p, float *d4p, float *d5p, float *d6p, float *d7p) {
   float d0 = *d0p, d1 = *d1p, d2 = *d2p, d3 = *d3p, d4 = *d4p, d5 = *d5p, d6 = *d6p, d7 = *d7p;
   float z1, z2, z3, z4, z5, z11, z13;

   float tmp0 = d0 + d7;
   float tmp7 = d0 - d7;
   float tmp1 = d1 + d6;
   float tmp6 = d1 - d6;
   float tmp2 = d2 + d5;
   float tmp5 = d2 - d5;
   float tmp3 = d3 + d4;
   float tmp4 = d3 - d4;

   // Even part
   float tmp10 = tmp0 + tmp3;   // phase 2
   float tmp13 = tmp0 - tmp3;
   float tmp11 = tmp1 + tmp2;
   float tmp12 = tmp1 - tmp2;

   d0 = tmp10 + tmp11;       // phase 3
   d4 = tmp10 - tmp11;

   z1 = (tmp12 + tmp13) * 0.707106781f; // c4
   d2 = tmp13 + z1;       // phase 5
   d6 = tmp13 - z1;

   // Odd part
   tmp10 = tmp4 + tmp5;       // phase 2
   tmp11 = tmp5 + tmp6;
   tmp12 = tmp6 + tmp7;

   // The rotator is modified from fig 4-8 to avoid extra negations.
   z5 = (tmp10 - tmp12) * 0.382683433f; // c6
   z2 = tmp10 * 0.541196100f + z5; // c2-c6
   z4 = tmp12 * 1.306562965f + z5; // c2+c6
   z3 = tmp11 * 0.707106781f; // c4

   z11 = tmp7 + z3;      // phase 5
   z13 = tmp7 - z3;

   *d5p = z13 + z2;         // phase 6
   *d3p = z13 - z2;
   *d1p = z11 + z4;
   *d7p = z11 - z4;

   *d0p = d0;  *d2p = d2;  *d4p = d4;  *d6p = d6;
}

// Assembly:
movq 0x10(%rsp), %r10
movq 0x8(%rsp), %rax
movss (%rdi), %xmm2
movss (%rsi), %xmm0
movss (%rdx), %xmm4
movss (%rcx), %xmm3
movss (%r8), %xmm5
movss (%r9), %xmm6
movss (%rax), %xmm7
movss (%r10), %xmm8
movaps %xmm2, %xmm1
addss %xmm8, %xmm1
subss %xmm8, %xmm2
movaps %xmm0, %xmm8
addss %xmm7, %xmm8
subss %xmm7, %xmm0
movaps %xmm4, %xmm7
addss %xmm6, %xmm7
subss %xmm6, %xmm4
movaps %xmm3, %xmm6
addss %xmm5, %xmm6
subss %xmm5, %xmm3
movaps %xmm6, %xmm5
addss %xmm1, %xmm5
subss %xmm6, %xmm1
movaps %xmm7, %xmm9
addss %xmm8, %xmm9
subss %xmm7, %xmm8
movaps %xmm9, %xmm6
addss %xmm5, %xmm6
subss %xmm9, %xmm5
addss %xmm1, %xmm8
movss 0x3d70(%rip), %xmm9     # 0x31428
mulss %xmm9, %xmm8
movaps %xmm1, %xmm7
addss %xmm8, %xmm7
subss %xmm8, %xmm1
addss %xmm4, %xmm3
addss %xmm0, %xmm4
addss %xmm2, %xmm0
movaps %xmm3, %xmm8
subss %xmm0, %xmm8
mulss 0x3d44(%rip), %xmm8     # 0x3142c
mulss 0x3d40(%rip), %xmm3     # 0x31430
mulss 0x3d3c(%rip), %xmm0     # 0x31434
addss %xmm8, %xmm3
addss %xmm8, %xmm0
mulss %xmm9, %xmm4
movaps %xmm2, %xmm8
addss %xmm4, %xmm8
subss %xmm4, %xmm2
movaps %xmm2, %xmm4
addss %xmm3, %xmm4
movss %xmm4, (%r9)
subss %xmm3, %xmm2
movss %xmm2, (%rcx)
movaps %xmm8, %xmm2
addss %xmm0, %xmm2
movss %xmm2, (%rsi)
subss %xmm0, %xmm8
movss %xmm8, (%r10)
movss %xmm6, (%rdi)
movss %xmm7, (%rdx)
movss %xmm5, (%r8)
movss %xmm1, (%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O2/alan0201tw[P]RayTracer/include/stb_image_write.h
// Function: stbiw__jpg_calcBits(int, unsigned short*)
static void stbiw__jpg_calcBits(int val, unsigned short bits[2]) {
   int tmp1 = val < 0 ? -val : val;
   val = val < 0 ? val-1 : val;
   bits[1] = 1;
   while(tmp1 >>= 1) {
      ++bits[1];
   }
   bits[0] = val & ((1<<bits[1])-1);
}

// Assembly:
movl %edi, %eax
negl %eax
cmovsl %edi, %eax
pushq $0x1
popq %rcx
cmpl $0x2, %eax
jb 0x2d765
shrl %eax
incl %ecx
jmp 0x2d75a
movw %cx, 0x2(%rsi)
movl %edi, %eax
sarl $0x1f, %eax
pushq $-0x1
popq %rdx
shll %cl, %edx
addl %edi, %eax
notl %edx
andl %eax, %edx
movw %dx, (%rsi)
retq
// File: /workspace/github_cpp_makefile_star2_O2/alan0201tw[P]RayTracer/include/camera.hpp
// Function: camera::get_ray(float, float) const
inline ray get_ray(float u, float v) const
    {
        // add time to construct ray
        vec3 rd = lens_radius * random_in_unit_disk();
        vec3 offset = camera_right * rd.x() + camera_up * rd.y();

        float time = open_time + drand48() * (close_time - open_time);

        return ray(origin + offset, lower_left_corner + u * horizontal + v * vertical - origin - offset, time);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x78, %rsp
movss %xmm1, 0xc(%rsp)
movss %xmm0, 0x8(%rsp)
movq %rsi, %r14
movq %rdi, %rbx
movss 0x54(%rsi), %xmm0
movss %xmm0, (%rsp)
callq 0x11ca7
movaps %xmm0, %xmm1
movss (%rsp), %xmm2
movaps %xmm2, %xmm0
mulss %xmm1, %xmm0
shufps $0x55, %xmm1, %xmm1     # xmm1 = xmm1[1,1,1,1]
mulss %xmm2, %xmm1
movaps %xmm1, 0x20(%rsp)
leaq 0x3c(%r14), %rdi
callq 0x8c23
movaps %xmm0, 0x10(%rsp)
movss %xmm1, (%rsp)
leaq 0x48(%r14), %rdi
movaps 0x20(%rsp), %xmm0
callq 0x8c23
addps 0x10(%rsp), %xmm0
addss (%rsp), %xmm1
leaq 0x68(%rsp), %r15
movlps %xmm0, (%r15)
movss %xmm1, 0x8(%r15)
cvtss2sd 0x58(%r14), %xmm0
movsd %xmm0, (%rsp)
callq 0x63e0
movss 0x5c(%r14), %xmm1
subss 0x58(%r14), %xmm1
cvtss2sd %xmm1, %xmm1
mulsd %xmm0, %xmm1
addsd (%rsp), %xmm1
cvtsd2ss %xmm1, %xmm0
movss %xmm0, (%rsp)
leaq 0x24(%r14), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x896a
movaps %xmm0, 0x20(%rsp)
movss %xmm1, 0x10(%rsp)
leaq 0xc(%r14), %rdi
movss 0x8(%rsp), %xmm0
callq 0x8980
leaq 0x48(%rsp), %rsi
movlps %xmm0, (%rsi)
movss %xmm1, 0x8(%rsi)
movq %r14, %rdi
callq 0x896a
movaps %xmm0, 0x30(%rsp)
movss %xmm1, 0x8(%rsp)
addq $0x18, %r14
movss 0xc(%rsp), %xmm0
movq %r14, %rdi
callq 0x8980
addps 0x30(%rsp), %xmm0
addss 0x8(%rsp), %xmm1
leaq 0x58(%rsp), %rdi
movlps %xmm0, (%rdi)
movss %xmm1, 0x8(%rdi)
movq %r12, %rsi
callq 0x9449
movsd (%r15), %xmm2
subps %xmm2, %xmm0
subss 0x8(%r15), %xmm1
movaps 0x20(%rsp), %xmm2
movlps %xmm2, (%rbx)
movss 0x10(%rsp), %xmm2
movss %xmm2, 0x8(%rbx)
movlps %xmm0, 0xc(%rbx)
movss %xmm1, 0x14(%rbx)
movss (%rsp), %xmm0
movss %xmm0, 0x18(%rbx)
movq %rbx, %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/aayush-jaiswal[P]covid-in/src/download_data.cpp
// Function: get_api_data[abi:cxx11](char const*)
std::string get_api_data(const char *api_url) {
    CURL *curl_handle = curl_easy_init();
    CURLcode return_code;

    if (!curl_handle) {
        std::cerr << "CURL ERROR! EXITING!";
        exit(2);
    }

    // setup
    curl_easy_setopt(curl_handle, CURLOPT_URL, api_url);
    curl_easy_setopt(curl_handle, CURLOPT_WRITEFUNCTION, write_data);

    std::string data;
    
    curl_easy_setopt(curl_handle, CURLOPT_WRITEDATA, &data);
    return_code = curl_easy_perform(curl_handle);
    curl_easy_cleanup(curl_handle);

    if (return_code != CURLE_OK) {
        std::cerr << "An error occured! Make sure you have an active internet connection!\n";
        exit(2);
    }

    return data;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
callq 0x6550
testq %rax, %rax
je 0x6eb2
movq %rax, %r14
movq %rax, %rdi
movl $0x2712, %esi           # imm = 0x2712
movq %r15, %rdx
xorl %eax, %eax
callq 0x64c0
leaq -0x51(%rip), %rdx       # 0x6e0c
movq %r14, %rdi
movl $0x4e2b, %esi           # imm = 0x4E2B
xorl %eax, %eax
callq 0x64c0
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
andq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movq %r14, %rdi
movl $0x2711, %esi           # imm = 0x2711
movq %rbx, %rdx
xorl %eax, %eax
callq 0x64c0
movq %r14, %rdi
callq 0x63a0
movl %eax, %ebp
movq %r14, %rdi
callq 0x60d0
testl %ebp, %ebp
jne 0x6ec7
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x3810f(%rip), %rdi     # 0x3efc8
leaq 0x1f144(%rip), %rsi     # 0x26004
callq 0x6320
jmp 0x6eda
movq 0x380fa(%rip), %rdi     # 0x3efc8
leaq 0x1f144(%rip), %rsi     # 0x26019
callq 0x6320
pushq $0x2
popq %rdi
callq 0x6390
movq %rax, %r14
movq %rbx, %rdi
callq 0x6678
movq %r14, %rdi
callq 0x6360
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/aayush-jaiswal[P]covid-in/src/format_data.cpp
// Function: print_formatted_tested(nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>)
void print_formatted_tested (json data) {
    std::cout << "### Test Data ###\n\n";
    std::cout << "Total Samples Tested: " << stripped_string(data["totalsamplestested"]) << '\n';
    std::cout << "Total Positive Cases: " << stripped_string(data["totalpositivecases"]) << '\n';
    std::cout << "Last Updated Time: " << stripped_string(data["updatetimestamp"]) << '\n';
    std::cout << "---------\n";
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rdi, %rbx
movq 0x37b37(%rip), %r14     # 0x3ef80
leaq 0x1ece7(%rip), %rsi     # 0x26137
movq %r14, %rdi
callq 0x6320
leaq 0x1ecec(%rip), %rsi     # 0x2614b
movq %r14, %rdi
callq 0x6320
movq %rax, %r14
leaq 0x1ecf1(%rip), %rsi     # 0x26162
movq %rbx, %rdi
callq 0x7c54
leaq 0x60(%rsp), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x93d4
movq %rsp, %rdi
movq %r15, %rsi
callq 0x6ef8
movq %rsp, %rsi
movq %r14, %rdi
callq 0x6170
pushq $0xa
popq %rsi
movq %rax, %rdi
callq 0x6370
movq %rsp, %rdi
callq 0x6678
leaq 0x60(%rsp), %rdi
callq 0x6678
movq 0x37abd(%rip), %rdi     # 0x3ef80
leaq 0x1ecab(%rip), %rsi     # 0x26175
callq 0x6320
movq %rax, %r14
leaq 0x1ecb3(%rip), %rsi     # 0x2618c
movq %rbx, %rdi
callq 0x7c54
leaq 0x40(%rsp), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x93d4
movq %rsp, %rdi
movq %r15, %rsi
callq 0x6ef8
movq %rsp, %rsi
movq %r14, %rdi
callq 0x6170
pushq $0xa
popq %rsi
movq %rax, %rdi
callq 0x6370
movq %rsp, %rdi
callq 0x6678
leaq 0x40(%rsp), %rdi
callq 0x6678
movq 0x37a55(%rip), %rdi     # 0x3ef80
leaq 0x1ebd6(%rip), %rsi     # 0x26108
callq 0x6320
movq %rax, %r14
leaq 0x1ec5e(%rip), %rsi     # 0x2619f
movq %rbx, %rdi
callq 0x7c54
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x93d4
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x6ef8
movq %rsp, %rsi
movq %r14, %rdi
callq 0x6170
pushq $0xa
popq %rsi
movq %rax, %rdi
callq 0x6370
movq %rsp, %rdi
callq 0x6678
leaq 0x20(%rsp), %rdi
callq 0x6678
movq 0x379ed(%rip), %rdi     # 0x3ef80
leaq 0x1eb92(%rip), %rsi     # 0x2612c
callq 0x6320
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
jmp 0x75c6
movq %rax, %rbx
jmp 0x75d8
movq %rax, %rbx
jmp 0x75ea
movq %rax, %rbx
movq %rsp, %rdi
callq 0x6678
leaq 0x20(%rsp), %rdi
jmp 0x75ef
movq %rax, %rbx
movq %rsp, %rdi
callq 0x6678
leaq 0x40(%rsp), %rdi
jmp 0x75ef
movq %rax, %rbx
movq %rsp, %rdi
callq 0x6678
leaq 0x60(%rsp), %rdi
callq 0x6678
movq %rbx, %rdi
callq 0x6360
// File: /workspace/github_cpp_makefile_star2_O2/aayush-jaiswal[P]covid-in/include/cxxopts.hpp
// Function: void cxxopts::values::parse_value<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&)
void
    parse_value(const std::string& text, std::vector<T>& value)
    {
      std::stringstream in(text);
      std::string token;
      while(in.eof() == false && std::getline(in, token, CXXOPTS_VECTOR_DELIMITER)) {
        T v;
        parse_value(token, v);
        value.emplace_back(std::move(v));
      }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1c8, %rsp            # imm = 0x1C8
movq %rsi, %rbx
movq %rdi, %rsi
leaq 0x40(%rsp), %r14
pushq $0x18
popq %rdx
movq %r14, %rdi
callq 0x6660
leaq 0x30(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x10(%rsp), %r13
leaq 0x20(%rsp), %r15
pushq $0x2c
popq %rbp
movq %rsp, %r12
movq 0x40(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x2, 0x60(%rsp,%rax)
jne 0x1eec2
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x6030
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x1eec2
movq %r13, (%rsp)
andq $0x0, 0x8(%rsp)
movb $0x0, 0x10(%rsp)
movq %r12, %rdi
movq %r15, %rsi
callq 0x6610
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1ef14
movq %r12, %rdi
callq 0x6678
jmp 0x1ee68
leaq 0x20(%rsp), %rdi
callq 0x6678
leaq 0x40(%rsp), %rdi
callq 0x61e0
addq $0x1c8, %rsp            # imm = 0x1C8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x1eef8
movq %rax, %rbx
movq %rsp, %rdi
callq 0x6678
leaq 0x20(%rsp), %rdi
callq 0x6678
leaq 0x40(%rsp), %rdi
callq 0x61e0
movq %rbx, %rdi
callq 0x6360
// File: /workspace/github_cpp_makefile_star2_O2/aayush-jaiswal[P]covid-in/include/json.hpp
// Function: nlohmann::detail::iter_impl<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>>::operator--()
iter_impl& operator--()
    {
        assert(m_object != nullptr);

        switch (m_object->m_type)
        {
            case value_t::object:
            {
                std::advance(m_it.object_iterator, -1);
                break;
            }

            case value_t::array:
            {
                std::advance(m_it.array_iterator, -1);
                break;
            }

            default:
            {
                --m_it.primitive_iterator;
                break;
            }
        }

        return *this;
    }

// Assembly:
pushq %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x258dd
movq %rdi, %rbx
movzbl (%rax), %eax
cmpl $0x2, %eax
je 0x258cd
cmpl $0x1, %eax
jne 0x258d4
leaq 0x8(%rbx), %rdi
pushq $-0x1
popq %rsi
callq 0x9779
jmp 0x258d8
addq $-0x10, 0x10(%rbx)
jmp 0x258d8
decq 0x18(%rbx)
movq %rbx, %rax
popq %rbx
retq
leaq 0xd5f(%rip), %rdi       # 0x26643
leaq 0x94c(%rip), %rsi       # 0x26237
leaq 0x4956(%rip), %rcx      # 0x2a248
movl $0x25c9, %edx           # imm = 0x25C9
callq 0x6110
// File: /workspace/github_cpp_makefile_star2_O2/geoherna[P]lib605/./src/lib605.cpp
// Function: lib605::operator<<(std::ostream&, lib605::Track&)
std::ostream& operator<< (std::ostream &out, Track &sTrack) {
		out << "Track bit length: ";
		switch(sTrack.GetTrackBitLength()) {
			case Track::TRACK_5_BIT: {
				out << "5" << std::endl;
				break;
			} case Track::TRACK_7_BIT: {
				out << "7" << std::endl;
				break;
			} case Track::TRACK_8_BIT: {
				out << "8" << std::endl;
				break;
			} default: break;
		}
		out << "Data length: " << sTrack.GetTrackDataLength();
		return out;
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x1b5b(%rip), %rsi      # 0x5000
callq 0x31d0
movl 0xc(%r14), %eax
cmpq $0x2, %rax
ja 0x34d2
leaq 0x1c81(%rip), %rcx      # 0x513c
movslq (%rcx,%rax,4), %rsi
addq %rcx, %rsi
movq %rbx, %rdi
callq 0x31d0
movq %rax, %rdi
callq 0x3110
leaq 0x1b40(%rip), %rsi      # 0x5019
movq %rbx, %rdi
callq 0x31d0
movl 0x8(%r14), %esi
movq %rax, %rdi
callq 0x3300
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/geoherna[P]lib605/./src/lib605.cpp
// Function: lib605::Magstripe::~Magstripe()
Magstripe::~Magstripe(void) {
		// Clean up the tracks
		delete this->Track1;
		delete this->Track2;
		delete this->Track3;
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
testq %r14, %r14
je 0x3561
movq %r14, %rdi
callq 0x32e0
pushq $0x10
popq %rsi
movq %r14, %rdi
callq 0x3200
movq 0x8(%rbx), %r14
testq %r14, %r14
je 0x357d
movq %r14, %rdi
callq 0x32e0
pushq $0x10
popq %rsi
movq %r14, %rdi
callq 0x3200
movq 0x10(%rbx), %rbx
testq %rbx, %rbx
je 0x3599
movq %rbx, %rdi
callq 0x32e0
pushq $0x10
popq %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3200
nop
// File: /workspace/github_cpp_makefile_star2_O2/geoherna[P]lib605/./src/lib605.cpp
// Function: lib605::MSR::CycleLED()
void MSR::CycleLED(void) noexcept {
		this->SetLED(MSR::MSR_LED::LED_RED);
		std::this_thread::sleep_for(std::chrono::milliseconds(1500));
		this->SetLED(MSR::MSR_LED::LED_YELLOW);
		std::this_thread::sleep_for(std::chrono::milliseconds(1500));
		this->SetLED(MSR::MSR_LED::LED_GREEN);
		std::this_thread::sleep_for(std::chrono::milliseconds(1500));
		this->SetLED(MSR::MSR_LED::LED_OFF);
	}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
pushq $0x2
popq %rsi
callq 0x32c0
leaq 0x8(%rsp), %rdi
movq $0x5dc, (%rdi)          # imm = 0x5DC
callq 0x3330
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x32c0
leaq 0x8(%rsp), %rdi
movq $0x5dc, (%rdi)          # imm = 0x5DC
callq 0x3330
movq %rbx, %rdi
xorl %esi, %esi
callq 0x32c0
leaq 0x8(%rsp), %rdi
movq $0x5dc, (%rdi)          # imm = 0x5DC
callq 0x3330
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0x32c0
addq $0x10, %rsp
popq %rbx
retq
movq %rax, %rdi
callq 0x4036
nop
// File: /workspace/github_cpp_makefile_star2_O2/geoherna[P]lib605/./src/lib605.cpp
// Function: lib605::MSR::MSR()
MSR::MSR(void) noexcept {
		// Set the initial state
		this->MSRConected = false;
		// Give the default device
		this->Device = DEFAULT_DEV;
	}

// Assembly:
pushq %rax
leaq 0x18(%rdi), %rax
movq %rax, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
leaq 0x8(%rdi), %rax
xorl %ecx, %ecx
movb %cl, 0x18(%rdi)
movb %cl, 0x4(%rdi)
leaq 0x181a(%rip), %rsi      # 0x5089
movq %rax, %rdi
callq 0x3350
popq %rax
retq
movq %rax, %rdi
callq 0x4036
nop
// File: /workspace/github_cpp_makefile_star2_O2/geoherna[P]lib605/./src/lib605.cpp
// Function: lib605::MSR::Connect(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool MSR::Connect(std::string Device) {
#if defined(DEBUG)
		std::cout << "[*] Connecting to device '" << Device <<"'" << std::end;
#endif
		if(Device == "") {
			std::cout << "[*] Null device name, unable to connect" << std::endl;
			return false;
		}
		struct termios options;
		if((this->devhndl = open(Device.c_str(), O_RDWR | O_NOCTTY)) < 0) {
#if defined(DEBUG)
			std::cout << "[*] Error opening device for use" << std::endl;
#endif
			return false;
		}
		tcgetattr(this->devhndl, &options);

		options.c_cflag = CS8 | CREAD | CLOCAL;
		options.c_oflag = 0;
		options.c_iflag = 0;

		cfsetispeed(&options, B9600);
		cfsetospeed(&options, B9600);

		tcsetattr(this->devhndl, TCSANOW, &options);

		return (this->MSRConected = true);
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x16e3(%rip), %rsi      # 0x503e
movq %r14, %rdi
callq 0x3370
testb %al, %al
je 0x3986
movq 0x366a(%rip), %rdi      # 0x6fd8
leaq 0x1721(%rip), %rsi      # 0x5096
callq 0x31d0
movq %rax, %rdi
callq 0x3110
xorl %ebp, %ebp
jmp 0x39e4
movq (%r14), %rdi
movl $0x102, %esi            # imm = 0x102
xorl %eax, %eax
callq 0x3170
movl %eax, (%rbx)
testl %eax, %eax
setns %bpl
js 0x39e4
leaq 0xc(%rsp), %r14
movl %eax, %edi
movq %r14, %rsi
callq 0x3230
movl $0x8b0, 0x8(%r14)       # imm = 0x8B0
andq $0x0, (%r14)
pushq $0xd
popq %r15
movq %r14, %rdi
movl %r15d, %esi
callq 0x3140
movq %r14, %rdi
movl %r15d, %esi
callq 0x3220
movl (%rbx), %edi
xorl %esi, %esi
movq %r14, %rdx
callq 0x3250
movb $0x1, 0x4(%rbx)
movl %ebp, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/geoherna[P]lib605/./src/lib605.cpp
// Function: lib605::MSR::Initialize()
bool MSR::Initialize(void) {
		if(!this->MSRConected) {
#if defined(DEBUG)
			std::cout << "[*] Unable to initialize, not connect to device" << std::endl;
#endif
			return false;
		}
#if defined(DEBUG)
		std::cout << "[*] Initializing Device" << std::end;
#endif
		this->CycleLED();
#if defined(DEBUG)
		std::cout << "[*] Performing self test" << std::end;
#endif
		this->SetLED(MSR::MSR_LED::LED_YELLOW);
		if(this->TestCommunication() && (this->TestRAM() && this->TestSensor())) {
#if defined(DEBUG)
		std::cout << "[*] Self test succeeded" << std::end;
#endif
			this->SetLED(MSR::MSR_LED::LED_GREEN);
			this->SendReset();
			return true;
		} else {
#if defined(DEBUG)
		std::cout << "[*] Self test failed, RAM or Sensor Error" << std::end;
#endif
			this->SetLED(MSR::MSR_LED::LED_RED);
			return false;
		}
	}

// Assembly:
cmpb $0x1, 0x4(%rdi)
jne 0x3a46
pushq %rbx
movq %rdi, %rbx
callq 0x31e0
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x32c0
movq %rbx, %rdi
callq 0x31b0
testb %al, %al
je 0x3a49
movq %rbx, %rdi
callq 0x3290
testb %al, %al
je 0x3a49
movq %rbx, %rdi
callq 0x3270
testb %al, %al
je 0x3a49
movq %rbx, %rdi
xorl %esi, %esi
callq 0x32c0
movq %rbx, %rdi
callq 0x3180
movb $0x1, %al
jmp 0x3a56
xorl %eax, %eax
retq
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x32c0
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/geoherna[P]lib605/./src/lib605.cpp
// Function: lib605::MSR::ReadBytes(char*, int)
int MSR::ReadBytes(char* buffer, int len) {
		if(!this->MSRConected) {
#if defined(DEBUG)
			std::cout << "[*] Error: unable to read from non-connected device" << std::endl;
#endif
			return -1;
		}
		int temp = 0;
		int count;

		if(buffer == NULL) return -1;

		while(temp != len) {
			count = read(this->devhndl, (buffer + temp), (len - temp));
			if(count < 0) return -1;
			if(count > 0) temp += count;
		}
    	return count;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq $-0x1
popq %rbp
testq %rsi, %rsi
je 0x3b8e
movq %rdi, %r15
cmpb $0x0, 0x4(%rdi)
je 0x3b8e
movl %edx, %ebx
movq %rsi, %r14
xorl %r12d, %r12d
movl %ebx, %ecx
subl %r12d, %ecx
je 0x3b90
movl (%r15), %edi
movl %r12d, %esi
addq %r14, %rsi
movslq %ecx, %rdx
callq 0x32a0
addl %eax, %r12d
testl %eax, %eax
jns 0x3b6f
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/geoherna[P]lib605/./src/lib605.cpp
// Function: lib605::MSR::GetModel[abi:cxx11]()
std::string MSR::GetModel(void) {
		if(!this->MSRConected) {
#if defined(DEBUG)
			std::cout << "[*] Error: unable to get model from non-connected device" << std::endl;
#endif
			return "ERROR";
		}
		char* model = new char[3];
		this->WriteAutoSize(MSR_REQ_MODEL);
		if(this->ReadBytes(model, 3) != 3) {
#if defined(DEBUG)
			std::cout << "[*] Error: unable to read model number, expected 3 bytes" << std::endl;
#endif
			return "ERROR";
		}
		if((memcmp((char*)model[0], MSR_ESC, 1) == 0) && model[2] == 'S') {
			model[0] = model[1];
			model[1] = '\0';
			std::string mdl(model);
			delete[] model;
			return mdl;
		}
		return "ERROR";
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpb $0x0, 0x4(%rsi)
je 0x3c16
movq %rsi, %r15
pushq $0x3
popq %rdi
callq 0x3030
movq %rax, %r14
leaq 0x1520(%rip), %rsi      # 0x50e5
movq %r15, %rdi
callq 0x3130
pushq $0x3
popq %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x30a0
cmpl $0x3, %eax
jne 0x3c24
movsbq (%r14), %rax
cmpb $0x1b, (%rax)
jne 0x3c32
cmpb $0x53, 0x2(%r14)
jne 0x3c32
movb 0x1(%r14), %al
movb %al, (%r14)
movb $0x0, 0x1(%r14)
leaq 0xd(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x32f0
movq %r14, %rdi
callq 0x3260
jmp 0x3c46
leaq 0x14c2(%rip), %rsi      # 0x50df
leaq 0xf(%rsp), %rdx
jmp 0x3c3e
leaq 0x14b4(%rip), %rsi      # 0x50df
leaq 0xe(%rsp), %rdx
jmp 0x3c3e
leaq 0x14a6(%rip), %rsi      # 0x50df
leaq 0xc(%rsp), %rdx
movq %rbx, %rdi
callq 0x32f0
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/geoherna[P]lib605/./src/lib605.cpp
// Function: lib605::MSR::GetFirmwareVersion[abi:cxx11]()
std::string MSR::GetFirmwareVersion(void) {
		if(!this->MSRConected) {
#if defined(DEBUG)
			std::cout << "[*] Error: unable to get firmware version from non-connected device" << std::endl;
#endif
			return "ERROR";
		}
		char* version = new char[9];
		this->WriteAutoSize(MSR_REQ_FIRM_VER);
		if(this->ReadBytes(version, 9) == 9) {
#if defined(DEBUG)
			std::cout << "[*] Error: unable to get firmware version" << std::endl;
#endif
			return "ERROR";
		}
		if(memcmp((char*)version[0], MSR_ESC, 1) == 0) {
			version[8] = '\0';
			memmove(version, version+1, strlen(version));
			std::string ver(version);
			delete[] version;
			return ver;
		}
		return "ERROR";
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpb $0x0, 0x4(%rsi)
je 0x3ca4
movq %rsi, %r15
pushq $0x9
popq %rdi
callq 0x3030
movq %rax, %r14
leaq 0x146d(%rip), %rsi      # 0x50e8
movq %r15, %rdi
callq 0x3130
pushq $0x9
popq %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x30a0
cmpl $0x9, %eax
jne 0x3cc5
leaq 0x1442(%rip), %rsi      # 0x50df
leaq 0xe(%rsp), %rdx
jmp 0x3cb0
leaq 0x1434(%rip), %rsi      # 0x50df
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x32f0
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movsbq (%r14), %rax
cmpb $0x1b, (%rax)
jne 0x3d09
movb $0x0, 0x8(%r14)
movq %r14, %r15
incq %r15
movq %r14, %rdi
callq 0x30f0
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x32d0
leaq 0xd(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x32f0
movq %r14, %rdi
callq 0x3260
jmp 0x3cb8
leaq 0x13cf(%rip), %rsi      # 0x50df
leaq 0xc(%rsp), %rdx
jmp 0x3cb0
nop
// File: /workspace/github_cpp_makefile_star2_O2/geoherna[P]lib605/./src/lib605.cpp
// Function: lib605::MSR::SetBPC(char, char, char)
bool MSR::SetBPC(char Track1, char Track2, char Track3) {
		if(!this->MSRConected) {
#if defined(DEBUG)
			std::cout << "[*] Unable to set BPC, not connect to device" << std::endl;
#endif
			return false;
		}
		char resp[5];
		char expt[5];
		char bpc_data[5];

		memcpy(bpc_data, (void*)MSR_SET_BPC, 2);
		memcpy(&bpc_data[2], (void*)&Track1, 1);
		memcpy(&bpc_data[3], (void*)&Track2, 1);
		memcpy(&bpc_data[4], (void*)&Track3, 1);

		memcpy(bpc_data, expt, 5);
		memcpy(&expt[0], MSR_OK, 2);

		this->WriteBytes(bpc_data, 5);
		if(this->ReadBytes(resp, 5) != 5) {
#if defined(DEBUG)
			std::cout << "[*] Error: Unable to set BPC, expected 5 bytes" << std::endl;
#endif
			return false;
		}

		if(memcmp(resp, expt, 5) != 0) {
#if defined(DEBUG)
			std::cout << "[*] Error: Unable to set BPC, unexpected response" << std::endl;
#endif
			return false;
		}

		return true;

	}

// Assembly:
cmpb $0x1, 0x4(%rdi)
jne 0x3d9e
pushq %rbp
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x12(%rsp), %rax
movw $0x6f1b, (%rax)         # imm = 0x6F1B
movb %sil, 0x2(%rax)
movb %dl, 0x3(%rax)
movb %cl, 0x4(%rax)
movw $0x301b, 0x8(%rsp)      # imm = 0x301B
pushq $0x5
popq %rbp
movq %rax, %rsi
movl %ebp, %edx
callq 0x3090
leaq 0xd(%rsp), %rsi
movq %rbx, %rdi
movl %ebp, %edx
callq 0x30a0
cmpl $0x5, %eax
jne 0x3da1
leaq 0xd(%rsp), %rdi
leaq 0x8(%rsp), %rsi
pushq $0x5
popq %rdx
callq 0x3210
testl %eax, %eax
sete %al
jmp 0x3da3
xorl %eax, %eax
retq
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/geoherna[P]lib605/./src/lib605.cpp
// Function: lib605::MSR::SetCoercivity(lib605::MSR::COERCIVITY)
bool MSR::SetCoercivity(COERCIVITY co) {
		if(!this->MSRConected) {
#if defined(DEBUG)
			std::cout << "[*] Unable to set Coercivity, not connect to device" << std::endl;
#endif
			return false;
		}
		char resp[2];
		switch(co) {
			case HI_CO: {
				this->WriteAutoSize(MSR_SET_HI_CO);
				break;
			} case LO_CO: {
				this->WriteAutoSize(MSR_SET_LO_CO);
				break;
			} default: break;
		}
		if(this->ReadBytes(resp, 2) != 2) {
#if defined(DEBUG)
			std::cout << "[*] Error: Unable to set Coercivity, expected 2 bytes" << std::endl;
#endif
			return false;
		}
		if(memcmp(resp, MSR_OK, 2) == 0) {
			return true;
		}
		return false;
	}

// Assembly:
cmpb $0x1, 0x4(%rdi)
jne 0x3e6a
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
testl %esi, %esi
je 0x3e6d
cmpl $0x1, %esi
jne 0x3e7c
leaq 0x1259(%rip), %rsi      # 0x50c1
jmp 0x3e74
xorl %eax, %eax
retq
leaq 0x128f(%rip), %rsi      # 0x5103
movq %rbx, %rdi
callq 0x3130
leaq 0xe(%rsp), %rsi
pushq $0x2
popq %rdx
movq %rbx, %rdi
callq 0x30a0
cmpl $0x2, %eax
jne 0x3e9d
cmpw $0x301b, 0xe(%rsp)      # imm = 0x301B
sete %al
jmp 0x3e9f
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/geoherna[P]lib605/./src/lib605.cpp
// Function: lib605::MSR::GetCoercivity()
MSR::COERCIVITY MSR::GetCoercivity(void) {
		if(!this->MSRConected) {
#if defined(DEBUG)
			std::cout << "[*] Unable to get Coercivity, not connect to device" << std::endl;
#endif
			return MSR::COERCIVITY::ERR;
		}
		char resp[2];
		this->WriteAutoSize(MSR_GET_CO_STAT);
		if(this->ReadBytes(resp, 2) != 2) {
#if defined(DEBUG)
			std::cout << "[*] Error: Unable to get Coercivity, expected 2 bytes" << std::endl;
#endif
			return MSR::COERCIVITY::ERR;
		}
		if(memcmp(resp, MSR_ESC "H", 2) == 0) {
			return MSR::COERCIVITY::HI_CO;
		} else if(memcmp(resp, MSR_ESC "L", 2) == 0) {
			return MSR::COERCIVITY::LO_CO;
		} else {
#if defined(DEBUG)
			std::cout << "[*] Error: Unable to get Coercivity, unexpected value" << std::endl;
#endif
			return MSR::COERCIVITY::ERR;
		}
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpb $0x1, 0x4(%rdi)
jne 0x3eef
movq %rdi, %r14
leaq 0x124c(%rip), %rsi      # 0x5106
callq 0x3130
leaq 0x6(%rsp), %rsi
pushq $0x2
popq %rbx
movq %r14, %rdi
movl %ebx, %edx
callq 0x30a0
cmpl $0x2, %eax
jne 0x3ef2
cmpw $0x481b, 0x6(%rsp)      # imm = 0x481B
je 0x3efc
xorl %ebx, %ebx
cmpw $0x4c1b, 0x6(%rsp)      # imm = 0x4C1B
setne %bl
incl %ebx
jmp 0x3ef2
pushq $0x2
popq %rbx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
xorl %ebx, %ebx
jmp 0x3ef2
// File: /workspace/github_cpp_makefile_star2_O2/geoherna[P]lib605/./src/lib605.cpp
// Function: lib605::MSR::SetLeadingZero(unsigned char, unsigned char)
bool MSR::SetLeadingZero(unsigned char Track1_3, unsigned char Track2) {
		if(!this->MSRConected) {
#if defined(DEBUG)
			std::cout << "[*] Unable to Set leading zero, not connect to device" << std::endl;
#endif
			return false;
		}
		char resp[2];
		char zero_dat[4];

		memcpy(zero_dat, (void*)MSR_SET_LEAD_ZERO, 2);
		memcpy(&zero_dat[2], (void*)&Track1_3, 1);
		memcpy(&zero_dat[3], (void*)&Track2, 1);

		this->WriteBytes(zero_dat, 4);
		if(this->ReadBytes(resp, 2) != 2) {
#if defined(DEBUG)
			std::cout << "[*] Error: Unable to set leading zero, expected 2 bytes" << std::endl;
#endif
			return false;
		}
		if(memcmp(resp, MSR_OK, 2) == 0) {
			return true;
		}
		return false;
	}

// Assembly:
cmpb $0x1, 0x4(%rdi)
jne 0x3f4b
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0xc(%rsp), %rax
movw $0x7a1b, (%rax)         # imm = 0x7A1B
movb %sil, 0x2(%rax)
movb %dl, 0x3(%rax)
pushq $0x4
popq %rdx
movq %rax, %rsi
callq 0x3090
leaq 0xa(%rsp), %rsi
pushq $0x2
popq %rdx
movq %rbx, %rdi
callq 0x30a0
cmpl $0x2, %eax
jne 0x3f4e
cmpw $0x301b, 0xa(%rsp)      # imm = 0x301B
sete %al
jmp 0x3f50
xorl %eax, %eax
retq
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/geoherna[P]lib605/./src/lib605.cpp
// Function: lib605::MSR::GetLeadZero()
std::tuple<unsigned char, unsigned char> MSR::GetLeadZero(void) {
		if(!this->MSRConected) {
#if defined(DEBUG)
			std::cout << "[*] Unable to get leading zero, not connect to device" << std::endl;
#endif
			return std::make_tuple(0x00, 0x00);
		}
		char resp[3];
		this->WriteAutoSize(MSR_CHECK_LEAD_ZERO);
		if(this->ReadBytes(resp, 3) != 3) {
#if defined(DEBUG)
			std::cout << "[*] Unable to get leading zero, expected 3 bytes" << std::endl;
#endif
			return std::make_tuple(0x00, 0x00);
		}
		return std::make_tuple(resp[1], resp[2]);
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpb $0x0, 0x4(%rsi)
je 0x3fa9
movq %rsi, %r14
leaq 0x119d(%rip), %rsi      # 0x510f
movq %r14, %rdi
callq 0x3130
leaq 0xd(%rsp), %r15
pushq $0x3
popq %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x30a0
xorl %ecx, %ecx
cmpl $0x3, %eax
movzbl 0x2(%r15), %eax
cmovnel %ecx, %eax
movzbl 0x1(%r15), %edx
cmovnel %ecx, %edx
movb %al, (%rbx)
movb %dl, 0x1(%rbx)
jmp 0x3fad
andw $0x0, (%rbx)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/AutomataLab[P]JSONSki/example/example3.cpp
// Function: main
int main() {
    char* file_path = "../dataset/twitter_sample_small_records.json";
    RecordSet* record_set = RecordLoader::loadRecords(file_path);
    if (record_set->size() == 0) {
        cout<<"record loading fails."<<endl;
        return -1;
    }

    QueryProcessor processor("$.entities.urls[*].url");
    int num_recs = record_set->size();
    for (int i = 0; i < num_recs; i++) {
        string output = processor.runQuery((*record_set)[i]);
        cout<<"matches are: "<<output<<endl;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
andq $-0x20, %rsp
subq $0xef80, %rsp           # imm = 0xEF80
leaq 0x9f033(%rip), %rdi     # 0xc4196
callq 0x24dc4
cmpq $0x0, 0x18(%rax)
je 0x25216
movq %rax, %rbx
leaq 0x9f05c(%rip), %rsi     # 0xc41d9
movq %rsp, %rdi
leaq 0x20(%rsp), %rdx
callq 0x970b0
leaq 0x40(%rsp), %rdi
movq %rsp, %rsi
callq 0x16760
movq %rsp, %rdi
callq 0x94680
movl 0x18(%rbx), %r13d
xorl %r14d, %r14d
testl %r13d, %r13d
cmovlel %r14d, %r13d
leaq 0x20(%rsp), %r15
leaq 0x9f037(%rip), %r12     # 0xc41f0
cmpq %r14, %r13
je 0x25208
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2527a
movq (%rax), %rdx
movq %r15, %rdi
leaq 0x40(%rsp), %rsi
callq 0x24b32
leaq 0xda2c0(%rip), %rdi     # 0xff4a0
movq %r12, %rsi
callq 0x8e2b0
movq %rax, %rdi
movq %r15, %rsi
callq 0x97180
movq %rax, %rdi
callq 0x8db90
movq %r15, %rdi
callq 0x94680
incq %r14
jmp 0x251b9
leaq 0x40(%rsp), %rdi
callq 0x16948
xorl %eax, %eax
jmp 0x25234
leaq 0xda283(%rip), %rdi     # 0xff4a0
leaq 0x9ef9f(%rip), %rsi     # 0xc41c3
callq 0x8e2b0
movq %rax, %rdi
callq 0x8db90
pushq $-0x1
popq %rax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x94680
jmp 0x25271
movq %rax, %rbx
jmp 0x25271
movq %rax, %rbx
jmp 0x25267
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x94680
leaq 0x40(%rsp), %rdi
callq 0x16948
movq %rbx, %rdi
callq 0x13730
nop
// File: /workspace/github_cpp_makefile_star2_O2/AutomataLab[P]JSONSki/example/../src/lib/Records.h
// Function: RecordSet::operator[](long)
Record*& operator[] (long idx) {
        if (idx >= 0 && idx < num_recs)
            return recs[idx];
        cout << "Array index in RecordSet out of bound."<<endl; 
        exit(0); 
    }

// Assembly:
testq %rsi, %rsi
js 0x25290
cmpq %rsi, 0x18(%rdi)
jle 0x25290
shlq $0x3, %rsi
addq (%rdi), %rsi
movq %rsi, %rax
retq
pushq %rax
leaq 0xda208(%rip), %rdi     # 0xff4a0
leaq 0x9ef5f(%rip), %rsi     # 0xc41fe
callq 0x8e2b0
movq %rax, %rdi
callq 0x8db90
xorl %edi, %edi
callq 0x131b0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/flastest[P]HeterogeneousParallelDijkstra/workloads.cc
// Function: print_dijkstra_results[abi:cxx11](boost::adjacency_list<boost::listS, boost::vecS, boost::directedS, boost::no_property, boost::property<boost::edge_weight_t, int, boost::no_property>, boost::no_property, boost::listS>, std::map<unsigned long, float, std::less<unsigned long>, std::allocator<std::pair<unsigned long const, float>>>)
string print_dijkstra_results(graph_t g, distance_map_t distances)
{
	string results;

	auto [current, finish] = vertices(g);
	while (current != finish)
	{
		results = results + "node is "+to_string(   static_cast<int>(*current)) + " and distance is " + to_string(static_cast<int>(distances[*current])) + "\n";


		//std::cout<<"node is "<<*current<<" and distance is "<<distances[*current]<<std::endl;

		current++;
	}

	return results;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rdx, 0x10(%rsp)
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rdi, 0x8(%rsp)
movb $0x0, 0x10(%rdi)
movq 0x20(%rsi), %rax
subq 0x18(%rsi), %rax
sarq $0x5, %rax
movq %rax, 0x18(%rsp)
xorl %r15d, %r15d
leaq 0xa8(%rsp), %rbx
leaq 0xc8(%rsp), %r13
leaq 0xe8(%rsp), %rbp
cmpq %r15, 0x18(%rsp)
je 0x37ba
leaq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rsi
leaq 0xc437(%rip), %rdx      # 0xfb16
callq 0x69d9
leaq 0x68(%rsp), %r12
movq %r12, %rdi
movl %r15d, %esi
callq 0x6a11
leaq 0x88(%rsp), %r14
movq %r14, %rdi
leaq 0x28(%rsp), %rsi
movq %r12, %rdx
callq 0x6972
leaq 0x48(%rsp), %rdi
movq %r14, %rsi
leaq 0xaa09(%rip), %rdx      # 0xe124
callq 0x6953
movq %r15, 0x20(%rsp)
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x6a6a
cvttss2si (%rax), %esi
movq %rbx, %rdi
callq 0x6a11
movq %r13, %rdi
leaq 0x48(%rsp), %rsi
movq %rbx, %rdx
callq 0x6972
movq %rbp, %rdi
movq %r13, %rsi
leaq 0xa9df(%rip), %rdx      # 0xe13c
callq 0x6953
movq 0x8(%rsp), %rdi
movq %rbp, %rsi
callq 0x32e0
movq %rbp, %rdi
callq 0x3110
movq %r13, %rdi
callq 0x3110
movq %rbx, %rdi
callq 0x3110
leaq 0x48(%rsp), %rdi
callq 0x3110
leaq 0x88(%rsp), %rdi
callq 0x3110
leaq 0x68(%rsp), %rdi
callq 0x3110
leaq 0x28(%rsp), %rdi
callq 0x3110
incq %r15
jmp 0x36c3
movq 0x8(%rsp), %rax
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x37e6
movq %rax, %rbx
leaq 0xc8(%rsp), %rdi
callq 0x3110
leaq 0xa8(%rsp), %rdi
callq 0x3110
jmp 0x380c
movq %rax, %rbx
jmp 0x3837
movq %rax, %rbx
jmp 0x382d
movq %rax, %rbx
jmp 0x3823
movq %rax, %rbx
jmp 0x3816
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x3110
leaq 0x88(%rsp), %rdi
callq 0x3110
leaq 0x68(%rsp), %rdi
callq 0x3110
leaq 0x28(%rsp), %rdi
callq 0x3110
movq 0x8(%rsp), %rdi
callq 0x3110
movq %rbx, %rdi
callq 0x3420
// File: /workspace/github_cpp_makefile_star2_O2/flastest[P]HeterogeneousParallelDijkstra/workloads.cc
// Function: testBGL(boost::adjacency_list<boost::listS, boost::vecS, boost::directedS, boost::no_property, boost::property<boost::edge_weight_t, int, boost::no_property>, boost::no_property, boost::listS>, unsigned long, std::vector<unsigned long, std::allocator<unsigned long>>&)
std::vector<int> testBGL (graph_t g, vertex_descriptor s, std::vector<vertex_descriptor> &p)
{
	
	// Keeps track of the predecessor of each vertex
	//std::vector<vertex_descriptor> p(num_vertices(g));
	// Keeps track of the distance to each vertex
	std::vector<int> d(num_vertices(g));



	boost::dijkstra_shortest_paths(g, s,
		predecessor_map(
	     make_iterator_property_map(p.begin(), get(vertex_index, g))).
	   distance_map(
	     make_iterator_property_map(d.begin(), get(vertex_index, g)))
	   );
	
	return d;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq 0x20(%rsi), %rsi
subq 0x18(%r12), %rsi
sarq $0x5, %rsi
leaq 0x8(%rsp), %r13
movq %r13, %rdx
callq 0x6aba
movq (%r14), %rax
movq (%rbx), %rcx
movq %rcx, (%r13)
movq %rax, 0x10(%r13)
leaq 0x8(%rsp), %rdx
movq %r12, %rdi
movq %r15, %rsi
callq 0x6b0b
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x74ca
movq %r14, %rdi
callq 0x3420
// File: /workspace/github_cpp_makefile_star2_O2/flastest[P]HeterogeneousParallelDijkstra/workloads.cc
// Function: timed_dijkstra(boost::adjacency_list<boost::listS, boost::vecS, boost::directedS, boost::no_property, boost::property<boost::edge_weight_t, int, boost::no_property>, boost::no_property, boost::listS>, unsigned long)
float timed_dijkstra(graph_t g, vertex_descriptor s)
{
	predecessor_map_t p;
	auto startTime = chrono::high_resolution_clock::now();
	auto distances = dijkstra_algorithm(g, s, p);
	auto endTime = chrono::high_resolution_clock::now();

	float t = chrono::duration_cast<std::chrono::microseconds>( endTime - startTime ).count();
	return t;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rdi, %r14
leaq 0x8(%rsp), %r15
movq %rsi, (%r15)
leaq 0x18(%rsp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
callq 0x3050
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
leaq 0x10(%rsp), %rcx
movq %r14, %rsi
movq %r15, %rdx
callq *0x10c72(%rip)          # 0x17250
callq 0x3050
subq %rbx, %rax
movl $0x3e8, %ecx            # imm = 0x3E8
cqto
idivq %rcx
cvtsi2ss %rax, %xmm0
movss %xmm0, 0x4(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x70ae
leaq 0x10(%rsp), %rdi
callq 0x7172
movss 0x4(%rsp), %xmm0
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x7172
movq %rbx, %rdi
callq 0x3420
// File: /workspace/github_cpp_makefile_star2_O2/flastest[P]HeterogeneousParallelDijkstra/workloads.cc
// Function: test_DOTA(bool)
bool test_DOTA(bool TEST_DEBUG){
	//aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaah
	if (TEST_DEBUG) std::cout<<"loading graph from BBO"<<std::endl;
	graph_t g = graph_from_file("DotaLeague/DotaLeague_Edge_Basic",true);


	//number of nodes in g
	int num_nodes = num_vertices(g);

	std::vector<vertex_descriptor> p(num_nodes);

	//get a source node...
	vertex_descriptor s = vertex(1, g);

	std::vector<int> BGL_results = testBGL ( g,  s, p);


	return true;
}

// Assembly:
pushq %rbx
subq $0xc0, %rsp
testl %edi, %edi
je 0x665b
movq 0x10981(%rip), %rdi     # 0x16fc8
leaq 0x7b88(%rip), %rsi      # 0xe1d6
callq 0x3270
movq %rax, %rdi
callq 0x3140
leaq 0x7b8b(%rip), %rsi      # 0xe1ed
leaq 0x30(%rsp), %rdi
movq %rsp, %rdx
callq 0x6c72
leaq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %rsi
pushq $0x1
popq %rdx
callq 0xcb4f
leaq 0x30(%rsp), %rdi
callq 0x3110
movq 0x70(%rsp), %rax
subq 0x68(%rsp), %rax
shrq $0x5, %rax
movslq %eax, %rsi
movq %rsp, %rdi
leaq 0x18(%rsp), %rdx
callq 0x6b5a
leaq 0x88(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x6bac
leaq 0x18(%rsp), %rdi
leaq 0x88(%rsp), %rsi
pushq $0x1
popq %rdx
movq %rsp, %rcx
callq 0x3849
leaq 0x88(%rsp), %rdi
callq 0x6bf0
leaq 0x18(%rsp), %rdi
callq 0x74ca
movq %rsp, %rdi
callq 0x7e16
leaq 0x50(%rsp), %rdi
callq 0x6bf0
movb $0x1, %al
addq $0xc0, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
callq 0x6bf0
jmp 0x671c
movq %rax, %rbx
movq %rsp, %rdi
callq 0x7e16
jmp 0x6729
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x6bf0
jmp 0x6747
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x3110
jmp 0x6747
movq %rax, %rbx
movq %rbx, %rdi
callq 0x3420
// File: /workspace/github_cpp_makefile_star2_O2/flastest[P]HeterogeneousParallelDijkstra/BGL_Dijkstra.cc
// Function: print_thread_debug(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::ostream&)
void print_thread_debug(int thread_id, std::string debug_message, ostream& output_stream)
{
	//first lock the mutex
	std::lock_guard<std::mutex> guard(print_mutex);
	//then print
	output_stream<< "thread: " << thread_id << ": " << debug_message <<std::endl;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movl %edi, %ebp
leaq 0xdb99(%rip), %rdi      # 0x17298
callq 0xb74e
leaq 0x6236(%rip), %rsi      # 0xf941
movq %r14, %rdi
callq 0x3270
movq %rax, %rdi
movl %ebp, %esi
callq 0x3410
leaq 0x6223(%rip), %rsi      # 0xf947
movq %rax, %rdi
callq 0x3270
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3250
movq %rax, %rdi
callq 0x3140
leaq 0xdb52(%rip), %rdi      # 0x17298
popq %rbx
popq %r14
popq %rbp
jmp 0x3210
movq %rax, %rbx
leaq 0xdb3f(%rip), %rdi      # 0x17298
callq 0x3210
movq %rbx, %rdi
callq 0x3420