LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: sharmaeklavya2[P]ddos-on-anycast/src/lib/place_victims.cpp
// Function: make_network_dag(Network const&, Graph&)
void make_network_dag(const Network& network, Graph& graph2) {
    Graph graph(network.size());
    for(int d=network.height(); d>=0; --d) {
        for(int v: network.depthwise[d]) {
            int u = network.nid[v];
            if(u < 0 || network.depth[u] != d) {
                if(d > 0) {
                    for(int u: network.up_nbrs[v]) {
                        graph.add_edge(u, v);
                    }
                }
            }
            else {
                graph.add_edge(u, v);
            }
        }
    }
    graph2.swap(graph);
}

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq 0xa0(%rsp), %rdi
callq 0x4950
movl %eax, %esi
leaq 0x60(%rsp), %rdi
callq 0x1a0c0
movq 0xa0(%rsp), %rdi
callq 0x4f20
movl %eax, 0x8(%rsp)
jmp 0x17bf3
movl 0x8(%rsp), %eax
movl %eax, 0x5c(%rsp)
cmpl $0x0, 0x5c(%rsp)
jl 0x17d8d
movq 0xa0(%rsp), %rdi
addq $0xa8, %rdi
movslq 0x5c(%rsp), %rsi
callq 0x4a60
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rdi
callq 0x4880
movq %rax, 0x38(%rsp)
movq 0x40(%rsp), %rdi
callq 0x48b0
movq %rax, 0x30(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x48e0
testb $0x1, %al
jne 0x17c5a
jmp 0x17d7b
leaq 0x38(%rsp), %rdi
callq 0x4920
movl (%rax), %eax
movl %eax, 0x2c(%rsp)
movq 0xa0(%rsp), %rdi
movslq 0x2c(%rsp), %rsi
callq 0x4970
movl (%rax), %eax
movl %eax, 0x28(%rsp)
cmpl $0x0, 0x28(%rsp)
jl 0x17cab
movq 0xa0(%rsp), %rdi
addq $0x30, %rdi
movslq 0x28(%rsp), %rsi
callq 0x4970
movl (%rax), %eax
cmpl 0x5c(%rsp), %eax
je 0x17d54
cmpl $0x0, 0x5c(%rsp)
jle 0x17d52
movq 0xa0(%rsp), %rdi
addq $0x78, %rdi
movslq 0x2c(%rsp), %rsi
callq 0x4a60
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x4880
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x48b0
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x48e0
testb $0x1, %al
jne 0x17d04
jmp 0x17d50
leaq 0x18(%rsp), %rdi
callq 0x4920
movl (%rax), %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %esi
movl 0x2c(%rsp), %edx
leaq 0x60(%rsp), %rdi
callq 0x1a1b0
jmp 0x17d28
jmp 0x17d2a
leaq 0x18(%rsp), %rdi
callq 0x4930
jmp 0x17cef
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x1a270
jmp 0x17db3
jmp 0x17d52
jmp 0x17d6a
movl 0x28(%rsp), %esi
movl 0x2c(%rsp), %edx
leaq 0x60(%rsp), %rdi
callq 0x1a1b0
jmp 0x17d68
jmp 0x17d6a
jmp 0x17d6c
leaq 0x38(%rsp), %rdi
callq 0x4930
jmp 0x17c42
jmp 0x17d7d
movl 0x5c(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x5c(%rsp)
jmp 0x17bfb
movq 0x98(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x1a210
jmp 0x17da1
leaq 0x60(%rsp), %rdi
callq 0x1a270
addq $0xa8, %rsp
retq
movq 0x50(%rsp), %rdi
callq 0x21f0
nopl (%rax)
// File: sharmaeklavya2[P]ddos-on-anycast/src/lib/place_victims.cpp
// Function: noisy_normalize(std::vector<double, std::allocator<double>>&, int, double, std::linear_congruential_engine<unsigned long, 48271ul, 0ul, 2147483647ul>&)
void noisy_normalize(vector<double>& weights, int x, double max_noise, rng_t& rng) {
    std::uniform_real_distribution<double> noise_dist(-max_noise, max_noise);
    double weight_sum = std::accumulate(weights.begin(), weights.end(), 0.0);
    for(double& w: weights) {
        w = w / weight_sum + noise_dist(rng);
    }
    weight_sum = std::accumulate(weights.begin(), weights.end(), 0.0);
    for(double& w: weights) {
        w = (w * x) / weight_sum;
    }
}

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movl %esi, 0x9c(%rsp)
movsd %xmm0, 0x90(%rsp)
movq %rdx, 0x88(%rsp)
movsd 0x90(%rsp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd 0x90(%rsp), %xmm1
leaq 0x78(%rsp), %rdi
callq 0xb310
movq 0xa0(%rsp), %rdi
callq 0x11f30
movq %rax, 0x68(%rsp)
movq 0xa0(%rsp), %rdi
callq 0x11da0
movq %rax, 0x60(%rsp)
movq 0x68(%rsp), %rdi
movq 0x60(%rsp), %rsi
xorps %xmm0, %xmm0
callq 0x1a2a0
movsd %xmm0, 0x70(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rdi
callq 0x11f30
movq %rax, 0x50(%rsp)
movq 0x58(%rsp), %rdi
callq 0x11da0
movq %rax, 0x48(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x1a310
testb $0x1, %al
jne 0x17e96
jmp 0x17eee
leaq 0x50(%rsp), %rdi
callq 0x1a350
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
movsd (%rax), %xmm0
divsd 0x70(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x88(%rsp), %rsi
leaq 0x78(%rsp), %rdi
callq 0xb340
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
addsd %xmm1, %xmm0
movq 0x40(%rsp), %rax
movsd %xmm0, (%rax)
leaq 0x50(%rsp), %rdi
callq 0x1a360
jmp 0x17e81
movq 0xa0(%rsp), %rdi
callq 0x11f30
movq %rax, 0x38(%rsp)
movq 0xa0(%rsp), %rdi
callq 0x11da0
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
xorps %xmm0, %xmm0
callq 0x1a2a0
movsd %xmm0, 0x70(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0x11f30
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0x11da0
movq %rax, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x1a310
testb $0x1, %al
jne 0x17f6a
jmp 0x17faa
leaq 0x20(%rsp), %rdi
callq 0x1a350
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movsd (%rax), %xmm0
cvtsi2sdl 0x9c(%rsp), %xmm1
mulsd %xmm1, %xmm0
divsd 0x70(%rsp), %xmm0
movq 0x10(%rsp), %rax
movsd %xmm0, (%rax)
leaq 0x20(%rsp), %rdi
callq 0x1a360
jmp 0x17f55
addq $0xa8, %rsp
retq
nopw %cs:(%rax,%rax)
// File: sharmaeklavya2[P]ddos-on-anycast/src/lib/sample.cpp
// Function: multi_sample(std::vector<double, std::allocator<double>> const&, int, std::vector<int, std::allocator<int>>&, std::linear_congruential_engine<unsigned long, 48271ul, 0ul, 2147483647ul>&)
void multi_sample(const vector<double>& weights, int m, ivec& indices, rng_t& rng) {
    int n = weights.size();
    indices.clear();
    if(m >= n) {
        for(int i=0; i<n; ++i) {
            indices.push_back(i);
        }
        return;
    }

    std::uniform_real_distribution<double> rdist;
    indices.reserve(m);
    SegTree segtree(weights);
    for(int i=0; i<m; ++i) {
        int index = segtree.cumsum_search(segtree.get_root() * rdist(rng));
        indices.push_back(index);
        segtree.update(index, 0.0);
    }
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movl %esi, 0x7c(%rsp)
movq %rdx, 0x70(%rsp)
movq %rcx, 0x68(%rsp)
movq 0x80(%rsp), %rdi
callq 0x11850
movl %eax, 0x64(%rsp)
movq 0x70(%rsp), %rdi
callq 0x1aa80
movl 0x7c(%rsp), %eax
cmpl 0x64(%rsp), %eax
jl 0x20535
movl $0x0, 0x60(%rsp)
movl 0x60(%rsp), %eax
cmpl 0x64(%rsp), %eax
jge 0x20530
movq 0x70(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x46f0
movl 0x60(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x60(%rsp)
jmp 0x2050a
jmp 0x20621
leaq 0x50(%rsp), %rdi
callq 0x20640
movq 0x70(%rsp), %rdi
movslq 0x7c(%rsp), %rsi
callq 0xa200
movq 0x80(%rsp), %rsi
leaq 0x30(%rsp), %rdi
callq 0x20660
movl $0x0, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
cmpl 0x7c(%rsp), %eax
jge 0x20617
leaq 0x30(%rsp), %rdi
callq 0x20760
movsd %xmm0, 0x10(%rsp)
jmp 0x20588
movq 0x68(%rsp), %rsi
leaq 0x50(%rsp), %rdi
callq 0xb340
movsd %xmm0, 0x8(%rsp)
jmp 0x2059f
movsd 0x8(%rsp), %xmm1
movsd 0x10(%rsp), %xmm0
mulsd %xmm1, %xmm0
leaq 0x30(%rsp), %rdi
callq 0x20730
movl %eax, 0x4(%rsp)
jmp 0x205bf
movl 0x4(%rsp), %eax
movl %eax, 0x28(%rsp)
movq 0x70(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x46f0
jmp 0x205d8
movl 0x28(%rsp), %esi
leaq 0x30(%rsp), %rdi
xorps %xmm0, %xmm0
callq 0x20780
jmp 0x205eb
jmp 0x205ed
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x20568
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x207c0
jmp 0x20629
leaq 0x30(%rsp), %rdi
callq 0x207c0
addq $0x88, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x21f0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: sharmaeklavya2[P]ddos-on-anycast/src/graph_gen.cpp
// Function: main
int main(int argc, char* argv[]) {
    char args_str[] = "n m seed";
    int n, m, seed=-1;
    if(argc <= 2 || argc >= 5) {
        fprintf(stderr, "usage: %s %s\n", argv[0], args_str);
        return 2;
    }
    else {
        n = atoi(argv[1]);
        m = atoi(argv[2]);
        if(argc == 4) {
            seed = atoi(argv[3]);
        }
    }
    if(seed == -1) {
        seed = int(time(nullptr));
    }

    ipvec l;

    make_random_connected_graph(n, m, l, seed);
    for(int i=0; i<n; ++i) {
        printf("%d\n", i);
    }

    for(const iipair& p: l) {
        int u = p.first, v = p.second;
        printf("%d %d\n", u, v);
    }
    return 0;
}

// Assembly:
subq $0x88, %rsp
movl $0x0, 0x84(%rsp)
movl %edi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq 0xcc0(%rip), %rax       # 0x216d5
movq %rax, 0x6f(%rsp)
movb 0xcbd(%rip), %al        # 0x216dd
movb %al, 0x77(%rsp)
movl $0xffffffff, 0x60(%rsp) # imm = 0xFFFFFFFF
cmpl $0x2, 0x80(%rsp)
jle 0x20a40
cmpl $0x5, 0x80(%rsp)
jl 0x20a75
movq 0xc581(%rip), %rax      # 0x2cfc8
movq (%rax), %rdi
movq 0x78(%rsp), %rax
movq (%rax), %rdx
leaq 0x6f(%rsp), %rcx
leaq 0xc80(%rip), %rsi       # 0x216de
movb $0x0, %al
callq 0x2180
movl $0x2, 0x84(%rsp)
jmp 0x20be2
movq 0x78(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x21b0
movl %eax, 0x68(%rsp)
movq 0x78(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x21b0
movl %eax, 0x64(%rsp)
cmpl $0x4, 0x80(%rsp)
jne 0x20ab5
movq 0x78(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x21b0
movl %eax, 0x60(%rsp)
jmp 0x20ab7
cmpl $-0x1, 0x60(%rsp)
jne 0x20acb
xorl %eax, %eax
movl %eax, %edi
callq 0x2120
movl %eax, 0x60(%rsp)
leaq 0x48(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x4a50
movq 0x8(%rsp), %rdx
movl 0x68(%rsp), %edi
movl 0x64(%rsp), %esi
movl 0x60(%rsp), %ecx
callq 0xc3e0
jmp 0x20af2
movl $0x0, 0x38(%rsp)
movl 0x38(%rsp), %eax
cmpl 0x68(%rsp), %eax
jge 0x20b44
movl 0x38(%rsp), %esi
leaq 0xb6b(%rip), %rdi       # 0x2167a
xorl %eax, %eax
callq 0x2030
jmp 0x20b18
jmp 0x20b1a
movl 0x38(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x38(%rsp)
jmp 0x20afa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x4ae0
jmp 0x20bf1
leaq 0x48(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdi
callq 0x7280
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rdi
callq 0x7100
movq %rax, 0x20(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x9f70
testb $0x1, %al
jne 0x20b81
jmp 0x20bcd
leaq 0x28(%rsp), %rdi
callq 0x9fb0
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x14(%rsp)
movq 0x18(%rsp), %rax
movl 0x4(%rax), %eax
movl %eax, 0x10(%rsp)
movl 0x14(%rsp), %esi
movl 0x10(%rsp), %edx
leaq 0xb36(%rip), %rdi       # 0x216ec
xorl %eax, %eax
callq 0x2030
jmp 0x20bbf
jmp 0x20bc1
leaq 0x28(%rsp), %rdi
callq 0x9fc0
jmp 0x20b6c
movl $0x0, 0x84(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x4ae0
movl 0x84(%rsp), %eax
addq $0x88, %rsp
retq
movq 0x40(%rsp), %rdi
callq 0x21f0
// File: hirakuni45[P]input_class/main.cpp
// Function: (anonymous namespace)::report_(int, int, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool)
void report_(int no, int subidx, int subnum, const std::string& title, bool err) noexcept
	{
		if(err) {
			std::cout << "\x1B[32;1m";
		} else {
			std::cout << "\x1B[31;1m";
		}

		std::cout << boost::format("(%2d) ") % no;
		std::cout << boost::format("(%2d/%2d) ") % subidx % subnum;
		std::cout << title;

		if(err) {
			std::cout << "  Pass." << std::endl;
		} else {
			auto i = static_cast<int>(err_st_);
			std::cout << ", " << errmsg_[i] << std::endl;
		}
		std::cout << "\x1B[37;m";
	}

// Assembly:
subq $0x218, %rsp            # imm = 0x218
movb %r8b, %al
movl %edi, 0x214(%rsp)
movl %esi, 0x210(%rsp)
movl %edx, 0x20c(%rsp)
movq %rcx, 0x200(%rsp)
andb $0x1, %al
movb %al, 0x1ff(%rsp)
testb $0x1, 0x1ff(%rsp)
je 0xa0c1
movq 0x18f27(%rip), %rdi     # 0x22fd8
leaq 0x11b9d(%rip), %rsi     # 0x1bc55
callq 0x52f0
jmp 0xa0bf
jmp 0xa0d8
movq 0x18f10(%rip), %rdi     # 0x22fd8
leaq 0x11b8e(%rip), %rsi     # 0x1bc5d
callq 0x52f0
jmp 0xa0d6
jmp 0xa0d8
leaq 0x11b86(%rip), %rsi     # 0x1bc65
leaq 0x118(%rsp), %rdi
callq 0xa3a0
jmp 0xa0ee
leaq 0x118(%rsp), %rdi
leaq 0x214(%rsp), %rsi
callq 0xa580
movq %rax, 0x28(%rsp)
jmp 0xa10a
movq 0x28(%rsp), %rsi
movq 0x18ec2(%rip), %rdi     # 0x22fd8
callq 0xaf60
jmp 0xa11d
leaq 0x118(%rsp), %rdi
callq 0xa7f0
leaq 0x11b3b(%rip), %rsi     # 0x1bc6c
leaq 0x38(%rsp), %rdi
callq 0xa3a0
jmp 0xa13d
leaq 0x38(%rsp), %rdi
leaq 0x210(%rsp), %rsi
callq 0xa580
movq %rax, 0x20(%rsp)
jmp 0xa156
movq 0x20(%rsp), %rdi
leaq 0x20c(%rsp), %rsi
callq 0xa580
movq %rax, 0x18(%rsp)
jmp 0xa16f
movq 0x18(%rsp), %rsi
movq 0x18e5d(%rip), %rdi     # 0x22fd8
callq 0xaf60
jmp 0xa182
leaq 0x38(%rsp), %rdi
callq 0xa7f0
movq 0x200(%rsp), %rsi
movq 0x18e3d(%rip), %rdi     # 0x22fd8
callq 0x52a0
jmp 0xa1a2
testb $0x1, 0x1ff(%rsp)
je 0xa1db
movq 0x18e25(%rip), %rdi     # 0x22fd8
leaq 0x11abd(%rip), %rsi     # 0x1bc77
callq 0x52f0
movq %rax, 0x10(%rsp)
jmp 0xa1c6
movq 0x10(%rsp), %rdi
movq 0x18dee(%rip), %rsi     # 0x22fc0
callq 0x5320
jmp 0xa1d9
jmp 0xa234
movzbl 0x1938a(%rip), %eax     # 0x2356c
movl %eax, 0x34(%rsp)
movq 0x18deb(%rip), %rdi     # 0x22fd8
leaq 0x11a8b(%rip), %rsi     # 0x1bc7f
callq 0x52f0
movq %rax, 0x8(%rsp)
jmp 0xa200
movq 0x8(%rsp), %rdi
movslq 0x34(%rsp), %rcx
leaq 0x1930f(%rip), %rax     # 0x23520
movq (%rax,%rcx,8), %rsi
callq 0x52f0
movq %rax, (%rsp)
jmp 0xa220
movq (%rsp), %rdi
movq 0x18d95(%rip), %rsi     # 0x22fc0
callq 0x5320
jmp 0xa232
jmp 0xa234
movq 0x18d9d(%rip), %rdi     # 0x22fd8
leaq 0x11a40(%rip), %rsi     # 0x1bc82
callq 0x52f0
jmp 0xa249
addq $0x218, %rsp            # imm = 0x218
retq
movq %rax, %rdi
callq 0xb250
nopl (%rax)
// File: hirakuni45[P]input_class/./input.hpp
// Function: utils::basic_input<utils::def_chainp>& utils::basic_input<utils::def_chainp>::operator%<char>(char&)
basic_input& operator % (T& val) noexcept
		{
			if(error_ != error::none) return *this;

			if constexpr(std::is_floating_point<T>::value) {
				auto tmp = nb_real_<T>();
				if(error_ == error::none) {
					++num_;
					val = tmp;
				}
			} else {
				if constexpr(sizeof(T) == 1) {
					if(mode_ == mode::CHA) {
						auto tmp = inp_(); 
						if(error_ == error::none) {
							++num_;
							val = tmp;
						}
						next_();
					} else {
						error_ = error::input_type;
					}
				} else {
					T tmp = nb_dec_<T>();
					if(error_ == error::none) {
						++num_;
						val = tmp;
					}
				}
			}
			if(ovf_) {
				error_ = error::overflow;
				ovf_ = false;
			}
			return *this;
		}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpb $0x0, 0x19(%rax)
je 0xaa1d
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0xaa9f
movq 0x10(%rsp), %rax
cmpb $0x1, 0x18(%rax)
jne 0xaa74
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
callq 0x17120
movb %al, 0xf(%rsp)
jmp 0xaa3c
movq 0x10(%rsp), %rax
movb 0xf(%rsp), %cl
movb %cl, 0x1f(%rsp)
cmpb $0x0, 0x19(%rax)
jne 0xaa68
movq 0x10(%rsp), %rax
movl 0x1c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x1c(%rax)
movb 0x1f(%rsp), %cl
movq 0x20(%rsp), %rax
movb %cl, (%rax)
movq 0x10(%rsp), %rdi
callq 0x16de0
jmp 0xaa7d
movq 0x10(%rsp), %rax
movb $0x3, 0x19(%rax)
movq 0x10(%rsp), %rax
testb $0x1, 0x1b(%rax)
je 0xaa95
movq 0x10(%rsp), %rax
movb $0x8, 0x19(%rax)
movb $0x0, 0x1b(%rax)
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
movq %rax, %rdi
callq 0xb250
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: hirakuni45[P]input_class/./input.hpp
// Function: utils::def_chainp::operator()()
char operator() () {
			if(unget_) {
				unget_ = false;
			} else {
				if(str_ == nullptr) {
					char ch;
					if(read(STDIN_FILENO, &ch, 1) == 1) {
						if(ch == '\n') ch = 0;
						last_ = ch;
					} else {
						last_ = 0;
					}
				} else {
					last_ = *str_;
					if(last_ != 0) { ++str_; }
				}
			}
			return last_;
		}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
testb $0x1, 0x9(%rax)
je 0x17142
movq (%rsp), %rax
movb $0x0, 0x9(%rax)
jmp 0x171b0
movq (%rsp), %rax
cmpq $0x0, (%rax)
jne 0x17189
xorl %edi, %edi
leaq 0xf(%rsp), %rsi
movl $0x1, %edx
callq 0x54b0
cmpq $0x1, %rax
jne 0x1717f
movsbl 0xf(%rsp), %eax
cmpl $0xa, %eax
jne 0x17172
movb $0x0, 0xf(%rsp)
movq (%rsp), %rax
movb 0xf(%rsp), %cl
movb %cl, 0x8(%rax)
jmp 0x17187
movq (%rsp), %rax
movb $0x0, 0x8(%rax)
jmp 0x171ae
movq (%rsp), %rax
movq (%rax), %rcx
movb (%rcx), %cl
movb %cl, 0x8(%rax)
movsbl 0x8(%rax), %eax
cmpl $0x0, %eax
je 0x171ac
movq (%rsp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x171ae
jmp 0x171b0
movq (%rsp), %rax
movb 0x8(%rax), %al
addq $0x18, %rsp
retq
nopl (%rax)
// File: hirakuni45[P]input_class/./input.hpp
// Function: int utils::basic_input<utils::def_chainp>::nb_dec_<int>()
T nb_dec_() noexcept
		{
			typedef typename std::make_unsigned<T>::type U;
			typedef typename std::make_signed<T>::type S;

			auto nbc = nbc_;
			auto neg = neg_();
			if(nbc > 0 && nbc_ == 0) {
				error_ = error::not_integer;
				return 0;
			}

			auto sign = std::is_signed<T>::value;
			T v = 0;
			switch(mode_) {
			case mode::BIN:
				v = bin_<U>();
				break;
			case mode::OCT:
				v = oct_<U>();
				break;
			case mode::DEC:
				if(!sign) {
					if(neg) {  // 符号無しにマイナス符号を付けた場合
						error_ = error::sign_type;
						return 0;
					}
				}
				v = dec_<T>();
				break;
			case mode::HEX:
				v = hex_<U>();
				break;
			case mode::AUTO:
				v = auto_num_<T>();
				break;
			default:
				error_ = error::not_integer;
				break;
			}
			if(error_ == error::none) {
				if(nbc == 0) {
					inp_.unget();
				}
				next_();
			}
			if(neg) {
				return -static_cast<S>(v);
			} else {
				return static_cast<S>(v);
			}
		}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movb 0x1a(%rdi), %al
movb %al, 0x17(%rsp)
callq 0x17330
andb $0x1, %al
movb %al, 0x16(%rsp)
movzbl 0x17(%rsp), %eax
cmpl $0x0, %eax
jle 0x17213
movq 0x8(%rsp), %rax
movzbl 0x1a(%rax), %eax
cmpl $0x0, %eax
jne 0x17213
movq 0x8(%rsp), %rax
movb $0x4, 0x19(%rax)
movl $0x0, 0x24(%rsp)
jmp 0x17318
movq 0x8(%rsp), %rax
movb $0x1, 0x15(%rsp)
movl $0x0, 0x10(%rsp)
movb 0x18(%rax), %al
addb $-0x2, %al
movzbl %al, %ecx
movq %rcx, (%rsp)
subb $0x5, %al
ja 0x172c3
movq (%rsp), %rax
leaq 0x40dc(%rip), %rcx      # 0x1b320
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rsp), %rdi
callq 0x173e0
movl %eax, 0x10(%rsp)
jmp 0x172cc
movq 0x8(%rsp), %rdi
callq 0x174e0
movl %eax, 0x10(%rsp)
jmp 0x172cc
testb $0x1, 0x15(%rsp)
jne 0x17293
testb $0x1, 0x16(%rsp)
je 0x17291
movq 0x8(%rsp), %rax
movb $0x5, 0x19(%rax)
movl $0x0, 0x24(%rsp)
jmp 0x17318
jmp 0x17293
movq 0x8(%rsp), %rdi
callq 0x175e0
movl %eax, 0x10(%rsp)
jmp 0x172cc
movq 0x8(%rsp), %rdi
callq 0x176d0
movl %eax, 0x10(%rsp)
jmp 0x172cc
movq 0x8(%rsp), %rdi
callq 0x17840
movl %eax, 0x10(%rsp)
jmp 0x172cc
movq 0x8(%rsp), %rax
movb $0x4, 0x19(%rax)
movq 0x8(%rsp), %rax
cmpb $0x0, 0x19(%rax)
jne 0x172fd
movzbl 0x17(%rsp), %eax
cmpl $0x0, %eax
jne 0x172f3
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
callq 0x17980
jmp 0x172f1
jmp 0x172f3
movq 0x8(%rsp), %rdi
callq 0x16de0
testb $0x1, 0x16(%rsp)
je 0x17310
xorl %eax, %eax
subl 0x10(%rsp), %eax
movl %eax, 0x24(%rsp)
jmp 0x17318
movl 0x10(%rsp), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
movq %rax, %rdi
callq 0xb250
nopl (%rax)
// File: hirakuni45[P]input_class/./input.hpp
// Function: utils::basic_input<utils::def_chainp>::neg_()
bool neg_() noexcept {
			bool neg = false;
			auto s = inp_();
			if(s == '-') {
				neg = true;
				if(nbc_ > 0) nbc_--;
			} else if(s == '+') {
				neg = false;
				if(nbc_ > 0) nbc_--;
			} else {
				inp_.unget();
			}
			return neg;
		}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
movb $0x0, 0xf(%rsp)
addq $0x8, %rdi
callq 0x17120
movb %al, 0xd(%rsp)
jmp 0x17356
movb 0xd(%rsp), %al
movb %al, 0xe(%rsp)
movsbl 0xe(%rsp), %eax
cmpl $0x2d, %eax
jne 0x17389
movq (%rsp), %rax
movb $0x1, 0xf(%rsp)
movzbl 0x1a(%rax), %eax
cmpl $0x0, %eax
jle 0x17387
movq (%rsp), %rax
movb 0x1a(%rax), %cl
addb $-0x1, %cl
movb %cl, 0x1a(%rax)
jmp 0x173c7
movsbl 0xe(%rsp), %eax
cmpl $0x2b, %eax
jne 0x173b4
movq (%rsp), %rax
movb $0x0, 0xf(%rsp)
movzbl 0x1a(%rax), %eax
cmpl $0x0, %eax
jle 0x173b2
movq (%rsp), %rax
movb 0x1a(%rax), %cl
addb $-0x1, %cl
movb %cl, 0x1a(%rax)
jmp 0x173c5
movq (%rsp), %rdi
addq $0x8, %rdi
callq 0x17980
jmp 0x173c3
jmp 0x173c5
jmp 0x173c7
movb 0xf(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
movq %rax, %rdi
callq 0xb250
nopw (%rax,%rax)
// File: hirakuni45[P]input_class/./input.hpp
// Function: unsigned int utils::basic_input<utils::def_chainp>::bin_<unsigned int>()
T bin_() noexcept {
			T a = 0;
			constexpr auto lim = static_cast<T>(1) << (sizeof(T) * 8 - 1);
			char ch;
			while((ch = inp_()) != 0) {
				if(ch >= '0' && ch <= '1') {
					if((a & lim) != 0) {
						ovf_ = true;
					}
					if(!ovf_) {
						a <<= 1;
						a += ch - '0';
					}
				} else if(nbc_ != 0 && ch == ' ') {
					// 文字数指定がある場合「スペース」は '0' と同等に扱う
				} else {
					break;
				}
				if(nbc_ > 0) {
					nbc_--;
					if(nbc_ == 0) break;
				}
			}
			return a;
		}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x1c(%rsp)
movl $0x80000000, 0x18(%rsp) # imm = 0x80000000
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
callq 0x17120
movb %al, 0x7(%rsp)
jmp 0x17417
movb 0x7(%rsp), %al
movb %al, 0x17(%rsp)
movsbl %al, %eax
cmpl $0x0, %eax
je 0x174c9
movsbl 0x17(%rsp), %eax
cmpl $0x30, %eax
jl 0x1747d
movsbl 0x17(%rsp), %eax
cmpl $0x31, %eax
jg 0x1747d
movl 0x1c(%rsp), %eax
andl $0x80000000, %eax       # imm = 0x80000000
cmpl $0x0, %eax
je 0x17456
movq 0x8(%rsp), %rax
movb $0x1, 0x1b(%rax)
movq 0x8(%rsp), %rax
testb $0x1, 0x1b(%rax)
jne 0x1747b
movl 0x1c(%rsp), %eax
shll %eax
movl %eax, 0x1c(%rsp)
movsbl 0x17(%rsp), %eax
subl $0x30, %eax
addl 0x1c(%rsp), %eax
movl %eax, 0x1c(%rsp)
jmp 0x1749b
movq 0x8(%rsp), %rax
movzbl 0x1a(%rax), %eax
cmpl $0x0, %eax
je 0x17497
movsbl 0x17(%rsp), %eax
cmpl $0x20, %eax
jne 0x17497
jmp 0x17499
jmp 0x174c9
jmp 0x1749b
movq 0x8(%rsp), %rax
movzbl 0x1a(%rax), %eax
cmpl $0x0, %eax
jle 0x174c4
movq 0x8(%rsp), %rax
movb 0x1a(%rax), %cl
addb $-0x1, %cl
movb %cl, 0x1a(%rax)
movzbl 0x1a(%rax), %eax
cmpl $0x0, %eax
jne 0x174c2
jmp 0x174c9
jmp 0x174c4
jmp 0x17403
movl 0x1c(%rsp), %eax
addq $0x28, %rsp
retq
movq %rax, %rdi
callq 0xb250
nopw (%rax,%rax)
// File: hirakuni45[P]input_class/./input.hpp
// Function: unsigned int utils::basic_input<utils::def_chainp>::oct_<unsigned int>()
T oct_() noexcept {
			T a = 0;
			constexpr auto lim = static_cast<T>(0b111) << (sizeof(T) * 8 - 4);
			char ch;
			while((ch = inp_()) != 0) {
				if(ch >= '0' && ch <= '7') {
					if((a & lim) != 0) {
						ovf_ = true;
					}
					if(!ovf_) {
						a <<= 3;
						a += ch - '0';
					}
				} else if(nbc_ != 0 && ch == ' ') {
					// 文字数指定がある場合「スペース」は '0' と同等に扱う
				} else {
					break;
				}
				if(nbc_ > 0) {
					nbc_--;
					if(nbc_ == 0) break;
				}
			}
			return a;
		}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x1c(%rsp)
movl $0x70000000, 0x18(%rsp) # imm = 0x70000000
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
callq 0x17120
movb %al, 0x7(%rsp)
jmp 0x17517
movb 0x7(%rsp), %al
movb %al, 0x17(%rsp)
movsbl %al, %eax
cmpl $0x0, %eax
je 0x175ca
movsbl 0x17(%rsp), %eax
cmpl $0x30, %eax
jl 0x1757e
movsbl 0x17(%rsp), %eax
cmpl $0x37, %eax
jg 0x1757e
movl 0x1c(%rsp), %eax
andl $0x70000000, %eax       # imm = 0x70000000
cmpl $0x0, %eax
je 0x17556
movq 0x8(%rsp), %rax
movb $0x1, 0x1b(%rax)
movq 0x8(%rsp), %rax
testb $0x1, 0x1b(%rax)
jne 0x1757c
movl 0x1c(%rsp), %eax
shll $0x3, %eax
movl %eax, 0x1c(%rsp)
movsbl 0x17(%rsp), %eax
subl $0x30, %eax
addl 0x1c(%rsp), %eax
movl %eax, 0x1c(%rsp)
jmp 0x1759c
movq 0x8(%rsp), %rax
movzbl 0x1a(%rax), %eax
cmpl $0x0, %eax
je 0x17598
movsbl 0x17(%rsp), %eax
cmpl $0x20, %eax
jne 0x17598
jmp 0x1759a
jmp 0x175ca
jmp 0x1759c
movq 0x8(%rsp), %rax
movzbl 0x1a(%rax), %eax
cmpl $0x0, %eax
jle 0x175c5
movq 0x8(%rsp), %rax
movb 0x1a(%rax), %cl
addb $-0x1, %cl
movb %cl, 0x1a(%rax)
movzbl 0x1a(%rax), %eax
cmpl $0x0, %eax
jne 0x175c3
jmp 0x175ca
jmp 0x175c5
jmp 0x17503
movl 0x1c(%rsp), %eax
addq $0x28, %rsp
retq
movq %rax, %rdi
callq 0xb250
nopl (%rax,%rax)
// File: hirakuni45[P]input_class/./input.hpp
// Function: unsigned int utils::basic_input<utils::def_chainp>::dec_<unsigned int>()
T dec_() noexcept {
			T a = 0;
			char ch;
			while((ch = inp_()) != 0) {
				if(!ovf_ && ch >= '0' && ch <= '9') {
					if constexpr (std::is_signed<T>::value) {
						a *= 10;
						a += ch - '0';
						if(a < 0) {
							ovf_ = true;
						}
					} else {
						auto b = a;
						a *= 10;
						a += ch - '0';
						if(b > a) {
							ovf_ = true;
						}
					}
				} else if(nbc_ != 0 && ch == ' ') {
					// 文字数指定がある場合「スペース」は '0' と同等に扱う
				} else {
					break;
				}
				if(nbc_ > 0) {
					nbc_--;
					if(nbc_ == 0) break;
				}
			}
			return a;
		}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x1c(%rsp)
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
callq 0x17120
movb %al, 0x7(%rsp)
jmp 0x182df
movb 0x7(%rsp), %al
movb %al, 0x1b(%rsp)
movsbl %al, %eax
cmpl $0x0, %eax
je 0x18394
movq 0x8(%rsp), %rax
testb $0x1, 0x1b(%rax)
jne 0x18348
movsbl 0x1b(%rsp), %eax
cmpl $0x30, %eax
jl 0x18348
movsbl 0x1b(%rsp), %eax
cmpl $0x39, %eax
jg 0x18348
movl 0x1c(%rsp), %eax
movl %eax, 0x14(%rsp)
imull $0xa, 0x1c(%rsp), %eax
movl %eax, 0x1c(%rsp)
movsbl 0x1b(%rsp), %eax
subl $0x30, %eax
addl 0x1c(%rsp), %eax
movl %eax, 0x1c(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jbe 0x18346
movq 0x8(%rsp), %rax
movb $0x1, 0x1b(%rax)
jmp 0x18366
movq 0x8(%rsp), %rax
movzbl 0x1a(%rax), %eax
cmpl $0x0, %eax
je 0x18362
movsbl 0x1b(%rsp), %eax
cmpl $0x20, %eax
jne 0x18362
jmp 0x18364
jmp 0x18394
jmp 0x18366
movq 0x8(%rsp), %rax
movzbl 0x1a(%rax), %eax
cmpl $0x0, %eax
jle 0x1838f
movq 0x8(%rsp), %rax
movb 0x1a(%rax), %cl
addb $-0x1, %cl
movb %cl, 0x1a(%rax)
movzbl 0x1a(%rax), %eax
cmpl $0x0, %eax
jne 0x1838d
jmp 0x18394
jmp 0x1838f
jmp 0x182cb
movl 0x1c(%rsp), %eax
addq $0x28, %rsp
retq
movq %rax, %rdi
callq 0xb250
nopw %cs:(%rax,%rax)
nop
// File: hirakuni45[P]input_class/./input.hpp
// Function: unsigned int utils::basic_input<utils::def_chainp>::hex_<unsigned int>()
T hex_() noexcept {
			T a = 0;
			constexpr auto lim = static_cast<T>(0b1111) << (sizeof(T) * 8 - 4);
			char ch;
			while((ch = inp_()) != 0) {
				auto ovf = (a & lim) != 0;
				if(ch >= 'a') { ch -= 0x20; }
				if(ch >= '0' && ch <= '9') {
					if(ovf) { ovf_ = true; }
					if(!ovf_) {
						a <<= 4;
						a += ch - '0';
					}
				} else if(ch >= 'A' && ch <= 'F') {
					if(ovf) { ovf_ = true; }
					if(!ovf_) {
						a <<= 4;
						a += ch - 'A' + 10;
					}
				} else if(nbc_ != 0 && ch == ' ') {
					// 文字数指定がある場合「スペース」は '0' と同等に扱う
				} else {
					break;
				}
				if(nbc_ > 0) {
					nbc_--;
					if(nbc_ == 0) break;
				}
			}
			return a;
		}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x1c(%rsp)
movl $0xf0000000, 0x18(%rsp) # imm = 0xF0000000
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
callq 0x17120
movb %al, 0x7(%rsp)
jmp 0x17707
movb 0x7(%rsp), %al
movb %al, 0x17(%rsp)
movsbl %al, %eax
cmpl $0x0, %eax
je 0x1782f
movl 0x1c(%rsp), %eax
andl $0xf0000000, %eax       # imm = 0xF0000000
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, 0x16(%rsp)
movsbl 0x17(%rsp), %eax
cmpl $0x61, %eax
jl 0x17746
movsbl 0x17(%rsp), %eax
subl $0x20, %eax
movb %al, 0x17(%rsp)
movsbl 0x17(%rsp), %eax
cmpl $0x30, %eax
jl 0x17792
movsbl 0x17(%rsp), %eax
cmpl $0x39, %eax
jg 0x17792
testb $0x1, 0x16(%rsp)
je 0x1776a
movq 0x8(%rsp), %rax
movb $0x1, 0x1b(%rax)
movq 0x8(%rsp), %rax
testb $0x1, 0x1b(%rax)
jne 0x17790
movl 0x1c(%rsp), %eax
shll $0x4, %eax
movl %eax, 0x1c(%rsp)
movsbl 0x17(%rsp), %eax
subl $0x30, %eax
addl 0x1c(%rsp), %eax
movl %eax, 0x1c(%rsp)
jmp 0x17801
movsbl 0x17(%rsp), %eax
cmpl $0x41, %eax
jl 0x177e1
movsbl 0x17(%rsp), %eax
cmpl $0x46, %eax
jg 0x177e1
testb $0x1, 0x16(%rsp)
je 0x177b6
movq 0x8(%rsp), %rax
movb $0x1, 0x1b(%rax)
movq 0x8(%rsp), %rax
testb $0x1, 0x1b(%rax)
jne 0x177df
movl 0x1c(%rsp), %eax
shll $0x4, %eax
movl %eax, 0x1c(%rsp)
movsbl 0x17(%rsp), %eax
subl $0x41, %eax
addl $0xa, %eax
addl 0x1c(%rsp), %eax
movl %eax, 0x1c(%rsp)
jmp 0x177ff
movq 0x8(%rsp), %rax
movzbl 0x1a(%rax), %eax
cmpl $0x0, %eax
je 0x177fb
movsbl 0x17(%rsp), %eax
cmpl $0x20, %eax
jne 0x177fb
jmp 0x177fd
jmp 0x1782f
jmp 0x177ff
jmp 0x17801
movq 0x8(%rsp), %rax
movzbl 0x1a(%rax), %eax
cmpl $0x0, %eax
jle 0x1782a
movq 0x8(%rsp), %rax
movb 0x1a(%rax), %cl
addb $-0x1, %cl
movb %cl, 0x1a(%rax)
movzbl 0x1a(%rax), %eax
cmpl $0x0, %eax
jne 0x17828
jmp 0x1782f
jmp 0x1782a
jmp 0x176f3
movl 0x1c(%rsp), %eax
addq $0x28, %rsp
retq
movq %rax, %rdi
callq 0xb250
// File: hirakuni45[P]input_class/./input.hpp
// Function: int utils::basic_input<utils::def_chainp>::auto_num_<int>()
T auto_num_() noexcept
		{
			enum class TYPE : uint8_t {
				dec,
				bin,
				oct,
				hex,
			};

			typedef typename std::make_unsigned<T>::type U;

			char ch = inp_();
			if(ch != '0') {  // 最初に０がある場合無視
				inp_.unget();
			}
			ch = inp_();
			if(ch >= 0x60) { ch -= 0x20; }
			T v = 0;
			TYPE t(TYPE::dec);
			if(ch == 'B') {
				t = TYPE::bin;
			} else if(ch == 'X') {
				t = TYPE::hex;
			} else if(ch == 'O') {
				t = TYPE::oct;
			} else {
				inp_.unget();
			}
			switch(t) {
			case TYPE::bin:
				v = bin_<U>();
				break;
			case TYPE::oct:
				v = oct_<U>();
				break;
			case TYPE::hex:
				v = hex_<U>();
				break;
			default:
				v = dec_<T>();
				break;
			}
			return v;
		}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x8, %rdi
callq 0x17120
movb %al, 0x16(%rsp)
jmp 0x17862
movb 0x16(%rsp), %al
movb %al, 0x1f(%rsp)
movsbl 0x1f(%rsp), %eax
cmpl $0x30, %eax
je 0x17886
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
callq 0x17980
jmp 0x17884
jmp 0x17886
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
callq 0x17120
movb %al, 0x7(%rsp)
jmp 0x1789a
movb 0x7(%rsp), %al
movb %al, 0x1f(%rsp)
movsbl 0x1f(%rsp), %eax
cmpl $0x60, %eax
jl 0x178b8
movsbl 0x1f(%rsp), %eax
subl $0x20, %eax
movb %al, 0x1f(%rsp)
movl $0x0, 0x18(%rsp)
movb $0x0, 0x17(%rsp)
movsbl 0x1f(%rsp), %eax
cmpl $0x42, %eax
jne 0x178d6
movb $0x1, 0x17(%rsp)
jmp 0x1790e
movsbl 0x1f(%rsp), %eax
cmpl $0x58, %eax
jne 0x178e7
movb $0x3, 0x17(%rsp)
jmp 0x1790c
movsbl 0x1f(%rsp), %eax
cmpl $0x4f, %eax
jne 0x178f8
movb $0x2, 0x17(%rsp)
jmp 0x1790a
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
callq 0x17980
jmp 0x17908
jmp 0x1790a
jmp 0x1790c
jmp 0x1790e
movb 0x17(%rsp), %al
movb %al, 0x6(%rsp)
subb $0x1, %al
je 0x17930
jmp 0x1791c
movb 0x6(%rsp), %al
subb $0x2, %al
je 0x17940
jmp 0x17926
movb 0x6(%rsp), %al
subb $0x3, %al
je 0x17950
jmp 0x17960
movq 0x8(%rsp), %rdi
callq 0x173e0
movl %eax, 0x18(%rsp)
jmp 0x1796e
movq 0x8(%rsp), %rdi
callq 0x174e0
movl %eax, 0x18(%rsp)
jmp 0x1796e
movq 0x8(%rsp), %rdi
callq 0x176d0
movl %eax, 0x18(%rsp)
jmp 0x1796e
movq 0x8(%rsp), %rdi
callq 0x175e0
movl %eax, 0x18(%rsp)
movl 0x18(%rsp), %eax
addq $0x28, %rsp
retq
movq %rax, %rdi
callq 0xb250
nop
// File: hirakuni45[P]input_class/./input.hpp
// Function: float utils::basic_input<utils::def_chainp>::nb_real_<float>()
T nb_real_() noexcept
		{
			bool neg = neg_();

			T v = 0.0f;
			switch(mode_) {
			case mode::REAL:
			case mode::AUTO:
				v = real_<T>();
				break;
			default:
				error_ = error::not_float;
				break;
			}
			if(error_ == error::none) {
				inp_.unget();
				next_();
			}
			if(neg) return -v;
			else return v;			
		}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x17330
movb %al, %cl
movq 0x8(%rsp), %rax
movb %cl, 0x17(%rsp)
movl $0x0, 0x10(%rsp)
movb 0x18(%rax), %al
addb $-0x6, %al
subb $0x1, %al
ja 0x17bc8
jmp 0x17bb6
movq 0x8(%rsp), %rdi
callq 0x17c30
movss %xmm0, 0x10(%rsp)
jmp 0x17bd1
movq 0x8(%rsp), %rax
movb $0x6, 0x19(%rax)
movq 0x8(%rsp), %rax
cmpb $0x0, 0x19(%rax)
jne 0x17bf4
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
callq 0x17980
movq 0x8(%rsp), %rdi
callq 0x16de0
testb $0x1, 0x17(%rsp)
je 0x17c16
movss 0x10(%rsp), %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
movss %xmm0, 0x24(%rsp)
jmp 0x17c22
movss 0x10(%rsp), %xmm0
movss %xmm0, 0x24(%rsp)
movss 0x24(%rsp), %xmm0
addq $0x28, %rsp
retq
nopl (%rax)
// File: hirakuni45[P]input_class/./input.hpp
// Function: float utils::basic_input<utils::def_chainp>::real_<float>()::real_t::add(char)
void add(char ch)
				{
					if(c >= (0xffff'ffff / 10)) {
						if(!p) ovf = true;
					} else {
						a *= 10;
						a += static_cast<uint32_t>(ch - '0');
						c *= 10;
					}
				}

// Assembly:
movb %sil, %al
movq %rdi, -0x8(%rsp)
movb %al, -0x9(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x18(%rsp)
cmpl $0x19999999, 0x8(%rax)  # imm = 0x19999999
jb 0x17f25
movq -0x18(%rsp), %rax
testb $0x1, 0xd(%rax)
jne 0x17f23
movq -0x18(%rsp), %rax
movb $0x1, 0xe(%rax)
jmp 0x17f42
movq -0x18(%rsp), %rax
imull $0xa, (%rax), %ecx
movl %ecx, (%rax)
movsbl -0x9(%rsp), %ecx
subl $0x30, %ecx
addl (%rax), %ecx
movl %ecx, (%rax)
imull $0xa, 0x8(%rax), %ecx
movl %ecx, 0x8(%rax)
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: hirakuni45[P]input_class/./input.hpp
// Function: float utils::basic_input<utils::def_chainp>::real_<float>()::real_t::point()
void point() {
					b = a;
					a = 0;
					c = 1;
					p = true;
				}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movl (%rax), %ecx
movl %ecx, 0x4(%rax)
movl $0x0, (%rax)
movl $0x1, 0x8(%rax)
movb $0x1, 0xd(%rax)
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: hirakuni45[P]input_class/./input.hpp
// Function: float utils::basic_input<utils::def_chainp>::real_<float>()::real_t::get() const
T get() const {
					if(p) {
						T tmp = static_cast<T>(b) + static_cast<T>(a) / static_cast<T>(c);
						if(sign) return -tmp;
						return tmp;
					} else {
						T tmp = static_cast<T>(a);
						if(sign) return -tmp;
						else return tmp;
					}				
				}

// Assembly:
movq %rdi, -0x10(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x20(%rsp)
testb $0x1, 0xd(%rax)
je 0x17fee
movq -0x20(%rsp), %rax
movl (%rax), %ecx
movl 0x4(%rax), %edx
cvtsi2ss %rdx, %xmm0
cvtsi2ss %rcx, %xmm1
movl 0x8(%rax), %ecx
cvtsi2ss %rcx, %xmm2
divss %xmm2, %xmm1
addss %xmm1, %xmm0
movss %xmm0, -0x14(%rsp)
testb $0x1, 0xc(%rax)
je 0x17fe0
movss -0x14(%rsp), %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
movss %xmm0, -0x4(%rsp)
jmp 0x1802d
movss -0x14(%rsp), %xmm0
movss %xmm0, -0x4(%rsp)
jmp 0x1802d
movq -0x20(%rsp), %rax
movl (%rax), %ecx
cvtsi2ss %rcx, %xmm0
movss %xmm0, -0x18(%rsp)
testb $0x1, 0xc(%rax)
je 0x18021
movss -0x18(%rsp), %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
movss %xmm0, -0x4(%rsp)
jmp 0x1802d
movss -0x18(%rsp), %xmm0
movss %xmm0, -0x4(%rsp)
movss -0x4(%rsp), %xmm0
retq
nopw %cs:(%rax,%rax)
nop
// File: awbrenn[P]robot-controller/Client.cpp
// Function: initalizeMiddleware()
void initalizeMiddleware()
{
// Create socket for sending/receiving datagrams 
   if ((sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0)
      cout << "socket() failed" << endl;

   // Construct local address structure 
   memset(&servAddr, 0, sizeof(servAddr));   // Zero out structure 
   servAddr.sin_family = AF_INET;                  // Internet address family 
   servAddr.sin_addr.s_addr = htonl(INADDR_ANY);   // Any incoming interface 
   servAddr.sin_port = htons(port);       // Local port    
   
   // If user gave a dotted decimal address, we need to resolve it  
   if (servAddr.sin_addr.s_addr == -1) {
      thehost = gethostbyname(ip);
      servAddr.sin_addr.s_addr = *((unsigned long *) thehost->h_addr_list[0]);
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x2, %esi
movl $0x11, %edx
movl %esi, %edi
callq 0x20a0
movl %eax, 0x5b4d(%rip)      # 0x92a8
cmpl $0x0, %eax
jge 0x3782
movq 0x5869(%rip), %rdi      # 0x8fd0
leaq 0x29c9(%rip), %rsi      # 0x6137
callq 0x21f0
movq %rax, %rdi
movq 0x583b(%rip), %rsi      # 0x8fb8
callq 0x2230
leaq 0x5b23(%rip), %rdi      # 0x92ac
xorl %esi, %esi
movl $0x10, %edx
callq 0x2130
movw $0x2, 0x5b0e(%rip)      # 0x92ac
xorl %edi, %edi
callq 0x2170
movl %eax, 0x5b05(%rip)      # 0x92b0
movl 0x5b2b(%rip), %eax      # 0x92dc
movzwl %ax, %edi
callq 0x2060
movw %ax, 0x5aee(%rip)       # 0x92ae
cmpl $-0x1, 0x5ae9(%rip)     # 0x92b0
jne 0x37f3
movq 0x5b10(%rip), %rdi      # 0x92e0
callq 0x2280
movq %rax, 0x5af4(%rip)      # 0x92d0
movq 0x5aed(%rip), %rax      # 0x92d0
movq 0x18(%rax), %rax
movq (%rax), %rax
movq (%rax), %rax
movl %eax, 0x5abd(%rip)      # 0x92b0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: awbrenn[P]robot-controller/Client.cpp
// Function: convertHeaderInfoToString[abi:cxx11](unsigned int)
string convertHeaderInfoToString(uint32_t header_info) 
{
    string header_info_string;
    char uint4_chunk;
    int size_of_uint32_t = 4;
    int bits_in_a_byte = 8;

    cout << "HEADER INFO:" << header_info << endl;

    for (int i = 0; i < size_of_uint32_t; ++i) {
        uint4_chunk = (char) ((header_info << (i * bits_in_a_byte)) >> (3 * bits_in_a_byte));
        cout << "step " << i << ": " << header_info << ", " << (uint32_t) uint4_chunk << endl;
        header_info_string.push_back(uint4_chunk);
    }

    return header_info_string;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movb $0x0, -0xd(%rbp)
callq 0x2330
movl $0x4, -0x14(%rbp)
movl $0x8, -0x18(%rbp)
movq 0x53e5(%rip), %rdi      # 0x8fd0
leaq 0x2555(%rip), %rsi      # 0x6147
callq 0x21f0
movq %rax, -0x30(%rbp)
jmp 0x3bfd
movq -0x30(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x2300
movq %rax, -0x48(%rbp)
jmp 0x3c0f
movq -0x48(%rbp), %rdi
movq 0x539e(%rip), %rsi      # 0x8fb8
callq 0x2230
jmp 0x3c21
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x3d10
movl -0xc(%rbp), %eax
movl -0x28(%rbp), %ecx
movl -0x18(%rbp), %edx
imull %edx, %ecx
shll %cl, %eax
movl %edx, %ecx
leal (%rcx,%rcx,2), %ecx
shrl %cl, %eax
movb %al, -0xe(%rbp)
movq 0x537d(%rip), %rdi      # 0x8fd0
leaq 0x24fa(%rip), %rsi      # 0x6154
callq 0x21f0
movq %rax, -0x50(%rbp)
jmp 0x3c65
movq -0x50(%rbp), %rdi
movl -0x28(%rbp), %esi
callq 0x23c0
movq %rax, -0x58(%rbp)
jmp 0x3c77
movq -0x58(%rbp), %rdi
leaq 0x2532(%rip), %rsi      # 0x61b4
callq 0x21f0
movq %rax, -0x60(%rbp)
jmp 0x3c8d
movq -0x60(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x2300
movq %rax, -0x68(%rbp)
jmp 0x3c9f
movq -0x68(%rbp), %rdi
leaq 0x24b0(%rip), %rsi      # 0x615a
callq 0x21f0
movq %rax, -0x70(%rbp)
jmp 0x3cb5
movq -0x70(%rbp), %rdi
movsbl -0xe(%rbp), %esi
callq 0x2300
movq %rax, -0x78(%rbp)
jmp 0x3cc8
movq -0x78(%rbp), %rdi
movq 0x52e5(%rip), %rsi      # 0x8fb8
callq 0x2230
jmp 0x3cda
movq -0x40(%rbp), %rdi
movsbl -0xe(%rbp), %esi
callq 0x21c0
jmp 0x3ce9
jmp 0x3ceb
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x3c28
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x2448
jmp 0x3d30
movb $0x1, -0xd(%rbp)
testb $0x1, -0xd(%rbp)
jne 0x3d23
movq -0x40(%rbp), %rdi
callq 0x2448
movq -0x38(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x23d0
nopl (%rax)
// File: awbrenn[P]robot-controller/Client.cpp
// Function: addHeaderToCommands(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>)
vector<string> addHeaderToCommands(vector<string> commands) 
{
    uint32_t number_of_commands = commands.size();
    string body;
    int i;

    /* add header to each of the fragmented responses */
    for (i = 0; i < (int) number_of_commands; i++) {
        body = commands[i];
        body = convertHeaderInfoToString(REQUEST_ID)
             + ROBOT_ID
             + body;
        commands[i] = body;
    }

    return commands;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rsi, -0xc8(%rbp)
movq %rdi, %rax
movq -0xc8(%rbp), %rdi
movq %rax, -0xc0(%rbp)
movq %rax, %rcx
movq %rcx, -0xb8(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
callq 0x4190
movl %eax, -0x14(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x2330
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x3eaf
movq -0xc8(%rbp), %rdi
movslq -0x3c(%rbp), %rsi
callq 0x41b0
movq %rax, %rsi
leaq -0x38(%rbp), %rdi
callq 0x2030
jmp 0x3db7
movl 0x5473(%rip), %esi      # 0x9230
leaq -0xb0(%rbp), %rdi
callq 0x3bb0
jmp 0x3dcb
leaq 0xf975e(%rip), %rdx     # 0xfd530
leaq -0x90(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
callq 0x41d0
jmp 0x3de7
leaq -0x70(%rbp), %rdi
leaq -0x90(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq 0x41d0
jmp 0x3dfd
leaq -0x38(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
leaq -0x70(%rbp), %rsi
movq %rsi, -0xd8(%rbp)
callq 0x22b0
movq -0xd8(%rbp), %rdi
callq 0x2448
leaq -0x90(%rbp), %rdi
callq 0x2448
leaq -0xb0(%rbp), %rdi
callq 0x2448
movq -0xc8(%rbp), %rdi
movslq -0x3c(%rbp), %rsi
callq 0x41b0
movq -0xd0(%rbp), %rsi
movq %rax, %rdi
callq 0x2030
jmp 0x3e5d
jmp 0x3e5f
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x3d8d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x3edb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x3ea1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x2448
leaq -0xb0(%rbp), %rdi
callq 0x2448
jmp 0x3edb
movq -0xc8(%rbp), %rsi
movq -0xc0(%rbp), %rdi
callq 0x4220
leaq -0x38(%rbp), %rdi
callq 0x2448
movq -0xb8(%rbp), %rax
addq $0xe0, %rsp
popq %rbp
retq
leaq -0x38(%rbp), %rdi
callq 0x2448
movq -0x48(%rbp), %rdi
callq 0x23d0
nopl (%rax)
// File: tomfunkhouser[P]gaps/apps/gapsview/gapsview.cpp
// Function: main
int 
main(int argc, char **argv)
{
  // Initialize GLUT
  GLUTInit(&argc, argv);

  // Parse program arguments
  if (!ParseArgs(argc, argv)) exit(-1);

  // Read data
  if (!ReadFiles()) exit(-1);

  // Run GLUT interface
  GLUTMainLoop();

  // Return success 
  return 0;
}

// Assembly:
subq $0x18, %rsp
movl $0x0, 0x14(%rsp)
movl %edi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rsi
leaq 0x10(%rsp), %rdi
callq 0x2ecc0
movl 0x10(%rsp), %edi
movq 0x8(%rsp), %rsi
callq 0x2ee30
cmpl $0x0, %eax
jne 0x2ec91
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x29c60
callq 0x2f810
cmpl $0x0, %eax
jne 0x2eca5
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x29c60
callq 0x2e530
xorl %eax, %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/apps/gapsview/gapsview.cpp
// Function: GLUTRedraw()
static void
GLUTRedraw(void)
{
  // Clear window 
  glClearColor(background_color[0], background_color[1], background_color[2], 1.0);
  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

  // Set viewing transformation
  viewer->Camera().Load();

  // Set lights
  static GLfloat light0_position[] = { 3.0, 4.0, 5.0, 0.0 };
  glLightfv(GL_LIGHT0, GL_POSITION, light0_position);
  static GLfloat light1_position[] = { -3.0, -2.0, -3.0, 0.0 };
  glLightfv(GL_LIGHT1, GL_POSITION, light1_position);

  // Draw everything
  DrawData(color_scheme);
  DrawSelectedPosition();
  DrawBBox();
  DrawAxes();

  // Swap buffers 
  glutSwapBuffers();
}

// Assembly:
pushq %rax
movsd 0x2bfd67(%rip), %xmm0   # 0x2efb30
cvtsd2ss %xmm0, %xmm0
movsd 0x2bfd63(%rip), %xmm1   # 0x2efb38
cvtsd2ss %xmm1, %xmm1
movsd 0x2bfd5f(%rip), %xmm2   # 0x2efb40
cvtsd2ss %xmm2, %xmm2
movss 0x236327(%rip), %xmm3   # 0x266114
callq 0x29250
movl $0x4100, %edi           # imm = 0x4100
callq 0x29a70
movq 0x2ceead(%rip), %rdi    # 0x2fecb0
callq 0x38d50
movq %rax, %rdi
xorl %esi, %esi
callq 0xeed00
movl $0x4000, %edi           # imm = 0x4000
movl $0x1203, %esi           # imm = 0x1203
leaq 0x2bfd2d(%rip), %rdx    # 0x2efb50
callq 0x293d0
movl $0x4001, %edi           # imm = 0x4001
movl $0x1203, %esi           # imm = 0x1203
leaq 0x2bfd27(%rip), %rdx    # 0x2efb60
callq 0x293d0
movl 0x2bfd2c(%rip), %edi    # 0x2efb70
callq 0x30d70
callq 0x31070
callq 0x31110
callq 0x31160
callq 0x1f41f0
popq %rax
retq
nop
// File: tomfunkhouser[P]gaps/apps/gapsview/gapsview.cpp
// Function: GLUTMotion(int, int)
static void
GLUTMotion(int x, int y)
{
  // Invert y coordinate
  y = GLUTwindow_height - y;

  // Compute mouse movement
  int dx = x - GLUTmouse[0];
  int dy = y - GLUTmouse[1];
  
  // World in hand navigation 
  if (GLUTbutton[0]) viewer->RotateWorld(1.0, world_origin, x, y, dx, dy);
  else if (GLUTbutton[1]) viewer->ScaleWorld(1.0, world_origin, x, y, dx, dy);
  else if (GLUTbutton[2]) viewer->TranslateWorld(1.0, world_origin, x, y, dx, dy);
  if (GLUTbutton[0] || GLUTbutton[1] || GLUTbutton[2]) glutPostRedisplay();

  // Remember mouse position 
  GLUTmouse[0] = x;
  GLUTmouse[1] = y;

  // Update mouse drag movement
  GLUTmouse_drag_distance_squared += dx*dx + dy*dy;
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
movl %esi, 0x10(%rsp)
movl 0x2beeb2(%rip), %eax    # 0x2efaf4
subl 0x10(%rsp), %eax
movl %eax, 0x10(%rsp)
movl 0x14(%rsp), %eax
subl 0x2ce2b4(%rip), %eax    # 0x2fef08
movl %eax, 0xc(%rsp)
movl 0x10(%rsp), %eax
subl 0x2ce2aa(%rip), %eax    # 0x2fef0c
movl %eax, 0x8(%rsp)
cmpl $0x0, 0x2ce2ab(%rip)    # 0x2fef18
je 0x30c9f
movq 0x2ce03a(%rip), %rdi    # 0x2fecb0
movl 0x14(%rsp), %edx
movl 0x10(%rsp), %ecx
movl 0xc(%rsp), %r8d
movl 0x8(%rsp), %r9d
movq (%rdi), %rax
movsd 0x23537d(%rip), %xmm0   # 0x266010
leaq 0x2cdbd6(%rip), %rsi    # 0x2fe870
callq *0x58(%rax)
jmp 0x30d13
cmpl $0x0, 0x2ce276(%rip)    # 0x2fef1c
je 0x30cd8
movq 0x2ce001(%rip), %rdi    # 0x2fecb0
movl 0x14(%rsp), %edx
movl 0x10(%rsp), %ecx
movl 0xc(%rsp), %r8d
movl 0x8(%rsp), %r9d
movq (%rdi), %rax
movsd 0x235344(%rip), %xmm0   # 0x266010
leaq 0x2cdb9d(%rip), %rsi    # 0x2fe870
callq *0x50(%rax)
jmp 0x30d11
cmpl $0x0, 0x2ce241(%rip)    # 0x2fef20
je 0x30d0f
movq 0x2cdfc8(%rip), %rdi    # 0x2fecb0
movl 0x14(%rsp), %edx
movl 0x10(%rsp), %ecx
movl 0xc(%rsp), %r8d
movl 0x8(%rsp), %r9d
movq (%rdi), %rax
movsd 0x23530b(%rip), %xmm0   # 0x266010
leaq 0x2cdb64(%rip), %rsi    # 0x2fe870
callq *0x48(%rax)
jmp 0x30d11
jmp 0x30d13
cmpl $0x0, 0x2ce1fe(%rip)    # 0x2fef18
jne 0x30d2e
cmpl $0x0, 0x2ce1f9(%rip)    # 0x2fef1c
jne 0x30d2e
cmpl $0x0, 0x2ce1f4(%rip)    # 0x2fef20
je 0x30d33
callq 0x1f4190
movl 0x14(%rsp), %eax
movl %eax, 0x2ce1cb(%rip)    # 0x2fef08
movl 0x10(%rsp), %eax
movl %eax, 0x2ce1c5(%rip)    # 0x2fef0c
movl 0xc(%rsp), %eax
imull 0xc(%rsp), %eax
movl 0x8(%rsp), %ecx
imull 0x8(%rsp), %ecx
addl %ecx, %eax
addl 0x2ce1b3(%rip), %eax    # 0x2fef14
movl %eax, 0x2ce1ad(%rip)    # 0x2fef14
addq $0x18, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/apps/gapsview/gapsview.cpp
// Function: DrawSelectedPosition()
static void
DrawSelectedPosition(void)
{
  // Check if should draw selected position
  if (!show_selected_position) return;

  // Draw sphere
  glEnable(GL_LIGHTING);
  RNLoadRgb(1, 0, 0);
  R3Sphere(selected_position, 0.05).Draw();
}

// Assembly:
subq $0x48, %rsp
cmpl $0x0, 0x2beb29(%rip)    # 0x2efba4
jne 0x3107f
jmp 0x310dc
movl $0xb50, %edi            # imm = 0xB50
callq 0x29a50
movl $0x1, %edi
xorl %edx, %edx
movl %edx, %esi
callq 0x39820
leaq 0x2cd7ea(%rip), %rsi    # 0x2fe888
leaq 0x20(%rsp), %rdi
movsd 0x234fd5(%rip), %xmm0   # 0x266080
callq 0x14d530
leaq 0x18(%rsp), %rdi
movl $0x772, %esi            # imm = 0x772
callq 0x38e50
jmp 0x310c1
movq 0x18(%rsp), %rsi
leaq 0x20(%rsp), %rdi
callq 0xf8e00
jmp 0x310d2
leaq 0x20(%rsp), %rdi
callq 0x398c0
addq $0x48, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x10(%rsp)
movl %eax, 0xc(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x398c0
movq 0x10(%rsp), %rdi
callq 0x29c10
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/apps/gapsview/gapsview.cpp
// Function: DrawBBox()
static void
DrawBBox(void)
{
  // Check if should draw bbox
  if (!show_bbox) return;

  // Draw bounding box
  glDisable(GL_LIGHTING);
  RNLoadRgb(0.5, 0.5, 0.5);
  world_bbox.Outline();
}

// Assembly:
pushq %rax
cmpl $0x0, 0x2cdde4(%rip)    # 0x2feefc
jne 0x3111c
jmp 0x31156
movl $0xb50, %edi            # imm = 0xB50
callq 0x2a130
movsd 0x234f22(%rip), %xmm2   # 0x266050
movaps %xmm2, %xmm0
movaps %xmm2, %xmm1
callq 0x38d60
movq %rsp, %rdi
movl $0x1, %esi
callq 0x38e50
movq (%rsp), %rsi
leaq 0x2cd6e7(%rip), %rdi    # 0x2fe838
callq 0x154bd0
popq %rax
retq
nopl (%rax,%rax)