LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/aspone[P]OrderBook/./OrderBook.h
// Function: OrderBook::OrderBook<unsigned int, OrderLevelEntry>::printMidpoint()
void printMidpoint() {
      if (sell_book_map_.empty() || buy_book_map_.empty()) {
         logger_.print("NAN\n");
         return;
      }

      unsigned long long sell_min = sell_book_map_.begin()->first;
      unsigned long long buy_max = buy_book_map_.rbegin()->first;
      double midpoint = (sell_min + buy_max) / 200.;
      char buffer[20];
      sprintf(buffer, "%.2f\n", midpoint);
      logger_.print(buffer);
   }

// Assembly:
subq $0xe8, %rsp
movq %rdi, 0xe0(%rsp)
movq 0xe0(%rsp), %rdi
movq %rdi, 0x30(%rsp)
addq $0x108, %rdi            # imm = 0x108
callq 0xb760
testb $0x1, %al
jne 0x7fa6
movq 0x30(%rsp), %rdi
addq $0xd8, %rdi
callq 0xb760
testb $0x1, %al
jne 0x7fa6
jmp 0x8059
movq 0x30(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0xbf(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x2310
movq 0x28(%rsp), %rdx
leaq 0x8389(%rip), %rsi      # 0x10357
leaq 0xc0(%rsp), %rdi
callq 0x2250
jmp 0x7fdd
movq 0x20(%rsp), %rdi
leaq 0xc0(%rsp), %rsi
callq 0xb8e0
jmp 0x7ff1
leaq 0xc0(%rsp), %rdi
callq 0x2110
leaq 0xbf(%rsp), %rdi
callq 0x2200
jmp 0x817f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb0(%rsp)
movl %eax, 0xac(%rsp)
jmp 0x8047
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb0(%rsp)
movl %eax, 0xac(%rsp)
leaq 0xc0(%rsp), %rdi
callq 0x2110
leaq 0xbf(%rsp), %rdi
callq 0x2200
jmp 0x81c5
movq 0x30(%rsp), %rdi
addq $0x108, %rdi            # imm = 0x108
callq 0x52c0
movq %rax, 0x98(%rsp)
leaq 0x98(%rsp), %rdi
callq 0x5340
movq 0x30(%rsp), %rsi
movq (%rax), %rax
movq %rax, 0xa0(%rsp)
addq $0xd8, %rsi
leaq 0x88(%rsp), %rdi
movq %rdi, (%rsp)
callq 0xefd0
movq (%rsp), %rdi
callq 0xf000
movq (%rax), %rax
movq %rax, 0x90(%rsp)
movq 0xa0(%rsp), %rax
movq 0x90(%rsp), %rcx
addq %rcx, %rax
movq %rax, %xmm0
movaps 0x7fc6(%rip), %xmm1     # 0x100a0
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x7fca(%rip), %xmm1     # 0x100b0
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd 0x7f83(%rip), %xmm1     # 0x10080
divsd %xmm1, %xmm0
movsd %xmm0, 0x80(%rsp)
movsd 0x80(%rsp), %xmm0
leaq 0x81a5(%rip), %rsi      # 0x102bf
leaq 0x60(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movb $0x1, %al
callq 0x2040
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x3f(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x2310
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
leaq 0x40(%rsp), %rdi
callq 0x2250
jmp 0x815a
movq 0x8(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0xb8e0
jmp 0x816b
leaq 0x40(%rsp), %rdi
callq 0x2110
leaq 0x3f(%rsp), %rdi
callq 0x2200
addq $0xe8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb0(%rsp)
movl %eax, 0xac(%rsp)
jmp 0x81bb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb0(%rsp)
movl %eax, 0xac(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x2110
leaq 0x3f(%rsp), %rdi
callq 0x2200
movq 0xb0(%rsp), %rdi
callq 0x2300
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/aspone[P]OrderBook/./MessageParser.h
// Function: OrderBook::MessageParser::tokenizeAndConvertToUint(char*, unsigned int&)
inline ParseStatus MessageParser::tokenizeAndConvertToUint(char *tk_msg, uint32_t &dest) {
   tk_msg = strtok(NULL, ",");
   if (tk_msg == NULL) {
      return ePS_CorruptMessage;
   }
   // Prevent boost qi from rolling on 1st bit
   else if (tk_msg[0] == '-') {
      return ePS_GenericBadValue;
   }
   else if (!qi::parse(tk_msg, &tk_msg[strlen(tk_msg)], uint_, dest)) {
      return ePS_GenericBadValue;
   }
   return ePS_Good;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
xorl %eax, %eax
movl %eax, %edi
leaq 0x8064(%rip), %rsi      # 0x10262
callq 0x22b0
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x821a
movl $0x1, 0x24(%rsp)
jmp 0x827b
movq 0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x8231
movl $0x5, 0x24(%rsp)
jmp 0x827b
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
callq 0x20a0
movq (%rsp), %rsi
addq %rax, %rsi
movq 0x8(%rsp), %rcx
leaq 0x10(%rsp), %rdi
leaq 0xff6f(%rip), %rdx      # 0x181cb
callq 0x83a0
testb $0x1, %al
jne 0x826f
movl $0x5, 0x24(%rsp)
jmp 0x827b
jmp 0x8271
jmp 0x8273
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/aspone[P]OrderBook/./MessageParser.h
// Function: OrderBook::MessageParser::tokenizeAndConvertToDouble(char*, double&)
inline ParseStatus MessageParser::tokenizeAndConvertToDouble(char *tk_msg, double &dest) {
   tk_msg = strtok(NULL, ",");
   if (tk_msg == NULL) {
      return ePS_CorruptMessage;
   }
   // Prevent boost qi from rolling on 1st bit
   else if (tk_msg[0] == '-') {
      return ePS_GenericBadValue;
   }
   else if (!qi::parse(tk_msg, &tk_msg[strlen(tk_msg)], double_, dest)) {
      return ePS_GenericBadValue;
   }
   return ePS_Good;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
xorl %eax, %eax
movl %eax, %edi
leaq 0x7f74(%rip), %rsi      # 0x10262
callq 0x22b0
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x830a
movl $0x1, 0x24(%rsp)
jmp 0x836b
movq 0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x8321
movl $0x5, 0x24(%rsp)
jmp 0x836b
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
callq 0x20a0
movq (%rsp), %rsi
addq %rax, %rsi
movq 0x8(%rsp), %rcx
leaq 0x10(%rsp), %rdi
leaq 0xfe86(%rip), %rdx      # 0x181d2
callq 0x8df0
testb $0x1, %al
jne 0x835f
movl $0x5, 0x24(%rsp)
jmp 0x836b
jmp 0x8361
jmp 0x8363
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/aspone[P]OrderBook/./MessageParser.h
// Function: OrderBook::MessageParser::reportStatus(OrderBook::ParseStatus)
inline void MessageParser::reportStatus(ParseStatus status) {
   switch (status) {
      case ePS_Good:
         FHErrorTracker::instance()->goodMessage();
         break;
      case ePS_CorruptMessage:
         FHErrorTracker::instance()->corruptMessage();
         break;
      case ePS_BadQuantity:
         FHErrorTracker::instance()->invalidQuantity();
         break;
      case ePS_BadPrice:
         FHErrorTracker::instance()->invalidPrice();
         break;
      case ePS_BadID:
         FHErrorTracker::instance()->invalidID();
         break;
      default:
         fprintf(stderr, "Unknown parsing error occurred.  Skipping report of error.\n");
         FAILASSERT();
         break;
   }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq %rax, (%rsp)
subq $0x4, %rax
ja 0x8d6a
movq (%rsp), %rax
leaq 0x73aa(%rip), %rcx      # 0x100c0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
callq 0x3a30
movq %rax, %rdi
callq 0x8380
jmp 0x8d82
callq 0x3a30
movq %rax, %rdi
callq 0x6810
jmp 0x8d82
callq 0x3a30
movq %rax, %rdi
callq 0x8d90
jmp 0x8d82
callq 0x3a30
movq %rax, %rdi
callq 0x8db0
jmp 0x8d82
callq 0x3a30
movq %rax, %rdi
callq 0x8dd0
jmp 0x8d82
movq 0xf267(%rip), %rax      # 0x17fd8
movq (%rax), %rdi
leaq 0x74e9(%rip), %rsi      # 0x10264
movb $0x0, %al
callq 0x2260
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aspone[P]OrderBook/./Logger.h
// Function: Logger::print(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void print(std::string msg) {
      // lazy init creation
      // Optimizeable.  For now, keep interface clean and hide temporal coupling
      // from users.
      if (thread_ == 0) {
         init();
      }
      // mutex protects against messing with messages_ while logging thread
      // is copying out to it's own queue
      std::lock_guard<std::mutex> lock(mutex_);
      messages_.push(msg);
      messages_available_ = true;
   }

// Assembly:
subq $0x38, %rsp
movq %rsi, (%rsp)
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rax)
jne 0xb90d
movq 0x8(%rsp), %rdi
callq 0xc060
movq 0x8(%rsp), %rsi
addq $0xb0, %rsi
leaq 0x20(%rsp), %rdi
callq 0xc100
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
addq $0x10, %rdi
callq 0xc130
jmp 0xb937
movq 0x8(%rsp), %rdi
addq $0x1, %rdi
movl $0x1, %esi
callq 0x6590
leaq 0x20(%rsp), %rdi
callq 0xc160
addq $0x38, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x20(%rsp), %rdi
callq 0xc160
movq 0x18(%rsp), %rdi
callq 0x2300
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aspone[P]OrderBook/./OrderBook.h
// Function: OrderBook::OrderBook<unsigned int, OrderLevelEntry>::checkCross() const
void checkCross() const {
      if (sell_book_map_.empty() || buy_book_map_.empty()) {
         return;
      }
      auto sit = sell_book_map_.begin();
      auto bit = buy_book_map_.end();
      --bit;
      if (sit->first <= bit->first) {
         FHErrorTracker::instance()->crossedBook();
      }
   }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x108, %rdi            # imm = 0x108
callq 0xb760
testb $0x1, %al
jne 0xb9ba
movq 0x8(%rsp), %rdi
addq $0xd8, %rdi
callq 0xb760
testb $0x1, %al
jne 0xb9ba
jmp 0xb9bc
jmp 0xba26
movq 0x8(%rsp), %rdi
addq $0x108, %rdi            # imm = 0x108
callq 0xd770
movq 0x8(%rsp), %rdi
movq %rax, 0x18(%rsp)
addq $0xd8, %rdi
callq 0xd7a0
movq %rax, 0x10(%rsp)
leaq 0x10(%rsp), %rdi
callq 0xd7d0
leaq 0x18(%rsp), %rdi
callq 0xd800
movq (%rax), %rax
movq %rax, (%rsp)
leaq 0x10(%rsp), %rdi
callq 0xd800
movq %rax, %rcx
movq (%rsp), %rax
cmpq (%rcx), %rax
ja 0xba26
callq 0x3a30
movq %rax, %rdi
callq 0xd820
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aspone[P]OrderBook/./Logger.h
// Function: Logger::runLogger()
void runLogger() {
      while (TRUE) {
         if (messages_available_ == true) {
            copyMessages();
            printMessages();
         }
         if (exit_ == true) {
            copyMessages();
            printMessages();
            return;
         }
      }
   }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
addq $0x1, %rdi
callq 0xc3b0
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0xc1ff
movq 0x8(%rsp), %rdi
callq 0xc440
movq 0x8(%rsp), %rdi
callq 0xc510
movq 0x8(%rsp), %rdi
callq 0xc3b0
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0xc22c
movq 0x8(%rsp), %rdi
callq 0xc440
movq 0x8(%rsp), %rdi
callq 0xc510
addq $0x18, %rsp
retq
jmp 0xc1d3
nop
// File: /workspace/github_c_makefile_star2_O0/aspone[P]OrderBook/./Logger.h
// Function: Logger::copyMessages()
void copyMessages() {
      // Just copy them all out.  Deal with strcpy costs here in bulk.
      // Could optimize later if it becomes a problem and blocks enqueue
      std::lock_guard<std::mutex> lock(mutex_);
      while (messages_.size() != 0) {
         messages_to_print_.push(messages_.front());
         messages_.pop();
      }
      messages_available_ = false;
   }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rsi
movq %rsi, 0x20(%rsp)
addq $0xb0, %rsi
leaq 0x38(%rsp), %rdi
callq 0xc100
movq 0x20(%rsp), %rdi
addq $0x10, %rdi
callq 0xc590
movq %rax, 0x18(%rsp)
jmp 0xc479
movq 0x18(%rsp), %rax
cmpq $0x0, %rax
je 0xc4e2
movq 0x20(%rsp), %rdi
movq %rdi, %rax
addq $0x60, %rax
movq %rax, 0x8(%rsp)
addq $0x10, %rdi
callq 0xc5a0
movq %rax, 0x10(%rsp)
jmp 0xc4a5
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdi
callq 0xc130
jmp 0xc4b6
movq 0x20(%rsp), %rdi
addq $0x10, %rdi
callq 0xc5b0
jmp 0xc4c6
jmp 0xc464
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0xc160
jmp 0xc501
movq 0x20(%rsp), %rdi
addq $0x1, %rdi
xorl %esi, %esi
callq 0x6590
leaq 0x38(%rsp), %rdi
callq 0xc160
addq $0x48, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x2300
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aspone[P]OrderBook/./DLList.h
// Function: OrderBook::DLList<OrderLevelEntry>::addNode(OrderLevelEntry*)
void addNode(NODE *input) {
      if (head_ == 0) {
         head_ = input;
         tail_ = head_;
         return;
      }

      head_->next_ = input;
      input->previous_ = head_;
      head_ = input;
   }

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x18(%rsp)
cmpq $0x0, 0x8(%rax)
jne 0xe383
movq -0x18(%rsp), %rax
movq -0x10(%rsp), %rcx
movq %rcx, 0x8(%rax)
movq 0x8(%rax), %rcx
movq %rcx, 0x10(%rax)
jmp 0xe3ab
movq -0x18(%rsp), %rax
movq -0x10(%rsp), %rdx
movq 0x8(%rax), %rcx
movq %rdx, 0x18(%rcx)
movq 0x8(%rax), %rdx
movq -0x10(%rsp), %rcx
movq %rdx, 0x20(%rcx)
movq -0x10(%rsp), %rcx
movq %rcx, 0x8(%rax)
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/aspone[P]OrderBook/./CountedOrderList.h
// Function: OrderBook::CountedOrderList<OrderLevelEntry>::printLevel(char, char*&, int&, int&)
void printLevel(char tag, char *&buffer, int &index, int &max_buffer) {
      NODE *tail = DLList<NODE>::getTail();
      while (tail != DLList<NODE>::getHead()) {
         // Need interim so I know len of level print
         // char level[50];
         // sprintf(level, "%c %u ", tag, tail->order_qty_);
         // safeCopyToBuffer(buffer, level, index, max_buffer);

         if (index + 50 > max_buffer) growBuffer(buffer, max_buffer);
         index += sprintf(&buffer[index], "%c %u ", tag, tail->order_qty_);

         tail = tail->next_;
      }
      // Need interim so I know len of level print
      // char level[50];
      // sprintf(level, "%c %u ", tag, tail->order_qty_);
      // safeCopyToBuffer(buffer, level, index, max_buffer);

      if (index + 50 > max_buffer) growBuffer(buffer, max_buffer);
      index += sprintf(&buffer[index], "%c %u ", tag, tail->order_qty_);
   }

// Assembly:
subq $0x48, %rsp
movb %sil, %al
movq %rdi, 0x40(%rsp)
movb %al, 0x3f(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x5680
movq %rax, 0x18(%rsp)
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0x5670
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
je 0xf6b2
movq 0x28(%rsp), %rax
movl (%rax), %eax
addl $0x32, %eax
movq 0x20(%rsp), %rcx
cmpl (%rcx), %eax
jle 0xf666
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x2990
movq 0x30(%rsp), %rax
movq (%rax), %rdi
movq 0x28(%rsp), %rax
movslq (%rax), %rax
addq %rax, %rdi
movsbl 0x3f(%rsp), %edx
movq 0x18(%rsp), %rax
movl 0x10(%rax), %ecx
leaq 0xcd5(%rip), %rsi       # 0x10362
movb $0x0, %al
callq 0x2040
movl %eax, %ecx
movq 0x28(%rsp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
jmp 0xf623
movq 0x28(%rsp), %rax
movl (%rax), %eax
addl $0x32, %eax
movq 0x20(%rsp), %rcx
cmpl (%rcx), %eax
jle 0xf6d4
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x2990
movq 0x30(%rsp), %rax
movq (%rax), %rdi
movq 0x28(%rsp), %rax
movslq (%rax), %rax
addq %rax, %rdi
movsbl 0x3f(%rsp), %edx
movq 0x18(%rsp), %rax
movl 0x10(%rax), %ecx
leaq 0xc67(%rip), %rsi       # 0x10362
movb $0x0, %al
callq 0x2040
movl %eax, %ecx
movq 0x28(%rsp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/DeforaOS[P]libSystem/tests/error.c
// Function: test
static int _test(void)
{
	int code;

	if((code = error_get_code()) != 0)
		return 1;
	error_set_code(255, NULL);
	if(error_get_code() != 255)
		return 2;
	error_print(NULL);
	error_print("error");
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x1030
movl %eax, -0x8(%rbp)
cmpl $0x0, %eax
je 0x119e
movl $0x1, -0x4(%rbp)
jmp 0x11df
movl $0xff, %edi
xorl %eax, %eax
movl %eax, %esi
movb $0x0, %al
callq 0x1050
callq 0x1030
cmpl $0xff, %eax
je 0x11c3
movl $0x2, -0x4(%rbp)
jmp 0x11df
xorl %eax, %eax
movl %eax, %edi
callq 0x1040
leaq 0xe31(%rip), %rdi       # 0x2004
callq 0x1040
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/crcx[P]retroforth/tools/retro-unu.c
// Function: read_line
void read_line(FILE *file, char *line_buffer) {
  int ch = getc(file);
  int count = 0;
  while ((ch != '\n') && (ch != EOF)) {
    line_buffer[count] = ch;
    count++;
    ch = getc(file);
  }
  line_buffer[count] = '\0';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x10a0
movl %eax, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
xorl %eax, %eax
cmpl $0xa, -0x14(%rbp)
movb %al, -0x19(%rbp)
je 0x11e8
cmpl $-0x1, -0x14(%rbp)
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x11f1
jmp 0x1218
movl -0x14(%rbp), %eax
movb %al, %dl
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x10a0
movl %eax, -0x14(%rbp)
jmp 0x11d3
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb $0x0, (%rax,%rcx)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/crcx[P]retroforth/tools/retro-unu.c
// Function: fence_boundary
int fence_boundary(char *buffer, int tests_enabled) {
  int flag = 1;
  if (strcmp(buffer, code_start) == 0) { flag = -1; }
  if (strcmp(buffer, code_end) == 0)   { flag = -1; }
  if (tests_enabled == 0) { return flag; }
  if (strcmp(buffer, test_start) == 0) { flag = -1; }
  if (strcmp(buffer, test_end) == 0)   { flag = -1; }
  return flag;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0x1, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x2e2f(%rip), %rsi      # 0x4080
callq 0x1060
cmpl $0x0, %eax
jne 0x1262
movl $0xffffffff, -0x18(%rbp) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rdi
leaq 0x2e43(%rip), %rsi      # 0x40b0
callq 0x1060
cmpl $0x0, %eax
jne 0x127e
movl $0xffffffff, -0x18(%rbp) # imm = 0xFFFFFFFF
cmpl $0x0, -0x14(%rbp)
jne 0x128c
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x12ca
movq -0x10(%rbp), %rdi
leaq 0x2e49(%rip), %rsi      # 0x40e0
callq 0x1060
cmpl $0x0, %eax
jne 0x12a8
movl $0xffffffff, -0x18(%rbp) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rdi
leaq 0x2e5d(%rip), %rsi      # 0x4110
callq 0x1060
cmpl $0x0, %eax
jne 0x12c4
movl $0xffffffff, -0x18(%rbp) # imm = 0xFFFFFFFF
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/crcx[P]retroforth/tools/retro-unu.c
// Function: unu
void unu(char *fname, int tests_enabled, Handler handler) {
  int inBlock = 0;
  char buffer[4096];
  FILE *fp;
  fp = fopen(fname, "r");
  if (fp == NULL) {
    printf("Unable to load file\n");
    exit(2);
  }
  while (!feof(fp)) {
    read_line(fp, buffer);
    if (fence_boundary(buffer, tests_enabled) == -1) {
      if (inBlock == 0) {
        inBlock = 1;
      } else {
        inBlock = 0;
      }
    } else {
      if (inBlock == 1) {
        handler(buffer);
      }
    }
  }
  fclose(fp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1030, %rsp           # imm = 0x1030
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xcfc(%rip), %rsi       # 0x2004
callq 0x1080
movq %rax, -0x1028(%rbp)
cmpq $0x0, -0x1028(%rbp)
jne 0x1336
leaq 0xce1(%rip), %rdi       # 0x2006
movb $0x0, %al
callq 0x1050
movl $0x2, %edi
callq 0x1090
jmp 0x1338
movq -0x1028(%rbp), %rdi
callq 0x1070
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x1352
jmp 0x13a8
movq -0x1028(%rbp), %rdi
leaq -0x1020(%rbp), %rsi
callq 0x11b0
leaq -0x1020(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x1230
cmpl $-0x1, %eax
jne 0x1391
cmpl $0x0, -0x1c(%rbp)
jne 0x1388
movl $0x1, -0x1c(%rbp)
jmp 0x138f
movl $0x0, -0x1c(%rbp)
jmp 0x13a6
cmpl $0x1, -0x1c(%rbp)
jne 0x13a4
movq -0x18(%rbp), %rax
leaq -0x1020(%rbp), %rdi
callq *%rax
jmp 0x13a6
jmp 0x1338
movq -0x1028(%rbp), %rdi
callq 0x1040
addq $0x1030, %rsp           # imm = 0x1030
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/phluid61[P]hsf/src/bytesequence.c
// Function: SH_ByteSequence__init
SH_ByteSequence*
SH_ByteSequence__init(sh_byte_t* value, size_t n, int* err) {
	SH_ByteSequence* obj;

	__cascade(err, (SH_ByteSequence*)0);

	if (n > SH_BYTESEQUENCE_LENGTH_MAX) {
		__raise(err, SH_E_BYTESEQUENCE_TOO_LONG);
		return (SH_ByteSequence*)0;
	}

	obj = (SH_ByteSequence*)malloc(sizeof(SH_ByteSequence));
	if ((SH_ByteSequence*)0 == obj) {
		__raise(err, SH_E_MALLOC_ERROR);
		return (SH_ByteSequence*)0;
	}

	obj->value = (sh_byte_t*)malloc(sizeof(sh_byte_t) * n);
	if ((sh_byte_t*)0 == obj->value) {
		free(obj);
		__raise(err, SH_E_MALLOC_ERROR);
		return (SH_ByteSequence*)0;
	}

	memcpy((void*)obj->value, (const void*)value, n);
	obj->length = n;

	__clear(err);
	return obj;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
xorl %eax, %eax
cmpq -0x20(%rbp), %rax
je 0x1163
movq -0x20(%rbp), %rcx
xorl %eax, %eax
cmpl (%rcx), %eax
je 0x1163
movq $0x0, -0x8(%rbp)
jmp 0x1242
cmpq $0x4000, -0x18(%rbp)    # imm = 0x4000
jbe 0x118c
xorl %eax, %eax
cmpq -0x20(%rbp), %rax
je 0x117f
movq -0x20(%rbp), %rax
movl $0x150001, (%rax)       # imm = 0x150001
movq $0x0, -0x8(%rbp)
jmp 0x1242
movl $0x10, %edi
callq 0x1050
movq %rax, -0x28(%rbp)
xorl %eax, %eax
cmpq -0x28(%rbp), %rax
jne 0x11c1
xorl %eax, %eax
cmpq -0x20(%rbp), %rax
je 0x11b4
movq -0x20(%rbp), %rax
movl $0x80000001, (%rax)     # imm = 0x80000001
movq $0x0, -0x8(%rbp)
jmp 0x1242
movq -0x18(%rbp), %rdi
shlq $0x0, %rdi
callq 0x1050
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
xorl %eax, %eax
cmpq (%rcx), %rax
jne 0x1208
movq -0x28(%rbp), %rdi
callq 0x1030
xorl %eax, %eax
cmpq -0x20(%rbp), %rax
je 0x11fe
movq -0x20(%rbp), %rax
movl $0x80000001, (%rax)     # imm = 0x80000001
movq $0x0, -0x8(%rbp)
jmp 0x1242
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x1040
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
xorl %eax, %eax
cmpq -0x20(%rbp), %rax
je 0x123a
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/phluid61[P]hsf/src/bytesequence.c
// Function: SH_ByteSequence__destroy
void
SH_ByteSequence__destroy(SH_ByteSequence* obj, int* err) {
	__cascade(err,);
	if ((sh_byte_t*)0 != obj->value) {
		free(obj->value);
	}
	free(obj);
	__clear(err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
je 0x1274
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpl (%rcx), %eax
je 0x1274
jmp 0x12a6
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpq (%rcx), %rax
je 0x128b
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rdi
callq 0x1030
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
je 0x12a6
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/carlitosmarin[P]Sistema-Ficheros-SOII/mi_chmod.c
// Function: main
int main (int argc, char **argv) {
	if (argc != 4) {
		printf("Número de parametros incorrectos\n");
		return -1;
	}
	//Montamos el disco
	bmount(argv[1]);

	unsigned int permisos = atoi(argv[2]);
	if(permisos < 0 || permisos > 7) {
		puts("Permisos introducidos invalidos\n");
		bumount();
		return -1;
	}

	if(mi_chmod (argv[3],permisos) == 0) printf("Permisos del fichero %s actualizados correctamente\n", argv[3]);
	else printf("Error: No se ha podido llevar a cabo mi_chmod\n");

	bumount();
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x4, -0x8(%rbp)
je 0x5e96
leaq 0x6d6(%rip), %rdi       # 0x6559
movb $0x0, %al
callq 0x1090
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5f27
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1290
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x1150
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jb 0x5ebf
cmpl $0x7, -0x14(%rbp)
jbe 0x5edb
leaq 0x6b6(%rip), %rdi       # 0x657c
callq 0x1060
movb $0x0, %al
callq 0x12f0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5f27
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movl -0x14(%rbp), %eax
movzbl %al, %esi
callq 0x57a0
cmpl $0x0, %eax
jne 0x5f0b
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
leaq 0x69b(%rip), %rdi       # 0x659d
movb $0x0, %al
callq 0x1090
jmp 0x5f19
leaq 0x6bf(%rip), %rdi       # 0x65d1
movb $0x0, %al
callq 0x1090
movb $0x0, %al
callq 0x12f0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/aligrudi[P]gpss/datgen.c
// Function: input
static int input(FILE *fp)
{
	int i;
	if (fscanf(fp, "%d", &pt_n) != 1)
		return -1;
	for (i = 0; i < pt_n; i++)
		if (fscanf(fp, "%d %d", &pt_x[i], &pt_y[i]) != 2)
			return -1;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0xbe4(%rip), %rsi       # 0x200b
leaq 0x2c32(%rip), %rdx      # 0x4060
movb $0x0, %al
callq 0x1030
cmpl $0x1, %eax
je 0x1443
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x14ad
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl 0x2c0d(%rip), %eax      # 0x4060
jge 0x14a6
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rax
leaq 0xb80a6c(%rip), %rdx    # 0xb81ed0
shlq $0x2, %rax
addq %rax, %rdx
movslq -0x14(%rbp), %rax
leaq 0xb8a69a(%rip), %rcx    # 0xb8bb10
shlq $0x2, %rax
addq %rax, %rcx
leaq 0xb84(%rip), %rsi       # 0x2008
movb $0x0, %al
callq 0x1030
cmpl $0x2, %eax
je 0x1499
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x14ad
jmp 0x149b
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x144a
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aligrudi[P]gpss/datgen.c
// Function: lowerleft
static int lowerleft(void)
{
	int ret = 0;
	int i;
	for (i = 1; i < pt_n; i++)
		if (pt_y[i] < pt_y[ret] || (pt_y[i] == pt_y[ret] && pt_x[i] < pt_x[ret]))
			ret = i;
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x0, -0x4(%rbp)
movl $0x1, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl 0x2b85(%rip), %eax      # 0x4060
jge 0x154a
movslq -0x8(%rbp), %rcx
leaq 0xb8a628(%rip), %rax    # 0xb8bb10
movl (%rax,%rcx,4), %eax
movslq -0x4(%rbp), %rdx
leaq 0xb8a61a(%rip), %rcx    # 0xb8bb10
cmpl (%rcx,%rdx,4), %eax
jl 0x1537
movslq -0x8(%rbp), %rcx
leaq 0xb8a60a(%rip), %rax    # 0xb8bb10
movl (%rax,%rcx,4), %eax
movslq -0x4(%rbp), %rdx
leaq 0xb8a5fc(%rip), %rcx    # 0xb8bb10
cmpl (%rcx,%rdx,4), %eax
jne 0x153d
movslq -0x8(%rbp), %rcx
leaq 0xb809ac(%rip), %rax    # 0xb81ed0
movl (%rax,%rcx,4), %eax
movslq -0x4(%rbp), %rdx
leaq 0xb8099e(%rip), %rcx    # 0xb81ed0
cmpl (%rcx,%rdx,4), %eax
jge 0x153d
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x153f
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x14d2
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/aligrudi[P]gpss/datgen.c
// Function: sortpoints
static void sortpoints(int base)
{
	int i;
	for (i = 0; i < pt_n; i++)
		if (pt_sorted[i] == base)
			break;
	pt_sorted[i] = pt_sorted[0];
	pt_sorted[0] = base;
	for (i = 0; i < pt_n; i++) {
		pt_sx[i] = pt_x[i] - pt_x[base];
		pt_sy[i] = pt_y[i] - pt_y[base];
		if (pt_sy[i] < 0 || (pt_sy[i] == 0 && pt_sx[i] > 0)) {
			pt_sx[i] = -pt_sx[i];
			pt_sy[i] = -pt_sy[i];
		}
	}
	pt_quicksort(pt_sorted + 1, pt_n - 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl 0x2af5(%rip), %eax      # 0x4060
jge 0x158f
movslq -0x8(%rbp), %rcx
leaq 0x2af8(%rip), %rax      # 0x4070
movl (%rax,%rcx,4), %eax
cmpl -0x4(%rbp), %eax
jne 0x1582
jmp 0x158f
jmp 0x1584
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x1562
movl 0x2adb(%rip), %edx      # 0x4070
movslq -0x8(%rbp), %rcx
leaq 0x2ad0(%rip), %rax      # 0x4070
movl %edx, (%rax,%rcx,4)
movl -0x4(%rbp), %eax
movl %eax, 0x2ac4(%rip)      # 0x4070
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl 0x2aa4(%rip), %eax      # 0x4060
jge 0x1695
movslq -0x8(%rbp), %rcx
leaq 0xb80903(%rip), %rax    # 0xb81ed0
movl (%rax,%rcx,4), %edx
movslq -0x4(%rbp), %rcx
leaq 0xb808f5(%rip), %rax    # 0xb81ed0
subl (%rax,%rcx,4), %edx
movslq -0x8(%rbp), %rcx
leaq 0xb94167(%rip), %rax    # 0xb95750
movl %edx, (%rax,%rcx,4)
movslq -0x8(%rbp), %rcx
leaq 0xb8a519(%rip), %rax    # 0xb8bb10
movl (%rax,%rcx,4), %edx
movslq -0x4(%rbp), %rcx
leaq 0xb8a50b(%rip), %rax    # 0xb8bb10
subl (%rax,%rcx,4), %edx
movslq -0x8(%rbp), %rcx
leaq 0xb9dd7d(%rip), %rax    # 0xb9f390
movl %edx, (%rax,%rcx,4)
movslq -0x8(%rbp), %rcx
leaq 0xb9dd6f(%rip), %rax    # 0xb9f390
cmpl $0x0, (%rax,%rcx,4)
jl 0x1649
movslq -0x8(%rbp), %rcx
leaq 0xb9dd5e(%rip), %rax    # 0xb9f390
cmpl $0x0, (%rax,%rcx,4)
jne 0x1685
movslq -0x8(%rbp), %rcx
leaq 0xb9410d(%rip), %rax    # 0xb95750
cmpl $0x0, (%rax,%rcx,4)
jle 0x1685
movslq -0x8(%rbp), %rcx
xorl %edx, %edx
leaq 0xb940fa(%rip), %rax    # 0xb95750
subl (%rax,%rcx,4), %edx
movslq -0x8(%rbp), %rcx
leaq 0xb940ec(%rip), %rax    # 0xb95750
movl %edx, (%rax,%rcx,4)
movslq -0x8(%rbp), %rcx
xorl %edx, %edx
leaq 0xb9dd1c(%rip), %rax    # 0xb9f390
subl (%rax,%rcx,4), %edx
movslq -0x8(%rbp), %rcx
leaq 0xb9dd0e(%rip), %rax    # 0xb9f390
movl %edx, (%rax,%rcx,4)
jmp 0x1687
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x15b3
movl 0x29c5(%rip), %esi      # 0x4060
subl $0x1, %esi
leaq 0x29cb(%rip), %rdi      # 0x4070
addq $0x4, %rdi
callq 0x1890
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aligrudi[P]gpss/datgen.c
// Function: line_add
static void line_add(int p0, int n, int *pt)
{
	ln[ln_n] = malloc((n + 1) * sizeof(ln[ln_n][0]));
	ln_cnt[ln_n] = n + 1;
	ln[ln_n][0] = p0;
	memcpy(ln[ln_n] + 1, pt, n * sizeof(ln[ln_n][0]));
	ln_n++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
shlq $0x2, %rdi
callq 0x1060
movq %rax, %rdx
movslq 0xec32(%rip), %rcx      # 0x103c0
leaq 0x3df53b(%rip), %rax    # 0x3e0cd0
movq %rdx, (%rax,%rcx,8)
movl -0x8(%rbp), %edx
addl $0x1, %edx
movslq 0xec1a(%rip), %rcx      # 0x103c0
leaq 0xec23(%rip), %rax      # 0x103d0
movl %edx, (%rax,%rcx,4)
movl -0x4(%rbp), %ecx
movslq 0xec06(%rip), %rdx      # 0x103c0
leaq 0x3df50f(%rip), %rax    # 0x3e0cd0
movq (%rax,%rdx,8), %rax
movl %ecx, (%rax)
movslq 0xebf2(%rip), %rcx      # 0x103c0
leaq 0x3df4fb(%rip), %rax    # 0x3e0cd0
movq (%rax,%rcx,8), %rdi
addq $0x4, %rdi
movq -0x10(%rbp), %rsi
movslq -0x8(%rbp), %rdx
shlq $0x2, %rdx
callq 0x1050
movl 0xebcc(%rip), %eax      # 0x103c0
addl $0x1, %eax
movl %eax, 0xebc3(%rip)      # 0x103c0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aligrudi[P]gpss/datgen.c
// Function: closestunmarked
static int closestunmarked(int p)
{
	int ret = -1;
	long retdis = 0;
	int i;
	for (i = 0; i < pt_n; i++) {
		if (!pt_mark[i] && (ret < 0 || pt_dist(p, i) < retdis)) {
			ret = i;
			retdis = pt_dist(p, i);
		}
	}
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl $0xffffffff, -0x8(%rbp) # imm = 0xFFFFFFFF
movq $0x0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl 0x2826(%rip), %eax      # 0x4060
jge 0x1886
movslq -0x14(%rbp), %rcx
leaq 0xc469(%rip), %rax      # 0xdcb0
cmpb $0x0, (%rax,%rcx)
jne 0x1879
cmpl $0x0, -0x8(%rbp)
jl 0x1864
movl -0x4(%rbp), %edi
movl -0x14(%rbp), %esi
callq 0x1b70
cmpq -0x10(%rbp), %rax
jge 0x1879
movl -0x14(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x4(%rbp), %edi
movl -0x14(%rbp), %esi
callq 0x1b70
movq %rax, -0x10(%rbp)
jmp 0x187b
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1831
movl -0x8(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/aligrudi[P]gpss/datgen.c
// Function: pt_insertion
static void pt_insertion(int *a, int n)
{
	int i, j;
	for (i = 0; i < n; i++) {
		int k = a[i];
		for (j = i - 1; j >= 0 && DEGCMP(pt_sx[k], pt_sy[k], pt_sx[a[j]], pt_sy[a[j]]) < 0; j--)
			a[j + 1] = a[j];
		a[j + 1] = k;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x1b67
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x18(%rbp)
movl -0x10(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x14(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x14(%rbp)
movb %al, -0x19(%rbp)
jl 0x1b14
movslq -0x18(%rbp), %rdx
xorl %eax, %eax
leaq 0xb93c93(%rip), %rcx    # 0xb95750
subl (%rcx,%rdx,4), %eax
cltq
movq -0x8(%rbp), %rcx
movslq -0x14(%rbp), %rdx
movslq (%rcx,%rdx,4), %rdx
leaq 0xb9d8bb(%rip), %rcx    # 0xb9f390
movslq (%rcx,%rdx,4), %rcx
imulq %rcx, %rax
movq -0x8(%rbp), %rcx
movslq -0x14(%rbp), %rdx
movslq (%rcx,%rdx,4), %rdx
leaq 0xb93c60(%rip), %rcx    # 0xb95750
movslq (%rcx,%rdx,4), %rcx
movslq -0x18(%rbp), %rsi
leaq 0xb9d891(%rip), %rdx    # 0xb9f390
movslq (%rdx,%rsi,4), %rdx
imulq %rdx, %rcx
addq %rcx, %rax
cmpq $0x0, %rax
setl %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x1b1d
jmp 0x1b46
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1aa5
movl -0x18(%rbp), %edx
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1a82
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Mikejmoffitt[P]romtools/bsplit/bsplit.c
// Function: split
void split(const char *in_fname, const char *out_even_fname, const char *out_odd_fname, int bytes)
{
	int c;
	FILE *fin, *fout_odd, *fout_even;
	fin = fopen(in_fname, "rb");
	if (!fin)
	{
		fprintf(stderr, "Couldn't open %s.\n", in_fname);
		return;
	}
	fout_odd = fopen(out_odd_fname, "wb");
	if (!fout_odd)
	{
		fprintf(stderr, "Couldn't open %s.\n", out_odd_fname);
		fclose(fin);
		return;
	}
	fout_even = fopen(out_even_fname, "wb");
	if (!fout_even)
	{
		fprintf(stderr, "Couldn't open %s.\n", out_even_fname);
		fclose(fin);
		fclose(fout_odd);
		return;
	}

	do
	{
		for (int i = 0; i < bytes; i++)
		{
			c = fgetc(fin);
			if (feof(fin))
			{
				goto done;
			}
			fputc(c, fout_even);
		}
		for (int i = 0; i < bytes; i++)
		{
			c = fgetc(fin);
			if (feof(fin))
			{
				goto done;
			}
			fputc(c, fout_odd);
		}
	}
	while (c != EOF);
done:
	fclose(fin);
	fclose(fout_odd);
	fclose(fout_even);
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movl %ecx, 0x2c(%rsp)
movq 0x40(%rsp), %rdi
leaq 0xe31(%rip), %rsi       # 0x2004
callq 0x1090
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x1207
movq 0x2e0c(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq 0x40(%rsp), %rdx
leaq 0xe0c(%rip), %rsi       # 0x2007
movb $0x0, %al
callq 0x1070
jmp 0x136c
movq 0x30(%rsp), %rdi
leaq 0xe07(%rip), %rsi       # 0x201a
callq 0x1090
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x1251
movq 0x2dcc(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq 0x30(%rsp), %rdx
leaq 0xdcc(%rip), %rsi       # 0x2007
movb $0x0, %al
callq 0x1070
movq 0x20(%rsp), %rdi
callq 0x1030
jmp 0x136c
movq 0x38(%rsp), %rdi
leaq 0xdbd(%rip), %rsi       # 0x201a
callq 0x1090
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x12a5
movq 0x2d82(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq 0x38(%rsp), %rdx
leaq 0xd82(%rip), %rsi       # 0x2007
movb $0x0, %al
callq 0x1070
movq 0x20(%rsp), %rdi
callq 0x1030
movq 0x18(%rsp), %rdi
callq 0x1030
jmp 0x136c
jmp 0x12a7
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x2c(%rsp), %eax
jge 0x12f3
movq 0x20(%rsp), %rdi
callq 0x1050
movl %eax, 0x28(%rsp)
movq 0x20(%rsp), %rdi
callq 0x1080
cmpl $0x0, %eax
je 0x12d8
jmp 0x134e
movl 0x28(%rsp), %edi
movq 0x10(%rsp), %rsi
callq 0x1060
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x12af
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
cmpl 0x2c(%rsp), %eax
jge 0x133f
movq 0x20(%rsp), %rdi
callq 0x1050
movl %eax, 0x28(%rsp)
movq 0x20(%rsp), %rdi
callq 0x1080
cmpl $0x0, %eax
je 0x1324
jmp 0x134e
movl 0x28(%rsp), %edi
movq 0x18(%rsp), %rsi
callq 0x1060
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x12fb
jmp 0x1341
cmpl $-0x1, 0x28(%rsp)
jne 0x12a7
jmp 0x134e
movq 0x20(%rsp), %rdi
callq 0x1030
movq 0x18(%rsp), %rdi
callq 0x1030
movq 0x10(%rsp), %rdi
callq 0x1030
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Mikejmoffitt[P]romtools/bsplit/bsplit.c
// Function: combine
void combine(const char *in_even_fname, const char *in_odd_fname, const char *out_fname, int bytes)
{
	int c;
	FILE *fin_odd, *fin_even, *fout;
	fout = fopen(out_fname, "wb");
	if (!fout)
	{
		fprintf(stderr, "Couldn't open %s.\n", out_fname);
		return;
	}
	fin_even = fopen(in_even_fname, "rb");
	if (!fin_even)
	{
		fprintf(stderr, "Couldn't open %s.\n", in_even_fname);
		fclose(fout);
		return;
	}
	fin_odd = fopen(in_odd_fname, "rb");
	if (!fin_odd)
	{
		fprintf(stderr, "Couldn't open %s.\n", in_odd_fname);
		fclose(fin_even);
		fclose(fout);
		return;
	}

	do
	{
		for (int i = 0; i < bytes; i++)
		{
			c = fgetc(fin_even);
			if (c != EOF)
			{
				fputc(c, fout);
			}
		}

		for (int i = 0; i < bytes; i++)
		{
			c = fgetc(fin_odd);
			if (c != EOF)
			{
				fputc(c, fout);
			}
		}
	} while (c != EOF);

	fclose(fout);
	fclose(fin_even);
	fclose(fin_odd);
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movl %ecx, 0x2c(%rsp)
movq 0x30(%rsp), %rdi
leaq 0xc77(%rip), %rsi       # 0x201a
callq 0x1090
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x13d7
movq 0x2c3c(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq 0x30(%rsp), %rdx
leaq 0xc3c(%rip), %rsi       # 0x2007
movb $0x0, %al
callq 0x1070
jmp 0x152a
movq 0x40(%rsp), %rdi
leaq 0xc21(%rip), %rsi       # 0x2004
callq 0x1090
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x1421
movq 0x2bfc(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq 0x40(%rsp), %rdx
leaq 0xbfc(%rip), %rsi       # 0x2007
movb $0x0, %al
callq 0x1070
movq 0x10(%rsp), %rdi
callq 0x1030
jmp 0x152a
movq 0x38(%rsp), %rdi
leaq 0xbd7(%rip), %rsi       # 0x2004
callq 0x1090
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x1475
movq 0x2bb2(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq 0x38(%rsp), %rdx
leaq 0xbb2(%rip), %rsi       # 0x2007
movb $0x0, %al
callq 0x1070
movq 0x18(%rsp), %rdi
callq 0x1030
movq 0x10(%rsp), %rdi
callq 0x1030
jmp 0x152a
jmp 0x1477
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x2c(%rsp), %eax
jge 0x14bb
movq 0x18(%rsp), %rdi
callq 0x1050
movl %eax, 0x28(%rsp)
cmpl $-0x1, 0x28(%rsp)
je 0x14ac
movl 0x28(%rsp), %edi
movq 0x10(%rsp), %rsi
callq 0x1060
jmp 0x14ae
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x147f
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
cmpl 0x2c(%rsp), %eax
jge 0x14ff
movq 0x20(%rsp), %rdi
callq 0x1050
movl %eax, 0x28(%rsp)
cmpl $-0x1, 0x28(%rsp)
je 0x14f0
movl 0x28(%rsp), %edi
movq 0x10(%rsp), %rsi
callq 0x1060
jmp 0x14f2
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x14c3
jmp 0x1501
cmpl $-0x1, 0x28(%rsp)
jne 0x1477
movq 0x10(%rsp), %rdi
callq 0x1030
movq 0x18(%rsp), %rdi
callq 0x1030
movq 0x20(%rsp), %rdi
callq 0x1030
addq $0x48, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Mikejmoffitt[P]romtools/bsplit/bsplit.c
// Function: exchange
void exchange(const char *in_fname, const char *out_fname)
{
	int c;
	uint8_t byte[2];
	FILE *fin, *fout;
	fout = fopen(out_fname, "wb");
	if (!fout)
	{
		fprintf(stderr, "Couldn't open %s.\n", out_fname);
		return;
	}
	fin = fopen(in_fname, "rb");
	if (!fin)
	{
		fprintf(stderr, "Couldn't open %s.\n", in_fname);
		fclose(fout);
		return;
	}

	do
	{
		c = fgetc(fin);
		if (c == EOF)
		{
			break;
		}
		byte[0] = c;
		c = fgetc(fin);
		if (c == EOF)
		{
			break;
		}
		byte[1] = c;

		fputc(byte[1], fout);
		fputc(byte[0], fout);
	} while (c != EOF);

	fclose(fout);
	fclose(fin);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
leaq 0xad0(%rip), %rsi       # 0x201a
callq 0x1090
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x157c
movq 0x2a97(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq 0x18(%rsp), %rdx
leaq 0xa97(%rip), %rsi       # 0x2007
movb $0x0, %al
callq 0x1070
jmp 0x1638
movq 0x20(%rsp), %rdi
leaq 0xa7c(%rip), %rsi       # 0x2004
callq 0x1090
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x15c2
movq 0x2a57(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq 0x20(%rsp), %rdx
leaq 0xa57(%rip), %rsi       # 0x2007
movb $0x0, %al
callq 0x1070
movq (%rsp), %rdi
callq 0x1030
jmp 0x1638
jmp 0x15c4
movq 0x8(%rsp), %rdi
callq 0x1050
movl %eax, 0x14(%rsp)
cmpl $-0x1, 0x14(%rsp)
jne 0x15db
jmp 0x1625
movl 0x14(%rsp), %eax
movb %al, 0x12(%rsp)
movq 0x8(%rsp), %rdi
callq 0x1050
movl %eax, 0x14(%rsp)
cmpl $-0x1, 0x14(%rsp)
jne 0x15fa
jmp 0x1625
movl 0x14(%rsp), %eax
movb %al, 0x13(%rsp)
movzbl 0x13(%rsp), %edi
movq (%rsp), %rsi
callq 0x1060
movzbl 0x12(%rsp), %edi
movq (%rsp), %rsi
callq 0x1060
cmpl $-0x1, 0x14(%rsp)
jne 0x15c4
movq (%rsp), %rdi
callq 0x1030
movq 0x8(%rsp), %rdi
callq 0x1030
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Mikejmoffitt[P]romtools/bsplit/bsplit.c
// Function: exchange_nybbles
void exchange_nybbles(const char *in_fname, const char *out_fname)
{
	int c;
	FILE *fin, *fout;
	fout = fopen(out_fname, "wb");
	if (!fout)
	{
		fprintf(stderr, "Couldn't open %s.\n", out_fname);
		return;
	}
	fin = fopen(in_fname, "rb");
	if (!fin)
	{
		fprintf(stderr, "Couldn't open %s.\n", in_fname);
		fclose(fout);
		return;
	}

	do
	{
		c = fgetc(fin);
		if (c == EOF)
		{
			break;
		}
		fputc(((c & 0xF) << 4) | ((c & 0xF0) >> 4), fout);
	} while (c != EOF);

	fclose(fout);
	fclose(fin);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
leaq 0x9c0(%rip), %rsi       # 0x201a
callq 0x1090
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x168c
movq 0x2987(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq 0x18(%rsp), %rdx
leaq 0x987(%rip), %rsi       # 0x2007
movb $0x0, %al
callq 0x1070
jmp 0x1726
movq 0x20(%rsp), %rdi
leaq 0x96c(%rip), %rsi       # 0x2004
callq 0x1090
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x16d2
movq 0x2947(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq 0x20(%rsp), %rdx
leaq 0x947(%rip), %rsi       # 0x2007
movb $0x0, %al
callq 0x1070
movq (%rsp), %rdi
callq 0x1030
jmp 0x1726
jmp 0x16d4
movq 0x8(%rsp), %rdi
callq 0x1050
movl %eax, 0x14(%rsp)
cmpl $-0x1, 0x14(%rsp)
jne 0x16eb
jmp 0x1713
movl 0x14(%rsp), %edi
andl $0xf, %edi
shll $0x4, %edi
movl 0x14(%rsp), %eax
andl $0xf0, %eax
sarl $0x4, %eax
orl %eax, %edi
movq (%rsp), %rsi
callq 0x1060
cmpl $-0x1, 0x14(%rsp)
jne 0x16d4
movq (%rsp), %rdi
callq 0x1030
movq 0x8(%rsp), %rdi
callq 0x1030
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Mikejmoffitt[P]romtools/bsplit/bsplit.c
// Function: exchange_halfnybbles
void exchange_halfnybbles(const char *in_fname, const char *out_fname)
{
	int c;
	uint8_t byte;
	FILE *fin, *fout;
	fout = fopen(out_fname, "wb");
	if (!fout)
	{
		fprintf(stderr, "Couldn't open %s.\n", out_fname);
		return;
	}
	fin = fopen(in_fname, "rb");
	if (!fin)
	{
		fprintf(stderr, "Couldn't open %s.\n", in_fname);
		fclose(fout);
		return;
	}

	do
	{
		c = fgetc(fin);
		if (c == EOF)
		{
			break;
		}
		byte = c;
		c = ((byte & 0x03) << 2) | ((byte & 0x0C) >> 2) | (((byte & 0x30) << 2) | ((byte & 0xC0) >> 2));

		fputc(c, fout);
	} while (c != EOF);

	fclose(fout);
	fclose(fin);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
leaq 0x8d0(%rip), %rsi       # 0x201a
callq 0x1090
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x177c
movq 0x2897(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq 0x18(%rsp), %rdx
leaq 0x897(%rip), %rsi       # 0x2007
movb $0x0, %al
callq 0x1070
jmp 0x1846
movq 0x20(%rsp), %rdi
leaq 0x87c(%rip), %rsi       # 0x2004
callq 0x1090
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x17c5
movq 0x2857(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq 0x20(%rsp), %rdx
leaq 0x857(%rip), %rsi       # 0x2007
movb $0x0, %al
callq 0x1070
movq (%rsp), %rdi
callq 0x1030
jmp 0x1846
jmp 0x17c7
movq 0x8(%rsp), %rdi
callq 0x1050
movl %eax, 0x14(%rsp)
cmpl $-0x1, 0x14(%rsp)
jne 0x17de
jmp 0x1833
movl 0x14(%rsp), %eax
movb %al, 0x13(%rsp)
movzbl 0x13(%rsp), %eax
andl $0x3, %eax
shll $0x2, %eax
movzbl 0x13(%rsp), %ecx
andl $0xc, %ecx
sarl $0x2, %ecx
orl %ecx, %eax
movzbl 0x13(%rsp), %ecx
andl $0x30, %ecx
shll $0x2, %ecx
movzbl 0x13(%rsp), %edx
andl $0xc0, %edx
sarl $0x2, %edx
orl %edx, %ecx
orl %ecx, %eax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %edi
movq (%rsp), %rsi
callq 0x1060
cmpl $-0x1, 0x14(%rsp)
jne 0x17c7
movq (%rsp), %rdi
callq 0x1030
movq 0x8(%rsp), %rdi
callq 0x1030
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Mikejmoffitt[P]romtools/bsplit/bsplit.c
// Function: usage
void usage(const char *name)
{
	printf("Usage: %s [op]\n", name);
	printf("    split: s in out.even out.odd <bytes per>\n");
	printf("  combine: c in.even in.odd out <bytes per>\n");
	printf(" exchange: x in out\n");
	printf(" ex. 4bit: n in out\n");
	printf(" ex. 2bit: z in out\n");
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rsi
leaq 0x7bd(%rip), %rdi       # 0x201d
movb $0x0, %al
callq 0x1040
leaq 0x7bf(%rip), %rdi       # 0x202d
movb $0x0, %al
callq 0x1040
leaq 0x7df(%rip), %rdi       # 0x205b
movb $0x0, %al
callq 0x1040
leaq 0x7fe(%rip), %rdi       # 0x2088
movb $0x0, %al
callq 0x1040
leaq 0x805(%rip), %rdi       # 0x209d
movb $0x0, %al
callq 0x1040
leaq 0x80c(%rip), %rdi       # 0x20b2
movb $0x0, %al
callq 0x1040
popq %rax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/waywardgeek[P]sonic/sonic.c
// Function: freeStreamBuffers
static void freeStreamBuffers(sonicStream stream) {
  if (stream->inputBuffer != NULL) {
    sonicFree(stream->inputBuffer);
  }
  if (stream->outputBuffer != NULL) {
    sonicFree(stream->outputBuffer);
  }
  if (stream->pitchBuffer != NULL) {
    sonicFree(stream->pitchBuffer);
  }
  if (stream->downSampleBuffer != NULL) {
    sonicFree(stream->downSampleBuffer);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x1602
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x1650
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x161a
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1650
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x1632
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x1650
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x164a
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x1650
addq $0x10, %rsp
popq %rbp
retq