LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: jkingan[P]ladyheather/heathmsc.cpp
// Function: show_cs_val(int, int, int)
void show_cs_val(int row,int col, int color)
{
char *s;
int i;

   s = strchr(out, ':');
   if(s == 0) return;

   i = s - &out[0] + 1;
   out[i] = 0;
   i = strlen(out);

   vidstr(row,col, WHITE, &blanks[TEXT_COLS-40]);
   vidstr(row,col, GREEN, out);
   vidstr(row,col+i+1, color, &out[i+1]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
leaq 0x285be8(%rip), %rdi    # 0x39b400
movl $0x3a, %esi
callq 0x9100
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x115832
jmp 0x1158ce
movq -0x18(%rbp), %rax
leaq 0x285bc3(%rip), %rcx    # 0x39b400
subq %rcx, %rax
addq $0x1, %rax
movl %eax, -0x1c(%rbp)
movslq -0x1c(%rbp), %rcx
leaq 0x285bae(%rip), %rax    # 0x39b400
movb $0x0, (%rax,%rcx)
leaq 0x285ba3(%rip), %rdi    # 0x39b400
callq 0x9120
movl %eax, -0x1c(%rbp)
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
leaq 0x162176(%rip), %rax    # 0x2779e8
movl (%rax), %eax
subl $0x28, %eax
cltq
leaq 0x285970(%rip), %rcx    # 0x39b1f0
addq %rax, %rcx
movl $0xf, %edx
callq 0x10ee0
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
movl $0xa, %edx
leaq 0x285b61(%rip), %rcx    # 0x39b400
callq 0x10ee0
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
addl -0x1c(%rbp), %esi
addl $0x1, %esi
movl -0xc(%rbp), %eax
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rdx
leaq 0x285b3d(%rip), %rcx    # 0x39b400
addq %rdx, %rcx
movzbl %al, %edx
callq 0x10ee0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jkingan[P]ladyheather/heathmsc.cpp
// Function: log_lpfrs_xml(_IO_FILE*)
void log_lpfrs_xml(FILE *file)
{
   fprintf(file, "        <aa>%g</aa>\n", lpfrs_aa);
   fprintf(file, "        <bb>%g</bb>\n", lpfrs_bb);
   fprintf(file, "        <cc>%g</cc>\n", lpfrs_cc);
   fprintf(file, "        <dd>%g</dd>\n", lpfrs_dd);
   fprintf(file, "        <ee>%g</ee>\n", lpfrs_ee);
   fprintf(file, "        <ff>%g</ff>\n", lpfrs_ff);
   fprintf(file, "        <gg>%g</gg>\n", lpfrs_gg);
   fprintf(file, "        <hh>%g</hh>\n", lpfrs_hh);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x2564a9(%rip), %rax    # 0x36cee0
movsd (%rax), %xmm0
leaq 0x7c616(%rip), %rsi     # 0x193058
movb $0x1, %al
callq 0x9550
movq -0x8(%rbp), %rdi
leaq 0x256484(%rip), %rax    # 0x36ced8
movsd (%rax), %xmm0
leaq 0x7c60e(%rip), %rsi     # 0x19306d
movb $0x1, %al
callq 0x9550
movq -0x8(%rbp), %rdi
leaq 0x25645f(%rip), %rax    # 0x36ced0
movsd (%rax), %xmm0
leaq 0x7c606(%rip), %rsi     # 0x193082
movb $0x1, %al
callq 0x9550
movq -0x8(%rbp), %rdi
leaq 0x25643a(%rip), %rax    # 0x36cec8
movsd (%rax), %xmm0
leaq 0x7c5fe(%rip), %rsi     # 0x193097
movb $0x1, %al
callq 0x9550
movq -0x8(%rbp), %rdi
leaq 0x256415(%rip), %rax    # 0x36cec0
movsd (%rax), %xmm0
leaq 0x7c5f6(%rip), %rsi     # 0x1930ac
movb $0x1, %al
callq 0x9550
movq -0x8(%rbp), %rdi
leaq 0x2563f0(%rip), %rax    # 0x36ceb8
movsd (%rax), %xmm0
leaq 0x7c5ee(%rip), %rsi     # 0x1930c1
movb $0x1, %al
callq 0x9550
movq -0x8(%rbp), %rdi
leaq 0x2563cb(%rip), %rax    # 0x36ceb0
movsd (%rax), %xmm0
leaq 0x7c5e6(%rip), %rsi     # 0x1930d6
movb $0x1, %al
callq 0x9550
movq -0x8(%rbp), %rdi
leaq 0x2563a6(%rip), %rax    # 0x36cea8
movsd (%rax), %xmm0
leaq 0x7c5de(%rip), %rsi     # 0x1930eb
movb $0x1, %al
callq 0x9550
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: jkingan[P]ladyheather/heathmsc.cpp
// Function: log_sro_xml(_IO_FILE*)
void log_sro_xml(FILE *file)
{
   fprintf(file, "        <aa>%g</aa>\n", sro_aa);
   fprintf(file, "        <bb>%g</bb>\n", sro_bb);
   fprintf(file, "        <cc>%g</cc>\n", sro_cc);
   fprintf(file, "        <dd>%g</dd>\n", sro_dd);
   fprintf(file, "        <ee>%g</ee>\n", sro_ee);
   fprintf(file, "        <ff>%g</ff>\n", sro_ff);
   fprintf(file, "        <gg>%g</gg>\n", sro_gg);
   fprintf(file, "        <hh>%g</hh>\n", sro_hh);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x256239(%rip), %rax    # 0x36cd80
movsd (%rax), %xmm0
leaq 0x7c506(%rip), %rsi     # 0x193058
movb $0x1, %al
callq 0x9550
movq -0x8(%rbp), %rdi
leaq 0x256214(%rip), %rax    # 0x36cd78
movsd (%rax), %xmm0
leaq 0x7c4fe(%rip), %rsi     # 0x19306d
movb $0x1, %al
callq 0x9550
movq -0x8(%rbp), %rdi
leaq 0x2561ef(%rip), %rax    # 0x36cd70
movsd (%rax), %xmm0
leaq 0x7c4f6(%rip), %rsi     # 0x193082
movb $0x1, %al
callq 0x9550
movq -0x8(%rbp), %rdi
leaq 0x2561ca(%rip), %rax    # 0x36cd68
movsd (%rax), %xmm0
leaq 0x7c4ee(%rip), %rsi     # 0x193097
movb $0x1, %al
callq 0x9550
movq -0x8(%rbp), %rdi
leaq 0x2561a5(%rip), %rax    # 0x36cd60
movsd (%rax), %xmm0
leaq 0x7c4e6(%rip), %rsi     # 0x1930ac
movb $0x1, %al
callq 0x9550
movq -0x8(%rbp), %rdi
leaq 0x256180(%rip), %rax    # 0x36cd58
movsd (%rax), %xmm0
leaq 0x7c4de(%rip), %rsi     # 0x1930c1
movb $0x1, %al
callq 0x9550
movq -0x8(%rbp), %rdi
leaq 0x25615b(%rip), %rax    # 0x36cd50
movsd (%rax), %xmm0
leaq 0x7c4d6(%rip), %rsi     # 0x1930d6
movb $0x1, %al
callq 0x9550
movq -0x8(%rbp), %rdi
leaq 0x256136(%rip), %rax    # 0x36cd48
movsd (%rax), %xmm0
leaq 0x7c4ce(%rip), %rsi     # 0x1930eb
movb $0x1, %al
callq 0x9550
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: jkingan[P]ladyheather/heathmsc.cpp
// Function: fake_tow(double)
u32 fake_tow(double jd)
{
u32 tow;

   // fake the time of week time stamp

   jd = jd - GPS_EPOCH;
   jd *= (24.0*60.0*60.0);

   tow = (u32) (jd+0.50);
// tow = tow % (u32) (24L*60L*60L*7L);
   return tow;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
movsd 0x72b3a(%rip), %xmm1    # 0x18e2d0
addsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
movsd 0x5385c(%rip), %xmm1    # 0x16f008
mulsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
movsd 0x538ce(%rip), %xmm1    # 0x16f090
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %rax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jkingan[P]ladyheather/heathmsc.cpp
// Function: write_log_error(char*, unsigned int)
void write_log_error(char *s, u32 val)
{
   if(log_file == 0) return;
   if(log_errors == 0) return;
   if(log_comments == 0) return;

   sprintf(log_text, "#! %s error: %u", s, (u32) val);
   write_log_comment(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq 0x17c7ca(%rip), %rax    # 0x29d540
cmpq $0x0, (%rax)
jne 0x120d7e
jmp 0x120dc6
leaq 0x17c856(%rip), %rax    # 0x29d5db
movzbl (%rax), %eax
cmpl $0x0, %eax
jne 0x120d8f
jmp 0x120dc6
leaq 0x17c85e(%rip), %rax    # 0x29d5f4
movzbl (%rax), %eax
cmpl $0x0, %eax
jne 0x120da0
jmp 0x120dc6
movq -0x8(%rbp), %rdx
movl -0xc(%rbp), %ecx
leaq 0x17bd92(%rip), %rdi    # 0x29cb40
leaq 0x74496(%rip), %rsi     # 0x19524b
movb $0x0, %al
callq 0x9060
movl $0x1, %edi
callq 0x10cbe0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: jkingan[P]ladyheather/heathmsc.cpp
// Function: write_log_utc(int)
void write_log_utc(int utc_offset)
{
   // write UTC offset changes to the log file

   if(log_file == 0) return;
   if(log_comments == 0) return;
   if((have_info & INFO_LOGGED) == 0) { // log file header not written yet   
      if(user_set_log) return;   // keeps bogus UTC entry out of log file
   }

   sprintf(log_text,"#");
   write_log_comment(1);
   sprintf(log_text,"#! New UTC offset: %d seconds", utc_offset);
   write_log_comment(1);
   sprintf(log_text,"#");
   write_log_comment(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
leaq 0x17c75e(%rip), %rax    # 0x29d540
cmpq $0x0, (%rax)
jne 0x120ded
jmp 0x120e84
leaq 0x17c800(%rip), %rax    # 0x29d5f4
movzbl (%rax), %eax
cmpl $0x0, %eax
jne 0x120e01
jmp 0x120e84
leaq 0x24bd4c(%rip), %rax    # 0x36cb54
movl (%rax), %eax
andl $0x200, %eax            # imm = 0x200
cmpl $0x0, %eax
jne 0x120e24
leaq 0x17c7c1(%rip), %rax    # 0x29d5dc
cmpb $0x0, (%rax)
je 0x120e22
jmp 0x120e84
jmp 0x120e24
leaq 0x17bd15(%rip), %rdi    # 0x29cb40
leaq 0x50f6a(%rip), %rsi     # 0x171d9c
movb $0x0, %al
callq 0x9060
movl $0x1, %edi
callq 0x10cbe0
movl -0x4(%rbp), %edx
leaq 0x17bcf3(%rip), %rdi    # 0x29cb40
leaq 0x74407(%rip), %rsi     # 0x19525b
movb $0x0, %al
callq 0x9060
movl $0x1, %edi
callq 0x10cbe0
leaq 0x17bcd4(%rip), %rdi    # 0x29cb40
leaq 0x50f29(%rip), %rsi     # 0x171d9c
movb $0x0, %al
callq 0x9060
movl $0x1, %edi
callq 0x10cbe0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: jkingan[P]ladyheather/heathmsc.cpp
// Function: write_log_leapsecond()
void write_log_leapsecond()
{
   // write leapsecond occurance in the log file

   sprintf(log_text,"#");
   write_log_comment(1);

   month = fix_month(month);
   sprintf(log_text,"#! Leapsecond: %02d:%02d:%02d %s   %02d %s %04d - interval %ld secs", 
      hours,minutes,seconds, (time_flags & TFLAGS_UTC)?"UTC":"GPS", day,months[month],year, log_interval);
   write_log_comment(1);

   sprintf(log_text,"#");
   write_log_comment(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x38, %rsp
leaq 0x17bca0(%rip), %rdi    # 0x29cb40
leaq 0x50ef5(%rip), %rsi     # 0x171d9c
movb $0x0, %al
callq 0x9060
movl $0x1, %edi
callq 0x10cbe0
leaq 0x24b7f9(%rip), %rax    # 0x36c6b8
movl (%rax), %edi
callq 0x9c2e0
movl %eax, %ecx
leaq 0x24b7e9(%rip), %rax    # 0x36c6b8
movl %ecx, (%rax)
leaq 0x24b7d8(%rip), %rax    # 0x36c6b0
movl (%rax), %eax
movl %eax, -0x14(%rbp)
leaq 0x24b7c8(%rip), %rax    # 0x36c6ac
movl (%rax), %eax
movl %eax, -0x10(%rbp)
leaq 0x24b7b8(%rip), %rax    # 0x36c6a8
movl (%rax), %eax
movl %eax, -0xc(%rbp)
leaq 0x24b788(%rip), %rax    # 0x36c684
movl (%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x120f13
leaq 0x76b33(%rip), %rax     # 0x197a40
movq %rax, -0x20(%rbp)
jmp 0x120f20
leaq 0x7553f(%rip), %rax     # 0x196459
movq %rax, -0x20(%rbp)
jmp 0x120f20
movl -0xc(%rbp), %r8d
movl -0x10(%rbp), %ecx
movl -0x14(%rbp), %edx
movq -0x20(%rbp), %r9
leaq 0x24b77f(%rip), %rax    # 0x36c6b4
movl (%rax), %ebx
leaq 0x24b77a(%rip), %rax    # 0x36c6b8
movslq (%rax), %rsi
leaq 0xa87f8(%rip), %rax     # 0x1c9740
movq (%rax,%rsi,8), %r11
leaq 0x24b769(%rip), %rax    # 0x36c6bc
movl (%rax), %r10d
leaq 0x15962b(%rip), %rax    # 0x27a588
movq (%rax), %rax
leaq 0x17bbd9(%rip), %rdi    # 0x29cb40
leaq 0x7430b(%rip), %rsi     # 0x195279
movl %ebx, (%rsp)
movq %r11, 0x8(%rsp)
movl %r10d, 0x10(%rsp)
movq %rax, 0x18(%rsp)
movb $0x0, %al
callq 0x9060
movl $0x1, %edi
callq 0x10cbe0
leaq 0x17bba8(%rip), %rdi    # 0x29cb40
leaq 0x50dfd(%rip), %rsi     # 0x171d9c
movb $0x0, %al
callq 0x9060
movl $0x1, %edi
callq 0x10cbe0
addq $0x38, %rsp
popq %rbx
popq %rbp
retq
nopw (%rax,%rax)
// File: jkingan[P]ladyheather/heathmsc.cpp
// Function: restore_plot_config()
void restore_plot_config()
{
int i;

   if(showing_adv_file) { // restore all plots
      showing_adv_file = 0;
      for(i=0; i<NUM_PLOTS+DERIVED_PLOTS; i++) {
         plot[i].show_plot = plot[i].old_show;
      }
      plot_sat_count = old_sat_plot;
      plot_adev_data = old_adev_plot;
      if(plot_adev_data == 0) adev_decades_shown = 0;
      adev_period = xxx_adev_period;       // aaaaaapppppp other periods
      keep_adevs_fresh = old_keep_fresh;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x2792d6(%rip), %rax    # 0x39a5d1
cmpb $0x0, (%rax)
je 0x1213c1
leaq 0x2792c6(%rip), %rax    # 0x39a5d1
movb $0x0, (%rax)
movl $0x0, -0x4(%rbp)
cmpl $0x14, -0x4(%rbp)
jge 0x121359
movslq -0x4(%rbp), %rcx
leaq 0x9b9fa(%rip), %rax     # 0x1bcd20
imulq $0xe8, %rcx, %rcx
addq %rcx, %rax
movl 0xc4(%rax), %ecx
movslq -0x4(%rbp), %rdx
leaq 0x9b9df(%rip), %rax     # 0x1bcd20
imulq $0xe8, %rdx, %rdx
addq %rdx, %rax
movl %ecx, 0x18(%rax)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x121315
leaq 0x279272(%rip), %rax    # 0x39a5d2
movb (%rax), %cl
leaq 0x159252(%rip), %rax    # 0x27a5bb
movb %cl, (%rax)
leaq 0x279261(%rip), %rax    # 0x39a5d3
movb (%rax), %cl
leaq 0x15923e(%rip), %rax    # 0x27a5b9
movb %cl, (%rax)
leaq 0x159235(%rip), %rax    # 0x27a5b9
movzbl (%rax), %eax
cmpl $0x0, %eax
jne 0x121399
leaq 0x156611(%rip), %rax    # 0x2779a4
movl $0x0, (%rax)
leaq 0x279238(%rip), %rax    # 0x39a5d8
movsd (%rax), %xmm0
leaq 0x17ab2d(%rip), %rax    # 0x29bed8
movsd %xmm0, (%rax)
leaq 0x27921e(%rip), %rax    # 0x39a5d4
movb (%rax), %cl
leaq 0x17ab5d(%rip), %rax    # 0x29bf1c
movb %cl, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jkingan[P]ladyheather/heathmsc.cpp
// Function: jdate(int, int, int)
double jdate(int y, int m, int d)
{
long j;
long j1;
long j2;
long j3;
long c;
long x;

   // return the julian date of the start of a given day

   if(m < 3) {
      m = m + 12;
      j = y - 1;
   }
   else j = y;

   c = (j / 100L);
   x = j - (100L * c);
   j1 = (146097L * c) / 4L;
   j2 = (36525L * x) / 100L;
   j3 = ((153L*(long)m) - 457L) / 5L;
   return (1721119.5-1.0) + (double) j1 + (double) j2 + (double) j3 + (double) d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
cmpl $0x3, -0x8(%rbp)
jge 0x12216a
movl -0x8(%rbp), %eax
addl $0xc, %eax
movl %eax, -0x8(%rbp)
movl -0x4(%rbp), %eax
subl $0x1, %eax
cltq
movq %rax, -0x18(%rbp)
jmp 0x122172
movslq -0x4(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl $0x64, %ecx
cqto
idivq %rcx
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
imulq $0x64, -0x38(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x40(%rbp)
imulq $0x23ab1, -0x38(%rbp), %rax # imm = 0x23AB1
movl $0x4, %ecx
cqto
idivq %rcx
movq %rax, -0x20(%rbp)
imulq $0x8ead, -0x40(%rbp), %rax # imm = 0x8EAD
movl $0x64, %ecx
cqto
idivq %rcx
movq %rax, -0x28(%rbp)
movslq -0x8(%rbp), %rax
imulq $0x99, %rax, %rax
subq $0x1c9, %rax            # imm = 0x1C9
movl $0x5, %ecx
cqto
idivq %rcx
movq %rax, -0x30(%rbp)
cvtsi2sdq -0x20(%rbp), %xmm1
movsd 0x6c14b(%rip), %xmm0    # 0x18e338
addsd %xmm1, %xmm0
cvtsi2sdq -0x28(%rbp), %xmm1
addsd %xmm1, %xmm0
cvtsi2sdq -0x30(%rbp), %xmm1
addsd %xmm1, %xmm0
cvtsi2sdl -0xc(%rbp), %xmm1
addsd %xmm1, %xmm0
popq %rbp
retq
// File: jkingan[P]ladyheather/heathmsc.cpp
// Function: xml_val(char*)
DATA_SIZE xml_val(char *line)
{
char *s;

   // get a numeric value from an XML data point line

   if(line == 0) return 0.0;

   s = strchr(line, '>');

   if(s == 0) return 0.0;
   else if(s[0] == 0) return 0.0;
   else return (DATA_SIZE) atof(s+1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x12228d
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x1222d8
movq -0x10(%rbp), %rdi
movl $0x3e, %esi
callq 0x9100
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x1222b0
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x1222d8
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x1222c6
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x1222d8
movq -0x18(%rbp), %rdi
addq $0x1, %rdi
callq 0x9480
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jkingan[P]ladyheather/heathmsc.cpp
// Function: xml_string(char*)
char *xml_string(char *line)
{
char *s;
char *s2;

   // get a string value from an XML data point line

   if(line == 0) return "";

   s = strchr(line, '>');
   if(s == 0) return "";
   else if(s[0] == 0) return "";

   s2 = strchr(s, '<');
   if(s2) *s2 = 0;

   return s+1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x122310
leaq 0x72288(%rip), %rax     # 0x194592
movq %rax, -0x8(%rbp)
jmp 0x12237d
movq -0x10(%rbp), %rdi
movl $0x3e, %esi
callq 0x9100
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x122336
leaq 0x72262(%rip), %rax     # 0x194592
movq %rax, -0x8(%rbp)
jmp 0x12237d
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x12234f
leaq 0x72249(%rip), %rax     # 0x194592
movq %rax, -0x8(%rbp)
jmp 0x12237d
jmp 0x122351
movq -0x18(%rbp), %rdi
movl $0x3c, %esi
callq 0x9100
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x122371
movq -0x20(%rbp), %rax
movb $0x0, (%rax)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: jkingan[P]ladyheather/heathmsc.cpp
// Function: set_log_title(char*)
void set_log_title(char *plot_title)
{
int i;

   // set the plot title string from info in a log file
   if(plot_title == 0) return;

   i = strlen(plot_title);

   if(i && (plot_title[i-1] == 0x0D)) plot_title[i-1] = 0;
   if(i && (plot_title[i-1] == 0x0A)) plot_title[i-1] = 0;
   if(plot_title[0]) title_type = USER;
   else              title_type = NONE;

   saw_log_title = 1;
   show_title();
   refresh_page();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x125978
jmp 0x125a17
movq -0x8(%rbp), %rdi
callq 0x9120
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x1259b1
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xd, %eax
jne 0x1259b1
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
cmpl $0x0, -0xc(%rbp)
je 0x1259de
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
jne 0x1259de
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
movq -0x8(%rbp), %rax
cmpb $0x0, (%rax)
je 0x1259f6
leaq 0x278abe(%rip), %rax    # 0x39e4ac
movl $0x2, (%rax)
jmp 0x125a03
leaq 0x278aaf(%rip), %rax    # 0x39e4ac
movl $0x0, (%rax)
movl $0x1, 0x2b3ea7(%rip)    # 0x3d98b4
callq 0x21820
callq 0xb0d0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: jkingan[P]ladyheather/heathmsc.cpp
// Function: alloc_mtie(int)
void alloc_mtie(int why)
{
   alloc_mtie_data(CHA_MTIE, adev_q_size);
   alloc_mtie_data(CHB_MTIE, adev_q_size);
   alloc_mtie_data(CHC_MTIE, adev_q_size);
   alloc_mtie_data(CHD_MTIE, adev_q_size);
   mtie_allocated = 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
leaq 0x174f96(%rip), %rax    # 0x29beb8
movq (%rax), %rax
movl %eax, %esi
xorl %edi, %edi
callq 0x15dc30
leaq 0x174f83(%rip), %rax    # 0x29beb8
movq (%rax), %rax
movl %eax, %esi
movl $0x1, %edi
callq 0x15dc30
leaq 0x174f6d(%rip), %rax    # 0x29beb8
movq (%rax), %rax
movl %eax, %esi
movl $0x2, %edi
callq 0x15dc30
leaq 0x174f57(%rip), %rax    # 0x29beb8
movq (%rax), %rax
movl %eax, %esi
movl $0x3, %edi
callq 0x15dc30
leaq 0x174f4d(%rip), %rax    # 0x29bec4
movl $0x1, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jkingan[P]ladyheather/heathmsc.cpp
// Function: force_adev_redraw(int)
void force_adev_redraw(int why)
{
    // force a redraw of the the adev tables and graphs
    have_time = 0;
    pps_adev_disp = ADEV_DISPLAY_RATE;
    osc_adev_disp = ADEV_DISPLAY_RATE;
    chc_adev_disp = ADEV_DISPLAY_RATE;
    chd_adev_disp = ADEV_DISPLAY_RATE;

    max_adev_width = 0;    // recalc table sizes
    adev_page_size = 0;
    adev_table_rows = 0;

    update_adev_display(ATYPE, 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
leaq 0x1763ba(%rip), %rax    # 0x29e0bc
movb $0x0, (%rax)
leaq 0x174024(%rip), %rax    # 0x29bd30
movl $0xa, (%rax)
leaq 0x174067(%rip), %rax    # 0x29bd80
movl $0xa, (%rax)
leaq 0x1740aa(%rip), %rax    # 0x29bdd0
movl $0xa, (%rax)
leaq 0x1740e5(%rip), %rax    # 0x29be18
movl $0xa, (%rax)
leaq 0x17412c(%rip), %rax    # 0x29be6c
movl $0x0, (%rax)
leaq 0x14fc4f(%rip), %rax    # 0x27799c
movl $0x0, (%rax)
leaq 0x14fc46(%rip), %rax    # 0x2779a0
movl $0x0, (%rax)
leaq 0x15aa89(%rip), %rax    # 0x2827f0
movl (%rax), %edi
movl $0x1, %esi
callq 0x166ba0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: jkingan[P]ladyheather/heathmsc.cpp
// Function: read_rawfile(char*)
int read_rawfile(char *s)
{
long seek_addr;

   // load a .raw capture file and treat it as a simulation file

   if(s == 0) return 0;
   strcpy(sim_name, s);

   s = strchr(sim_name, ',');
   if(s) {  // seek offset set
      *s = 0;
      seek_addr = (long) atoi(s+1);
   }
   else seek_addr = 0;

   sim_file = topen(sim_name, "rb");
   if(sim_file == 0) return 1;
   if(rcvr_type != CS_RCVR) sim_file_read |= 0x01;

   kbd_sim = 1;  // flag that a keyboard command opened the simulation file
   fseek(sim_file, seek_addr, SEEK_SET);
   sim_eof = 0;

   return 2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x12828f
movl $0x0, -0x4(%rbp)
jmp 0x128370
movq -0x10(%rbp), %rsi
leaq 0x1744a6(%rip), %rdi    # 0x29c740
callq 0x9350
leaq 0x17449a(%rip), %rdi    # 0x29c740
movl $0x2c, %esi
callq 0x9100
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1282d7
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
movq -0x10(%rbp), %rdi
addq $0x1, %rdi
callq 0x95c0
cltq
movq %rax, -0x18(%rbp)
jmp 0x1282df
movq $0x0, -0x18(%rbp)
leaq 0x17445a(%rip), %rdi    # 0x29c740
leaq 0x5a80b(%rip), %rsi     # 0x182af8
callq 0x9b20
movq %rax, %rcx
leaq 0x1752a4(%rip), %rax    # 0x29d5a0
movq %rcx, (%rax)
leaq 0x17529a(%rip), %rax    # 0x29d5a0
cmpq $0x0, (%rax)
jne 0x128315
movl $0x1, -0x4(%rbp)
jmp 0x128370
leaq 0x14f794(%rip), %rax    # 0x277ab0
cmpq $0x20000, (%rax)        # imm = 0x20000
je 0x12833a
leaq 0x15a4c0(%rip), %rax    # 0x2827ec
movl (%rax), %ecx
orl $0x1, %ecx
leaq 0x15a4b4(%rip), %rax    # 0x2827ec
movl %ecx, (%rax)
leaq 0x17527f(%rip), %rax    # 0x29d5c0
movl $0x1, (%rax)
leaq 0x175252(%rip), %rax    # 0x29d5a0
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
xorl %edx, %edx
callq 0x93e0
leaq 0x175255(%rip), %rax    # 0x29d5b8
movl $0x0, (%rax)
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: jkingan[P]ladyheather/heathmsc.cpp
// Function: read_signals(char*)
void read_signals(char *s)
{
FILE *sig_file;
float az, el, sig;

   // stop recording live signal strength data and load in signal strength 
   // data from a log file

   sig_file = topen(s, "r");
   if(sig_file == 0) return;
   clear_signals();       // flush the old data
   
   plot_signals = 4;      // show the pretty color map

   while(fgets(out, sizeof out, sig_file) != NULL) {
      if((out[0] == '*') || (out[0] == ';') || (out[0] == '/') || (out[0] == '#')) {
         continue;  // comment line
      }
      sscanf(out, "%f %f %f", &az, &el, &sig);
      log_signal(az, el, sig, 0);
   }

   fclose(sig_file);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x58506(%rip), %rsi     # 0x18400d
callq 0x9b20
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x12bb1c
jmp 0x12bbc9
callq 0x157510
leaq 0x14eacd(%rip), %rax    # 0x27a5f5
movb $0x4, (%rax)
movq -0x10(%rbp), %rdx
leaq 0x26f8ca(%rip), %rdi    # 0x39b400
movl $0x201, %esi            # imm = 0x201
callq 0x95e0
cmpq $0x0, %rax
je 0x12bbc0
leaq 0x26f8b3(%rip), %rax    # 0x39b400
movsbl (%rax), %eax
cmpl $0x2a, %eax
je 0x12bb82
leaq 0x26f8a4(%rip), %rax    # 0x39b400
movsbl (%rax), %eax
cmpl $0x3b, %eax
je 0x12bb82
leaq 0x26f895(%rip), %rax    # 0x39b400
movsbl (%rax), %eax
cmpl $0x2f, %eax
je 0x12bb82
leaq 0x26f886(%rip), %rax    # 0x39b400
movsbl (%rax), %eax
cmpl $0x23, %eax
jne 0x12bb84
jmp 0x12bb2b
leaq 0x26f875(%rip), %rdi    # 0x39b400
leaq 0x6c1af(%rip), %rsi     # 0x197d41
leaq -0x14(%rbp), %rdx
leaq -0x18(%rbp), %rcx
leaq -0x1c(%rbp), %r8
movb $0x0, %al
callq 0x9370
movss -0x14(%rbp), %xmm0
movss -0x18(%rbp), %xmm1
movss -0x1c(%rbp), %xmm2
xorl %edi, %edi
callq 0x157800
jmp 0x12bb2b
movq -0x10(%rbp), %rdi
callq 0x9380
addq $0x20, %rsp
popq %rbp
retq
nop
// File: jkingan[P]ladyheather/heathmsc.cpp
// Function: read_prn(char*)
void read_prn(char *s)
{
FILE *prn_file;
double jd;
int prn;
float az, el, sig;

   // load in satellie time, prn, az, el, signal strength 
   // data from a .prn file

   prn_file = topen(s, "r");
   if(prn_file == 0) return;

   while(fgets(out, sizeof out, prn_file) != NULL) {
      if((out[0] == '*') || (out[0] == ';') || (out[0] == '/') || (out[0] == '#')) {
         continue;  // comment line
      }
      sscanf(out, "%lf %d %f %f %f", &jd, &prn, &az, &el, &sig);
      log_signal(az, el, sig, 0);   // !!!!! do something with this data?
   }

   fclose(prn_file);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x58426(%rip), %rsi     # 0x18400d
callq 0x9b20
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x12bbfc
jmp 0x12bcac
jmp 0x12bbfe
movq -0x10(%rbp), %rdx
leaq 0x26f7f7(%rip), %rdi    # 0x39b400
movl $0x201, %esi            # imm = 0x201
callq 0x95e0
cmpq $0x0, %rax
je 0x12bca3
leaq 0x26f7dc(%rip), %rax    # 0x39b400
movsbl (%rax), %eax
cmpl $0x2a, %eax
je 0x12bc59
leaq 0x26f7cd(%rip), %rax    # 0x39b400
movsbl (%rax), %eax
cmpl $0x3b, %eax
je 0x12bc59
leaq 0x26f7be(%rip), %rax    # 0x39b400
movsbl (%rax), %eax
cmpl $0x2f, %eax
je 0x12bc59
leaq 0x26f7af(%rip), %rax    # 0x39b400
movsbl (%rax), %eax
cmpl $0x23, %eax
jne 0x12bc5b
jmp 0x12bbfe
leaq 0x26f79e(%rip), %rdi    # 0x39b400
leaq 0x6c0d1(%rip), %rsi     # 0x197d3a
leaq -0x18(%rbp), %rdx
leaq -0x1c(%rbp), %rcx
leaq -0x20(%rbp), %r8
leaq -0x24(%rbp), %r9
leaq -0x28(%rbp), %rax
movq %rax, (%rsp)
movb $0x0, %al
callq 0x9370
movss -0x20(%rbp), %xmm0
movss -0x24(%rbp), %xmm1
movss -0x28(%rbp), %xmm2
xorl %edi, %edi
callq 0x157800
jmp 0x12bbfe
movq -0x10(%rbp), %rdi
callq 0x9380
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jkingan[P]ladyheather/heathmsc.cpp
// Function: bump_time()
void bump_time(void)
{
  // add one second to current time value
  month = fix_month(month);
  if(++seconds >= 60) {
     seconds = 0;
     if(++minutes >= 60) {
        minutes = 0;
        if(++hours >= 24) {
           hours = 0;
           if(++day > dim[month]) {
              day = 1;
              if(++month > 12) {
                 month = 1;
                 ++year;
              }
           }
        }
     }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x23fd5d(%rip), %rax    # 0x36c6b8
movl (%rax), %edi
callq 0x9c2e0
movl %eax, %ecx
leaq 0x23fd4d(%rip), %rax    # 0x36c6b8
movl %ecx, (%rax)
leaq 0x23fd34(%rip), %rax    # 0x36c6a8
movl (%rax), %eax
addl $0x1, %eax
leaq 0x23fd28(%rip), %rcx    # 0x36c6a8
movl %eax, (%rcx)
cmpl $0x3c, %eax
jl 0x12ca6a
leaq 0x23fd16(%rip), %rax    # 0x36c6a8
movl $0x0, (%rax)
leaq 0x23fd0d(%rip), %rax    # 0x36c6ac
movl (%rax), %eax
addl $0x1, %eax
leaq 0x23fd01(%rip), %rcx    # 0x36c6ac
movl %eax, (%rcx)
cmpl $0x3c, %eax
jl 0x12ca68
leaq 0x23fcef(%rip), %rax    # 0x36c6ac
movl $0x0, (%rax)
leaq 0x23fce6(%rip), %rax    # 0x36c6b0
movl (%rax), %eax
addl $0x1, %eax
leaq 0x23fcda(%rip), %rcx    # 0x36c6b0
movl %eax, (%rcx)
cmpl $0x18, %eax
jl 0x12ca66
leaq 0x23fcc8(%rip), %rax    # 0x36c6b0
movl $0x0, (%rax)
leaq 0x23fcbf(%rip), %rax    # 0x36c6b4
movl (%rax), %eax
addl $0x1, %eax
leaq 0x23fcb3(%rip), %rcx    # 0x36c6b4
movl %eax, (%rcx)
leaq 0x23fcae(%rip), %rcx    # 0x36c6b8
movslq (%rcx), %rdx
leaq 0x9ccec(%rip), %rcx     # 0x1c9700
cmpl (%rcx,%rdx,4), %eax
jle 0x12ca64
leaq 0x23fc94(%rip), %rax    # 0x36c6b4
movl $0x1, (%rax)
leaq 0x23fc8b(%rip), %rax    # 0x36c6b8
movl (%rax), %eax
addl $0x1, %eax
leaq 0x23fc7f(%rip), %rcx    # 0x36c6b8
movl %eax, (%rcx)
cmpl $0xc, %eax
jle 0x12ca62
leaq 0x23fc71(%rip), %rax    # 0x36c6b8
movl $0x1, (%rax)
leaq 0x23fc68(%rip), %rax    # 0x36c6bc
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0x23fc5c(%rip), %rax    # 0x36c6bc
movl %ecx, (%rax)
jmp 0x12ca64
jmp 0x12ca66
jmp 0x12ca68
jmp 0x12ca6a
popq %rbp
retq
nopl (%rax)
// File: jkingan[P]ladyheather/heathmsc.cpp
// Function: sbas_prn(int)
int sbas_prn(int prn)
{
   // convert receiver PRN id to RINEX standard values
   // Ublox IMES is 183 .. 192
   // Ublox QZSS is 193 .. 197

   if(rcvr_type == GPSD_RCVR) {  // we don't know the actual receiver type GPSD is using
      return 0;
   }
   else if(rcvr_type == ESIP_RCVR) {
      if((prn >= 33) && (prn < 64)) {
         return prn + (120-33) - 100;
      }
   }
   else if(rcvr_type == NMEA_RCVR) {  
      if((prn >= 33) && (prn < 64)) {
         return (prn+87) - 100;
      }
   }
   else if(rcvr_type == TSIP_RCVR) {
      return 0;
   }
   else if(rcvr_type == VENUS_RCVR) {  // ???? is this correct
      if((prn >= 33) && (prn < 64)) {
         return (prn+87) - 100;
      }
   }
   else if((prn >= 120) && (prn <= 158))  {
      return prn-100;
   }

   return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
leaq 0x14afc2(%rip), %rax    # 0x277ab0
cmpq $0x200, (%rax)          # imm = 0x200
jne 0x12cb03
movl $0x0, -0x4(%rbp)
jmp 0x12cbcc
movl $0x80000000, %ecx       # imm = 0x80000000
leaq 0x14afa1(%rip), %rax    # 0x277ab0
cmpq %rcx, (%rax)
jne 0x12cb36
cmpl $0x21, -0x8(%rbp)
jl 0x12cb31
cmpl $0x40, -0x8(%rbp)
jge 0x12cb31
movl -0x8(%rbp), %eax
addl $0x57, %eax
subl $0x64, %eax
movl %eax, -0x4(%rbp)
jmp 0x12cbcc
jmp 0x12cbc3
leaq 0x14af73(%rip), %rax    # 0x277ab0
cmpq $0x2, (%rax)
jne 0x12cb5f
cmpl $0x21, -0x8(%rbp)
jl 0x12cb5d
cmpl $0x40, -0x8(%rbp)
jge 0x12cb5d
movl -0x8(%rbp), %eax
addl $0x57, %eax
subl $0x64, %eax
movl %eax, -0x4(%rbp)
jmp 0x12cbcc
jmp 0x12cbc1
leaq 0x14af4a(%rip), %rax    # 0x277ab0
cmpq $0x1, (%rax)
jne 0x12cb75
movl $0x0, -0x4(%rbp)
jmp 0x12cbcc
leaq 0x14af34(%rip), %rax    # 0x277ab0
cmpq $0x80, (%rax)
jne 0x12cba1
cmpl $0x21, -0x8(%rbp)
jl 0x12cb9f
cmpl $0x40, -0x8(%rbp)
jge 0x12cb9f
movl -0x8(%rbp), %eax
addl $0x57, %eax
subl $0x64, %eax
movl %eax, -0x4(%rbp)
jmp 0x12cbcc
jmp 0x12cbbd
cmpl $0x78, -0x8(%rbp)
jl 0x12cbbb
cmpl $0x9e, -0x8(%rbp)
jg 0x12cbbb
movl -0x8(%rbp), %eax
subl $0x64, %eax
movl %eax, -0x4(%rbp)
jmp 0x12cbcc
jmp 0x12cbbd
jmp 0x12cbbf
jmp 0x12cbc1
jmp 0x12cbc3
jmp 0x12cbc5
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jkingan[P]ladyheather/heathmsc.cpp
// Function: glonass_prn(int)
int glonass_prn(int prn)
{
   if(rcvr_type == GPSD_RCVR) { // we don't know the actual receiver type GPSD is using 
      return 0;
   }
   else if(rcvr_type == ESIP_RCVR) {
      if(prn < 65) return 0;
      if(prn > 92) return 0;
   }
   else {
      if(prn < 65) return 0;
      if(prn > 96) return 0;
   }
   return (prn-64);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
leaq 0x14ae82(%rip), %rax    # 0x277ab0
cmpq $0x200, (%rax)          # imm = 0x200
jne 0x12cc40
movl $0x0, -0x4(%rbp)
jmp 0x12cc9c
movl $0x80000000, %ecx       # imm = 0x80000000
leaq 0x14ae64(%rip), %rax    # 0x277ab0
cmpq %rcx, (%rax)
jne 0x12cc71
cmpl $0x41, -0x8(%rbp)
jge 0x12cc60
movl $0x0, -0x4(%rbp)
jmp 0x12cc9c
cmpl $0x5c, -0x8(%rbp)
jle 0x12cc6f
movl $0x0, -0x4(%rbp)
jmp 0x12cc9c
jmp 0x12cc91
cmpl $0x41, -0x8(%rbp)
jge 0x12cc80
movl $0x0, -0x4(%rbp)
jmp 0x12cc9c
cmpl $0x60, -0x8(%rbp)
jle 0x12cc8f
movl $0x0, -0x4(%rbp)
jmp 0x12cc9c
jmp 0x12cc91
jmp 0x12cc93
movl -0x8(%rbp), %eax
subl $0x40, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jkingan[P]ladyheather/heathmsc.cpp
// Function: galileo_prn(int)
int galileo_prn(int prn)
{
   if(rcvr_type == UBX_RCVR) {
      if((prn >= 211) && (prn <= 246)) return prn-210;
   }
   else if(rcvr_type == VENUS_RCVR) {
      if((prn >= 301) && (prn <= 350)) return prn-300;
   }
   else if(0 && (rcvr_type == TSIP_RCVR)) {
      // 183, 192,193,200
      if((prn >= 97) && (prn <= 133)) return prn-96;
   }
   return 0;  // not yet supported
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
leaq 0x14adb2(%rip), %rax    # 0x277ab0
cmpq $0x4, (%rax)
jne 0x12cd25
cmpl $0xd3, -0x8(%rbp)
jl 0x12cd23
cmpl $0xf6, -0x8(%rbp)
jg 0x12cd23
movl -0x8(%rbp), %eax
subl $0xd2, %eax
movl %eax, -0x4(%rbp)
jmp 0x12cd61
jmp 0x12cd5a
leaq 0x14ad84(%rip), %rax    # 0x277ab0
cmpq $0x80, (%rax)
jne 0x12cd56
cmpl $0x12d, -0x8(%rbp)      # imm = 0x12D
jl 0x12cd54
cmpl $0x15e, -0x8(%rbp)      # imm = 0x15E
jg 0x12cd54
movl -0x8(%rbp), %eax
subl $0x12c, %eax            # imm = 0x12C
movl %eax, -0x4(%rbp)
jmp 0x12cd61
jmp 0x12cd58
jmp 0x12cd58
jmp 0x12cd5a
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jkingan[P]ladyheather/heathmsc.cpp
// Function: beidou_prn(int)
int beidou_prn(int prn)
{
   // not supported in RINEX before v3.0
   if(1 && (rcvr_type == UBX_RCVR)) {
      if((prn >= 159) && (prn <= 163)) return prn-158;
      else if((prn >= 33) && (prn <= 64)) return 6+(prn-33);
   }
   else if(rcvr_type == VENUS_RCVR) {
      if((prn >= 201) && (prn <= 237)) return prn-200;
   }
   else if(0 && (rcvr_type == TSIP_RCVR)) {
      if((prn >= 201) && (prn <= 237)) return prn-200;
   }
   return 0;  // not yet supported
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
leaq 0x14acf2(%rip), %rax    # 0x277ab0
cmpq $0x4, (%rax)
jne 0x12ce01
cmpl $0x9f, -0x8(%rbp)
jl 0x12cde3
cmpl $0xa3, -0x8(%rbp)
jg 0x12cde3
movl -0x8(%rbp), %eax
subl $0x9e, %eax
movl %eax, -0x4(%rbp)
jmp 0x12ce3d
cmpl $0x21, -0x8(%rbp)
jl 0x12cdfd
cmpl $0x40, -0x8(%rbp)
jg 0x12cdfd
movl -0x8(%rbp), %eax
subl $0x21, %eax
addl $0x6, %eax
movl %eax, -0x4(%rbp)
jmp 0x12ce3d
jmp 0x12cdff
jmp 0x12ce36
leaq 0x14aca8(%rip), %rax    # 0x277ab0
cmpq $0x80, (%rax)
jne 0x12ce32
cmpl $0xc9, -0x8(%rbp)
jl 0x12ce30
cmpl $0xed, -0x8(%rbp)
jg 0x12ce30
movl -0x8(%rbp), %eax
subl $0xc8, %eax
movl %eax, -0x4(%rbp)
jmp 0x12ce3d
jmp 0x12ce34
jmp 0x12ce34
jmp 0x12ce36
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jkingan[P]ladyheather/heathmsc.cpp
// Function: qzss_prn(int)
int qzss_prn(int prn)
{
   // returns the RINEX PRN id code if sat is a QZSS satellite
   if(rcvr_type == ESIP_RCVR) {
      if((prn >= 93) && (prn < 199)) return prn-92;
   }
   else if(rcvr_type == TSIP_RCVR) {
      // 183, 192, 193, 200
   }
   else if(rcvr_type == UBX_RCVR){
      if((prn >= 193) && (prn <= 197)) return prn-192;
   }
   else if(rcvr_type == VENUS_RCVR){
      if((prn >= 193) && (prn <= 199)) return prn-192;
   }

   return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl $0x80000000, %ecx       # imm = 0x80000000
leaq 0x14ac0d(%rip), %rax    # 0x277ab0
cmpq %rcx, (%rax)
jne 0x12cec4
cmpl $0x5d, -0x8(%rbp)
jl 0x12cec2
cmpl $0xc7, -0x8(%rbp)
jge 0x12cec2
movl -0x8(%rbp), %eax
subl $0x5c, %eax
movl %eax, -0x4(%rbp)
jmp 0x12cf3f
jmp 0x12cf38
leaq 0x14abe5(%rip), %rax    # 0x277ab0
cmpq $0x1, (%rax)
jne 0x12ced3
jmp 0x12cf36
leaq 0x14abd6(%rip), %rax    # 0x277ab0
cmpq $0x4, (%rax)
jne 0x12cf01
cmpl $0xc1, -0x8(%rbp)
jl 0x12ceff
cmpl $0xc5, -0x8(%rbp)
jg 0x12ceff
movl -0x8(%rbp), %eax
subl $0xc0, %eax
movl %eax, -0x4(%rbp)
jmp 0x12cf3f
jmp 0x12cf34
leaq 0x14aba8(%rip), %rax    # 0x277ab0
cmpq $0x80, (%rax)
jne 0x12cf32
cmpl $0xc1, -0x8(%rbp)
jl 0x12cf30
cmpl $0xc7, -0x8(%rbp)
jg 0x12cf30
movl -0x8(%rbp), %eax
subl $0xc0, %eax
movl %eax, -0x4(%rbp)
jmp 0x12cf3f
jmp 0x12cf32
jmp 0x12cf34
jmp 0x12cf36
jmp 0x12cf38
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jkingan[P]ladyheather/heathmsc.cpp
// Function: gnss_letter(int)
char gnss_letter(int prn)
{
char c;

   rinex_gnss(prn);
   if(rcvr_type == GPSD_RCVR)  c = ' ';
   else if(gnss_sat & GPS)     c = 'G';
   else if(gnss_sat & BEIDOU)  c = 'C';
   else if(gnss_sat & GALILEO) c = 'E';
   else if(gnss_sat & IRNSS)   c = 'I';
   else if(gnss_sat & QZSS)    c = 'J';
   else if(gnss_sat & IMES)    c = 'M';
   else if(gnss_sat & GLONASS) c = 'R';
   else if(gnss_sat & SBAS)    c = 'S';
   else                        c = ' ';

   return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %edi
callq 0x12d280
leaq 0x14a7e6(%rip), %rax    # 0x277ab0
cmpq $0x200, (%rax)          # imm = 0x200
jne 0x12d2dc
movb $0x20, -0x5(%rbp)
jmp 0x12d3b7
leaq 0xa2b7d(%rip), %rax     # 0x1cfe60
movl (%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x12d2f6
movb $0x47, -0x5(%rbp)
jmp 0x12d3b5
leaq 0xa2b63(%rip), %rax     # 0x1cfe60
movl (%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x12d310
movb $0x43, -0x5(%rbp)
jmp 0x12d3b3
leaq 0xa2b49(%rip), %rax     # 0x1cfe60
movl (%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x12d32a
movb $0x45, -0x5(%rbp)
jmp 0x12d3b1
leaq 0xa2b2f(%rip), %rax     # 0x1cfe60
movl (%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x12d341
movb $0x49, -0x5(%rbp)
jmp 0x12d3af
leaq 0xa2b18(%rip), %rax     # 0x1cfe60
movl (%rax), %eax
andl $0x4000, %eax           # imm = 0x4000
cmpl $0x0, %eax
je 0x12d35a
movb $0x4a, -0x5(%rbp)
jmp 0x12d3ad
leaq 0xa2aff(%rip), %rax     # 0x1cfe60
movl (%rax), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
je 0x12d373
movb $0x4d, -0x5(%rbp)
jmp 0x12d3ab
leaq 0xa2ae6(%rip), %rax     # 0x1cfe60
movl (%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x12d38a
movb $0x52, -0x5(%rbp)
jmp 0x12d3a9
leaq 0xa2acf(%rip), %rax     # 0x1cfe60
movl (%rax), %eax
andl $0x8000, %eax           # imm = 0x8000
cmpl $0x0, %eax
je 0x12d3a3
movb $0x53, -0x5(%rbp)
jmp 0x12d3a7
movb $0x20, -0x5(%rbp)
jmp 0x12d3a9
jmp 0x12d3ab
jmp 0x12d3ad
jmp 0x12d3af
jmp 0x12d3b1
jmp 0x12d3b3
jmp 0x12d3b5
jmp 0x12d3b7
movb -0x5(%rbp), %al
addq $0x10, %rsp
popq %rbp
retq
// File: jkingan[P]ladyheather/heathmsc.cpp
// Function: gnss_id(int)
char *gnss_id(int prn)
{
char *s;

   rinex_gnss(prn);
   if(rcvr_type == GPSD_RCVR)  s = "PRN";
   else if(gnss_sat & GPS)     s = "GPS";
   else if(gnss_sat & BEIDOU)  s = "BEIDOU";
   else if(gnss_sat & GALILEO) s = "GALILEO";
   else if(gnss_sat & IRNSS)   s = "IRNSS";
   else if(gnss_sat & QZSS)    s = "QZSS";
   else if(gnss_sat & IMES)    s = "IMES";
   else if(gnss_sat & GLONASS) s = "GLONASS";
   else if(gnss_sat & SBAS)    s = "SBAS";
   else                        s = "PRN";

   return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %edi
callq 0x12d280
leaq 0x14a6d6(%rip), %rax    # 0x277ab0
cmpq $0x200, (%rax)          # imm = 0x200
jne 0x12d3f3
leaq 0x688ed(%rip), %rax     # 0x195cd7
movq %rax, -0x10(%rbp)
jmp 0x12d510
leaq 0xa2a66(%rip), %rax     # 0x1cfe60
movl (%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x12d414
leaq 0x6904e(%rip), %rax     # 0x196459
movq %rax, -0x10(%rbp)
jmp 0x12d50e
leaq 0xa2a45(%rip), %rax     # 0x1cfe60
movl (%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x12d435
leaq 0x68b58(%rip), %rax     # 0x195f84
movq %rax, -0x10(%rbp)
jmp 0x12d50c
leaq 0xa2a24(%rip), %rax     # 0x1cfe60
movl (%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x12d456
leaq 0x68b3e(%rip), %rax     # 0x195f8b
movq %rax, -0x10(%rbp)
jmp 0x12d50a
leaq 0xa2a03(%rip), %rax     # 0x1cfe60
movl (%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x12d477
leaq 0x5056a(%rip), %rax     # 0x17d9d8
movq %rax, -0x10(%rbp)
jmp 0x12d508
leaq 0xa29e2(%rip), %rax     # 0x1cfe60
movl (%rax), %eax
andl $0x4000, %eax           # imm = 0x4000
cmpl $0x0, %eax
je 0x12d497
leaq 0x68b02(%rip), %rax     # 0x195f93
movq %rax, -0x10(%rbp)
jmp 0x12d506
leaq 0xa29c2(%rip), %rax     # 0x1cfe60
movl (%rax), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
je 0x12d4b7
leaq 0x68ae7(%rip), %rax     # 0x195f98
movq %rax, -0x10(%rbp)
jmp 0x12d504
leaq 0xa29a2(%rip), %rax     # 0x1cfe60
movl (%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x12d4d5
leaq 0x68ace(%rip), %rax     # 0x195f9d
movq %rax, -0x10(%rbp)
jmp 0x12d502
leaq 0xa2984(%rip), %rax     # 0x1cfe60
movl (%rax), %eax
andl $0x8000, %eax           # imm = 0x8000
cmpl $0x0, %eax
je 0x12d4f5
leaq 0x5a51d(%rip), %rax     # 0x187a0c
movq %rax, -0x10(%rbp)
jmp 0x12d500
leaq 0x687db(%rip), %rax     # 0x195cd7
movq %rax, -0x10(%rbp)
jmp 0x12d502
jmp 0x12d504
jmp 0x12d506
jmp 0x12d508
jmp 0x12d50a
jmp 0x12d50c
jmp 0x12d50e
jmp 0x12d510
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: jkingan[P]ladyheather/heathmsc.cpp
// Function: good_raw(int)
int good_raw(int prn)
{
   // return the RINEX system id char if it's a satellite we support
   if(sat[prn].level_msg == 0) return 0;  // sat is not tracked
   if(sat[prn].tracking <= 0) return 0;

   if(rinex_prn(prn)) {
      if     (gps_sat(prn))     return gps_sat(prn);      // it's a GPS sat
      else if(sbas_sat(prn))    return sbas_sat(prn);     // it's a SBAS sat
      else if(glonass_sat(prn)) return glonass_sat(prn);  // 
      else if(galileo_sat(prn)) return galileo_sat(prn);  // 
      else if(beidou_sat(prn))  return beidou_sat(prn);   // 
   }

   return 0;  // it's not OK to output the sat's RAW measurements
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movslq -0x8(%rbp), %rcx
leaq 0x170c5a(%rip), %rax    # 0x29e190
imulq $0x348, %rcx, %rcx      # imm = 0x348
addq %rcx, %rax
cmpl $0x0, 0x1c(%rax)
jne 0x12d552
movl $0x0, -0x4(%rbp)
jmp 0x12d620
movslq -0x8(%rbp), %rcx
leaq 0x170c33(%rip), %rax    # 0x29e190
imulq $0x348, %rcx, %rcx      # imm = 0x348
addq %rcx, %rax
cmpl $0x0, 0x218(%rax)
jg 0x12d57c
movl $0x0, -0x4(%rbp)
jmp 0x12d620
movl -0x8(%rbp), %edi
callq 0x12d020
cmpl $0x0, %eax
je 0x12d619
movl -0x8(%rbp), %edi
callq 0x12caa0
cmpl $0x0, %eax
je 0x12d5a7
movl -0x8(%rbp), %edi
callq 0x12caa0
movl %eax, -0x4(%rbp)
jmp 0x12d620
movl -0x8(%rbp), %edi
callq 0x12cbe0
cmpl $0x0, %eax
je 0x12d5c1
movl -0x8(%rbp), %edi
callq 0x12cbe0
movl %eax, -0x4(%rbp)
jmp 0x12d620
movl -0x8(%rbp), %edi
callq 0x12ccb0
cmpl $0x0, %eax
je 0x12d5db
movl -0x8(%rbp), %edi
callq 0x12ccb0
movl %eax, -0x4(%rbp)
jmp 0x12d620
movl -0x8(%rbp), %edi
callq 0x12cd70
cmpl $0x0, %eax
je 0x12d5f5
movl -0x8(%rbp), %edi
callq 0x12cd70
movl %eax, -0x4(%rbp)
jmp 0x12d620
movl -0x8(%rbp), %edi
callq 0x12ce50
cmpl $0x0, %eax
je 0x12d60f
movl -0x8(%rbp), %edi
callq 0x12ce50
movl %eax, -0x4(%rbp)
jmp 0x12d620
jmp 0x12d611
jmp 0x12d613
jmp 0x12d615
jmp 0x12d617
jmp 0x12d619
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: jkingan[P]ladyheather/heathmsc.cpp
// Function: add_obs_val(_IO_FILE*, char*, int*)
void add_obs_val(FILE *file, char *meas, int *obs_count)
{
int max_obs;

   // add the observation value to the output string

   if(file == 0) return;
   if(meas == 0) return;
   if(obs_count == 0) return;

   max_obs = 5;
   if(rinex_fmt >= 3.0) max_obs = 100;

   fprintf(file, "%s", meas);
   *obs_count = (*obs_count)+1;
   if(*obs_count >= max_obs) {
      fprintf(file, "\n");
      out[0] = 0;
      *obs_count = 0;
      obs_data_written = 1;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x12d650
jmp 0x12d6f2
cmpq $0x0, -0x10(%rbp)
jne 0x12d65c
jmp 0x12d6f2
cmpq $0x0, -0x18(%rbp)
jne 0x12d668
jmp 0x12d6f2
movl $0x5, -0x1c(%rbp)
leaq 0x1700ea(%rip), %rax    # 0x29d760
movsd (%rax), %xmm0
movsd 0x41b5e(%rip), %xmm1    # 0x16f1e0
ucomisd %xmm1, %xmm0
jb 0x12d68f
movl $0x64, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq 0x6348f(%rip), %rsi     # 0x190b2d
movb $0x0, %al
callq 0x9550
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movl (%rax), %eax
cmpl -0x1c(%rbp), %eax
jl 0x12d6f2
movq -0x8(%rbp), %rdi
leaq 0x6af5c(%rip), %rsi     # 0x198626
movb $0x0, %al
callq 0x9550
leaq 0x26dd28(%rip), %rax    # 0x39b400
movb $0x0, (%rax)
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
leaq 0x16fee8(%rip), %rax    # 0x29d5d4
movl $0x1, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: jkingan[P]ladyheather/heathmsc.cpp
// Function: add_obs_type(int*, int, int)
int add_obs_type(int *obs_type, int count, int obs)
{
int i;

   // add an observation ID to the observation type list

   if(obs_type == 0) return count;
   if(count >= MAX_OBS) return count;

   for(i=0; i<count; i++) {  // filter out duplicates
      if(obs_type[i] == obs) return count;
   }

   obs_type[count++] = obs;
   return obs;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x12d71d
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x12d77d
cmpl $0x1b, -0x14(%rbp)
jl 0x12d72b
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x12d77d
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x12d75f
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x18(%rbp), %eax
jne 0x12d752
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x12d77d
jmp 0x12d754
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x12d732
movl -0x18(%rbp), %edx
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x14(%rbp)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jkingan[P]ladyheather/heathmsc.cpp
// Function: rinex_cppr(int, double, double)
double rinex_cppr(int prn, double range, double carrier)
{
double cp_range;
int gnss;

  // convert carrier phase to pseudorange
  // (testing shows this actually makes things worse)
  if(use_rinex_cppr == 0) return range;
  if(have_phase == 0) return range;

  gnss = rinex_gnss(prn);
  if(gnss & GPS) ;           // sats in 1575.426 Mhz L1
  else if(gnss & SBAS) ;
  else if(gnss & GALILEO) ;
  else return range;

  cp_range = carrier * ((LIGHTSPEED*1000.0)/1575.42E6);
if(0 &&debug_file) fprintf(debug_file, "cppr(%d,%f): %f -> %f\n", prn,carrier, range,cp_range);
  return cp_range;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0xc(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd %xmm1, -0x20(%rbp)
leaq 0x16dc90(%rip), %rax    # 0x29d76c
cmpl $0x0, (%rax)
jne 0x12faed
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x12fb65
leaq 0x23ca30(%rip), %rax    # 0x36c524
cmpl $0x0, (%rax)
jne 0x12fb05
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x12fb65
movl -0xc(%rbp), %edi
callq 0x12d280
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x12fb1d
jmp 0x12fb49
movl -0x2c(%rbp), %eax
andl $0x8000, %eax           # imm = 0x8000
cmpl $0x0, %eax
je 0x12fb2c
jmp 0x12fb47
movl -0x2c(%rbp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x12fb39
jmp 0x12fb45
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x12fb65
jmp 0x12fb47
jmp 0x12fb49
movsd 0x5e7ff(%rip), %xmm0    # 0x18e350
mulsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
// File: jkingan[P]ladyheather/heathmsc.cpp
// Function: leap_year(int)
int leap_year(int year)
{
   if(year % 4) return 0;        // not a leap year
   if((year % 100) == 0) {       // most likely,  not a leap year
      if(year % 400) return 0;   // not a leap year
   }
   return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
je 0x1328f0
movl $0x0, -0x4(%rbp)
jmp 0x132922
movl -0x8(%rbp), %eax
movl $0x64, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x13291b
movl -0x8(%rbp), %eax
movl $0x190, %ecx            # imm = 0x190
cltd
idivl %ecx
cmpl $0x0, %edx
je 0x132919
movl $0x0, -0x4(%rbp)
jmp 0x132922
jmp 0x13291b
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)