LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/corecodec[P]coremake/coremake.c
// Function: getarg
void getarg(char* s, const char** in)
{
    int quote = 0;

	while (**in && isspace(**in))
        ++(*in);

	for (;**in && (quote || !isspace(**in));++(*in))
    {
        if (**in == '"')
        {
            quote = !quote;
            continue;
        }
        *(s++) = **in;
    }

    *s = 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %r15
movb (%r15), %bpl
testb %bpl, %bpl
je 0xeac5
callq 0x2370
incq %r15
movq (%rax), %rcx
movsbq %bpl, %rdx
testb $0x20, 0x1(%rcx,%rdx,2)
je 0xeac5
movq %r15, (%r14)
movb (%r15), %bpl
incq %r15
testb %bpl, %bpl
jne 0xeaa9
movq (%r14), %rax
movb (%rax), %r15b
testb %r15b, %r15b
je 0xeb13
xorl %ebp, %ebp
testl %ebp, %ebp
jne 0xeae9
callq 0x2370
movq (%rax), %rax
movsbq %r15b, %rcx
testb $0x20, 0x1(%rax,%rcx,2)
jne 0xeb13
cmpb $0x22, %r15b
jne 0xeafa
xorl %eax, %eax
testl %ebp, %ebp
sete %al
movl %eax, %ebp
jmp 0xeb00
movb %r15b, (%rbx)
incq %rbx
movq (%r14), %rax
leaq 0x1(%rax), %rcx
movq %rcx, (%r14)
movb 0x1(%rax), %r15b
testb %r15b, %r15b
jne 0xead2
movb $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/corecodec[P]coremake/coremake.c
// Function: build_file
void build_file(item* p,const char* filename, int reader_flags)
{
	reader r;
    reader_init(&r);
	strcpy(r.filename,filename);
	pathunix(r.filename);
	r.r.f = fopen(filename,"r");
	r.pos = r.line;
	if (!r.r.f)
	{
		printf("'%s' build file not found!\r\n",filename);
		exit(1);
	}
    r.r.flags = reader_flags;
    r.r.filename_kind = reader_flags;
	build_parse(p,&r,0,0,NULL);
	fclose(r.r.f);
    reader_free(&r);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x33da
movq 0x38(%r15), %rdi
movq %r14, %rsi
callq 0x20b0
movq 0x38(%r15), %rax
movzbl (%rax), %ecx
cmpl $0x5c, %ecx
je 0x1087d
testl %ecx, %ecx
jne 0x10880
jmp 0x10885
movb $0x2f, (%rax)
incq %rax
jmp 0x1086f
leaq 0x1ae3(%rip), %rsi      # 0x1236f
movq %r14, %rdi
callq 0x22e0
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rcx
movq %rcx, 0x28(%rsp)
testq %rax, %rax
je 0x108f5
leaq 0x8(%rsp), %r14
movl %ebp, 0x10(%r14)
movl %ebp, 0x14(%r14)
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0xeb21
movq (%r14), %rdi
callq 0x20f0
movq 0x38(%r14), %rdi
callq 0x2050
movq 0x28(%r14), %rdi
callq 0x2050
movq 0x30(%r14), %rdi
callq 0x2050
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2b42(%rip), %rdi      # 0x1343e
movq %r14, %rsi
xorl %eax, %eax
callq 0x2140
movl $0x1, %edi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O1/corecodec[P]coremake/coremake.c
// Function: default_workspace
item* default_workspace(item* workspace,item* i,item* p)
{
	item** child;
	if (!p) return i;
	for (child=p->child;child!=p->childend;++child)
    {
        if (!i)
        {
            truncfilename(proj);
            i = item_get(workspace,proj,1);
        }
        item_get(item_get(i,"use",1),(*child)->value,1);
    }
    return i;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
testq %rdx, %rdx
je 0x1098f
movq %rdx, %rbx
movq 0x18(%rdx), %rbp
cmpq 0x20(%rdx), %rbp
je 0x1098f
movq %rdi, %r14
leaq 0x6896(%rip), %r12      # 0x171d0
leaq 0x179b(%rip), %r13      # 0x120dc
testq %r15, %r15
jne 0x10961
movq %r12, %rdi
callq 0x3c23
movq %r14, %rdi
movq %r12, %rsi
movl $0x1, %edx
callq 0x2745
movq %rax, %r15
movq %r15, %rdi
movq %r13, %rsi
movl $0x1, %edx
callq 0x2745
movq (%rbp), %rcx
movq (%rcx), %rsi
movq %rax, %rdi
movl $0x1, %edx
callq 0x2745
addq $0x8, %rbp
cmpq 0x20(%rbx), %rbp
jne 0x10941
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/iZhangHui[P]CppPrimer/CH16_TemplatesAndGenericProgramming/exercises/ex16_41.cc
// Function: main
int main(int argc, char const *argv[])
{
	using namespace std;
	auto a = numeric_limits<int>::min();
	cout << a << " + " << a << " = " << my_sum(a, a) << endl;

	auto b = numeric_limits<unsigned int>::max();
	cout << b << " + " << b << " = " << my_sum(b, b) << endl;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x2dca(%rip), %r14      # 0x3fd8
movq %r14, %rdi
movl $0x80000000, %esi       # imm = 0x80000000
callq 0x10b0
movq %rax, %r15
leaq 0xddf(%rip), %rbx       # 0x2004
movl $0x3, %edx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1090
movq %r15, %rdi
movl $0x80000000, %esi       # imm = 0x80000000
callq 0x10b0
movq %rax, %r12
leaq 0xdbc(%rip), %r15       # 0x2008
movl $0x3, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x1090
movabsq $-0x100000000, %rsi     # imm = 0xFFFFFFFF00000000
movq %r12, %rdi
callq 0x1070
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x1080
movsbl %al, %esi
movq %r12, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1050
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movq %r14, %rdi
callq 0x1040
movq %rax, %r14
movl $0x3, %edx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1090
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movq %r14, %rdi
callq 0x1040
movq %rax, %rbx
movl $0x3, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x1090
movabsq $0x1fffffffe, %rsi      # imm = 0x1FFFFFFFE
movq %rbx, %rdi
callq 0x1040
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1080
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1050
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jaldhar[P]Lets-Build-a-Simple-Interpreter/calc5.cc
// Function: Interpreter::factor()
long Interpreter::factor() {
    Token token = _current_token;
    if (token.type == TOKENTYPE::LPAREN) {
        eat(TOKENTYPE::LPAREN);
        long result = expression();
        eat(TOKENTYPE::RPAREN);
        return result;
    } else {
        eat(TOKENTYPE::INTEGER);
        return token.value;
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x6, 0x8(%rdi)
jne 0x2b58
movq %rbx, %rdi
movl $0x6, %esi
callq 0x2a38
movq %rbx, %rdi
callq 0x293a
movq %rax, %r14
movl $0x7, %esi
jmp 0x2b61
movq 0x10(%rbx), %r14
movl $0x1, %esi
movq %rbx, %rdi
callq 0x2a38
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/maydali28[P]cpp-socket/matrix_hal/server.cpp
// Function: matrix_hal::server::bind()
int server::bind(){
  matrix_hal::socketAddr* sockaddr = new socketAddr(address,this->port);
  addr = sockaddr->to_sockaddr_in();

  socketfd = ::socket(AF_INET,SOCK_DGRAM,0);

  if(socketfd == -1){
    return errno;
  }
  int yes =1;
  if(::setsockopt(socketfd,SOL_SOCKET,SO_REUSEADDR,&yes,sizeof(int)) != 0){
    close();
    return errno;
  }
  int n;
  unsigned int m = sizeof(n);
getsockopt(socketfd,SOL_SOCKET,SO_RCVBUF,(void *)&n, &m);
  printf("%d %d\n",n,m);

  if(::bind(socketfd,(struct sockaddr *)&addr,sizeof(struct sockaddr))!= 0){
    close();
    return errno;
  }

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movl $0x28, %edi
callq 0x21d0
movq %rax, %r14
leaq -0x40(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
leaq -0x50(%rbp), %rdi
callq 0x26ea
movl 0x20(%rbx), %edx
leaq -0x50(%rbp), %rsi
movq %r14, %rdi
callq 0x27fc
movq -0x50(%rbp), %rdi
cmpq %r15, %rdi
je 0x2589
callq 0x21a0
movq %r14, %rdi
callq 0x284c
movq %rax, 0x28(%rbx)
movq %rdx, 0x30(%rbx)
movl $0x2, %edi
movl $0x2, %esi
xorl %edx, %edx
callq 0x2080
movl %eax, 0x24(%rbx)
cmpl $-0x1, %eax
je 0x263f
leaq -0x2c(%rbp), %rcx
movl $0x1, (%rcx)
movl %eax, %edi
movl $0x1, %esi
movl $0x2, %edx
movl $0x4, %r8d
callq 0x2270
testl %eax, %eax
jne 0x2632
leaq 0x28(%rbx), %r15
leaq -0x24(%rbp), %r14
movl $0x4, (%r14)
movl 0x24(%rbx), %edi
leaq -0x28(%rbp), %r12
movl $0x1, %esi
movl $0x8, %edx
movq %r12, %rcx
movq %r14, %r8
callq 0x2150
movl (%r12), %esi
movl (%r14), %edx
leaq 0x19f8(%rip), %rdi      # 0x400c
xorl %r14d, %r14d
xorl %eax, %eax
callq 0x2050
movl 0x24(%rbx), %edi
movq %r15, %rsi
movl $0x10, %edx
callq 0x2070
testl %eax, %eax
je 0x2647
movl 0x24(%rbx), %edi
cmpl $-0x1, %edi
je 0x263f
callq 0x2290
callq 0x2040
movl (%rax), %r14d
movl %r14d, %eax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x50(%rbp), %rdi
cmpq %r15, %rdi
je 0x266d
callq 0x21a0
jmp 0x266d
movq %rax, %rbx
movq %r14, %rdi
callq 0x21a0
movq %rbx, %rdi
callq 0x2260
nop
// File: /workspace/github_cpp_makefile_star2_O1/maydali28[P]cpp-socket/matrix_hal/socketAddr.cpp
// Function: matrix_hal::socketAddr::to_sockaddr_in()
struct sockaddr_in socketAddr::to_sockaddr_in(){
    struct sockaddr_in addr;
    //addr = (struct sockaddr_in *) malloc(sizeof(struct sockaddr_in));
    memset(&addr,0,sizeof(addr));

    addr.sin_family = AF_INET;
    addr.sin_port = htons(port);
    inet_aton(address.c_str(),&(addr.sin_addr));

    return addr;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
xorps %xmm0, %xmm0
leaq -0x1c(%rbp), %rbx
movaps %xmm0, -0x4(%rbx)
movw $0x2, -0x4(%rbx)
movzwl 0x20(%rdi), %eax
rolw $0x8, %ax
movw %ax, -0x2(%rbx)
movq (%rdi), %rdi
movq %rbx, %rsi
callq 0x2140
movq -0x4(%rbx), %rax
movq 0x4(%rbx), %rdx
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/maydali28[P]cpp-socket/matrix_hal/socketUDP.cpp
// Function: matrix_hal::socketUDP::receive()
Datagram socketUDP::receive(){
    socklen_t size = sizeof(struct sockaddr_in);
    char * Buffer = (char*) malloc(MAX_BUFFER*sizeof(char));
    struct sockaddr_in addressClt;
    Datagram ret;
    if(::recvfrom(socketfd,Buffer,sizeof(Buffer),0,(struct sockaddr *) &addressClt,&size)){
      ret.data = Buffer;
      ret.address = addressClt;
      free(Buffer);
    }
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r12
movq %rdi, %rbx
leaq -0x34(%rbp), %r13
movl $0x10, (%r13)
movl $0x400, %edi            # imm = 0x400
callq 0x2210
movq %rax, %r14
leaq 0x10(%rbx), %rax
movq %rax, -0x30(%rbp)
leaq 0x20(%rbx), %r15
movq %r15, 0x10(%rbx)
movq $0x0, 0x18(%rbx)
movb $0x0, 0x20(%rbx)
movl (%r12), %edi
leaq -0x44(%rbp), %r8
movl $0x8, %edx
movq %r14, %rsi
xorl %ecx, %ecx
movq %r13, %r9
callq 0x2160
testq %rax, %rax
je 0x2a30
movq 0x18(%rbx), %r12
movq %r14, %rdi
callq 0x20d0
movq -0x30(%rbp), %rdi
xorl %esi, %esi
movq %r12, %rdx
movq %r14, %rcx
movq %rax, %r8
callq 0x2240
movups -0x44(%rbp), %xmm0
movups %xmm0, (%rbx)
movq %r14, %rdi
callq 0x21f0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x30(%rbp), %rax
movq (%rax), %rdi
cmpq %r15, %rdi
je 0x2a56
callq 0x21a0
movq %rbx, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O1/maydali28[P]cpp-socket/matrix_hal/socketUDP.cpp
// Function: matrix_hal::socketUDP::send(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int socketUDP::send(std::string data){
    struct sockaddr_in address;
    address.sin_family = AF_INET;
    address.sin_port = (this->address).sin_port;
    address.sin_addr = (this->address).sin_addr;
    if (sendto(this->socketfd, (void*)data.c_str(), data.length() + 1, 0, (struct sockaddr*)&address, sizeof(struct sockaddr_in)) == -1)
    {
        return 0;
    }
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq -0x10(%rbp), %r8
movw $0x2, (%r8)
movzwl 0x6(%rdi), %eax
movw %ax, 0x2(%r8)
movl 0x8(%rdi), %eax
movl %eax, 0x4(%r8)
movl (%rdi), %edi
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
incq %rdx
movq %rax, %rsi
xorl %ecx, %ecx
movl $0x10, %r9d
callq 0x2060
xorl %ecx, %ecx
cmpq $-0x1, %rax
setne %cl
movl %ecx, %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/maydali28[P]cpp-socket/matrix_hal/socketUDP.cpp
// Function: matrix_hal::socketUDP::send(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int socketUDP::send(std::string ip,std::string data){
    struct sockaddr_in address;
    address.sin_family = AF_INET;
    address.sin_port = (this->address).sin_port;
    inet_aton(ip.c_str(), &address.sin_addr);
    if (sendto(this->socketfd, (void*)data.c_str(), data.length() + 1, 0, (struct sockaddr*)&address, sizeof(struct sockaddr_in)) == -1)
    {
        return 0;
    }
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rdi, %r14
leaq -0x1c(%rbp), %rax
movw $0x2, -0x4(%rax)
movzwl 0x6(%rdi), %ecx
movw %cx, -0x2(%rax)
movq (%rsi), %rdi
movq %rax, %rsi
callq 0x2140
movl (%r14), %edi
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
incq %rdx
leaq -0x20(%rbp), %r8
xorl %ecx, %ecx
movl $0x10, %r9d
callq 0x2060
xorl %ecx, %ecx
cmpq $-0x1, %rax
setne %cl
movl %ecx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/maydali28[P]cpp-socket/matrix_hal/socketUDP.cpp
// Function: matrix_hal::socketUDP::send(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int socketUDP::send(std::string ip, int port, std::string data){
    struct sockaddr_in address;
    address.sin_family = AF_INET;
    address.sin_port = htons(port);
    inet_aton(ip.c_str(), &address.sin_addr);
    if (sendto(this->socketfd, (void*)data.c_str(), data.length() + 1, 0, (struct sockaddr*)&address, sizeof(struct sockaddr_in)) == -1)
    {
        return 0;
    }
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movq %rdi, %r14
leaq -0x1c(%rbp), %rax
movw $0x2, -0x4(%rax)
rolw $0x8, %dx
movw %dx, -0x2(%rax)
movq (%rsi), %rdi
movq %rax, %rsi
callq 0x2140
movl (%r14), %edi
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
incq %rdx
leaq -0x20(%rbp), %r8
xorl %ecx, %ecx
movl $0x10, %r9d
callq 0x2060
xorl %ecx, %ecx
cmpq $-0x1, %rax
setne %cl
movl %ecx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/maydali28[P]cpp-socket/prog.cpp
// Function: main
int main(void){
  matrix_hal::server *srv = new matrix_hal::server(8080);
  int err = srv->bind();
  if(err != 0){
    std::cout<<strerror(err)<<std::endl;
    exit(err);
  }
  matrix_hal::socketUDP* socket = srv->getConnexion();
  if(!socket->valid()){
    delete socket;
    exit(0);
  }

std::valarray<int16_t> raw_data_ = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
// matrix_hal::Datagram msg;
//    while (true) {
int tab[1024];
for(int i = 0;i<1024;i++){
tab[i] = 11111;
printf("%d\n",tab[i] );
}
  		socket->send("127.0.0.1",2012,raw_data_,raw_data_.size()) == 1 ? std::cout<<"ok"<<std::endl : std::cout<<"not ok"<<std::endl;
  		// std::cout<<msg.data<<std::endl;
//  }


}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movl $0x38, %edi
callq 0x21d0
movq %rax, %rbx
movq %rax, %rdi
movl $0x1f90, %esi           # imm = 0x1F90
callq 0x243c
movq %rbx, %rdi
callq 0x2532
testl %eax, %eax
jne 0x2f66
movq %rbx, %rdi
callq 0x267e
movq %rax, %r14
movq %rax, %rdi
callq 0x2978
testb %al, %al
je 0x2f8f
movl $0x14, %edi
callq 0x21d0
movq %rax, %rbx
movups 0x11f4(%rip), %xmm0     # 0x4040
movups %xmm0, (%rax)
movl $0xa0009, 0x10(%rax)    # imm = 0xA0009
movl $0x400, %r12d           # imm = 0x400
leaq 0x11ac(%rip), %r15      # 0x400f
movq %r15, %rdi
movl $0x2b67, %esi           # imm = 0x2B67
xorl %eax, %eax
callq 0x2050
decl %r12d
jne 0x2e63
leaq -0x40(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x11cd(%rip), %rsi      # 0x4054
leaq 0x11cf(%rip), %rdx      # 0x405d
leaq -0x50(%rbp), %rdi
callq 0x2fdc
movq $0xa, -0x30(%rbp)
movl $0x14, %edi
callq 0x21d0
leaq -0x30(%rbp), %r15
movq %rax, 0x8(%r15)
movq (%r15), %rdx
addq %rdx, %rdx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2170
leaq -0x50(%rbp), %rsi
movq %r14, %rdi
movl $0x7dc, %edx            # imm = 0x7DC
movq %r15, %rcx
movl $0xa, %r8d
callq 0x2b6e
xorl %ecx, %ecx
cmpl $0x1, %eax
setne %cl
leaq 0x1177(%rip), %rax      # 0x4062
leaq 0x116c(%rip), %rsi      # 0x405e
cmoveq %rax, %rsi
leaq 0x2(,%rcx,4), %rdx
movq 0x30d3(%rip), %r14      # 0x5fd8
movq %r14, %rdi
callq 0x21e0
movq (%r14), %rax
addq -0x18(%rax), %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x21b0
movsbl %al, %esi
movq 0x30ad(%rip), %rdi      # 0x5fd8
callq 0x2030
movq %rax, %rdi
callq 0x2120
movq -0x28(%rbp), %rdi
callq 0x21a0
movq -0x50(%rbp), %rdi
cmpq %r12, %rdi
je 0x2f4f
callq 0x21a0
movq %rbx, %rdi
callq 0x21a0
xorl %eax, %eax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %r14d
movl %eax, %edi
callq 0x20b0
movq 0x3061(%rip), %rdi      # 0x5fd8
movq %rax, %rsi
callq 0x21c0
movq %rax, %rdi
callq 0x20f0
movl %r14d, %edi
callq 0x2200
movq %r14, %rdi
callq 0x291e
movq %r14, %rdi
callq 0x21a0
xorl %edi, %edi
callq 0x2200
movq %rax, %r14
jmp 0x2fbe
jmp 0x2fad
movq %rax, %r14
jmp 0x2fcc
movq %rax, %r14
movq -0x28(%rbp), %rdi
callq 0x21a0
movq -0x50(%rbp), %rdi
cmpq %r12, %rdi
je 0x2fcc
callq 0x21a0
movq %rbx, %rdi
callq 0x21a0
movq %r14, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O1/dannycalegari[P]circle_pack/./Trigonometry_routine.cc
// Function: midpoint(Point, Point)
Point midpoint(Point P, Point Q){
	Point R;
	R.x=(P.x+Q.x)/2.0;
	R.y=(P.y+Q.y)/2.0;
	R.z=(P.z+Q.z)/2.0;
	return(R);
}

// Assembly:
movq %rdi, %rax
movsd 0x8(%rsp), %xmm0
addsd 0x20(%rsp), %xmm0
movsd 0x89eb(%rip), %xmm1     # 0xb008
mulsd %xmm1, %xmm0
movsd %xmm0, (%rdi)
movsd 0x10(%rsp), %xmm0
addsd 0x28(%rsp), %xmm0
mulsd %xmm1, %xmm0
movsd 0x18(%rsp), %xmm2
addsd 0x30(%rsp), %xmm2
movsd %xmm0, 0x8(%rdi)
mulsd %xmm1, %xmm2
movsd %xmm2, 0x10(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/dannycalegari[P]circle_pack/./Trigonometry_routine.cc
// Function: operator*(Point, double)
Point operator*(Point P, double d){
	Point Q;
	Q.x=P.x*d;
	Q.y=P.y*d;
	Q.z=P.z*d;
	return(Q);
}

// Assembly:
movq %rdi, %rax
movsd 0x8(%rsp), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, (%rdi)
movsd 0x10(%rsp), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rdi)
mulsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x10(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/dannycalegari[P]circle_pack/./Trigonometry_routine.cc
// Function: operator+(Point, Point)
Point operator+(Point P, Point Q){
	Point R;
	R.x=P.x+Q.x;
	R.y=P.y+Q.y;
	R.z=P.z+Q.z;
	return(R);
}

// Assembly:
movq %rdi, %rax
movsd 0x8(%rsp), %xmm0
addsd 0x20(%rsp), %xmm0
movsd %xmm0, (%rdi)
movsd 0x10(%rsp), %xmm0
addsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x8(%rdi)
movsd 0x18(%rsp), %xmm0
addsd 0x30(%rsp), %xmm0
movsd %xmm0, 0x10(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/dannycalegari[P]circle_pack/./Trigonometry_routine.cc
// Function: cross(Point, Point)
Point cross(Point P, Point Q){
	Point R;
	R.z=P.x*Q.y-P.y*Q.x;
	R.y=P.z*Q.x-P.x*Q.z;
	R.x=P.y*Q.z-P.z*Q.y;
	return(R);
}

// Assembly:
movq %rdi, %rax
movsd 0x20(%rsp), %xmm0
movsd 0x28(%rsp), %xmm1
movsd 0x8(%rsp), %xmm2
movsd 0x10(%rsp), %xmm3
movapd %xmm0, %xmm4
mulsd %xmm3, %xmm4
movapd %xmm2, %xmm5
mulsd %xmm1, %xmm5
subsd %xmm4, %xmm5
movsd %xmm5, 0x10(%rdi)
movsd 0x18(%rsp), %xmm4
movsd 0x30(%rsp), %xmm5
mulsd %xmm5, %xmm2
mulsd %xmm4, %xmm0
subsd %xmm2, %xmm0
movsd %xmm0, 0x8(%rdi)
mulsd %xmm4, %xmm1
mulsd %xmm5, %xmm3
subsd %xmm1, %xmm3
movsd %xmm3, (%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/dannycalegari[P]circle_pack/./Trigonometry_routine.cc
// Function: write_Matrix(Matrix)
void write_Matrix(Matrix M){
	int i,j;
	for(i=0;i<3;i++){
		for(j=0;j<3;j++){
			cout << M.e[i][j] << " ";
		};
		cout << "\n";
	};
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r13d, %r13d
movq 0xc7ab(%rip), %r14      # 0xefd0
leaq 0x8e74(%rip), %r15      # 0xb6a0
leaq (,%r13,2), %rbp
addq %r13, %rbp
xorl %r12d, %r12d
movq (%rbx), %rax
movq (%rax,%rbp,8), %rax
movsd (%rax,%r12,8), %xmm0
movq %r14, %rdi
callq 0x2330
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x2220
incq %r12
cmpq $0x3, %r12
jne 0x283a
movl $0x1, %edx
movq %r14, %rdi
leaq 0x8e92(%rip), %rsi      # 0xb709
callq 0x2220
incq %r13
cmpq $0x3, %r13
jne 0x282c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/dannycalegari[P]circle_pack/./Trigonometry_routine.cc
// Function: hyp_ang(Point)
double hyp_ang(Point P){	// hyperbolic angle from origin; also works as Euclidean angle
	double d;
	d=hyp_dist(P);
	if(d==0.0){
		return(0.0);
	};
	return(atan2(P.y,P.x));
}

// Assembly:
pushq %rax
movsd 0x20(%rsp), %xmm0
movsd 0x7697(%rip), %xmm1     # 0xb010
ucomisd %xmm0, %xmm1
ja 0x3990
callq 0x23a0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x3996
jp 0x3996
xorpd %xmm0, %xmm0
popq %rax
retq
leaq 0x10(%rsp), %rax
movsd (%rax), %xmm1
movsd 0x8(%rax), %xmm0
popq %rax
jmp 0x2040
// File: /workspace/github_cpp_makefile_star2_O1/dannycalegari[P]circle_pack/./Trigonometry_routine.cc
// Function: Euc_ang(Point)
double Euc_ang(Point P){
	Point Q;
	Q=P;
	Q.z=0.0;
	if(norm(Q)==0.0){
		return(0.0);
	};
	return(atan2(P.y,P.x));
}

// Assembly:
subq $0x18, %rsp
movsd 0x20(%rsp), %xmm1
movsd 0x28(%rsp), %xmm3
movapd %xmm3, %xmm2
mulsd %xmm3, %xmm2
movapd %xmm1, %xmm0
mulsd %xmm1, %xmm0
addsd %xmm2, %xmm0
xorpd %xmm2, %xmm2
ucomisd %xmm2, %xmm0
jb 0x39de
sqrtsd %xmm0, %xmm0
jmp 0x39ff
movsd %xmm1, 0x10(%rsp)
movsd %xmm3, 0x8(%rsp)
callq 0x2170
xorpd %xmm2, %xmm2
movsd 0x8(%rsp), %xmm3
movsd 0x10(%rsp), %xmm1
ucomisd %xmm2, %xmm0
jne 0x3a10
jp 0x3a10
xorpd %xmm0, %xmm0
addq $0x18, %rsp
retq
movapd %xmm3, %xmm0
addq $0x18, %rsp
jmp 0x2040
// File: /workspace/github_cpp_makefile_star2_O1/dannycalegari[P]circle_pack/./Trigonometry_routine.cc
// Function: hyperboloid_to_Poincare(Point)
Point hyperboloid_to_Poincare(Point P){	// change coordinates from hyperboloid to Poincare model
	// this can be used to change geometry from hyperbolic to Euclidean
	Point Q;
	Q.x=P.x/(P.z+1.0);
	Q.y=P.y/(P.z+1.0);
	Q.z=1.0;
	return(Q);
}

// Assembly:
movq %rdi, %rax
movsd 0x8(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
addsd 0x7508(%rip), %xmm1     # 0xb010
divsd %xmm1, %xmm0
movsd %xmm0, (%rdi)
movsd 0x10(%rsp), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rdi)
movabsq $0x3ff0000000000000, %rcx # imm = 0x3FF0000000000000
movq %rcx, 0x10(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/dannycalegari[P]circle_pack/./Trigonometry_routine.cc
// Function: Euclidean_to_sphere(Point)
Point Euclidean_to_sphere(Point Q){
	Point R;
	R.x=2.0*Q.x/(1.0+Q.x*Q.x+Q.y*Q.y);
	R.y=2.0*Q.y/(1.0+Q.x*Q.x+Q.y*Q.y);
	R.z=(1.0-Q.x*Q.x-Q.y*Q.y)/(1.0+Q.x*Q.x+Q.y*Q.y);
	return(R);
}

// Assembly:
movq %rdi, %rax
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
movapd %xmm0, %xmm2
addsd %xmm0, %xmm2
mulsd %xmm0, %xmm0
movsd 0x74bf(%rip), %xmm3     # 0xb010
movapd %xmm0, %xmm4
addsd %xmm3, %xmm4
movapd %xmm1, %xmm5
mulsd %xmm1, %xmm5
addsd %xmm5, %xmm4
divsd %xmm4, %xmm2
movsd %xmm2, (%rdi)
addsd %xmm1, %xmm1
divsd %xmm4, %xmm1
movsd %xmm1, 0x8(%rdi)
subsd %xmm0, %xmm3
subsd %xmm5, %xmm3
divsd %xmm4, %xmm3
movsd %xmm3, 0x10(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/dannycalegari[P]circle_pack/./Trigonometry_routine.cc
// Function: hyperboloid_to_sphere(Point)
Point hyperboloid_to_sphere(Point P){
	Point Q,R;
	Q=hyperboloid_to_Poincare(P);
//	R.x=2.0*Q.x/(1.0+Q.x*Q.x+Q.y*Q.y);
//	R.y=2.0*Q.y/(1.0+Q.x*Q.x+Q.y*Q.y);
//	R.z=(1.0-Q.x*Q.x-Q.y*Q.y)/(1.0+Q.x*Q.x+Q.y*Q.y);
	R=Euclidean_to_sphere(Q);
	return(R);
}

// Assembly:
movq %rdi, %rax
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
movsd 0x746d(%rip), %xmm2     # 0xb010
movsd 0x18(%rsp), %xmm3
addsd %xmm2, %xmm3
divsd %xmm3, %xmm0
divsd %xmm3, %xmm1
movapd %xmm0, %xmm3
addsd %xmm0, %xmm3
mulsd %xmm0, %xmm0
movapd %xmm0, %xmm4
addsd %xmm2, %xmm4
movapd %xmm1, %xmm5
mulsd %xmm1, %xmm5
addsd %xmm5, %xmm4
divsd %xmm4, %xmm3
addsd %xmm1, %xmm1
divsd %xmm4, %xmm1
subsd %xmm0, %xmm2
subsd %xmm5, %xmm2
divsd %xmm4, %xmm2
movsd %xmm3, (%rdi)
movsd %xmm1, 0x8(%rdi)
movsd %xmm2, 0x10(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/dannycalegari[P]circle_pack/./Packing.cc
// Function: Packing::which_edge(int, int)
int Packing::which_edge(int i, int j){	// returns e if adj[i][e]=j and returns -1 if there is no e.
	int e;
	bool found_yet;
	found_yet=false;
	for(e=0;e<(int) adj[i].size();e++){
		if(adj[i][e]==j){
			found_yet=true;
			return(e);
		};
	};
	if(found_yet==false){
		return(-1);
	};
	return(-1);
}

// Assembly:
movslq %esi, %rax
movq (%rdi), %rsi
leaq (%rax,%rax,2), %rax
movq (%rsi,%rax,8), %rcx
movq 0x8(%rsi,%rax,8), %rsi
subq %rcx, %rsi
shrq $0x2, %rsi
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %esi, %esi
jle 0x3c34
andl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
xorl %edi, %edi
cmpl %edx, (%rcx,%rdi,4)
je 0x3c35
incq %rdi
cmpq %rdi, %rsi
jne 0x3c27
retq
movl %edi, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/dannycalegari[P]circle_pack/./Packing.cc
// Function: Packing::determine_inner_vertices()
void Packing::determine_inner_vertices(){
	int i;
	inner.clear();
	for(i=1;i<(int) adj.size();i++){
		if(which_edge(i,INFV)==-1){
			inner.push_back(i);
		};
	};
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x48(%rdi), %rax
cmpq %rax, 0x50(%rdi)
je 0x3c52
movq %rax, 0x50(%rbx)
movl $0x1, 0xc(%rsp)
movq (%rbx), %rcx
movq 0x8(%rbx), %rax
subq %rcx, %rax
shrq $0x3, %rax
imull $0xaaaaaaab, %eax, %eax # imm = 0xAAAAAAAB
cmpl $0x2, %eax
jl 0x3cfe
leaq 0x48(%rbx), %r14
movl $0x1, %eax
leaq 0xc(%rsp), %r15
movslq %eax, %rdx
leaq (%rdx,%rdx,2), %rsi
movq (%rcx,%rsi,8), %rdx
movq 0x8(%rcx,%rsi,8), %rcx
subq %rdx, %rcx
shrq $0x2, %rcx
testl %ecx, %ecx
jle 0x3cbb
movl 0xbc(%rbx), %esi
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
xorl %edi, %edi
cmpl %esi, (%rdx,%rdi,4)
je 0x3cdc
incq %rdi
cmpq %rdi, %rcx
jne 0x3cae
movq 0x50(%rbx), %rsi
cmpq 0x58(%rbx), %rsi
je 0x3cd1
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x50(%rbx)
jmp 0x3cdc
movq %r14, %rdi
movq %r15, %rdx
callq 0x9c56
movl 0xc(%rsp), %eax
incl %eax
movl %eax, 0xc(%rsp)
movq (%rbx), %rcx
movq 0x8(%rbx), %rdx
subq %rcx, %rdx
shrq $0x3, %rdx
imull $0xaaaaaaab, %edx, %edx # imm = 0xAAAAAAAB
cmpl %edx, %eax
jl 0x3c85
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/dannycalegari[P]circle_pack/./Packing.cc
// Function: Packing::determine_labels()
void Packing::determine_labels(){
	int i;
	lab.clear();
	lab.push_back(0.0);
	for(i=0;i<(int) adj.size();i++){
		lab.push_back(exp(-2.0*rad[i]));
	};
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x30(%rdi), %rax
cmpq %rax, 0x38(%rdi)
je 0x3d21
movq %rax, 0x38(%rbx)
leaq 0x30(%rbx), %r14
movq $0x0, (%rsp)
movq 0x38(%rbx), %rsi
cmpq 0x40(%rbx), %rsi
je 0x3d48
movq $0x0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x38(%rbx)
jmp 0x3d53
movq %rsp, %rdx
movq %r14, %rdi
callq 0x982a
movq 0x8(%rbx), %rax
subq (%rbx), %rax
shrq $0x3, %rax
imull $0xaaaaaaab, %eax, %eax # imm = 0xAAAAAAAB
testl %eax, %eax
jle 0x3dc8
xorl %r12d, %r12d
movq %rsp, %r15
movq 0x18(%rbx), %rax
movsd (%rax,%r12,8), %xmm0
mulsd 0x7298(%rip), %xmm0     # 0xb018
callq 0x23c0
movsd %xmm0, (%rsp)
movq 0x38(%rbx), %rsi
cmpq 0x40(%rbx), %rsi
je 0x3da2
movsd %xmm0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x38(%rbx)
jmp 0x3dad
movq %r14, %rdi
movq %r15, %rdx
callq 0x982a
incq %r12
movq 0x8(%rbx), %rax
subq (%rbx), %rax
shrq $0x3, %rax
imull $0xaaaaaaab, %eax, %eax # imm = 0xAAAAAAAB
cltq
cmpq %rax, %r12
jl 0x3d6e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/dannycalegari[P]circle_pack/./Packing.cc
// Function: angle_at_C(double, double, double, char)
double angle_at_C(double a, double b, double c, char geometry){	
	// in a triangle with side lengths a,b,c, what is the angle at C (i.e. opposite c)?
	double t,u;
	if(geometry=='E'){	// Euclidean geometry
		// Euclidean cosine rule: c*c = a*a + b*b - 2*a*b*cos(C)
		// so C = acos((a*a + b*b - c*c)/(2*a*b));
		t=(a*a+b*b-c*c)/(2.0*a*b);
		return(acos(t));
	} else if(geometry=='S'){	// Spherical geometry
		// Spherical cosine rule: cos(c) = cos(a)*cos(b)+sin(a)*sin(b)*cos(C)
		// so C=acos((cos(c)-cos(a)*cos(b))/(sin(a)*sin(b)))
		u=sin(a)*sin(b);
		t=(cos(c)-(cos(a)*cos(b)))/u;
		return(acos(t));
	} else if(geometry=='H'){	// Hyperbolic geometry
		// Hyperbolic cosine rule: cosh(c) = cosh(a)*cosh(b)-sinh(a)*sinh(b)*cos(C)
		// so C=acos((cosh(c)-cosh(a)*cosh(b))/(sinh(a)*sinh(b)))
		u=-sinh(a)*sinh(b);
		t=(cosh(c)-(cosh(a)*cosh(b)))/u;
		return(acos(t));
	};
	return(0.0);
}

// Assembly:
subq $0x38, %rsp
cmpl $0x53, %edi
je 0x418d
cmpl $0x48, %edi
je 0x4124
cmpl $0x45, %edi
jne 0x4211
movapd %xmm1, %xmm4
mulsd %xmm1, %xmm4
movapd %xmm0, %xmm3
mulsd %xmm0, %xmm3
addsd %xmm4, %xmm3
mulsd %xmm2, %xmm2
subsd %xmm2, %xmm3
addsd %xmm0, %xmm0
mulsd %xmm1, %xmm0
divsd %xmm0, %xmm3
jmp 0x4204
movsd %xmm1, 0x18(%rsp)
movsd %xmm0, 0x10(%rsp)
movsd %xmm2, 0x8(%rsp)
callq 0x21b0
xorps 0x6f7e(%rip), %xmm0     # 0xb0c0
movaps %xmm0, 0x20(%rsp)
movsd 0x18(%rsp), %xmm0
callq 0x21b0
mulsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x2290
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x2290
movsd %xmm0, 0x10(%rsp)
movsd 0x18(%rsp), %xmm0
callq 0x2290
jmp 0x41ee
movsd %xmm1, 0x18(%rsp)
movsd %xmm0, 0x10(%rsp)
movsd %xmm2, 0x8(%rsp)
callq 0x2060
movsd %xmm0, 0x20(%rsp)
movsd 0x18(%rsp), %xmm0
callq 0x2060
mulsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x23d0
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x23d0
movsd %xmm0, 0x10(%rsp)
movsd 0x18(%rsp), %xmm0
callq 0x23d0
movsd 0x8(%rsp), %xmm3
mulsd 0x10(%rsp), %xmm0
subsd %xmm0, %xmm3
divsd 0x20(%rsp), %xmm3
movapd %xmm3, %xmm0
addq $0x38, %rsp
jmp 0x21c0
xorps %xmm0, %xmm0
addq $0x38, %rsp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/dannycalegari[P]circle_pack/./Packing.cc
// Function: Packing::wedge(int, int)
double Packing::wedge(int i,int e){	// angle at vertex i between edge e and e+1
	int j,k;	// i -e-> j, i -(e+1)-> k
	j=adj[i][e];
	k=adj[i][(e+1)%adj[i].size()];	
	return(angle_at_C(rad[i]+rad[j],rad[i]+rad[k],rad[j]+rad[k],geometry));
}

// Assembly:
movslq %esi, %rcx
leaq (%rcx,%rcx,2), %rax
movslq %edx, %rdx
movq (%rdi), %rsi
movq 0x18(%rdi), %r8
movq (%rsi,%rax,8), %r9
movq 0x8(%rsi,%rax,8), %rsi
movslq (%r9,%rdx,4), %r10
incl %edx
movslq %edx, %rax
subq %r9, %rsi
sarq $0x2, %rsi
xorl %edx, %edx
divq %rsi
movslq (%r9,%rdx,4), %rax
movsd (%r8,%rcx,8), %xmm1
movsd (%r8,%r10,8), %xmm2
movapd %xmm1, %xmm0
addsd %xmm2, %xmm0
movsd (%r8,%rax,8), %xmm3
addsd %xmm3, %xmm1
addsd %xmm3, %xmm2
movsbl 0x60(%rdi), %edi
jmp 0x40dc
// File: /workspace/github_cpp_makefile_star2_O1/dannycalegari[P]circle_pack/./Packing.cc
// Function: Packing::hyperbolic_wedge(int, int)
double Packing::hyperbolic_wedge(int i,int e){	// angle at vertex i between e and e+1; computed via labels
	int j,k;	// i -e-> j, i -(e+1)-> k
	j=adj[i][e];
	k=adj[i][(e+1)%adj[i].size()];	
	double v,u,w;
	v=lab[i];
	u=lab[j];
	w=lab[k];
	return(2.0*asin(sqrt(v*(1.0-u)*(1.0-w)/((1.0-v*u)*(1.0-v*w)))));
}

// Assembly:
pushq %rax
movslq %esi, %rcx
leaq (%rcx,%rcx,2), %rax
movslq %edx, %rdx
movq (%rdi), %rsi
movq 0x30(%rdi), %rdi
movq (%rsi,%rax,8), %r8
movq 0x8(%rsi,%rax,8), %rsi
movslq (%r8,%rdx,4), %r9
incl %edx
movslq %edx, %rax
subq %r8, %rsi
sarq $0x2, %rsi
xorl %edx, %edx
divq %rsi
movslq (%r8,%rdx,4), %rax
movsd (%rdi,%rcx,8), %xmm1
movsd (%rdi,%r9,8), %xmm2
movsd (%rdi,%rax,8), %xmm3
movsd 0x6d4c(%rip), %xmm4     # 0xb010
movapd %xmm4, %xmm5
subsd %xmm2, %xmm5
mulsd %xmm1, %xmm5
movapd %xmm4, %xmm0
subsd %xmm3, %xmm0
mulsd %xmm5, %xmm0
mulsd %xmm1, %xmm2
movapd %xmm4, %xmm5
subsd %xmm2, %xmm5
mulsd %xmm3, %xmm1
subsd %xmm1, %xmm4
mulsd %xmm5, %xmm4
divsd %xmm4, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x4308
sqrtsd %xmm0, %xmm0
jmp 0x430d
callq 0x2170
callq 0x2370
addsd %xmm0, %xmm0
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O1/dannycalegari[P]circle_pack/./Packing.cc
// Function: Packing::angle(int)
double Packing::angle(int i){	// angle at vertex i; for correct packing, this should be 2pi
	int e;
	double angle;
	angle=0.0;	// initialize
	for(e=0;e<(int) adj[i].size();e++){
		if(geometry=='E' || geometry=='S'){
			angle=angle+wedge(i,e);
		} else {
			angle=angle+hyperbolic_wedge(i,e);
		};
	};
	return(angle);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movslq %esi, %rax
movq (%rdi), %rcx
leaq (%rax,%rax,2), %r15
movq 0x8(%rcx,%r15,8), %rax
subq (%rcx,%r15,8), %rax
shrq $0x2, %rax
testl %eax, %eax
jle 0x4398
movl %esi, %ebx
movq %rdi, %r14
xorl %ebp, %ebp
xorpd %xmm0, %xmm0
movsd %xmm0, (%rsp)
movzbl 0x60(%r14), %eax
cmpl $0x53, %eax
je 0x4359
cmpl $0x45, %eax
jne 0x4367
movq %r14, %rdi
movl %ebx, %esi
movl %ebp, %edx
callq 0x421a
jmp 0x4373
movq %r14, %rdi
movl %ebx, %esi
movl %ebp, %edx
callq 0x4278
movsd (%rsp), %xmm1
addsd %xmm0, %xmm1
movapd %xmm1, %xmm0
incl %ebp
movq (%r14), %rax
movq 0x8(%rax,%r15,8), %rcx
subq (%rax,%r15,8), %rcx
shrq $0x2, %rcx
cmpl %ecx, %ebp
jl 0x4345
jmp 0x439c
xorpd %xmm0, %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/dannycalegari[P]circle_pack/./Packing.cc
// Function: Packing::hyperbolic_correct_radius(int)
void Packing::hyperbolic_correct_radius(int j){	// determines "label of best fit" given angle and valence
	double beta, delta;
	double dk;
	double vhat;
	double t,u;
	double v;
	dk = (double) adj[j].size();
	beta=sin(angle(j)/(2.0*dk));
	delta=sin(TWOPI/(2.0*dk));
	v=lab[j];
	vhat=(beta-sqrt(v))/((beta*v)-sqrt(v));
	if(vhat<0){
		vhat=0.0;
	};
	t=2.0*delta/(sqrt((1.0-vhat)*(1.0-vhat)+4.0*delta*delta*vhat) + (1.0-vhat));
	u=t*t;
	lab[j]=u;	// determine new label
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %r14
movslq %esi, %rbx
movq (%rdi), %rax
leaq (%rbx,%rbx,2), %rcx
movq 0x8(%rax,%rcx,8), %rdx
subq (%rax,%rcx,8), %rdx
sarq $0x2, %rdx
movq %rdx, %xmm0
punpckldq 0x6bdc(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x6be4(%rip), %xmm0     # 0xb100
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movapd %xmm1, 0x10(%rsp)
movl %ebx, %esi
callq 0x4318
movapd 0x10(%rsp), %xmm1
addsd %xmm1, %xmm1
movapd %xmm1, 0x10(%rsp)
divsd %xmm1, %xmm0
callq 0x2060
movsd %xmm0, 0x8(%rsp)
movsd 0x6acc(%rip), %xmm0     # 0xb028
divsd 0x10(%rsp), %xmm0
callq 0x2060
movsd %xmm0, 0x10(%rsp)
movq 0x30(%r14), %rax
movsd (%rax,%rbx,8), %xmm1
sqrtsd %xmm1, %xmm2
xorpd %xmm4, %xmm4
ucomisd %xmm4, %xmm1
movapd %xmm2, %xmm0
movsd %xmm1, 0x30(%rsp)
jae 0x45ad
movapd %xmm1, %xmm0
movsd %xmm2, 0x28(%rsp)
callq 0x2170
xorpd %xmm4, %xmm4
movsd 0x28(%rsp), %xmm2
movsd 0x30(%rsp), %xmm1
movsd 0x8(%rsp), %xmm3
subsd %xmm0, %xmm3
ucomisd %xmm4, %xmm1
jae 0x45dc
movapd %xmm1, %xmm0
movsd %xmm3, 0x28(%rsp)
callq 0x2170
movsd 0x28(%rsp), %xmm3
movsd 0x30(%rsp), %xmm1
movapd %xmm0, %xmm2
movsd 0x8(%rsp), %xmm0
mulsd %xmm1, %xmm0
subsd %xmm2, %xmm0
divsd %xmm0, %xmm3
xorpd %xmm1, %xmm1
xorpd %xmm0, %xmm0
maxsd %xmm3, %xmm0
movsd 0x10(%rsp), %xmm3
movapd %xmm3, %xmm4
addsd %xmm3, %xmm4
movsd 0x6a00(%rip), %xmm5     # 0xb010
subsd %xmm0, %xmm5
movsd 0x6a14(%rip), %xmm2     # 0xb030
mulsd %xmm3, %xmm2
mulsd %xmm3, %xmm2
mulsd %xmm0, %xmm2
movapd %xmm5, %xmm0
mulsd %xmm5, %xmm0
addsd %xmm2, %xmm0
ucomisd %xmm1, %xmm0
jb 0x4640
sqrtsd %xmm0, %xmm0
jmp 0x465d
movsd %xmm4, 0x10(%rsp)
movsd %xmm5, 0x8(%rsp)
callq 0x2170
movsd 0x8(%rsp), %xmm5
movsd 0x10(%rsp), %xmm4
addsd %xmm5, %xmm0
divsd %xmm0, %xmm4
mulsd %xmm4, %xmm4
movq 0x30(%r14), %rax
movsd %xmm4, (%rax,%rbx,8)
addq $0x38, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/dannycalegari[P]circle_pack/./Packing.cc
// Function: Packing::Euclidean_correct_radius(int)
void Packing::Euclidean_correct_radius(int j){	// determines "radius of best fit" given angle and valence
	double beta, delta;
	double dk;
	double vhat;
	dk = (double) adj[j].size();
	beta=sin(angle(j)/(2.0*dk));
	delta=sin(TWOPI/(2.0*dk));	
	vhat=rad[j]*beta/(1.0-beta);
	rad[j]=vhat*(1.0-delta)/delta;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
movslq %esi, %rbx
movq (%rdi), %rax
leaq (%rbx,%rbx,2), %rcx
movq 0x8(%rax,%rcx,8), %rdx
subq (%rax,%rcx,8), %rdx
sarq $0x2, %rdx
movq %rdx, %xmm0
punpckldq 0x6a48(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x6a50(%rip), %xmm0     # 0xb100
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movapd %xmm1, (%rsp)
movl %ebx, %esi
callq 0x4318
movapd (%rsp), %xmm1
addsd %xmm1, %xmm1
movapd %xmm1, (%rsp)
divsd %xmm1, %xmm0
callq 0x2060
movsd %xmm0, 0x10(%rsp)
movsd 0x693b(%rip), %xmm0     # 0xb028
divsd (%rsp), %xmm0
callq 0x2060
movq 0x18(%r14), %rax
movsd (%rax,%rbx,8), %xmm1
movsd 0x10(%rsp), %xmm4
mulsd %xmm4, %xmm1
movsd 0x68fe(%rip), %xmm2     # 0xb010
movapd %xmm2, %xmm3
subsd %xmm4, %xmm3
divsd %xmm3, %xmm1
subsd %xmm0, %xmm2
mulsd %xmm1, %xmm2
divsd %xmm0, %xmm2
movsd %xmm2, (%rax,%rbx,8)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/dannycalegari[P]circle_pack/./Packing.cc
// Function: Packing::write_radii()
void Packing::write_radii(){
	cout << "geometry is " << geometry << "\n";
	int i;
	if(geometry=='H'){
		cout << "circle " << 0 << " is the ideal circle \n";
		for(i=0;i<(int) adj.size();i++){
			if(i==INFV){
				cout << "circle " << INFV << " is the ideal circle \n";
			} else {
				cout << "circle " << i << " has radius " << rad[i] << "\n";
			};
		};
	} else {
		for(i=0;i<(int) adj.size();i++){
			cout << "circle " << i << " has radius " << rad[i] << "\n";
		};	
	};
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xa407(%rip), %r14      # 0xefd0
leaq 0x6d9d(%rip), %rsi      # 0xb96d
movl $0xc, %edx
movq %r14, %rdi
callq 0x2220
movb 0x60(%rbx), %al
leaq 0x7(%rsp), %rsi
movb %al, (%rsi)
movl $0x1, %edx
movq %r14, %rdi
callq 0x2220
leaq 0x6b0e(%rip), %rsi      # 0xb709
movl $0x1, %edx
movq %rax, %rdi
callq 0x2220
cmpb $0x48, 0x60(%rbx)
jne 0x4d1e
movq 0xa3b7(%rip), %r14      # 0xefd0
leaq 0x6660(%rip), %rsi      # 0xb280
movl $0x7, %edx
movq %r14, %rdi
callq 0x2220
movq %r14, %rdi
xorl %esi, %esi
callq 0x2390
leaq 0x664a(%rip), %rsi      # 0xb288
movl $0x16, %edx
movq %rax, %rdi
callq 0x2220
movq 0x8(%rbx), %rax
subq (%rbx), %rax
shrq $0x3, %rax
imull $0xaaaaaaab, %eax, %eax # imm = 0xAAAAAAAB
testl %eax, %eax
jle 0x4dbe
xorl %r14d, %r14d
movq 0xa362(%rip), %r15      # 0xefd0
leaq 0x660b(%rip), %r12      # 0xb280
leaq 0x6a8d(%rip), %r13      # 0xb709
movl 0xbc(%rbx), %ebp
movl $0x7, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x2220
cmpq %rbp, %r14
jne 0x4cb6
movl 0xbc(%rbx), %esi
movq %r15, %rdi
callq 0x2390
movl $0x16, %edx
movq %rax, %rdi
leaq 0x65d4(%rip), %rsi      # 0xb288
jmp 0x4cf5
movq %r15, %rdi
movl %r14d, %esi
callq 0x2390
movq %rax, %rbp
movl $0xc, %edx
movq %rax, %rdi
leaq 0x65cc(%rip), %rsi      # 0xb29f
callq 0x2220
movq 0x18(%rbx), %rax
movsd (%rax,%r14,8), %xmm0
movq %rbp, %rdi
callq 0x2330
movl $0x1, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x2220
incq %r14
movq 0x8(%rbx), %rax
subq (%rbx), %rax
shrq $0x3, %rax
imull $0xaaaaaaab, %eax, %eax # imm = 0xAAAAAAAB
cltq
cmpq %rax, %r14
jl 0x4c7c
jmp 0x4dbe
movq 0x8(%rbx), %rax
subq (%rbx), %rax
shrq $0x3, %rax
imull $0xaaaaaaab, %eax, %eax # imm = 0xAAAAAAAB
testl %eax, %eax
jle 0x4dbe
xorl %r14d, %r14d
movq 0xa28f(%rip), %r15      # 0xefd0
leaq 0x6557(%rip), %r13      # 0xb29f
leaq 0x69ba(%rip), %rbp      # 0xb709
movl $0x7, %edx
movq %r15, %rdi
leaq 0x6522(%rip), %rsi      # 0xb280
callq 0x2220
movq %r15, %rdi
movl %r14d, %esi
callq 0x2390
movq %rax, %r12
movl $0xc, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x2220
movq 0x18(%rbx), %rax
movsd (%rax,%r14,8), %xmm0
movq %r12, %rdi
callq 0x2330
movl $0x1, %edx
movq %rax, %rdi
movq %rbp, %rsi
callq 0x2220
incq %r14
movq 0x8(%rbx), %rax
subq (%rbx), %rax
shrq $0x3, %rax
imull $0xaaaaaaab, %eax, %eax # imm = 0xAAAAAAAB
cltq
cmpq %rax, %r14
jl 0x4d4f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/dannycalegari[P]circle_pack/./Layout_routine.cc
// Function: Packing::write_distances_to_vertex_INFV()
void Packing::write_distances_to_vertex_INFV(){
	int i;
	for(i=0;i<(int) adj.size();i++){
		cout << "vertex " << i << " is distance " << dist[i] << " to vertex " << INFV << " (i.e. to vertex INFV).\n";
	};
	cout << "maximum distance is " << maximum_distance << "\n";
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rax
subq (%rdi), %rax
shrq $0x3, %rax
imull $0xaaaaaaab, %eax, %eax # imm = 0xAAAAAAAB
testl %eax, %eax
jle 0x5244
xorl %r14d, %r14d
movq 0x9e33(%rip), %r15      # 0xefd0
leaq 0x6138(%rip), %rbp      # 0xb2dc
leaq 0x613d(%rip), %r12      # 0xb2e8
movl $0x7, %edx
movq %r15, %rdi
leaq 0x6126(%rip), %rsi      # 0xb2e0
callq 0x2220
movq %r15, %rdi
movl %r14d, %esi
callq 0x2390
movq %rax, %r13
movl $0xd, %edx
movq %rax, %rdi
leaq 0x60f2(%rip), %rsi      # 0xb2ce
callq 0x2220
movq 0x80(%rbx), %rax
movl (%rax,%r14,4), %esi
movq %r13, %rdi
callq 0x2390
movq %rax, %r13
movl $0xb, %edx
movq %rax, %rdi
movq %rbp, %rsi
callq 0x2220
movl 0xbc(%rbx), %esi
movq %r13, %rdi
callq 0x2390
movl $0x18, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x2220
incq %r14
movq 0x8(%rbx), %rax
subq (%rbx), %rax
shrq $0x3, %rax
imull $0xaaaaaaab, %eax, %eax # imm = 0xAAAAAAAB
cltq
cmpq %rax, %r14
jl 0x51ab
movq 0x9d85(%rip), %r14      # 0xefd0
leaq 0x60af(%rip), %rsi      # 0xb301
movl $0x14, %edx
movq %r14, %rdi
callq 0x2220
movl 0x98(%rbx), %esi
movq %r14, %rdi
callq 0x2390
leaq 0x6495(%rip), %rsi      # 0xb709
movl $0x1, %edx
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2220
nop
// File: /workspace/github_cpp_makefile_star2_O1/dannycalegari[P]circle_pack/./Layout_routine.cc
// Function: Packing::already_laid_out(int)
bool Packing::already_laid_out(int i){
	int j;
	bool found_index;
	found_index=false;
	for(j=0;j<(int) lay.size();j++){
		if(lay[j][0]==i){	// did we lay it out?
			found_index=true;
		};
	};
	return(found_index);
}

// Assembly:
movq 0x68(%rdi), %rcx
movq 0x70(%rdi), %rax
subq %rcx, %rax
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rdx
testl %edx, %edx
jle 0x52d5
andl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
xorl %eax, %eax
movl $0x1, %edi
movq (%rcx), %r8
cmpl %esi, (%r8)
movzbl %al, %eax
cmovel %edi, %eax
addq $0x18, %rcx
decq %rdx
jne 0x52be
jmp 0x52d7
xorl %eax, %eax
andb $0x1, %al
retq
// File: /workspace/github_cpp_makefile_star2_O1/dannycalegari[P]circle_pack/./Layout_routine.cc
// Function: Packing::initialize_centers()
void Packing::initialize_centers(){
	if(verbose){
		cout << "initializing centers to 0.\n";
	};
	Point P;
	int i;
	P.x=0.0;
	P.y=0.0;
	P.z=1.0;
	for(i=0;i<(int) adj.size();i++){
		center.push_back(P);	// initialize center to origin
	};
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
cmpb $0x1, 0xb8(%rdi)
jne 0x5eda
movq 0x9107(%rip), %rdi      # 0xefd0
leaq 0x5494(%rip), %rsi      # 0xb364
movl $0x1b, %edx
callq 0x2220
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, 0x10(%rsp)
movq 0x8(%rbx), %rax
subq (%rbx), %rax
shrq $0x3, %rax
imull $0xaaaaaaab, %eax, %eax # imm = 0xAAAAAAAB
testl %eax, %eax
jle 0x5f5d
leaq 0xa0(%rbx), %r14
xorl %ebp, %ebp
movq %rsp, %r15
movq 0xa8(%rbx), %rsi
cmpq 0xb0(%rbx), %rsi
je 0x5f3b
movq 0x10(%rsp), %rax
movq %rax, 0x10(%rsi)
movaps (%rsp), %xmm0
movups %xmm0, (%rsi)
addq $0x18, 0xa8(%rbx)
jmp 0x5f46
movq %r14, %rdi
movq %r15, %rdx
callq 0xa13c
movq 0x8(%rbx), %rax
subq (%rbx), %rax
incl %ebp
shrq $0x3, %rax
imull $0xaaaaaaab, %eax, %eax # imm = 0xAAAAAAAB
cmpl %eax, %ebp
jl 0x5f11
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/dannycalegari[P]circle_pack/./Layout_routine.cc
// Function: Packing::write_centers()
void Packing::write_centers(){
	cout << "geometry is " << geometry << "\n";
	int i;
	for(i=0;i<(int) adj.size();i++){
		if(i==INFV){
			cout << "INFV ";
		};
		cout << "vertex " << i << " has center " << center[i].x << " " << center[i].y << " " << center[i].z << "\n";
	};
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8e1d(%rip), %r14      # 0xefd0
leaq 0x57b3(%rip), %rsi      # 0xb96d
movl $0xc, %edx
movq %r14, %rdi
callq 0x2220
movb 0x60(%rbx), %al
leaq 0x7(%rsp), %rsi
movb %al, (%rsi)
movl $0x1, %edx
movq %r14, %rdi
callq 0x2220
leaq 0x5524(%rip), %rsi      # 0xb709
movl $0x1, %edx
movq %rax, %rdi
callq 0x2220
movq 0x8(%rbx), %rax
subq (%rbx), %rax
shrq $0x3, %rax
imull $0xaaaaaaab, %eax, %eax # imm = 0xAAAAAAAB
testl %eax, %eax
jle 0x6312
xorl %r15d, %r15d
movq 0x8dbb(%rip), %r14      # 0xefd0
leaq 0x5484(%rip), %rbp      # 0xb6a0
xorl %r12d, %r12d
movl 0xbc(%rbx), %eax
cmpq %rax, %r12
jne 0x623e
movl $0x5, %edx
movq %r14, %rdi
leaq 0x515d(%rip), %rsi      # 0xb396
callq 0x2220
movl $0x7, %edx
movq %r14, %rdi
leaq 0x5093(%rip), %rsi      # 0xb2e0
callq 0x2220
movq %r14, %rdi
movl %r12d, %esi
callq 0x2390
movq %rax, %r13
movl $0xc, %edx
movq %rax, %rdi
leaq 0x512d(%rip), %rsi      # 0xb39c
callq 0x2220
movq 0xa0(%rbx), %rax
movsd (%rax,%r15), %xmm0
movq %r13, %rdi
callq 0x2330
movq %rax, %r13
movl $0x1, %edx
movq %rax, %rdi
movq %rbp, %rsi
callq 0x2220
movq 0xa0(%rbx), %rax
movsd 0x8(%rax,%r15), %xmm0
movq %r13, %rdi
callq 0x2330
movq %rax, %r13
movl $0x1, %edx
movq %rax, %rdi
movq %rbp, %rsi
callq 0x2220
movq 0xa0(%rbx), %rax
movsd 0x10(%rax,%r15), %xmm0
movq %r13, %rdi
callq 0x2330
movl $0x1, %edx
movq %rax, %rdi
leaq 0x541f(%rip), %rsi      # 0xb709
callq 0x2220
incq %r12
movq 0x8(%rbx), %rax
subq (%rbx), %rax
shrq $0x3, %rax
imull $0xaaaaaaab, %eax, %eax # imm = 0xAAAAAAAB
cltq
addq $0x18, %r15
cmpq %rax, %r12
jl 0x621f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop