LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: alan0201tw[P]RayTracer/include/stb_image.h
// Function: stbi__pnm_info(stbi__context*, int*, int*, int*)
static int      stbi__pnm_info(stbi__context *s, int *x, int *y, int *comp)
{
   int maxv, dummy;
   char c, p, t;

   if (!x) x = &dummy;
   if (!y) y = &dummy;
   if (!comp) comp = &dummy;

   stbi__rewind(s);

   // Get identifier
   p = (char) stbi__get8(s);
   t = (char) stbi__get8(s);
   if (p != 'P' || (t != '5' && t != '6')) {
       stbi__rewind(s);
       return 0;
   }

   *comp = (t == '6') ? 3 : 1;  // '5' is 1-component .pgm; '6' is 3-component .ppm

   c = (char) stbi__get8(s);
   stbi__pnm_skip_whitespace(s, &c);

   *x = stbi__pnm_getinteger(s, &c); // read width
   stbi__pnm_skip_whitespace(s, &c);

   *y = stbi__pnm_getinteger(s, &c); // read height
   stbi__pnm_skip_whitespace(s, &c);

   maxv = stbi__pnm_getinteger(s, &c);  // read max value

   if (maxv > 255)
      return stbi__err("max value > 255", "PPM image not 8-bit");
   else
      return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x6f5d7
leaq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x6f5e6
leaq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x6f5f5
leaq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5ebe0
movq -0x10(%rbp), %rdi
callq 0x65d00
movb %al, -0x32(%rbp)
movq -0x10(%rbp), %rdi
callq 0x65d00
movb %al, -0x33(%rbp)
movsbl -0x32(%rbp), %eax
cmpl $0x50, %eax
jne 0x6f631
movsbl -0x33(%rbp), %eax
cmpl $0x35, %eax
je 0x6f646
movsbl -0x33(%rbp), %eax
cmpl $0x36, %eax
je 0x6f646
movq -0x10(%rbp), %rdi
callq 0x5ebe0
movl $0x0, -0x4(%rbp)
jmp 0x6f6ee
movsbl -0x33(%rbp), %edx
movl $0x1, %ecx
movl $0x3, %eax
cmpl $0x36, %edx
cmovel %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x65d00
movb %al, -0x31(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x31(%rbp), %rsi
callq 0x6f700
movq -0x10(%rbp), %rdi
leaq -0x31(%rbp), %rsi
callq 0x6f7e0
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rdi
leaq -0x31(%rbp), %rsi
callq 0x6f700
movq -0x10(%rbp), %rdi
leaq -0x31(%rbp), %rsi
callq 0x6f7e0
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rdi
leaq -0x31(%rbp), %rsi
callq 0x6f700
movq -0x10(%rbp), %rdi
leaq -0x31(%rbp), %rsi
callq 0x6f7e0
movl %eax, -0x2c(%rbp)
cmpl $0xff, -0x2c(%rbp)
jle 0x6f6e7
leaq 0x120ca(%rip), %rdi     # 0x817a7
callq 0x56040
movl %eax, -0x4(%rbp)
jmp 0x6f6ee
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: alan0201tw[P]RayTracer/include/stb_image.h
// Function: stbi__tga_get_comp(int, int, int*)
static int stbi__tga_get_comp(int bits_per_pixel, int is_grey, int* is_rgb16)
{
   // only RGB or RGBA (incl. 16bit) or grey allowed
   if (is_rgb16) *is_rgb16 = 0;
   switch(bits_per_pixel) {
      case 8:  return STBI_grey;
      case 16: if(is_grey) return STBI_grey_alpha;
               // fallthrough
      case 15: if(is_rgb16) *is_rgb16 = 1;
               return STBI_rgb;
      case 24: // fallthrough
      case 32: return bits_per_pixel/8;
      default: return 0;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x6fc8f
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
movl -0x8(%rbp), %eax
addl $-0x8, %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x18, %eax
ja 0x6fcf8
movq -0x20(%rbp), %rax
leaq 0xf6e9(%rip), %rcx      # 0x7f394
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x1, -0x4(%rbp)
jmp 0x6fcff
cmpl $0x0, -0xc(%rbp)
je 0x6fccc
movl $0x2, -0x4(%rbp)
jmp 0x6fcff
jmp 0x6fcce
cmpq $0x0, -0x18(%rbp)
je 0x6fcdf
movq -0x18(%rbp), %rax
movl $0x1, (%rax)
movl $0x3, -0x4(%rbp)
jmp 0x6fcff
movl -0x8(%rbp), %eax
movl $0x8, %ecx
cltd
idivl %ecx
movl %eax, -0x4(%rbp)
jmp 0x6fcff
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: alan0201tw[P]RayTracer/include/stb_image.h
// Function: stbi__convert_8_to_16(unsigned char*, int, int, int)
static stbi__uint16 *stbi__convert_8_to_16(stbi_uc *orig, int w, int h, int channels)
{
   int i;
   int img_len = w * h * channels;
   stbi__uint16 *enlarged;

   enlarged = (stbi__uint16 *) stbi__malloc(img_len*2);
   if (enlarged == NULL) return (stbi__uint16 *) stbi__errpuc("outofmem", "Out of memory");

   for (i = 0; i < img_len; ++i)
      enlarged[i] = (stbi__uint16)((orig[i] << 8) + orig[i]); // replicate to high and low byte, maps 0->0, 255->0xffff

   STBI_FREE(orig);
   return enlarged;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl -0x14(%rbp), %eax
imull -0x18(%rbp), %eax
imull -0x1c(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
shll %eax
movslq %eax, %rdi
callq 0x57060
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x6fe08
leaq 0x11310(%rip), %rdi     # 0x81102
callq 0x56040
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
cmovneq %rax, %rax
movq %rax, -0x8(%rbp)
jmp 0x6fe5f
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x6fe4e
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movzbl (%rax,%rcx), %eax
shll $0x8, %eax
movq -0x10(%rbp), %rcx
movslq -0x20(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
addl %ecx, %eax
movw %ax, %dx
movq -0x30(%rbp), %rax
movslq -0x20(%rbp), %rcx
movw %dx, (%rax,%rcx,2)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x6fe0f
movq -0x10(%rbp), %rdi
callq 0x75e0
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: alan0201tw[P]RayTracer/include/stb_image.h
// Function: stbi__ldr_to_hdr(unsigned char*, int, int, int)
static float   *stbi__ldr_to_hdr(stbi_uc *data, int x, int y, int comp)
{
   int i,k,n;
   float *output;
   if (!data) return NULL;
   output = (float *) stbi__malloc_mad4(x, y, comp, sizeof(float), 0);
   if (output == NULL) { STBI_FREE(data); return stbi__errpf("outofmem", "Out of memory"); }
   // compute number of non-alpha components
   if (comp & 1) n = comp; else n = comp-1;
   for (i=0; i < x*y; ++i) {
      for (k=0; k < n; ++k) {
         output[i*comp + k] = (float) (pow(data[i*comp+k]/255.0f, stbi__l2h_gamma) * stbi__l2h_scale);
      }
   }
   if (n < comp) {
      for (i=0; i < x*y; ++i) {
         output[i*comp + n] = data[i*comp + n]/255.0f;
      }
   }
   STBI_FREE(data);
   return output;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x6ff09
movq $0x0, -0x8(%rbp)
jmp 0x70074
movl -0x14(%rbp), %edi
movl -0x18(%rbp), %esi
movl -0x1c(%rbp), %edx
movl $0x4, %ecx
xorl %r8d, %r8d
callq 0x6fa80
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x6ff53
movq -0x10(%rbp), %rdi
callq 0x75e0
leaq 0x111c8(%rip), %rdi     # 0x81102
callq 0x56040
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
cmovneq %rax, %rax
movq %rax, -0x8(%rbp)
jmp 0x70074
movl -0x1c(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x6ff66
movl -0x1c(%rbp), %eax
movl %eax, -0x28(%rbp)
jmp 0x6ff6f
movl -0x1c(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x28(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl -0x14(%rbp), %ecx
imull -0x18(%rbp), %ecx
cmpl %ecx, %eax
jge 0x6fffe
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x28(%rbp), %eax
jge 0x6ffee
movq -0x10(%rbp), %rax
movl -0x20(%rbp), %ecx
imull -0x1c(%rbp), %ecx
addl -0x24(%rbp), %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
cvtsi2ss %eax, %xmm0
movss 0xe27c(%rip), %xmm1     # 0x7e230
divss %xmm1, %xmm0
movss 0x40510(%rip), %xmm1    # 0xb04d0
callq 0x74700
mulss 0x40507(%rip), %xmm0    # 0xb04d4
movq -0x30(%rbp), %rax
movl -0x20(%rbp), %ecx
imull -0x1c(%rbp), %ecx
addl -0x24(%rbp), %ecx
movslq %ecx, %rcx
movss %xmm0, (%rax,%rcx,4)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x6ff8b
jmp 0x6fff0
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x6ff76
movl -0x28(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x70063
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl -0x14(%rbp), %ecx
imull -0x18(%rbp), %ecx
cmpl %ecx, %eax
jge 0x70061
movq -0x10(%rbp), %rax
movl -0x20(%rbp), %ecx
imull -0x1c(%rbp), %ecx
addl -0x28(%rbp), %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
cvtsi2ss %eax, %xmm0
movss 0xe1f4(%rip), %xmm1     # 0x7e230
divss %xmm1, %xmm0
movq -0x30(%rbp), %rax
movl -0x20(%rbp), %ecx
imull -0x1c(%rbp), %ecx
addl -0x28(%rbp), %ecx
movslq %ecx, %rcx
movss %xmm0, (%rax,%rcx,4)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x7000d
jmp 0x70063
movq -0x10(%rbp), %rdi
callq 0x75e0
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: alan0201tw[P]RayTracer/include/stb_image.h
// Function: stbi__hdr_test_core(stbi__context*, char const*)
static int stbi__hdr_test_core(stbi__context *s, const char *signature)
{
   int i;
   for (i=0; signature[i]; ++i)
      if (stbi__get8(s) != signature[i])
          return 0;
   stbi__rewind(s);
   return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x71237
movq -0x10(%rbp), %rdi
callq 0x65d00
movzbl %al, %eax
movq -0x18(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x7122a
movl $0x0, -0x4(%rbp)
jmp 0x71247
jmp 0x7122c
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x711f7
movq -0x10(%rbp), %rdi
callq 0x5ebe0
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: alan0201tw[P]RayTracer/include/stb_image.h
// Function: stbi__jpeg_info(stbi__context*, int*, int*, int*)
static int stbi__jpeg_info(stbi__context *s, int *x, int *y, int *comp)
{
   int result;
   stbi__jpeg* j = (stbi__jpeg*) (stbi__malloc(sizeof(stbi__jpeg)));
   j->s = s;
   result = stbi__jpeg_info_raw(j, x, y, comp);
   STBI_FREE(j);
   return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x4888, %edi           # imm = 0x4888
callq 0x57060
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x71ba0
movl %eax, -0x24(%rbp)
movq -0x30(%rbp), %rdi
callq 0x75e0
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: alan0201tw[P]RayTracer/include/stb_image.h
// Function: stbi__bmp_info(stbi__context*, int*, int*, int*)
static int stbi__bmp_info(stbi__context *s, int *x, int *y, int *comp)
{
   void *p;
   stbi__bmp_data info;

   info.all_a = 255;
   p = stbi__bmp_parse_header(s, &info);
   stbi__rewind( s );
   if (p == NULL)
      return 0;
   if (x) *x = s->img_x;
   if (y) *y = s->img_y;
   if (comp) *comp = info.ma ? 4 : 3;
   return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl $0xff, -0x34(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x6d6b0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5ebe0
cmpq $0x0, -0x30(%rbp)
jne 0x71379
movl $0x0, -0x4(%rbp)
jmp 0x713c7
cmpq $0x0, -0x18(%rbp)
je 0x7138c
movq -0x10(%rbp), %rax
movl (%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
cmpq $0x0, -0x20(%rbp)
je 0x713a0
movq -0x10(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
cmpq $0x0, -0x28(%rbp)
je 0x713c0
movl -0x38(%rbp), %edx
movl $0x3, %ecx
movl $0x4, %eax
cmpl $0x0, %edx
cmovnel %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
// File: alan0201tw[P]RayTracer/include/stb_image.h
// Function: stbi__psd_info(stbi__context*, int*, int*, int*)
static int stbi__psd_info(stbi__context *s, int *x, int *y, int *comp)
{
   int channelCount, dummy, depth;
   if (!x) x = &dummy;
   if (!y) y = &dummy;
   if (!comp) comp = &dummy;
   if (stbi__get32be(s) != 0x38425053) {
       stbi__rewind( s );
       return 0;
   }
   if (stbi__get16be(s) != 1) {
       stbi__rewind( s );
       return 0;
   }
   stbi__skip(s, 6);
   channelCount = stbi__get16be(s);
   if (channelCount < 0 || channelCount > 16) {
       stbi__rewind( s );
       return 0;
   }
   *y = stbi__get32be(s);
   *x = stbi__get32be(s);
   depth = stbi__get16be(s);
   if (depth != 8 && depth != 16) {
       stbi__rewind( s );
       return 0;
   }
   if (stbi__get16be(s) != 3) {
       stbi__rewind( s );
       return 0;
   }
   *comp = 4;
   return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x713f7
leaq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x71406
leaq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x71415
leaq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6b410
cmpl $0x38425053, %eax       # imm = 0x38425053
je 0x7143a
movq -0x10(%rbp), %rdi
callq 0x5ebe0
movl $0x0, -0x4(%rbp)
jmp 0x71512
movq -0x10(%rbp), %rdi
callq 0x65e40
cmpl $0x1, %eax
je 0x7145d
movq -0x10(%rbp), %rdi
callq 0x5ebe0
movl $0x0, -0x4(%rbp)
jmp 0x71512
movq -0x10(%rbp), %rdi
movl $0x6, %esi
callq 0x661f0
movq -0x10(%rbp), %rdi
callq 0x65e40
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jl 0x71483
cmpl $0x10, -0x2c(%rbp)
jle 0x71495
movq -0x10(%rbp), %rdi
callq 0x5ebe0
movl $0x0, -0x4(%rbp)
jmp 0x71512
movq -0x10(%rbp), %rdi
callq 0x6b410
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x6b410
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x65e40
movl %eax, -0x34(%rbp)
cmpl $0x8, -0x34(%rbp)
je 0x714e1
cmpl $0x10, -0x34(%rbp)
je 0x714e1
movq -0x10(%rbp), %rdi
callq 0x5ebe0
movl $0x0, -0x4(%rbp)
jmp 0x71512
movq -0x10(%rbp), %rdi
callq 0x65e40
cmpl $0x3, %eax
je 0x71501
movq -0x10(%rbp), %rdi
callq 0x5ebe0
movl $0x0, -0x4(%rbp)
jmp 0x71512
movq -0x28(%rbp), %rax
movl $0x4, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: alan0201tw[P]RayTracer/include/stb_image.h
// Function: stbi__jpeg_info_raw(stbi__jpeg*, int*, int*, int*)
static int stbi__jpeg_info_raw(stbi__jpeg *j, int *x, int *y, int *comp)
{
   if (!stbi__decode_jpeg_header(j, STBI__SCAN_header)) {
      stbi__rewind( j->s );
      return 0;
   }
   if (x) *x = j->s->img_x;
   if (y) *y = j->s->img_y;
   if (comp) *comp = j->s->img_n >= 3 ? 3 : 1;
   return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x5ea70
cmpl $0x0, %eax
jne 0x71be0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x5ebe0
movl $0x0, -0x4(%rbp)
jmp 0x71c3b
cmpq $0x0, -0x18(%rbp)
je 0x71bf6
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl (%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
cmpq $0x0, -0x20(%rbp)
je 0x71c0d
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x4(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
cmpq $0x0, -0x28(%rbp)
je 0x71c34
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x8(%rax), %edx
movl $0x1, %ecx
movl $0x3, %eax
cmpl $0x3, %edx
cmovgel %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: alan0201tw[P]RayTracer/include/stb_image.h
// Function: stbi__gif_info_raw(stbi__context*, int*, int*, int*)
static int stbi__gif_info_raw(stbi__context *s, int *x, int *y, int *comp)
{
   stbi__gif* g = (stbi__gif*) stbi__malloc(sizeof(stbi__gif));
   if (!stbi__gif_header(s, g, comp, 1)) {
      STBI_FREE(g);
      stbi__rewind( s );
      return 0;
   }
   if (x) *x = g->w;
   if (y) *y = g->h;
   STBI_FREE(g);
   return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl $0x8870, %edi           # imm = 0x8870
callq 0x57060
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
movl $0x1, %ecx
callq 0x6e540
cmpl $0x0, %eax
jne 0x71d4c
movq -0x30(%rbp), %rdi
callq 0x75e0
movq -0x10(%rbp), %rdi
callq 0x5ebe0
movl $0x0, -0x4(%rbp)
jmp 0x71d83
cmpq $0x0, -0x18(%rbp)
je 0x71d5f
movq -0x30(%rbp), %rax
movl (%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
cmpq $0x0, -0x20(%rbp)
je 0x71d73
movq -0x30(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x30(%rbp), %rdi
callq 0x75e0
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: alan0201tw[P]RayTracer/include/stb_image.h
// Function: stbi__png_is16(stbi__context*)
static int stbi__png_is16(stbi__context *s)
{
   stbi__png p;
   p.s = s;
   if (!stbi__png_info_raw(&p, NULL, NULL, NULL))
	   return 0;
   if (p.depth != 16) {
      stbi__rewind(p.s);
      return 0;
   }
   return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x38(%rbp), %rdi
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rsi
movq %rcx, %rdx
callq 0x71c50
cmpl $0x0, %eax
jne 0x71dc5
movl $0x0, -0x4(%rbp)
jmp 0x71de4
cmpl $0x10, -0x18(%rbp)
je 0x71ddd
movq -0x38(%rbp), %rdi
callq 0x5ebe0
movl $0x0, -0x4(%rbp)
jmp 0x71de4
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: alan0201tw[P]RayTracer/include/stb_image.h
// Function: stbi__psd_is16(stbi__context*)
static int stbi__psd_is16(stbi__context *s)
{
   int channelCount, depth;
   if (stbi__get32be(s) != 0x38425053) {
       stbi__rewind( s );
       return 0;
   }
   if (stbi__get16be(s) != 1) {
       stbi__rewind( s );
       return 0;
   }
   stbi__skip(s, 6);
   channelCount = stbi__get16be(s);
   if (channelCount < 0 || channelCount > 16) {
       stbi__rewind( s );
       return 0;
   }
   (void) stbi__get32be(s);
   (void) stbi__get32be(s);
   depth = stbi__get16be(s);
   if (depth != 16) {
       stbi__rewind( s );
       return 0;
   }
   return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6b410
cmpl $0x38425053, %eax       # imm = 0x38425053
je 0x71e21
movq -0x10(%rbp), %rdi
callq 0x5ebe0
movl $0x0, -0x4(%rbp)
jmp 0x71eb6
movq -0x10(%rbp), %rdi
callq 0x65e40
cmpl $0x1, %eax
je 0x71e41
movq -0x10(%rbp), %rdi
callq 0x5ebe0
movl $0x0, -0x4(%rbp)
jmp 0x71eb6
movq -0x10(%rbp), %rdi
movl $0x6, %esi
callq 0x661f0
movq -0x10(%rbp), %rdi
callq 0x65e40
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0x71e67
cmpl $0x10, -0x14(%rbp)
jle 0x71e79
movq -0x10(%rbp), %rdi
callq 0x5ebe0
movl $0x0, -0x4(%rbp)
jmp 0x71eb6
movq -0x10(%rbp), %rdi
callq 0x6b410
movq -0x10(%rbp), %rdi
callq 0x6b410
movq -0x10(%rbp), %rdi
callq 0x65e40
movl %eax, -0x18(%rbp)
cmpl $0x10, -0x18(%rbp)
je 0x71eaf
movq -0x10(%rbp), %rdi
callq 0x5ebe0
movl $0x0, -0x4(%rbp)
jmp 0x71eb6
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movzwl 0x2(%rax), %eax
addl -0x28(%rbp), %eax
movl %eax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movzwl (%rax), %eax
movl $0x18, %ecx
subl -0x28(%rbp), %ecx
shll %cl, %eax
orl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
cmpl $0x8, -0x28(%rbp)
jl 0x7332a
movl -0x24(%rbp), %eax
sarl $0x10, %eax
andl $0xff, %eax
movb %al, -0x29(%rbp)
movq -0x8(%rbp), %rdi
movzbl -0x29(%rbp), %esi
callq 0x72d70
movzbl -0x29(%rbp), %eax
cmpl $0xff, %eax
jne 0x73316
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x72d70
movl -0x24(%rbp), %eax
shll $0x8, %eax
movl %eax, -0x24(%rbp)
movl -0x28(%rbp), %eax
subl $0x8, %eax
movl %eax, -0x28(%rbp)
jmp 0x732df
movl -0x24(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl -0x28(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x0, -0x4(%rbp)
jge 0x7369b
xorl %eax, %eax
subl -0x4(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0x736a1
movl -0x4(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x4(%rbp)
jge 0x736b8
movl -0x4(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x736be
movl -0x4(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movq -0x10(%rbp), %rax
movw $0x1, 0x2(%rax)
movl -0x14(%rbp), %eax
sarl %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
je 0x736ed
movq -0x10(%rbp), %rax
movw 0x2(%rax), %cx
addw $0x1, %cx
movw %cx, 0x2(%rax)
jmp 0x736ce
movl -0x4(%rbp), %eax
movq -0x10(%rbp), %rcx
movzwl 0x2(%rcx), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
subl $0x1, %ecx
andl %ecx, %eax
movw %ax, %cx
movq -0x10(%rbp), %rax
movw %cx, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: alan0201tw[P]RayTracer/include/vec3.hpp
// Function: vec3::operator/=(float)
inline vec3& vec3::operator/=(const float t) {
    float k = 1.0/t;

    e[0]  *= k;
    e[1]  *= k;
    e[2]  *= k;
    return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movss -0xc(%rbp), %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0xa1e6(%rip), %xmm0     # 0x7e478
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x10(%rbp)
movss -0x10(%rbp), %xmm0
mulss (%rax), %xmm0
movss %xmm0, (%rax)
movss -0x10(%rbp), %xmm0
mulss 0x4(%rax), %xmm0
movss %xmm0, 0x4(%rax)
movss -0x10(%rbp), %xmm0
mulss 0x8(%rax), %xmm0
movss %xmm0, 0x8(%rax)
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x8740
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x9478
movq 0x9bb6e(%rip), %rdi     # 0xa4fd0
leaq 0x64b9b(%rip), %rsi     # 0x6e004
callq 0x8490
movl $0x2, %edi
callq 0x8530
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rdx
xorl %eax, %eax
movb %al, -0x41(%rbp)
movl $0x2712, %esi           # imm = 0x2712
callq 0x8670
movb -0x41(%rbp), %al
movq -0x18(%rbp), %rdi
leaq -0xad(%rip), %rdx       # 0x93f0
movl $0x4e2b, %esi           # imm = 0x4E2B
callq 0x8670
movq -0x40(%rbp), %rdi
movb $0x0, -0x1d(%rbp)
callq 0x82b0
movq -0x40(%rbp), %rdx
movb -0x41(%rbp), %al
movq -0x18(%rbp), %rdi
movl $0x2711, %esi           # imm = 0x2711
callq 0x8670
jmp 0x94cb
movq -0x18(%rbp), %rdi
callq 0x8540
movl %eax, -0x48(%rbp)
jmp 0x94d9
movl -0x48(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x8140
jmp 0x94ea
cmpl $0x0, -0x1c(%rbp)
je 0x9526
movq 0x9bad9(%rip), %rdi     # 0xa4fd0
leaq 0x64b1b(%rip), %rsi     # 0x6e019
callq 0x8490
jmp 0x9505
movl $0x2, %edi
callq 0x8530
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x8908
jmp 0x9543
movb $0x1, -0x1d(%rbp)
testb $0x1, -0x1d(%rbp)
jne 0x9539
movq -0x40(%rbp), %rdi
callq 0x8908
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x8500
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x210, %rsp            # imm = 0x210
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1f0(%rbp)
movl $0x10, %edi
movl $0x8, %esi
callq 0x5ae10
movq -0x1f0(%rbp), %rsi
movl %eax, %edx
leaq -0x198(%rbp), %rdi
callq 0x88e0
leaq -0x1b8(%rbp), %rdi
callq 0x82b0
movq -0x198(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x198(%rbp,%rax), %rdi
callq 0x88a0
movb %al, -0x1f1(%rbp)
jmp 0x5acce
movb -0x1f1(%rbp), %al
andb $0x1, %al
movzbl %al, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x1f2(%rbp)
jne 0x5ad33
leaq -0x198(%rbp), %rdi
leaq -0x1b8(%rbp), %rsi
movl $0x2c, %edx
callq 0x8030
movq %rax, -0x200(%rbp)
jmp 0x5ad07
movq -0x200(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x82d0
movb %al, -0x201(%rbp)
jmp 0x5ad25
movb -0x201(%rbp), %al
movb %al, -0x1f2(%rbp)
jmp 0x5ad33
movb -0x1f2(%rbp), %al
testb $0x1, %al
jne 0x5ad3f
jmp 0x5adbe
leaq -0x1e8(%rbp), %rdi
movq %rdi, -0x210(%rbp)
callq 0x82b0
movq -0x210(%rbp), %rsi
leaq -0x1b8(%rbp), %rdi
callq 0x5ae30
jmp 0x5ad67
movq -0x10(%rbp), %rdi
leaq -0x1e8(%rbp), %rsi
callq 0x5ae60
jmp 0x5ad79
leaq -0x1e8(%rbp), %rdi
callq 0x8908
jmp 0x5acae
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c0(%rbp)
movl %eax, -0x1c4(%rbp)
jmp 0x5addf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c0(%rbp)
movl %eax, -0x1c4(%rbp)
leaq -0x1e8(%rbp), %rdi
callq 0x8908
jmp 0x5addf
leaq -0x1b8(%rbp), %rdi
callq 0x8908
leaq -0x198(%rbp), %rdi
callq 0x82f0
addq $0x210, %rsp            # imm = 0x210
popq %rbp
retq
leaq -0x1b8(%rbp), %rdi
callq 0x8908
leaq -0x198(%rbp), %rdi
callq 0x82f0
movq -0x1c0(%rbp), %rdi
callq 0x8500
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, (%rax)
je 0x6d5ec
jmp 0x6d60b
leaq 0x13c4(%rip), %rdi      # 0x6e9b7
leaq 0xc90(%rip), %rsi       # 0x6e28a
movl $0x25c9, %edx           # imm = 0x25C9
leaq 0x5972(%rip), %rcx      # 0x72f78
callq 0x8190
movq -0x10(%rbp), %rax
movq (%rax), %rax
movb (%rax), %al
movb %al, -0x11(%rbp)
subb $0x1, %al
je 0x6d626
jmp 0x6d61d
movb -0x11(%rbp), %al
subb $0x2, %al
je 0x6d63a
jmp 0x6d652
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x11a20
jmp 0x6d663
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
addq $0x8, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x11a70
jmp 0x6d663
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
addq $0x10, %rdi
callq 0x6d670
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: geoherna[P]lib605/./src/lib605.cpp
// Function: lib605::Track::Track(unsigned char*, int, lib605::Track::TRACK_BIT_LEN)
Track::Track(unsigned char* data, int data_len, Track::TRACK_BIT_LEN bit_len) {
		// Set all of the class members
		this->TrackData = data;
		this->TrackDataLength = data_len;
		this->TrackBitLength = bit_len;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, (%rax)
movl -0x14(%rbp), %ecx
movl %ecx, 0x8(%rax)
movl -0x18(%rbp), %ecx
movl %ecx, 0xc(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x3567(%rip), %rsi      # 0x9032
callq 0x53f0
movq -0x10(%rbp), %rdi
callq 0x5130
movl %eax, %ecx
movl %ecx, -0x14(%rbp)
testl %eax, %eax
je 0x5af8
jmp 0x5ae4
movl -0x14(%rbp), %eax
subl $0x1, %eax
je 0x5b19
jmp 0x5aee
movl -0x14(%rbp), %eax
subl $0x2, %eax
je 0x5b3a
jmp 0x5b5b
movq -0x8(%rbp), %rdi
leaq 0x3542(%rip), %rsi      # 0x9045
callq 0x53f0
movq %rax, %rdi
movq 0x64b6(%rip), %rsi      # 0xbfc8
callq 0x5450
jmp 0x5b5d
movq -0x8(%rbp), %rdi
leaq 0x3523(%rip), %rsi      # 0x9047
callq 0x53f0
movq %rax, %rdi
movq 0x6495(%rip), %rsi      # 0xbfc8
callq 0x5450
jmp 0x5b5d
movq -0x8(%rbp), %rdi
leaq 0x3504(%rip), %rsi      # 0x9049
callq 0x53f0
movq %rax, %rdi
movq 0x6474(%rip), %rsi      # 0xbfc8
callq 0x5450
jmp 0x5b5d
jmp 0x5b5d
movq -0x8(%rbp), %rdi
leaq 0x34e3(%rip), %rsi      # 0x904b
callq 0x53f0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5510
movq -0x20(%rbp), %rdi
movl %eax, %esi
callq 0x5780
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x5c58
movq -0x10(%rbp), %rdi
callq 0x5720
movq -0x10(%rbp), %rdi
movl $0x10, %esi
callq 0x5430
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x5c81
movq -0x20(%rbp), %rdi
callq 0x5720
movq -0x20(%rbp), %rdi
movl $0x10, %esi
callq 0x5430
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x5caa
movq -0x28(%rbp), %rdi
callq 0x5720
movq -0x28(%rbp), %rdi
movl $0x10, %esi
callq 0x5430
addq $0x30, %rsp
popq %rbp
retq
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movl $0x2, %esi
callq 0x5690
jmp 0x6160
movl $0x5dc, -0x14(%rbp)     # imm = 0x5DC
leaq -0x10(%rbp), %rdi
leaq -0x14(%rbp), %rsi
callq 0x5790
jmp 0x6176
leaq -0x10(%rbp), %rdi
callq 0x5830
jmp 0x6181
movq -0x40(%rbp), %rdi
movl $0x1, %esi
callq 0x5690
jmp 0x6191
movl $0x5dc, -0x24(%rbp)     # imm = 0x5DC
leaq -0x20(%rbp), %rdi
leaq -0x24(%rbp), %rsi
callq 0x5790
jmp 0x61a7
leaq -0x20(%rbp), %rdi
callq 0x5830
jmp 0x61b2
movq -0x40(%rbp), %rdi
xorl %esi, %esi
callq 0x5690
jmp 0x61bf
movl $0x5dc, -0x34(%rbp)     # imm = 0x5DC
leaq -0x30(%rbp), %rdi
leaq -0x34(%rbp), %rsi
callq 0x5790
jmp 0x61d5
leaq -0x30(%rbp), %rdi
callq 0x5830
jmp 0x61e0
movq -0x40(%rbp), %rdi
movl $0x4, %esi
callq 0x5690
jmp 0x61f0
addq $0x40, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x7470
nop
// File: geoherna[P]lib605/./src/lib605.cpp
// Function: lib605::MSR::SetLED(lib605::MSR::MSR_LED)
void MSR::SetLED(MSR_LED LED) {
		if(!this->MSRConected) {
#if defined(DEBUG)
			std::cout << "[*] Error: Unable to reset non-connected device" << std::endl;
#endif
			return;
		}
		switch(LED) {
			case LED_GREEN: {
				this->WriteAutoSize(MSR_GREEN_LED_ON);
				break;
			} case LED_YELLOW: {
				this->WriteAutoSize(MSR_YELLOW_LED_ON);
				break;
			} case LED_RED: {
				this->WriteAutoSize(MSR_RED_LED_ON);
				break;
			} case LED_ALL: {
				this->WriteAutoSize(MSR_ALL_LED_ON);
				break;
			} case LED_OFF: {
				this->WriteAutoSize(MSR_ALL_LED_OFF);
				break;
			}default: break;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
testb $0x1, 0x4(%rax)
jne 0x621f
jmp 0x629c
movl -0xc(%rbp), %eax
movq %rax, -0x20(%rbp)
subq $0x4, %rax
ja 0x629a
movq -0x20(%rbp), %rax
leaq 0x2dc9(%rip), %rcx      # 0x9000
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x18(%rbp), %rdi
leaq 0x2eba(%rip), %rsi      # 0x9105
callq 0x5240
jmp 0x629c
movq -0x18(%rbp), %rdi
leaq 0x2eab(%rip), %rsi      # 0x9108
callq 0x5240
jmp 0x629c
movq -0x18(%rbp), %rdi
leaq 0x2e9c(%rip), %rsi      # 0x910b
callq 0x5240
jmp 0x629c
movq -0x18(%rbp), %rdi
leaq 0x2e8d(%rip), %rsi      # 0x910e
callq 0x5240
jmp 0x629c
movq -0x18(%rbp), %rdi
leaq 0x2e7e(%rip), %rsi      # 0x9111
callq 0x5240
jmp 0x629c
jmp 0x629c
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x8, %rdi
movq %rdi, -0x10(%rbp)
callq 0x55e0
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movb $0x0, 0x4(%rax)
leaq 0x2dd7(%rip), %rsi      # 0x90bb
callq 0x55b0
jmp 0x62eb
addq $0x20, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x7470
nopl (%rax)
// File: geoherna[P]lib605/./src/lib605.cpp
// Function: lib605::MSR::Disconnect()
void MSR::Disconnect(void) {
		if(!this->MSRConected) {
#if defined(DEBUG)
			std::cout << "[*] Unable to disconnect, not connect to device" << std::endl;
#endif
			return;
		}
#if defined(DEBUG)
		std::cout << "[*] Disconnecting from device" << std::end;
#endif
		this->SendReset();
		close(this->devhndl);
		this->MSRConected = false;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
testb $0x1, 0x4(%rax)
jne 0x63bc
jmp 0x63d8
movq -0x10(%rbp), %rdi
callq 0x5320
movq -0x10(%rbp), %rax
movl (%rax), %edi
callq 0x58c0
movq -0x10(%rbp), %rax
movb $0x0, 0x4(%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: 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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rsi, -0x70(%rbp)
movq %rdi, %rax
movq -0x70(%rbp), %rdi
movq %rdi, -0x68(%rbp)
movq %rax, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq 0x2cd2(%rip), %rsi      # 0x9150
callq 0x58f0
testb $0x1, %al
jne 0x6489
jmp 0x64b4
movq 0x5b40(%rip), %rdi      # 0xbfd0
leaq 0x2c31(%rip), %rsi      # 0x90c8
callq 0x53f0
movq %rax, %rdi
movq 0x5b22(%rip), %rsi      # 0xbfc8
callq 0x5450
movb $0x0, -0x1(%rbp)
jmp 0x653a
movq -0x68(%rbp), %rdi
callq 0x51b0
movq %rax, %rdi
movl $0x102, %esi            # imm = 0x102
movb $0x0, %al
callq 0x52e0
movq -0x60(%rbp), %rcx
movl %eax, (%rcx)
cmpl $0x0, %eax
jge 0x64dd
movb $0x0, -0x1(%rbp)
jmp 0x653a
movq -0x60(%rbp), %rax
movl (%rax), %edi
leaq -0x54(%rbp), %rsi
callq 0x54f0
movl $0x8b0, -0x4c(%rbp)     # imm = 0x8B0
movl $0x0, -0x50(%rbp)
movl $0x0, -0x54(%rbp)
leaq -0x54(%rbp), %rdi
movl $0xd, %esi
callq 0x5250
leaq -0x54(%rbp), %rdi
movl $0xd, %esi
callq 0x54b0
movq -0x60(%rbp), %rax
movl (%rax), %edi
xorl %esi, %esi
leaq -0x54(%rbp), %rdx
callq 0x5550
movq -0x60(%rbp), %rax
movb $0x1, 0x4(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
testb $0x1, 0x4(%rax)
jne 0x6570
movb $0x0, -0x1(%rbp)
jmp 0x65e0
movq -0x18(%rbp), %rdi
callq 0x5400
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x5690
movq -0x18(%rbp), %rdi
callq 0x53b0
testb $0x1, %al
jne 0x6596
jmp 0x65ce
movq -0x18(%rbp), %rdi
callq 0x5610
testb $0x1, %al
jne 0x65a5
jmp 0x65ce
movq -0x18(%rbp), %rdi
callq 0x55d0
testb $0x1, %al
jne 0x65b4
jmp 0x65ce
movq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x5690
movq -0x18(%rbp), %rdi
callq 0x5320
movb $0x1, -0x1(%rbp)
jmp 0x65e0
movq -0x18(%rbp), %rdi
movl $0x2, %esi
callq 0x5690
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: geoherna[P]lib605/./src/lib605.cpp
// Function: lib605::MSR::TestCommunication()
bool MSR::TestCommunication(void) {
		if(!this->MSRConected) {
#if defined(DEBUG)
			std::cout << "[*] Unable to test, not connect to device" << std::endl;
#endif
			return false;
		}
#if defined(DEBUG)
		std::cout << "[*] Performing communication test" << std::end;
#endif
		char resp[2];
		this->WriteAutoSize(MSR_COM_TEST);
		if(this->ReadBytes((char*)&resp, 2) != 2) {
#if defined(DEBUG)
			std::cout << "[*] Communication self test failed, expected back 2 bytes" << std::endl;
#endif
			return false;
		}
		if(memcmp(resp, (MSR_ESC "\x79"), 2) != 0) {
#if defined(DEBUG)
			std::cout << "[*] Communication self test failed, expected <ESC>\\x79 got other" << std::endl;
#endif
			return false;
		}
		return true;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
testb $0x1, 0x4(%rax)
jne 0x6610
movb $0x0, -0x1(%rbp)
jmp 0x665d
movq -0x20(%rbp), %rdi
leaq 0x2ad5(%rip), %rsi      # 0x90f0
callq 0x5240
movq -0x20(%rbp), %rdi
leaq -0x12(%rbp), %rsi
movl $0x2, %edx
callq 0x5160
cmpl $0x2, %eax
je 0x663d
movb $0x0, -0x1(%rbp)
jmp 0x665d
leaq -0x12(%rbp), %rax
movw (%rax), %ax
subw $0x791b, %ax            # imm = 0x791B
setne %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x6659
movb $0x0, -0x1(%rbp)
jmp 0x665d
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: geoherna[P]lib605/./src/lib605.cpp
// Function: lib605::MSR::TestRAM()
bool MSR::TestRAM(void) {
		if(!this->MSRConected) {
#if defined(DEBUG)
			std::cout << "[*] Unable to test, not connect to device" << std::endl;
#endif
			return false;
		}
#if defined(DEBUG)
		std::cout << "[*] Performing RAM test" << std::end;
#endif
		char resp[2];
		this->WriteAutoSize(MSR_RAM_TEST);
		if(this->ReadBytes((char*)&resp, 2) != 2) {
#if defined(DEBUG)
			std::cout << "[*] Ram self test failed, expected back 2 bytes" << std::endl;
#endif
			return false;
		}
		if(memcmp(resp, MSR_OK, 2) == 0) {
			return true;
		}else if (memcmp(resp, MSR_FAIL, 2) == 0) {
#if defined(DEBUG)
			std::cout << "[*] RAM self test failed, got MSR_FAIL" << std::endl;
#endif
			return false;
		} else {
#if defined(DEBUG)
			std::cout << "[*] RAM self test failed, expected MSR_OK or MSR_FAIL, got other" << std::endl;
#endif
			return false;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
testb $0x1, 0x4(%rax)
jne 0x6690
movb $0x0, -0x1(%rbp)
jmp 0x66f9
movq -0x20(%rbp), %rdi
leaq 0x2a61(%rip), %rsi      # 0x90fc
callq 0x5240
movq -0x20(%rbp), %rdi
leaq -0x12(%rbp), %rsi
movl $0x2, %edx
callq 0x5160
cmpl $0x2, %eax
je 0x66bd
movb $0x0, -0x1(%rbp)
jmp 0x66f9
leaq -0x12(%rbp), %rax
movw (%rax), %ax
subw $0x301b, %ax            # imm = 0x301B
setne %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x66d9
movb $0x1, -0x1(%rbp)
jmp 0x66f9
leaq -0x12(%rbp), %rax
movw (%rax), %ax
subw $0x411b, %ax            # imm = 0x411B
setne %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x66f5
movb $0x0, -0x1(%rbp)
jmp 0x66f9
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: geoherna[P]lib605/./src/lib605.cpp
// Function: lib605::MSR::TestSensor()
bool MSR::TestSensor(void) {
		if(!this->MSRConected) {
#if defined(DEBUG)
			std::cout << "[*] Unable to test, not connect to device" << std::endl;
#endif
			return false;
		}
#if defined(DEBUG)
		std::cout << "[*] Performing sensor test" << std::end;
#endif
		char resp[2];
		this->WriteAutoSize(MSR_SENS_TEST);
		// The device wont respond unless a reset is issued
		this->SendReset();
		if(this->ReadBytes((char*)&resp, 2) != 2) {
#if defined(DEBUG)
			std::cout << "[*] Sensor self test failed, expected back 2 bytes" << std::endl;
#endif
			return false;
		}
		if(memcmp(resp, MSR_OK, 2) != 0) {
#if defined(DEBUG)
			std::cout << "[*] Sensor self test failed, expected MSR_OK got something else" << std::endl;
#endif
			return false;
		}
		return true;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
testb $0x1, 0x4(%rax)
jne 0x6730
movb $0x0, -0x1(%rbp)
jmp 0x6786
movq -0x20(%rbp), %rdi
leaq 0x29bb(%rip), %rsi      # 0x90f6
callq 0x5240
movq -0x20(%rbp), %rdi
callq 0x5320
movq -0x20(%rbp), %rdi
leaq -0x12(%rbp), %rsi
movl $0x2, %edx
callq 0x5160
cmpl $0x2, %eax
je 0x6766
movb $0x0, -0x1(%rbp)
jmp 0x6786
leaq -0x12(%rbp), %rax
movw (%rax), %ax
subw $0x301b, %ax            # imm = 0x301B
setne %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x6782
movb $0x0, -0x1(%rbp)
jmp 0x6786
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: geoherna[P]lib605/./src/lib605.cpp
// Function: lib605::MSR::SendReset()
void MSR::SendReset(void) {
		if(!this->MSRConected) {
#if defined(DEBUG)
			std::cout << "[*] Error: Unable to reset non-connected device" << std::endl;
#endif
			return;
		}
		this->WriteAutoSize(MSR_RESET);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
testb $0x1, 0x4(%rax)
jne 0x67bc
jmp 0x67cc
movq -0x10(%rbp), %rdi
leaq 0x293b(%rip), %rsi      # 0x9102
callq 0x5240
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
testb $0x1, 0x4(%rax)
jne 0x683a
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x68a3
movl $0x0, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x6851
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x68a3
jmp 0x6853
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
je 0x689d
movq -0x30(%rbp), %rax
movl (%rax), %edi
movq -0x18(%rbp), %rsi
movslq -0x20(%rbp), %rax
addq %rax, %rsi
movl -0x1c(%rbp), %eax
subl -0x20(%rbp), %eax
movslq %eax, %rdx
callq 0x5630
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jge 0x688c
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x68a3
cmpl $0x0, -0x24(%rbp)
jle 0x689b
movl -0x24(%rbp), %eax
addl -0x20(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0x6853
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: geoherna[P]lib605/./src/lib605.cpp
// Function: lib605::MSR::WriteBytes(char*, int)
int MSR::WriteBytes(char* buffer, int len) {
		if(!this->MSRConected) {
#if defined(DEBUG)
			std::cout << "[*] Error: unable to write to non-connected device" << std::endl;
#endif
			return -1;
		}
		int count = 0;
		count = write(this->devhndl, buffer, len);
		return count;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
testb $0x1, 0x4(%rax)
jne 0x6d6a
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6d8d
movq -0x28(%rbp), %rax
movl $0x0, -0x20(%rbp)
movl (%rax), %edi
movq -0x18(%rbp), %rsi
movslq -0x1c(%rbp), %rdx
callq 0x5180
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)