LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: jkingan[P]ladyheather/heather.cpp
// Function: process_script_file()
int process_script_file()
{
int i;

   if(script_fault) {  // error in script,  abort
      close_script(1);
      getting_string = 0;
      alarm_wait = 0;
      return 0;
   }
   else if(KBHIT()) {  // key pressed,  abort script
      i = edit_error("Script aborted...  key pressed.");
      close_script(1);
      getting_string = 0;
      alarm_wait = 0;
      return 0;
   }
   else if(alarm_wait && (alarm_time || alarm_date || egg_timer || egg_val)) { // script is waiting for an alarm to trigger
      return 0;
   }
   else {   // get keyboard command from the script file  // !!!!!! what about force_si_cmd?
      i = get_script();
      if(i) do_kbd(i);
      return i;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpl $0x0, 0x27484d(%rip)    # 0x29e0ac
je 0x29887
movl $0x1, %edi
callq 0x293a0
movw $0x0, 0x374f74(%rip)    # 0x39e7e8
movb $0x0, 0x34387f(%rip)    # 0x36d0fa
movl $0x0, -0x4(%rbp)
jmp 0x29917
callq 0xf3d0
cmpl $0x0, %eax
je 0x298c3
leaq 0x14738e(%rip), %rdi    # 0x170c26
callq 0x30d60
movl %eax, -0x8(%rbp)
movl $0x1, %edi
callq 0x293a0
movw $0x0, 0x374f35(%rip)    # 0x39e7e8
movb $0x0, 0x343840(%rip)    # 0x36d0fa
movl $0x0, -0x4(%rbp)
jmp 0x29917
cmpb $0x0, 0x343830(%rip)    # 0x36d0fa
je 0x298fb
cmpl $0x0, 0x343829(%rip)    # 0x36d0fc
jne 0x298f2
cmpl $0x0, 0x343830(%rip)    # 0x36d10c
jne 0x298f2
cmpq $0x0, 0x343802(%rip)    # 0x36d0e8
jne 0x298f2
cmpq $0x0, 0x343800(%rip)    # 0x36d0f0
je 0x298fb
movl $0x0, -0x4(%rbp)
jmp 0x29917
callq 0x29750
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
je 0x29911
movl -0x8(%rbp), %edi
callq 0x62a60
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
// File: jkingan[P]ladyheather/heather.cpp
// Function: process_extra_ports(int)
void process_extra_ports(int why)
{
   // process any data from the various extra input data ports

   if(enviro_port_open()) {  // monitoring a external environmental sensor
      get_enviro_message(THERMO_PORT);  // aaattt
   }
   else if(com[THERMO_PORT].port_used > 0) {  // for data loss recovery
      get_enviro_message(THERMO_PORT);  // aaattt
   }


   if(ticc_port_open()) {  // monitoring a GPS on the RCVR_PORT and a TICC on the TICC_PORT
      get_ticc_message(TICC_PORT);  // aaattt
   }
   else if(com[TICC_PORT].port_used > 0) {  // for data loss recovery
      get_ticc_message(TICC_PORT);  // aaattt
   }


   if(dac_port_open()) {  // monitoring external ADC
      get_dac_message(DAC_PORT);
   }
   else if(com[DAC_PORT].port_used > 0) {  // for data loss recovery
      get_dac_message(DAC_PORT);  // aaattt
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
callq 0xe8440
cmpl $0x0, %eax
je 0x2b531
movl $0xf, %edi
callq 0xe9e60
jmp 0x2b546
cmpl $0x0, 0x364554(%rip)    # 0x38fa8c
jle 0x2b544
movl $0xf, %edi
callq 0xe9e60
jmp 0x2b546
callq 0x992e0
cmpl $0x0, %eax
je 0x2b55c
movl $0xd, %edi
callq 0xebd40
jmp 0x2b571
cmpl $0x0, 0x360069(%rip)    # 0x38b5cc
jle 0x2b56f
movl $0xd, %edi
callq 0xebd40
jmp 0x2b571
callq 0xea380
cmpl $0x0, %eax
je 0x2b587
movl $0x10, %edi
callq 0xea6e0
jmp 0x2b59c
cmpl $0x0, 0x36675e(%rip)    # 0x391cec
jle 0x2b59a
movl $0x10, %edi
callq 0xea6e0
jmp 0x2b59c
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jkingan[P]ladyheather/heather.cpp
// Function: get_device_messages(int)
void get_device_messages(int serial_avail)
{
   // process any data from the various input devices

   if(serial_avail && (((rcvr_type == NO_RCVR) || (rcvr_type == TIDE_RCVR)) || com[RCVR_PORT].process_com || sim_file)) {  // we have receiver serial data to process
      get_rcvr_message();  // process the incoming GPS messages
      system_busy = 2;
   }
   process_extra_ports(1);  // process the extra devices
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
je 0x2b5fa
cmpq $0x400, 0x24c4e4(%rip) # imm = 0x400
je 0x2b5ee
cmpq $0x800000, 0x24c4d7(%rip) # imm = 0x800000
je 0x2b5ee
cmpl $0x0, 0x3598d2(%rip)    # 0x384eb4
jne 0x2b5ee
cmpq $0x0, 0x271fb4(%rip)    # 0x29d5a0
je 0x2b5fa
callq 0x109470
movb $0x2, 0x36ac0e(%rip)    # 0x396208
movl $0x1, %edi
callq 0x2b510
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: jkingan[P]ladyheather/heather.cpp
// Function: check_com_timer(unsigned int)
int check_com_timer(unsigned port)
{
double to;

   // see if no data from com port for last com_timeout msecs

   update_pwm();
   if(port >= NUM_COM_PORTS) return 0;

   to = com[port].last_com_time + com[port].com_timeout;
   if(to < this_msec) {  // com data lost
      com[port].last_com_time = this_msec;
      if(com[port].com_data_lost == DATA_LOSS_REINIT) com[port].com_data_lost = DATA_LOSS_NO_INIT;
      else                                            com[port].com_data_lost = DATA_LOSS_REINIT;
   }

   return com[port].com_data_lost;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
callq 0x11ee60
cmpl $0x13, -0x8(%rbp)
jb 0x2b632
movl $0x0, -0x4(%rbp)
jmp 0x2b730
movl -0x8(%rbp), %eax
movl %eax, %ecx
leaq 0x341e82(%rip), %rax    # 0x36d4c0
imulq $0x2260, %rcx, %rcx     # imm = 0x2260
addq %rcx, %rax
movsd 0x2248(%rax), %xmm0
movl -0x8(%rbp), %eax
movl %eax, %ecx
leaq 0x341e64(%rip), %rax    # 0x36d4c0
imulq $0x2260, %rcx, %rcx     # imm = 0x2260
addq %rcx, %rax
addsd 0x2238(%rax), %xmm0
movsd %xmm0, -0x10(%rbp)
movsd -0x10(%rbp), %xmm1
movsd 0x3412c8(%rip), %xmm0   # 0x36c948
ucomisd %xmm1, %xmm0
jbe 0x2b710
movsd 0x3412b6(%rip), %xmm0   # 0x36c948
movl -0x8(%rbp), %eax
movl %eax, %ecx
leaq 0x341e22(%rip), %rax    # 0x36d4c0
imulq $0x2260, %rcx, %rcx     # imm = 0x2260
addq %rcx, %rax
movsd %xmm0, 0x2248(%rax)
movl -0x8(%rbp), %eax
movl %eax, %ecx
leaq 0x341e04(%rip), %rax    # 0x36d4c0
imulq $0x2260, %rcx, %rcx     # imm = 0x2260
addq %rcx, %rax
movzbl 0x2250(%rax), %eax
cmpl $0x1, %eax
jne 0x2b6f1
movl -0x8(%rbp), %eax
movl %eax, %ecx
leaq 0x341de2(%rip), %rax    # 0x36d4c0
imulq $0x2260, %rcx, %rcx     # imm = 0x2260
addq %rcx, %rax
movb $0x2, 0x2250(%rax)
jmp 0x2b70e
movl -0x8(%rbp), %eax
movl %eax, %ecx
leaq 0x341dc3(%rip), %rax    # 0x36d4c0
imulq $0x2260, %rcx, %rcx     # imm = 0x2260
addq %rcx, %rax
movb $0x1, 0x2250(%rax)
jmp 0x2b710
movl -0x8(%rbp), %eax
movl %eax, %ecx
leaq 0x341da4(%rip), %rax    # 0x36d4c0
imulq $0x2260, %rcx, %rcx     # imm = 0x2260
addq %rcx, %rax
movzbl 0x2250(%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: jkingan[P]ladyheather/heather.cpp
// Function: sound_tick_clock()
void sound_tick_clock()
{
   // play the tick clock sounds

   if(minute_tick && (tick_clock & 0x02)) {
      if(minute_file) play_tune(MINUTE_FILE, 1); // minute tick sound
      else BEEP(16);
   }
   else if(tick_clock & 0x01) {
      if(seconds_file) play_tune(SECONDS_FILE, 1);
      else if(click_file) play_tune(CLICK_FILE, 1);
      else BEEP(17);
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $0x0, 0x3414a5(%rip)    # 0x36d0e0
je 0x2bc74
movzbl 0x341488(%rip), %eax    # 0x36d0cc
andl $0x2, %eax
cmpl $0x0, %eax
je 0x2bc74
cmpb $0x0, 0x34184e(%rip)    # 0x36d4a1
je 0x2bc68
leaq 0x1437b7(%rip), %rdi    # 0x16f413
movl $0x1, %esi
callq 0x9de0
jmp 0x2bc72
movl $0x10, %edi
callq 0x9ec0
jmp 0x2bccb
movzbl 0x341451(%rip), %eax    # 0x36d0cc
andl $0x1, %eax
cmpl $0x0, %eax
je 0x2bcc9
cmpb $0x0, 0x341818(%rip)    # 0x36d4a2
je 0x2bc9f
leaq 0x143793(%rip), %rdi    # 0x16f426
movl $0x1, %esi
callq 0x9de0
jmp 0x2bcc7
cmpb $0x0, 0x341802(%rip)    # 0x36d4a8
je 0x2bcbb
leaq 0x143752(%rip), %rdi    # 0x16f401
movl $0x1, %esi
callq 0x9de0
jmp 0x2bcc5
movl $0x11, %edi
callq 0x9ec0
jmp 0x2bcc7
jmp 0x2bcc9
jmp 0x2bccb
popq %rbp
retq
nopl (%rax)
// File: jkingan[P]ladyheather/heather.cpp
// Function: fine_tick_check()
void fine_tick_check()
{
   // This routine attempts to provide an audible tick clock where the ticks
   // occur the the "true" second instead of when the receiver time message
   // arrives.  It does this by having silly_clocks() set a triiger
   // variable (in milliseconds). When this number of milliseconds has elapsed
   // the tick sound(s) are played.  The trigger variable is checked in
   // wherever the serial port is polled for input characters.

   if(fine_tick_clock == 0) return;   // fine tick clock not active
   if(tick_clock == 0) return;        // singing clock not in tick clock mode
   if(fine_tick_msec < 0.0) return;   // trigger already used
   if(GetMsecs() < fine_tick_msec) return;  // trigger time not elasped

   fine_tick_msec = (-1.0);   // flag trigger has been used
   sound_tick_clock();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $0x0, 0x3413f5(%rip)    # 0x36d0d0
jne 0x2bcdf
jmp 0x2bd29
movzbl 0x3413e6(%rip), %eax    # 0x36d0cc
cmpl $0x0, %eax
jne 0x2bced
jmp 0x2bd29
xorps %xmm0, %xmm0
ucomisd 0x3413e0(%rip), %xmm0   # 0x36d0d8
jbe 0x2bcfc
jmp 0x2bd29
callq 0xb630
movaps %xmm0, %xmm1
movsd 0x3413cc(%rip), %xmm0   # 0x36d0d8
ucomisd %xmm1, %xmm0
jbe 0x2bd14
jmp 0x2bd29
movsd 0x1433fc(%rip), %xmm0   # 0x16f118
movsd %xmm0, 0x3413b4(%rip)   # 0x36d0d8
callq 0x2bc30
popq %rbp
retq
nopl (%rax,%rax)
// File: jkingan[P]ladyheather/heather.cpp
// Function: reset_com_timer(unsigned int)
void reset_com_timer(unsigned port)
{
   // reset the com port data loss timer

   update_pwm();
   if(port >= NUM_COM_PORTS) return;

   com[port].last_com_time = this_msec;
   com[port].com_data_lost = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
callq 0x11ee60
cmpl $0x13, -0x4(%rbp)
jb 0x2bd48
jmp 0x2bd8b
movsd 0x340bf8(%rip), %xmm0   # 0x36c948
movl -0x4(%rbp), %eax
movl %eax, %ecx
leaq 0x341764(%rip), %rax    # 0x36d4c0
imulq $0x2260, %rcx, %rcx     # imm = 0x2260
addq %rcx, %rax
movsd %xmm0, 0x2248(%rax)
movl -0x4(%rbp), %eax
movl %eax, %ecx
leaq 0x341746(%rip), %rax    # 0x36d4c0
imulq $0x2260, %rcx, %rcx     # imm = 0x2260
addq %rcx, %rax
movb $0x0, 0x2250(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jkingan[P]ladyheather/heather.cpp
// Function: get_log_file()
void get_log_file()
{
int i;

   if(read_log[0]) {       // user specified a log file to read in
      first_key = ' ';
      i = reload_log(read_log, 1);
      if(i == 0) {         // log file found
         plot_review(0L);  // enter plot review mode to start plot at first point
         #ifdef ADEV_STUFF
            force_adev_redraw(5);    // and make sure adev tables are showing
         #endif
         pause_data = user_pause_data^1;
      }
      reset_first_key(1);
      prot_menu = 0;
      draw_plot(REFRESH_SCREEN);
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpb $0x0, 0x26fef1(%rip)    # 0x29bf40
je 0x2c0b3
movl $0x20, 0x2720dd(%rip)   # 0x29e138
leaq 0x26fede(%rip), %rdi    # 0x29bf40
movl $0x1, %esi
callq 0x128380
movl %eax, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jne 0x2c098
xorl %eax, %eax
movl %eax, %edi
callq 0x28900
movl $0x5, %edi
callq 0x127cf0
movzbl 0x24e386(%rip), %eax    # 0x27a415
xorl $0x1, %eax
movb %al, 0x24e37c(%rip)     # 0x27a414
movl $0x1, %edi
callq 0x37780
movb $0x0, 0x24e28f(%rip)    # 0x27a338
movl $0x1, %edi
callq 0x24e80
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: jkingan[P]ladyheather/heather.cpp
// Function: scroll_up(unsigned int)
void scroll_up(unsigned port)
{
int row;

   // scroll the terminal image buffer up a line and send it to the screen

   if(term_row >= (term_rows-1)) {  // scroll up a line
      for(row=term_header_lines; row<term_rows-1; row++) {
         strcpy(&term_screen[row][0], &term_screen[row+1][0]);
      }
      term_screen[term_rows-1][0] = 0;
   }

   ++term_row;
   if(term_row >= term_rows) {  // scroll up a line
      term_row = term_rows-1;
   }
   term_screen[term_row][0] = 0;

   show_term_screen(port);
// if((zoom_screen == 'H') && ZOOM_SLEEP) Sleep(ZOOM_SLEEP);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl 0x27131f(%rip), %eax    # 0x29d610
movl 0x375659(%rip), %ecx    # 0x3a1950
subl $0x1, %ecx
cmpl %ecx, %eax
jl 0x2c375
movl 0x375658(%rip), %eax    # 0x3a195c
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl 0x375640(%rip), %ecx    # 0x3a1950
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x2c355
movslq -0x8(%rbp), %rax
leaq 0x3734ee(%rip), %rdi    # 0x39f810
imulq $0x85, %rax, %rax
addq %rax, %rdi
movl -0x8(%rbp), %eax
addl $0x1, %eax
cltq
leaq 0x3734d5(%rip), %rsi    # 0x39f810
imulq $0x85, %rax, %rax
addq %rax, %rsi
callq 0x9350
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x2c307
movl 0x3755f5(%rip), %eax    # 0x3a1950
subl $0x1, %eax
movslq %eax, %rcx
leaq 0x3734a8(%rip), %rax    # 0x39f810
imulq $0x85, %rcx, %rcx
addq %rcx, %rax
movb $0x0, (%rax)
movl 0x271295(%rip), %eax    # 0x29d610
addl $0x1, %eax
movl %eax, 0x27128c(%rip)    # 0x29d610
movl 0x271286(%rip), %eax    # 0x29d610
cmpl 0x3755c0(%rip), %eax    # 0x3a1950
jl 0x2c3a1
movl 0x3755b8(%rip), %eax    # 0x3a1950
subl $0x1, %eax
movl %eax, 0x27126f(%rip)    # 0x29d610
movslq 0x271268(%rip), %rcx    # 0x29d610
leaq 0x373461(%rip), %rax    # 0x39f810
imulq $0x85, %rcx, %rcx
addq %rcx, %rax
movb $0x0, (%rax)
movl -0x4(%rbp), %edi
callq 0x2c120
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: jkingan[P]ladyheather/heather.cpp
// Function: init_term()
void init_term()
{
int row;

   // initialize the terminal image buffer

   term_rows = (SCREEN_HEIGHT/TEXT_HEIGHT) - 1;
   if(term_rows > MAX_TERM_ROWS) term_rows = MAX_TERM_ROWS;

   term_cols = (SCREEN_WIDTH/TEXT_WIDTH);
   if(term_cols > MAX_TERM_COLS) term_cols = MAX_TERM_COLS;

   for(row=0; row<term_rows; row++) term_screen[row][0] = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x24b60a(%rip), %eax    # 0x2779e4
cltd
idivl 0x24b613(%rip)          # 0x2779f4
subl $0x1, %eax
movl %eax, 0x375566(%rip)    # 0x3a1950
cmpl $0x40, 0x37555f(%rip)   # 0x3a1950
jle 0x2c3fd
movl $0x40, 0x375553(%rip)   # 0x3a1950
movl 0x24b5dd(%rip), %eax    # 0x2779e0
cltd
idivl 0x24b5e6(%rip)          # 0x2779f0
movl %eax, 0x375544(%rip)    # 0x3a1954
cmpl $0x84, 0x37553a(%rip)   # 0x3a1954
jle 0x2c426
movl $0x84, 0x37552e(%rip)   # 0x3a1954
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
cmpl 0x37551a(%rip), %eax    # 0x3a1950
jge 0x2c45b
movslq -0x4(%rbp), %rcx
leaq 0x3733cd(%rip), %rax    # 0x39f810
imulq $0x85, %rcx, %rcx
addq %rcx, %rax
movb $0x0, (%rax)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x2c42d
popq %rbp
retq
nopl (%rax)
// File: jkingan[P]ladyheather/heather.cpp
// Function: save_term_kbd(int)
void save_term_kbd(int i)
{
   // save a keyboard char into the last command buffer

   if(last_was_keybuf) {  // the last command we sent was the buffered keyboard command
      tkbd_col = 0;             // start buffering this command
      term_kbd[tkbd_col] = 0;
      last_was_keybuf = 0;
   }

   if(tkbd_col < (MAX_TERM_COLS-1)) {  // add kbd char to last command buffer
      term_kbd[tkbd_col++] = i;
      term_kbd[tkbd_col] = 0;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
cmpl $0x0, 0x37558e(%rip)    # 0x3a19fc
je 0x2c496
movl $0x0, 0x37557e(%rip)    # 0x3a19f8
movslq 0x375577(%rip), %rcx    # 0x3a19f8
leaq 0x3754e8(%rip), %rax    # 0x3a1970
movb $0x0, (%rax,%rcx)
movl $0x0, 0x375566(%rip)    # 0x3a19fc
cmpl $0x83, 0x375558(%rip)   # 0x3a19f8
jge 0x2c4d7
movl -0x4(%rbp), %eax
movb %al, %dl
movl 0x37554b(%rip), %eax    # 0x3a19f8
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0x375540(%rip)    # 0x3a19f8
movslq %eax, %rcx
leaq 0x3754ae(%rip), %rax    # 0x3a1970
movb %dl, (%rax,%rcx)
movslq 0x37552c(%rip), %rcx    # 0x3a19f8
leaq 0x37549d(%rip), %rax    # 0x3a1970
movb $0x0, (%rax,%rcx)
popq %rbp
retq
nopl (%rax)
// File: jkingan[P]ladyheather/heather.cpp
// Function: set_monitor_mode(int)
void set_monitor_mode(int kbd_flag)
{
   // enable monitor port screen

   change_zoom_config(26);
   zoom_screen = 'O';
   pause_monitor = 0;

   init_term();
   set_term_header(monitor_port);
   term_row = term_header_lines;
   term_col = 0;
   show_term_screen(monitor_port);  // draw the terminal screen image
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x1a, %edi
callq 0x375a0
movb $0x4f, 0x33f19c(%rip)   # 0x36b988
movl $0x0, 0x270e26(%rip)    # 0x29d61c
callq 0x2c3d0
movl 0x340caf(%rip), %edi    # 0x36d4b0
callq 0x2c4e0
movl 0x375150(%rip), %eax    # 0x3a195c
movl %eax, 0x270dfe(%rip)    # 0x29d610
movl $0x0, 0x270df8(%rip)    # 0x29d614
movl 0x340c8e(%rip), %edi    # 0x36d4b0
callq 0x2c120
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: jkingan[P]ladyheather/heather.cpp
// Function: dump_stream(int)
void dump_stream(int init)
{
int row, col;
unsigned i;

   again:
   erase_screen();
   vidstr(0,0, GREEN, "Stream dump:");
   refresh_page();
   if(init) init_messages(4, 0);

   row = 2;
   col = 0;
   while(1) {
      serve_os_queue();

      if(SERIAL_DATA_AVAILABLE(RCVR_PORT)) {
         reset_com_timer(RCVR_PORT);
         i = get_serial_char(RCVR_PORT);
//       sprintf(out, "%02X(%c) ", i,i);
         sprintf(out, "%02X", i);
         vidstr(row,col, WHITE, out);
         refresh_page();
         col += 3;
         if(col >= 48) {
            col = 0;
            ++row;
            if(row > 32) {
               row = 2;
            }
         }
      }
      else {
         check_com_timer(RCVR_PORT);
      }

      serve_os_queue();
      if(KBHIT()) {
         i = GETCH();
         if(i == ESC_CHAR) {
            clean_up();
            error_exit(6666, "User pressed ESC during dump_stream()");
         }
         else goto again;
      }
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
callq 0x117e0
xorl %esi, %esi
movl $0xa, %edx
leaq 0x1445b6(%rip), %rcx    # 0x171414
movl %esi, %edi
callq 0x10ee0
callq 0xb0d0
cmpl $0x0, -0x4(%rbp)
je 0x2ce7c
movl $0x4, %edi
xorl %esi, %esi
callq 0x86290
movl $0x2, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
callq 0x290e0
movl $0xa, %edi
callq 0xcad0
cmpl $0x0, %eax
je 0x2cf1c
movl $0xa, %edi
callq 0x2bd30
movl $0xa, %edi
callq 0xcd60
movzbl %al, %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %edx
leaq 0x36e53e(%rip), %rdi    # 0x39b400
leaq 0x160fbd(%rip), %rsi    # 0x18de86
movb $0x0, %al
callq 0x9060
movl -0x8(%rbp), %edi
movl -0xc(%rbp), %esi
movl $0xf, %edx
leaq 0x36e51e(%rip), %rcx    # 0x39b400
callq 0x10ee0
callq 0xb0d0
movl -0xc(%rbp), %eax
addl $0x3, %eax
movl %eax, -0xc(%rbp)
cmpl $0x30, -0xc(%rbp)
jl 0x2cf1a
movl $0x0, -0xc(%rbp)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
cmpl $0x20, -0x8(%rbp)
jle 0x2cf18
movl $0x2, -0x8(%rbp)
jmp 0x2cf1a
jmp 0x2cf26
movl $0xa, %edi
callq 0x2b610
callq 0x290e0
callq 0xf3d0
cmpl $0x0, %eax
je 0x2cf62
callq 0xf3f0
movl %eax, -0x10(%rbp)
cmpl $0x1b, -0x10(%rbp)
jne 0x2cf5b
callq 0x2c0c0
movl $0x1a0a, %edi           # imm = 0x1A0A
leaq 0x1444cd(%rip), %rsi    # 0x171421
callq 0xc050
jmp 0x2cf60
jmp 0x2ce4b
jmp 0x2cf62
jmp 0x2ce8a
nopw (%rax,%rax)
// File: jkingan[P]ladyheather/heather.cpp
// Function: option_handle_hd(int, char**)
void option_handle_hd(int argc, char ** argv)
{
    int argIndex;
    for(argIndex = 1; argIndex < argc; argIndex++) {
        char * arg = argv[argIndex];
        if((*arg == '/' || *arg == '-') && 0 == strncmp(arg+1,"hd",2) &&
           (*(arg+3) == '=' || *(arg+3) == ':')) {
            realpath(arg+4, heather_path);
            if(*(heather_path + strlen(heather_path)-1) != '/') {
                strcat(heather_path,"/");
            }
            printf("New heather_path of %s\n", heather_path);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x2d595
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
je 0x2d4ee
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x2d585
movq -0x20(%rbp), %rdi
addq $0x1, %rdi
leaq 0x143fc5(%rip), %rsi    # 0x1714c2
movl $0x2, %edx
callq 0x9140
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x2d585
movq -0x20(%rbp), %rax
movsbl 0x3(%rax), %eax
cmpl $0x3d, %eax
je 0x2d529
movq -0x20(%rbp), %rax
movsbl 0x3(%rax), %eax
cmpl $0x3a, %eax
jne 0x2d585
movq -0x20(%rbp), %rdi
addq $0x4, %rdi
leaq 0x1a2938(%rip), %rsi    # 0x1cfe70
callq 0x90e0
leaq 0x1a292c(%rip), %rdi    # 0x1cfe70
callq 0x9120
movq %rax, %rcx
leaq 0x1a291d(%rip), %rax    # 0x1cfe70
movsbl -0x1(%rax,%rcx), %eax
cmpl $0x2f, %eax
je 0x2d570
leaq 0x1a290c(%rip), %rdi    # 0x1cfe70
leaq 0x1429fd(%rip), %rsi    # 0x16ff68
callq 0x96a0
leaq 0x143f4e(%rip), %rdi    # 0x1714c5
leaq 0x1a28f2(%rip), %rsi    # 0x1cfe70
movb $0x0, %al
callq 0x9030
jmp 0x2d587
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2d4b6
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: jkingan[P]ladyheather/heather.cpp
// Function: config_tz_info()
void config_tz_info()
{
char *s;

   // If user did not set the time zone, try to get time zone info from
   // system environment variable.

   if(time_zone_set) return;  // user set the string

   s = getenv("TZ");
   if(s == 0) s = getenv("tz");
   if(s == 0) return;

   strncpy(out, s, 128);
   out[127] = 0;

   set_time_zone(out);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpb $0x0, 0x33f275(%rip)    # 0x36ca74
je 0x2d803
jmp 0x2d85b
leaq 0x14c12d(%rip), %rdi    # 0x179937
callq 0x9470
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x2d82a
leaq 0x169ee7(%rip), %rdi    # 0x197708
callq 0x9470
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x2d833
jmp 0x2d85b
movq -0x8(%rbp), %rsi
leaq 0x36dbc2(%rip), %rdi    # 0x39b400
movl $0x80, %edx
callq 0x9170
movb $0x0, 0x36dc30(%rip)    # 0x39b47f
leaq 0x36dbaa(%rip), %rdi    # 0x39b400
callq 0x136e90
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jkingan[P]ladyheather/heather.cpp
// Function: read_default_lla()
int read_default_lla()
{
FILE *file;
int i;

   // get default location from a file if the device does not have a GPS

   lat = 0.0;
   lon = 0.0;
   alt = 0.0;
   i = (-1);
   file = fopen(LOCN_FILE, "r");
   if(file) {
      while(fgets(out, sizeof out, file) != NULL) {
         strupr(out);
         if(strstr(out, "LOC")) ;
         else {
            i = parse_lla(out);
            if(i == LLA_OK) {
               lat = precise_lat;
               lon = precise_lon;
               alt = precise_alt;
               default_lat = lat;
               default_lon = lon;
               default_alt = alt;
               ref_lat = lat;
               ref_lon = lon;
               ref_alt = alt;
               cos_factor = cos(ref_lat);
               if(cos_factor == 0.0) cos_factor = 0.001;
               break;
            }
         }
      }

      fclose(file);
      file = 0;
   }

   return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
xorps %xmm0, %xmm0
movsd %xmm0, 0x33e92d(%rip)   # 0x36c1b0
xorps %xmm0, %xmm0
movsd %xmm0, 0x33e92a(%rip)   # 0x36c1b8
xorps %xmm0, %xmm0
movsd %xmm0, 0x33e927(%rip)   # 0x36c1c0
movl $0xffffffff, -0xc(%rbp) # imm = 0xFFFFFFFF
leaq 0x143ca1(%rip), %rdi    # 0x171548
leaq 0x15675f(%rip), %rsi    # 0x18400d
callq 0x9440
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x2da08
jmp 0x2d8c4
movq -0x8(%rbp), %rdx
leaq 0x36db31(%rip), %rdi    # 0x39b400
movl $0x201, %esi            # imm = 0x201
callq 0x95e0
cmpq $0x0, %rax
je 0x2d9f7
leaq 0x36db16(%rip), %rdi    # 0x39b400
callq 0x9890
leaq 0x36db0a(%rip), %rdi    # 0x39b400
leaq 0x1434c8(%rip), %rsi    # 0x170dc5
callq 0x9090
cmpq $0x0, %rax
je 0x2d90d
jmp 0x2d9f2
leaq 0x36daec(%rip), %rdi    # 0x39b400
callq 0x45770
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x2d9f0
movsd 0x36cba2(%rip), %xmm0   # 0x39a4d0
movsd %xmm0, 0x33e87a(%rip)   # 0x36c1b0
movsd 0x36cb9a(%rip), %xmm0   # 0x39a4d8
movsd %xmm0, 0x33e872(%rip)   # 0x36c1b8
movsd 0x36cb92(%rip), %xmm0   # 0x39a4e0
movsd %xmm0, 0x33e86a(%rip)   # 0x36c1c0
movsd 0x33e852(%rip), %xmm0   # 0x36c1b0
movsd %xmm0, 0x36cba2(%rip)   # 0x39a508
movsd 0x33e84a(%rip), %xmm0   # 0x36c1b8
movsd %xmm0, 0x36cb9a(%rip)   # 0x39a510
movsd 0x33e842(%rip), %xmm0   # 0x36c1c0
movsd %xmm0, 0x36cb92(%rip)   # 0x39a518
movsd 0x33e822(%rip), %xmm0   # 0x36c1b0
movsd %xmm0, 0x36cb5a(%rip)   # 0x39a4f0
movsd 0x33e81a(%rip), %xmm0   # 0x36c1b8
movsd %xmm0, 0x36cb52(%rip)   # 0x39a4f8
movsd 0x33e812(%rip), %xmm0   # 0x36c1c0
movsd %xmm0, 0x36cb4a(%rip)   # 0x39a500
movsd 0x36cb32(%rip), %xmm0   # 0x39a4f0
callq 0x96f0
movsd %xmm0, 0x33e7dd(%rip)   # 0x36c1a8
movsd 0x33e7d5(%rip), %xmm0   # 0x36c1a8
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x2d9ee
jp 0x2d9ee
movsd 0x1417aa(%rip), %xmm0   # 0x16f190
movsd %xmm0, 0x33e7ba(%rip)   # 0x36c1a8
jmp 0x2d9f7
jmp 0x2d9f2
jmp 0x2d8c4
movq -0x8(%rbp), %rdi
callq 0x9380
movq $0x0, -0x8(%rbp)
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jkingan[P]ladyheather/heather.cpp
// Function: show_help_msg(char*)
void show_help_msg(char *s)
{
unsigned i;
char c;

   // show() the help_msg[] line by line

   i = 0;
   out[i] = 0;
   while(*s) {
      c = *s++;
      if(c == 0) {
         break;
      }
      if(c == '\r') c = ' ';

      if(c == '\n') {
         show(out);
         i = 0;
      }
      else if(i < (sizeof(out)-2)){
         out[i++] = c;
         out[i] = 0;
      }
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0x36d221(%rip), %rax    # 0x39b400
movb $0x0, (%rax,%rcx)
movq -0x8(%rbp), %rax
cmpb $0x0, (%rax)
je 0x2e278
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movb (%rax), %al
movb %al, -0xd(%rbp)
movsbl -0xd(%rbp), %eax
cmpl $0x0, %eax
jne 0x2e20f
jmp 0x2e278
movsbl -0xd(%rbp), %eax
cmpl $0xd, %eax
jne 0x2e21c
movb $0x20, -0xd(%rbp)
movsbl -0xd(%rbp), %eax
cmpl $0xa, %eax
jne 0x2e23a
leaq 0x36d1d4(%rip), %rdi    # 0x39b400
callq 0x2e030
movl $0x0, -0xc(%rbp)
jmp 0x2e273
movl -0xc(%rbp), %eax
cmpq $0x1ff, %rax            # imm = 0x1FF
jae 0x2e271
movb -0xd(%rbp), %dl
movl -0xc(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0xc(%rbp)
movl %eax, %eax
movl %eax, %ecx
leaq 0x36d1a2(%rip), %rax    # 0x39b400
movb %dl, (%rax,%rcx)
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0x36d193(%rip), %rax    # 0x39b400
movb $0x0, (%rax,%rcx)
jmp 0x2e273
jmp 0x2e1e3
addq $0x10, %rsp
popq %rbp
retq
nop
// File: jkingan[P]ladyheather/heathui.cpp
// Function: show_rpn_defines(int, int)
void show_rpn_defines(int row, int col)
{
int i;

   // display user defined operations (limited by screen height)
   strcpy(out, "User DEFINEd operations:  define edit  savedefs saveall showdefs  run");
   vidstr(row++, 0, WHITE, out);

   if(num_rpn_defs) {
      for(i=0; i<num_rpn_defs; i++) {  // show the DEFINEs
         if(rpn_defs[i]) {
            sprintf(out, "(%s)", rpn_defs[i]);
            vidstr(row++,col, WHITE, out);
            if(row >= (TEXT_ROWS-1)) break;   // !!!!could use PLOT_ROW or MOUSE_ROW
         }
      }
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
leaq 0x36d13b(%rip), %rdi    # 0x39b400
leaq 0x14368c(%rip), %rsi    # 0x171958
callq 0x9350
movl -0x4(%rbp), %edi
movl %edi, %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
xorl %esi, %esi
movl $0xf, %edx
leaq 0x36d116(%rip), %rcx    # 0x39b400
callq 0x10ee0
cmpl $0x0, 0x373f72(%rip)    # 0x3a2268
je 0x2e38c
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl 0x373f5c(%rip), %eax    # 0x3a2268
jge 0x2e38a
movslq -0xc(%rbp), %rcx
leaq 0x373c27(%rip), %rax    # 0x3a1f40
cmpq $0x0, (%rax,%rcx,8)
je 0x2e37a
movslq -0xc(%rbp), %rcx
leaq 0x373c15(%rip), %rax    # 0x3a1f40
movq (%rax,%rcx,8), %rdx
leaq 0x36d0ca(%rip), %rdi    # 0x39b400
leaq 0x1582de(%rip), %rsi    # 0x18661b
movb $0x0, %al
callq 0x9060
movl -0x4(%rbp), %edi
movl %edi, %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
movl -0x8(%rbp), %esi
movl $0xf, %edx
leaq 0x36d0a2(%rip), %rcx    # 0x39b400
callq 0x10ee0
movl -0x4(%rbp), %eax
leaq 0x24967f(%rip), %rcx    # 0x2779ec
movl (%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jl 0x2e378
jmp 0x2e38a
jmp 0x2e37a
jmp 0x2e37c
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2e303
jmp 0x2e38c
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jkingan[P]ladyheather/heathui.cpp
// Function: rpn_error(char*)
void rpn_error(char *s)
{
   // flash calculator error message on the srceen
   if(s == 0) return;
   erase_screen();
   vidstr(0,0, YELLOW, s);
   refresh_page();
   BEEP(7834);
   Sleep(1000);

   edit_buffer[0] = ' ';
   edit_buffer[1] = 0;
   rpn_err_flag = 1;
   start_calc(1234);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x2e655
jmp 0x2e6ae
callq 0x117e0
movq -0x8(%rbp), %rcx
xorl %esi, %esi
movl $0xe, %edx
movl %esi, %edi
callq 0x10ee0
callq 0xb0d0
movl $0x1e9a, %edi           # imm = 0x1E9A
callq 0x9ec0
movl $0x3e8, %edi            # imm = 0x3E8
callq 0xb8b0
leaq 0x36fe34(%rip), %rax    # 0x39e4c0
movb $0x20, (%rax)
leaq 0x36fe2a(%rip), %rax    # 0x39e4c0
movb $0x0, 0x1(%rax)
movl $0x1, 0x375254(%rip)    # 0x3a38f8
movl $0x4d2, %edi            # imm = 0x4D2
callq 0x2e6c0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jkingan[P]ladyheather/heathui.cpp
// Function: start_calc(int)
void start_calc(int why)
{
int i;

   if(deg_mode == 1.0) edit_info1 = "Calculator is in RADIANS mode";
   else                edit_info1 = "Calculator is in DEGREES mode";
   if(calc_rcvr) {
      edit_info2 =                   "To exit calculator (and program) type EXIT";
   }
   else {
      edit_info2 =                   "To exit calculator mode press ESC or <cr>";
   }
   if(zoom_screen == '`') {
      edit_info3 = "Enter ?<cr> for calculator command list.";
      if(calc_rcvr == 0) {
         edit_info4 = "When done, use GR to erase calculator results from plot area";
      }
   }
   else if(calc_rcvr == 0) {
      edit_info3 = "When done, use GR to erase calculator results from plot area";
   }


   i = rpn_mode;
   rpn_mode = (1);
   show_version_header();
   rpn_mode = i;
   show_rpn_help = 0;
   start_edit(CALC_CMD, "Enter RPN calculator commands separated by spaces. (ESC ESC to abort)");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movsd 0x19a975(%rip), %xmm0   # 0x1c9048
movsd 0x14098d(%rip), %xmm1   # 0x16f068
ucomisd %xmm1, %xmm0
jne 0x2e6f6
jp 0x2e6f6
leaq 0x3700d6(%rip), %rax    # 0x39e7c0
leaq 0x15109d(%rip), %rcx    # 0x17f78e
movq %rcx, (%rax)
jmp 0x2e707
leaq 0x3700c3(%rip), %rax    # 0x39e7c0
leaq 0x1510a8(%rip), %rcx    # 0x17f7ac
movq %rcx, (%rax)
leaq 0x2493b2(%rip), %rax    # 0x277ac0
cmpl $0x0, (%rax)
je 0x2e726
leaq 0x3700ae(%rip), %rax    # 0x39e7c8
leaq 0x1510a9(%rip), %rcx    # 0x17f7ca
movq %rcx, (%rax)
jmp 0x2e737
leaq 0x37009b(%rip), %rax    # 0x39e7c8
leaq 0x1510c1(%rip), %rcx    # 0x17f7f5
movq %rcx, (%rax)
leaq 0x33d24a(%rip), %rax    # 0x36b988
movzbl (%rax), %eax
cmpl $0x60, %eax
jne 0x2e776
leaq 0x370083(%rip), %rax    # 0x39e7d0
leaq 0x1510cb(%rip), %rcx    # 0x17f81f
movq %rcx, (%rax)
leaq 0x249362(%rip), %rax    # 0x277ac0
cmpl $0x0, (%rax)
jne 0x2e774
leaq 0x37006e(%rip), %rax    # 0x39e7d8
leaq 0x1510d7(%rip), %rcx    # 0x17f848
movq %rcx, (%rax)
jmp 0x2e795
leaq 0x249343(%rip), %rax    # 0x277ac0
cmpl $0x0, (%rax)
jne 0x2e793
leaq 0x370047(%rip), %rax    # 0x39e7d0
leaq 0x1510b8(%rip), %rcx    # 0x17f848
movq %rcx, (%rax)
jmp 0x2e795
leaq 0x36c26c(%rip), %rax    # 0x39aa08
movl (%rax), %eax
movl %eax, -0x8(%rbp)
leaq 0x36c260(%rip), %rax    # 0x39aa08
movl $0x1, (%rax)
callq 0x9c6d0
movl -0x8(%rbp), %ecx
leaq 0x36c24b(%rip), %rax    # 0x39aa08
movl %ecx, (%rax)
leaq 0x36c246(%rip), %rax    # 0x39aa0c
movl $0x0, (%rax)
movl $0x180, %edi            # imm = 0x180
leaq 0x1510ad(%rip), %rsi    # 0x17f885
callq 0x3d470
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jkingan[P]ladyheather/heathui.cpp
// Function: rpn_clear(int)
void rpn_clear(int flag)
{
int i;

   // clear stack and/or memory

   if(flag & 0x01) {  // clear stack
      for(i=0; i<RPN_SIZE; i++) {
         rpn[i] = 0.0;
      }
   }

   if(flag & 0x02) { // clear memory
      for(i=0; i<RPN_MEM; i++) {
         rpn_mem[i] = 0.0;
      }
   }

   last_x = 0.0;
   last_rpn0 = 0.0;
   last_was_clx = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x2e834
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl 0x19a82e(%rip), %eax    # 0x1c9040
jge 0x2e832
movslq -0x8(%rbp), %rcx
leaq 0x373331(%rip), %rax    # 0x3a1b50
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x2e809
jmp 0x2e834
movl -0x4(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x2e86c
movl $0x0, -0x8(%rbp)
cmpl $0x64, -0x8(%rbp)
jge 0x2e86a
movslq -0x8(%rbp), %rcx
leaq 0x373389(%rip), %rax    # 0x3a1be0
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x2e846
jmp 0x2e86c
xorps %xmm0, %xmm0
movsd %xmm0, 0x373691(%rip)   # 0x3a1f08
xorps %xmm0, %xmm0
movsd %xmm0, 0x373696(%rip)   # 0x3a1f18
movl $0x0, 0x373684(%rip)    # 0x3a1f10
popq %rbp
retq
nop
// File: jkingan[P]ladyheather/heathui.cpp
// Function: rpn_down()
void rpn_down()
{
int i;
int count;
double val;

   // rotate stack down
   last_was_clx = 0;

   count = 1;
   if(isdigit(msg_field[4])) count = atoi(&msg_field[4]);
   if(count < 0) count = 0-count;
   count %= RPN_SIZE;

   while(count--) {
      val = rpn[0];
      for(i=0; i<RPN_SIZE-1; i++) {
         rpn[i] = rpn[i+1];
      }
      rpn[RPN_SIZE-1] = val;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, 0x37366e(%rip)    # 0x3a1f10
movl $0x1, -0x8(%rbp)
leaq 0x36c370(%rip), %rax    # 0x39ac20
movsbl 0x4(%rax), %edi
callq 0x9330
cmpl $0x0, %eax
je 0x2e8d1
leaq 0x36c35b(%rip), %rdi    # 0x39ac20
addq $0x4, %rdi
callq 0x95c0
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jge 0x2e8df
xorl %eax, %eax
subl -0x8(%rbp), %eax
movl %eax, -0x8(%rbp)
movl 0x19a75b(%rip), %ecx    # 0x1c9040
movl -0x8(%rbp), %eax
cltd
idivl %ecx
movl %edx, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x8(%rbp)
cmpl $0x0, %eax
je 0x2e974
movsd 0x37324a(%rip), %xmm0   # 0x3a1b50
movsd %xmm0, -0x10(%rbp)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl 0x19a725(%rip), %ecx    # 0x1c9040
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x2e952
movl -0x4(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rcx
leaq 0x37321e(%rip), %rax    # 0x3a1b50
movsd (%rax,%rcx,8), %xmm0
movslq -0x4(%rbp), %rcx
leaq 0x37320e(%rip), %rax    # 0x3a1b50
movsd %xmm0, (%rax,%rcx,8)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x2e912
movsd -0x10(%rbp), %xmm0
movl 0x19a6e3(%rip), %eax    # 0x1c9040
subl $0x1, %eax
movslq %eax, %rcx
leaq 0x3731e6(%rip), %rax    # 0x3a1b50
movsd %xmm0, (%rax,%rcx,8)
jmp 0x2e8ee
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: jkingan[P]ladyheather/heathui.cpp
// Function: rpn_up()
void rpn_up()
{
int i;
int count;
double val;

   // rotate stack up
   last_was_clx = 0;

   count = 1;
   if(isdigit(msg_field[2])) count = atoi(&msg_field[2]);
   if(count < 0) count = 0-count;
   count %= RPN_SIZE;

   while(count--) {
      val = rpn[RPN_SIZE-1];
      for(i=RPN_SIZE-1; i; i--) {
         rpn[i] = rpn[i-1];
      }
      rpn[0] = val;
      last_rpn0 = val;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, 0x37357e(%rip)    # 0x3a1f10
movl $0x1, -0x8(%rbp)
leaq 0x36c280(%rip), %rax    # 0x39ac20
movsbl 0x2(%rax), %edi
callq 0x9330
cmpl $0x0, %eax
je 0x2e9c1
leaq 0x36c26b(%rip), %rdi    # 0x39ac20
addq $0x2, %rdi
callq 0x95c0
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jge 0x2e9cf
xorl %eax, %eax
subl -0x8(%rbp), %eax
movl %eax, -0x8(%rbp)
movl 0x19a66b(%rip), %ecx    # 0x1c9040
movl -0x8(%rbp), %eax
cltd
idivl %ecx
movl %edx, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x8(%rbp)
cmpl $0x0, %eax
je 0x2ea6c
movl 0x19a64c(%rip), %eax    # 0x1c9040
subl $0x1, %eax
movslq %eax, %rcx
leaq 0x37314f(%rip), %rax    # 0x3a1b50
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x10(%rbp)
movl 0x19a62f(%rip), %eax    # 0x1c9040
subl $0x1, %eax
movl %eax, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
je 0x2ea4d
movl -0x4(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rcx
leaq 0x373123(%rip), %rax    # 0x3a1b50
movsd (%rax,%rcx,8), %xmm0
movslq -0x4(%rbp), %rcx
leaq 0x373113(%rip), %rax    # 0x3a1b50
movsd %xmm0, (%rax,%rcx,8)
movl -0x4(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x2ea17
movsd -0x10(%rbp), %xmm0
movsd %xmm0, 0x3730f6(%rip)   # 0x3a1b50
movsd -0x10(%rbp), %xmm0
movsd %xmm0, 0x3734b1(%rip)   # 0x3a1f18
jmp 0x2e9de
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jkingan[P]ladyheather/heathui.cpp
// Function: rpn_top()
double rpn_top()
{
double val;
int i;

   // get stack top into last_x and drop the stack one level
   // (used to prepare for a two operand command)
   last_was_clx = 0;

   val = rpn[0];
   last_x = last_rpn0 = val;

   for(i=0; i<RPN_SIZE-1; i++) {
      rpn[i] = rpn[i+1];
   }
   return val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x0, 0x373482(%rip)    # 0x3a1f10
movsd 0x3730ba(%rip), %xmm0   # 0x3a1b50
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
movsd %xmm0, 0x373470(%rip)   # 0x3a1f18
movsd %xmm0, 0x373458(%rip)   # 0x3a1f08
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl 0x19a580(%rip), %ecx    # 0x1c9040
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x2eaf7
movl -0xc(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rcx
leaq 0x373079(%rip), %rax    # 0x3a1b50
movsd (%rax,%rcx,8), %xmm0
movslq -0xc(%rbp), %rcx
leaq 0x373069(%rip), %rax    # 0x3a1b50
movsd %xmm0, (%rax,%rcx,8)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2eab7
movsd -0x8(%rbp), %xmm0
popq %rbp
retq
nop
// File: jkingan[P]ladyheather/heathui.cpp
// Function: rpn_drop()
void rpn_drop()
{
int count;
double last;

   // drop stack down
   last_was_clx = 0;

   count = 1;
   if(isdigit(msg_field[4])) count = atoi(&msg_field[4]);
   if(count < 0) count = 0-count;
   count %= RPN_SIZE;

   last = rpn[0];
   while(count--) {
      rpn_top();
   }
   last_x = last;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, 0x3733fe(%rip)    # 0x3a1f10
movl $0x1, -0x4(%rbp)
leaq 0x36c100(%rip), %rax    # 0x39ac20
movsbl 0x4(%rax), %edi
callq 0x9330
cmpl $0x0, %eax
je 0x2eb41
leaq 0x36c0eb(%rip), %rdi    # 0x39ac20
addq $0x4, %rdi
callq 0x95c0
movl %eax, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jge 0x2eb4f
xorl %eax, %eax
subl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
movl 0x19a4eb(%rip), %ecx    # 0x1c9040
movl -0x4(%rbp), %eax
cltd
idivl %ecx
movl %edx, -0x4(%rbp)
movsd 0x372fea(%rip), %xmm0   # 0x3a1b50
movsd %xmm0, -0x10(%rbp)
movl -0x4(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x4(%rbp)
cmpl $0x0, %eax
je 0x2eb82
callq 0x2ea80
jmp 0x2eb6b
movsd -0x10(%rbp), %xmm0
movsd %xmm0, 0x373379(%rip)   # 0x3a1f08
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jkingan[P]ladyheather/heathui.cpp
// Function: rpn_push(double)
void rpn_push(double val)
{
int i;

   // push val onto stack
   if(last_was_clx == 0) {
      for(i=RPN_SIZE-1; i; i--) {
         rpn[i] = rpn[i-1];
      }
   }
   rpn[0] = val;
   last_was_clx = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movsd %xmm0, -0x8(%rbp)
cmpl $0x0, 0x373360(%rip)    # 0x3a1f10
jne 0x2ebf6
movl 0x19a488(%rip), %eax    # 0x1c9040
subl $0x1, %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x2ebf4
movl -0xc(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rcx
leaq 0x372f7c(%rip), %rax    # 0x3a1b50
movsd (%rax,%rcx,8), %xmm0
movslq -0xc(%rbp), %rcx
leaq 0x372f6c(%rip), %rax    # 0x3a1b50
movsd %xmm0, (%rax,%rcx,8)
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2ebbe
jmp 0x2ebf6
movsd -0x8(%rbp), %xmm0
movsd %xmm0, 0x372f4d(%rip)   # 0x3a1b50
movl $0x0, 0x373303(%rip)    # 0x3a1f10
popq %rbp
retq
nop
// File: jkingan[P]ladyheather/heathui.cpp
// Function: rpn_inc(double)
void rpn_inc(double val)
{
double last;

   // does ISZ and DSZ commands
   last = rpn[0];
   rpn[0] += val;
   if(rpn[0] == 0) skip_next_rpn = 1;
   last_x = last;
   last_was_clx = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movsd %xmm0, -0x8(%rbp)
movsd 0x372f2f(%rip), %xmm0   # 0x3a1b50
movsd %xmm0, -0x10(%rbp)
movsd -0x8(%rbp), %xmm0
addsd 0x372f1d(%rip), %xmm0   # 0x3a1b50
movsd %xmm0, 0x372f15(%rip)   # 0x3a1b50
movsd 0x372f0d(%rip), %xmm0   # 0x3a1b50
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x2ec58
jp 0x2ec58
movl $0x1, 0x3732d4(%rip)    # 0x3a1f2c
movsd -0x10(%rbp), %xmm0
movsd %xmm0, 0x3732a3(%rip)   # 0x3a1f08
movl $0x0, 0x3732a1(%rip)    # 0x3a1f10
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jkingan[P]ladyheather/heathui.cpp
// Function: rpn_stack()
void rpn_stack()
{
int count;
double val;
double last;

   // push the value at a specified stack location onto the stack

   count = 1;
   if(isdigit(msg_field[5])) count = atoi(&msg_field[5]);
   if(count < 0) count = 0-count;
   count %= RPN_SIZE;

   val = rpn[count];

   last = rpn[0];
   rpn_push(val);
   last_x = last;
   last_was_clx = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x1, -0x4(%rbp)
leaq 0x36bf8a(%rip), %rax    # 0x39ac20
movsbl 0x5(%rax), %edi
callq 0x9330
cmpl $0x0, %eax
je 0x2ecb7
leaq 0x36bf75(%rip), %rdi    # 0x39ac20
addq $0x5, %rdi
callq 0x95c0
movl %eax, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jge 0x2ecc5
xorl %eax, %eax
subl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
movl 0x19a375(%rip), %ecx    # 0x1c9040
movl -0x4(%rbp), %eax
cltd
idivl %ecx
movl %edx, -0x4(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0x372e71(%rip), %rax    # 0x3a1b50
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x10(%rbp)
movsd 0x372e5f(%rip), %xmm0   # 0x3a1b50
movsd %xmm0, -0x18(%rbp)
movsd -0x10(%rbp), %xmm0
callq 0x2eba0
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x3731fb(%rip)   # 0x3a1f08
movl $0x0, 0x3731f9(%rip)    # 0x3a1f10
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: jkingan[P]ladyheather/heathui.cpp
// Function: rpn_swap()
void rpn_swap()
{
int count;
double val;
double last;

   // swap X and a value on the stack

   count = 1;
   if(isdigit(msg_field[4])) count = atoi(&msg_field[4]);
   if(count < 0) count = 0-count;
   count %= RPN_SIZE;

   last = rpn[0];

   val = rpn[0];
   rpn[0] = rpn[count];
   rpn[count] = val;

   last_x = last;
   last_was_clx = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x1, -0x4(%rbp)
leaq 0x36beea(%rip), %rax    # 0x39ac20
movsbl 0x4(%rax), %edi
callq 0x9330
cmpl $0x0, %eax
je 0x2ed57
leaq 0x36bed5(%rip), %rdi    # 0x39ac20
addq $0x4, %rdi
callq 0x95c0
movl %eax, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jge 0x2ed65
xorl %eax, %eax
subl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
movl 0x19a2d5(%rip), %ecx    # 0x1c9040
movl -0x4(%rbp), %eax
cltd
idivl %ecx
movl %edx, -0x4(%rbp)
movsd 0x372dd4(%rip), %xmm0   # 0x3a1b50
movsd %xmm0, -0x18(%rbp)
movsd 0x372dc7(%rip), %xmm0   # 0x3a1b50
movsd %xmm0, -0x10(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0x372db7(%rip), %rax    # 0x3a1b50
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, 0x372daa(%rip)   # 0x3a1b50
movsd -0x10(%rbp), %xmm0
movslq -0x4(%rbp), %rcx
leaq 0x372d9a(%rip), %rax    # 0x3a1b50
movsd %xmm0, (%rax,%rcx,8)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x373140(%rip)   # 0x3a1f08
movl $0x0, 0x37313e(%rip)    # 0x3a1f10
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: jkingan[P]ladyheather/heathui.cpp
// Function: rpn_new(double)
void rpn_new(double val)
{
   // replace top of stack and lastx with new value

   last_x = rpn[0];
   last_rpn0 = val;
   rpn[0] = val;
   last_was_clx = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movsd %xmm0, -0x8(%rbp)
movsd 0x372d5f(%rip), %xmm0   # 0x3a1b50
movsd %xmm0, 0x37310f(%rip)   # 0x3a1f08
movsd -0x8(%rbp), %xmm0
movsd %xmm0, 0x373112(%rip)   # 0x3a1f18
movsd -0x8(%rbp), %xmm0
movsd %xmm0, 0x372d3d(%rip)   # 0x3a1b50
movl $0x0, 0x3730f3(%rip)    # 0x3a1f10
popq %rbp
retq
nop
// File: jkingan[P]ladyheather/heathui.cpp
// Function: rpn_recall()
void rpn_recall()
{
int i;
int sign;

   // push memory location onto stack
   sign = msg_field[3];
   i = 0;
   if(isdigit(sign)) i = atoi(&msg_field[3]);
   else if(sign) i = atoi(&msg_field[4]);
   if(i < 0) i = 0 - i;

   sprintf(out, "Memory index out of range 0..%d", RPN_MEM);
   if(i >= RPN_MEM) rpn_error(out);
   else if(sign == '+') rpn_push(rpn[0]+rpn_mem[i]);
   else if(sign == '-') rpn_push(rpn[0]-rpn_mem[i]);
   else if(sign == '*') rpn_push(rpn[0]*rpn_mem[i]);
   else if(sign == '/') rpn_push(rpn[0]/rpn_mem[i]);
   else if(sign == '@') {  // indirect
      i = (int) rpn_mem[i];
      i = i % RPN_MEM;
      rpn_push(rpn_mem[i]);
   }
   else rpn_push(rpn_mem[i]);
   last_was_clx = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x36bbf1(%rip), %rax    # 0x39ac20
movsbl 0x3(%rax), %eax
movl %eax, -0x8(%rbp)
movl $0x0, -0x4(%rbp)
movl -0x8(%rbp), %edi
callq 0x9330
cmpl $0x0, %eax
je 0x2f05f
leaq 0x36bbcf(%rip), %rdi    # 0x39ac20
addq $0x3, %rdi
callq 0x95c0
movl %eax, -0x4(%rbp)
jmp 0x2f07a
cmpl $0x0, -0x8(%rbp)
je 0x2f078
leaq 0x36bbb4(%rip), %rdi    # 0x39ac20
addq $0x4, %rdi
callq 0x95c0
movl %eax, -0x4(%rbp)
jmp 0x2f07a
cmpl $0x0, -0x4(%rbp)
jge 0x2f088
xorl %eax, %eax
subl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
leaq 0x36c371(%rip), %rdi    # 0x39b400
leaq 0x142d82(%rip), %rsi    # 0x171e18
movl $0x64, %edx
movb $0x0, %al
callq 0x9060
cmpl $0x64, -0x4(%rbp)
jl 0x2f0b9
leaq 0x36c351(%rip), %rdi    # 0x39b400
callq 0x2e640
jmp 0x2f1b0
cmpl $0x2b, -0x8(%rbp)
jne 0x2f0e1
movsd 0x372a89(%rip), %xmm0   # 0x3a1b50
movslq -0x4(%rbp), %rcx
leaq 0x372b0e(%rip), %rax    # 0x3a1be0
addsd (%rax,%rcx,8), %xmm0
callq 0x2eba0
jmp 0x2f1ae
cmpl $0x2d, -0x8(%rbp)
jne 0x2f109
movsd 0x372a61(%rip), %xmm0   # 0x3a1b50
movslq -0x4(%rbp), %rcx
leaq 0x372ae6(%rip), %rax    # 0x3a1be0
subsd (%rax,%rcx,8), %xmm0
callq 0x2eba0
jmp 0x2f1ac
cmpl $0x2a, -0x8(%rbp)
jne 0x2f12e
movsd 0x372a39(%rip), %xmm0   # 0x3a1b50
movslq -0x4(%rbp), %rcx
leaq 0x372abe(%rip), %rax    # 0x3a1be0
mulsd (%rax,%rcx,8), %xmm0
callq 0x2eba0
jmp 0x2f1aa
cmpl $0x2f, -0x8(%rbp)
jne 0x2f153
movsd 0x372a14(%rip), %xmm0   # 0x3a1b50
movslq -0x4(%rbp), %rcx
leaq 0x372a99(%rip), %rax    # 0x3a1be0
divsd (%rax,%rcx,8), %xmm0
callq 0x2eba0
jmp 0x2f1a8
cmpl $0x40, -0x8(%rbp)
jne 0x2f191
movslq -0x4(%rbp), %rcx
leaq 0x372a7c(%rip), %rax    # 0x3a1be0
cvttsd2si (%rax,%rcx,8), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl $0x64, %ecx
cltd
idivl %ecx
movl %edx, -0x4(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0x372a5b(%rip), %rax    # 0x3a1be0
movsd (%rax,%rcx,8), %xmm0
callq 0x2eba0
jmp 0x2f1a6
movslq -0x4(%rbp), %rcx
leaq 0x372a44(%rip), %rax    # 0x3a1be0
movsd (%rax,%rcx,8), %xmm0
callq 0x2eba0
jmp 0x2f1a8
jmp 0x2f1aa
jmp 0x2f1ac
jmp 0x2f1ae
jmp 0x2f1b0
movl $0x0, 0x372d56(%rip)    # 0x3a1f10
addq $0x10, %rsp
popq %rbp
retq
// File: jkingan[P]ladyheather/heathui.cpp
// Function: rpn_max()
void rpn_max()
{
double last;
double x0,y0;
double val;

   // maximum of x and y

   last = rpn[0];

   x0 = rpn_top();
   y0 = rpn_top();
   if(x0 > y0) val = x0;
   else        val = y0;
   rpn_push(val);

   last_x = last;
   last_was_clx = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movsd 0x372980(%rip), %xmm0   # 0x3a1b50
movsd %xmm0, -0x8(%rbp)
callq 0x2ea80
movsd %xmm0, -0x10(%rbp)
callq 0x2ea80
movsd %xmm0, -0x18(%rbp)
movsd -0x10(%rbp), %xmm0
ucomisd -0x18(%rbp), %xmm0
jbe 0x2f201
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
jmp 0x2f20b
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
callq 0x2eba0
movsd -0x8(%rbp), %xmm0
movsd %xmm0, 0x372ce6(%rip)   # 0x3a1f08
movl $0x0, 0x372ce4(%rip)    # 0x3a1f10
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jkingan[P]ladyheather/heathui.cpp
// Function: rpn_min()
void rpn_min()
{
double last;
double x0,y0;
double val;

   // minimum of x and y

   last = rpn[0];

   x0 = rpn_top();
   y0 = rpn_top();
   if(x0 < y0) val = x0;
   else        val = y0;
   rpn_push(val);

   last_x = last;
   last_was_clx = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movsd 0x372900(%rip), %xmm0   # 0x3a1b50
movsd %xmm0, -0x8(%rbp)
callq 0x2ea80
movsd %xmm0, -0x10(%rbp)
callq 0x2ea80
movsd %xmm0, -0x18(%rbp)
movsd -0x10(%rbp), %xmm1
movsd -0x18(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x2f285
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
jmp 0x2f28f
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
callq 0x2eba0
movsd -0x8(%rbp), %xmm0
movsd %xmm0, 0x372c62(%rip)   # 0x3a1f08
movl $0x0, 0x372c60(%rip)    # 0x3a1f10
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)