LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: mitchellsayer[P]FastPointCloudSegmentation/src/./nanoflann.hpp
// Function: bool nanoflann::KDTreeSingleIndexAdaptor<nanoflann::L2_Simple_Adaptor<float, ScanlinePointCloud, float>, ScanlinePointCloud, 3, unsigned long>::findNeighbors<nanoflann::KNNResultSet<float, unsigned long, unsigned long>>(nanoflann::KNNResultSet<float, unsigned long, unsigned long>&, float const*, nanoflann::SearchParams const&) const
bool findNeighbors(RESULTSET& result, const ElementType* vec, const SearchParams& searchParams) const
		{
			assert(vec);
            if (size() == 0)
                return false;
			if (!root_node)
                throw std::runtime_error("[nanoflann] findNeighbors() called before building the index.");
			float epsError = 1+searchParams.eps;

			distance_vector_t dists; // fixed or variable-sized container (depending on DIM)
			dists.assign((DIM>0 ? DIM : dim) ,0); // Fill it with zeros.
			DistanceType distsq = computeInitialDistances(vec, dists);
			searchLevel(result, vec, root_node, distsq, dists, epsError);  // "count_leaf" parameter removed since was neither used nor returned to the user.
            return result.full();
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x6cf9
jmp 0x6d18
leaq 0xb558(%rip), %rdi      # 0x12258
leaq 0xb555(%rip), %rsi      # 0x1225c
movl $0x387, %edx            # imm = 0x387
leaq 0xb559(%rip), %rcx      # 0x1226c
callq 0x2100
movq -0x58(%rbp), %rdi
callq 0x11330
cmpq $0x0, %rax
jne 0x6d30
movb $0x0, -0x1(%rbp)
jmp 0x6e05
movq -0x58(%rbp), %rax
cmpq $0x0, 0x48(%rax)
jne 0x6d8e
movl $0x10, %edi
callq 0x20c0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x60(%rbp)
leaq 0xb696(%rip), %rsi      # 0x123ec
callq 0x2080
jmp 0x6d5d
movq -0x60(%rbp), %rdi
movq 0x13288(%rip), %rsi     # 0x19ff0
movq 0x13241(%rip), %rdx     # 0x19fb0
callq 0x2350
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x2140
jmp 0x6e10
movq -0x28(%rbp), %rax
movss 0xb27a(%rip), %xmm0     # 0x12014
addss 0x4(%rax), %xmm0
movss %xmm0, -0x38(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x48(%rbp)
leaq -0x44(%rbp), %rdi
movl $0x3, %esi
leaq -0x48(%rbp), %rdx
callq 0x11350
movq -0x58(%rbp), %rdi
movq -0x20(%rbp), %rsi
leaq -0x44(%rbp), %rdx
callq 0x113d0
movq -0x58(%rbp), %rdi
movss %xmm0, -0x4c(%rbp)
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq 0x48(%rdi), %rcx
movss -0x4c(%rbp), %xmm0
movss -0x38(%rbp), %xmm1
leaq -0x44(%rbp), %r8
callq 0x115a0
movq -0x18(%rbp), %rdi
callq 0x11880
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x2370
nopl (%rax)
// File: mitchellsayer[P]FastPointCloudSegmentation/src/./point_cloud_segmenter.h
// Function: PointCloudSegmenter::PointCloudSegmenter(int, int, int, int, int, double, double, int, double, double)
PointCloudSegmenter(int m_x, int m_y, int iterations, int num_lpr, int num_segs, double seed_thresh, double dist_thresh, int n_scan, double run_thresh, double merge_thresh) { //Constructor
      n_iter = iterations;
      n_lpr = num_lpr;
      n_segs = num_segs;
      th_seeds = seed_thresh;
      th_dist = dist_thresh;
      max_x = m_x;
      max_y = m_y;
      n_scanlines = n_scan;
      th_run = run_thresh;
      th_merge = merge_thresh;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movl %r9d, -0x1c(%rbp)
movsd %xmm0, -0x28(%rbp)
movsd %xmm1, -0x30(%rbp)
movsd %xmm2, -0x38(%rbp)
movsd %xmm3, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x57b0
movq -0x48(%rbp), %rdi
addq $0x18, %rdi
callq 0x57b0
movq -0x48(%rbp), %rdi
addq $0x30, %rdi
callq 0x57b0
movq -0x48(%rbp), %rdi
addq $0x88, %rdi
callq 0x6010
movq -0x48(%rbp), %rdi
addq $0xa0, %rdi
callq 0x6010
movq -0x48(%rbp), %rdi
addq $0xb8, %rdi
callq 0x6010
movq -0x48(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, 0x58(%rax)
movl -0x18(%rbp), %ecx
movl %ecx, 0x5c(%rax)
movl -0x1c(%rbp), %ecx
movl %ecx, 0x60(%rax)
movsd -0x28(%rbp), %xmm0
movsd %xmm0, 0x48(%rax)
movsd -0x30(%rbp), %xmm0
movsd %xmm0, 0x50(%rax)
movl -0xc(%rbp), %ecx
movl %ecx, 0x80(%rax)
movl -0x10(%rbp), %ecx
movl %ecx, 0x84(%rax)
movl 0x10(%rbp), %ecx
movl %ecx, 0x64(%rax)
movsd -0x38(%rbp), %xmm0
movsd %xmm0, 0x70(%rax)
movsd -0x40(%rbp), %xmm0
movsd %xmm0, 0x78(%rax)
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: mitchellsayer[P]FastPointCloudSegmentation/src/./vec3.h
// Function: Vec3::Vec3(float, float, float)
Vec3(float a, float b, float c) : x(a), y(b), z(c) {
      r = sqrt(x*x + y*y);
      theta = atan2(z, r) * 180 / 3.1415926;
      label = -1;
      theta_horizontal = atan2(y, x) - 3.14159265/2;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movss %xmm1, -0x10(%rbp)
movss %xmm2, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movss -0xc(%rbp), %xmm0
movss %xmm0, (%rax)
movss -0x10(%rbp), %xmm0
movss %xmm0, 0x4(%rax)
movss -0x14(%rbp), %xmm0
movss %xmm0, 0x8(%rax)
movss (%rax), %xmm0
movss (%rax), %xmm2
movss 0x4(%rax), %xmm1
mulss 0x4(%rax), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
callq 0x5c00
movq -0x20(%rbp), %rax
movss %xmm0, 0xc(%rax)
movss 0x8(%rax), %xmm0
movss 0xc(%rax), %xmm1
callq 0x9570
movq -0x20(%rbp), %rax
movss 0xad11(%rip), %xmm1     # 0x12024
mulss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0xad35(%rip), %xmm1     # 0x12058
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x10(%rax)
movss 0xaccc(%rip), %xmm0     # 0x12004
movss %xmm0, 0x18(%rax)
movss 0x4(%rax), %xmm0
movss (%rax), %xmm1
callq 0x9570
movq -0x20(%rbp), %rax
cvtss2sd %xmm0, %xmm0
movsd 0xacf5(%rip), %xmm1     # 0x12050
subsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x14(%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: mitchellsayer[P]FastPointCloudSegmentation/src/./nanoflann.hpp
// Function: nanoflann::PooledAllocator::free_all()
void free_all()
		{
			while (base != NULL) {
				void *prev = *(static_cast<void**>( base)); /* Get pointer to prev block. */
				::free(base);
				base = prev;
			}
			internal_init();
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x8245
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
movq (%rcx), %rcx
movq %rcx, -0x10(%rbp)
movq 0x8(%rax), %rdi
callq 0x2250
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
jmp 0x8214
movq -0x18(%rbp), %rdi
callq 0x8260
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: mitchellsayer[P]FastPointCloudSegmentation/src/./nanoflann.hpp
// Function: nanoflann::KDTreeSingleIndexAdaptor<nanoflann::L2_Simple_Adaptor<float, ScanlinePointCloud, float>, ScanlinePointCloud, 3, unsigned long>::init_vind()
void init_vind()
		{
			// Create a permutable array of indices to the input vectors.
			m_size = dataset.kdtree_get_point_count();
			if (vind.size()!=m_size) vind.resize(m_size);
			for (size_t i = 0; i < m_size; i++) vind[i] = i;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x20(%rax), %rdi
callq 0xf2f0
movq -0x18(%rbp), %rdi
movq %rax, 0x30(%rdi)
callq 0xf450
movq -0x18(%rbp), %rcx
cmpq 0x30(%rcx), %rax
je 0xf351
movq -0x18(%rbp), %rdi
movq 0x30(%rdi), %rsi
callq 0xf470
movq $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
cmpq 0x30(%rcx), %rax
jae 0xf391
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rsi
callq 0xf500
movq -0x20(%rbp), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0xf359
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: mitchellsayer[P]FastPointCloudSegmentation/src/./nanoflann.hpp
// Function: nanoflann::PooledAllocator::malloc(unsigned long)
void* malloc(const size_t req_size)
		{
			/* Round size up to a multiple of wordsize.  The following expression
			    only works for WORDSIZE that is a power of 2, by masking last bits of
			    incremented size to zero.
			 */
			const size_t size = (req_size + (WORDSIZE - 1)) & ~(WORDSIZE - 1);

			/* Check whether a new block must be allocated.  Note that the first word
			    of a block is reserved for a pointer to the previous block.
			 */
			if (size > remaining) {

				wastedMemory += remaining;

				/* Allocate new storage. */
				const size_t blocksize = (size + sizeof(void*) + (WORDSIZE-1) > BLOCKSIZE) ?
							size + sizeof(void*) + (WORDSIZE-1) : BLOCKSIZE;

				// use the standard C malloc to allocate memory
				void* m = ::malloc(blocksize);
				if (!m) {
					fprintf(stderr,"Failed to allocate memory.\n");
					return NULL;
				}

				/* Fill first word of new block with pointer to previous block. */
				static_cast<void**>(m)[0] = base;
				base = m;

				size_t shift = 0;
				//int size_t = (WORDSIZE - ( (((size_t)m) + sizeof(void*)) & (WORDSIZE-1))) & (WORDSIZE-1);

				remaining = blocksize - sizeof(void*) - shift;
				loc = (static_cast<char*>(m) + sizeof(void*) + shift);
			}
			void* rloc = loc;
			loc = static_cast<char*>(loc) + size;
			remaining -= size;

			usedMemory += size;

			return rloc;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x48(%rbp)
movq -0x18(%rbp), %rax
addq $0xf, %rax
andq $-0x10, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq (%rcx), %rax
jbe 0x10b61
movq -0x48(%rbp), %rax
movq (%rax), %rcx
addq 0x20(%rax), %rcx
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rax
addq $0x8, %rax
addq $0xf, %rax
cmpq $0x2000, %rax           # imm = 0x2000
jbe 0x10ada
movq -0x20(%rbp), %rax
addq $0x8, %rax
addq $0xf, %rax
movq %rax, -0x50(%rbp)
jmp 0x10ae5
movl $0x2000, %eax           # imm = 0x2000
movq %rax, -0x50(%rbp)
jmp 0x10ae5
movq -0x50(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x2280
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x10b23
movq 0x94c0(%rip), %rax      # 0x19fc8
movq (%rax), %rdi
leaq 0x16e0(%rip), %rsi      # 0x121f2
movb $0x0, %al
callq 0x22b0
movq $0x0, -0x8(%rbp)
jmp 0x10b9a
movq -0x48(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x30(%rbp), %rcx
movq %rdx, (%rcx)
movq -0x30(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq $0x0, -0x38(%rbp)
movq -0x28(%rbp), %rcx
subq $0x8, %rcx
subq -0x38(%rbp), %rcx
movq %rcx, (%rax)
movq -0x30(%rbp), %rcx
addq $0x8, %rcx
addq -0x38(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x48(%rbp), %rax
movq 0x10(%rax), %rcx
movq %rcx, -0x40(%rbp)
movq 0x10(%rax), %rcx
addq -0x20(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rdx
movq (%rax), %rcx
subq %rdx, %rcx
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
addq 0x18(%rax), %rcx
movq %rcx, 0x18(%rax)
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: mitchellsayer[P]FastPointCloudSegmentation/src/./nanoflann.hpp
// Function: nanoflann::KDTreeSingleIndexAdaptor<nanoflann::L2_Simple_Adaptor<float, ScanlinePointCloud, float>, ScanlinePointCloud, 3, unsigned long>::computeMinMax(unsigned long*, unsigned long, int, float&, float&)
void computeMinMax(IndexType* ind, IndexType count, int element, ElementType& min_elem, ElementType& max_elem)
		{
			min_elem = dataset_get(ind[0],element);
			max_elem = dataset_get(ind[0],element);
			for (IndexType i=1; i<count; ++i) {
				ElementType val = dataset_get(ind[i],element);
				if (val<min_elem) min_elem = val;
				if (val>max_elem) max_elem = val;
			}
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movl -0x1c(%rbp), %edx
callq 0x105e0
movq -0x48(%rbp), %rdi
movq -0x28(%rbp), %rax
movss %xmm0, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movl -0x1c(%rbp), %edx
callq 0x105e0
movq -0x30(%rbp), %rax
movss %xmm0, (%rax)
movq $0x1, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x10ca2
movq -0x48(%rbp), %rdi
movq -0x10(%rbp), %rax
movq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movl -0x1c(%rbp), %edx
callq 0x105e0
movss %xmm0, -0x3c(%rbp)
movss -0x3c(%rbp), %xmm1
movq -0x28(%rbp), %rax
movss (%rax), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x10c77
movss -0x3c(%rbp), %xmm0
movq -0x28(%rbp), %rax
movss %xmm0, (%rax)
movss -0x3c(%rbp), %xmm0
movq -0x30(%rbp), %rax
ucomiss (%rax), %xmm0
jbe 0x10c92
movss -0x3c(%rbp), %xmm0
movq -0x30(%rbp), %rax
movss %xmm0, (%rax)
jmp 0x10c94
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x10c31
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: mitchellsayer[P]FastPointCloudSegmentation/src/./nanoflann.hpp
// Function: nanoflann::KDTreeSingleIndexAdaptor<nanoflann::L2_Simple_Adaptor<float, ScanlinePointCloud, float>, ScanlinePointCloud, 3, unsigned long>::computeInitialDistances(float const*, nanoflann::CArray<float, 3ul>&) const
DistanceType computeInitialDistances(const ElementType* vec, distance_vector_t& dists) const
		{
			assert(vec);
			DistanceType distsq = DistanceType();

			for (int i = 0; i < (DIM>0 ? DIM : dim); ++i) {
				if (vec[i] < root_bbox[i].low) {
					dists[i] = distance.accum_dist(vec[i], root_bbox[i].low, i);
					distsq += dists[i];
				}
				if (vec[i] > root_bbox[i].high) {
					dists[i] = distance.accum_dist(vec[i], root_bbox[i].high, i);
					distsq += dists[i];
				}
			}

			return distsq;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x113f5
jmp 0x11414
leaq 0xe5c(%rip), %rdi       # 0x12258
leaq 0xe59(%rip), %rsi       # 0x1225c
movl $0x4a1, %edx            # imm = 0x4A1
leaq 0x1075(%rip), %rcx      # 0x12484
callq 0x2100
xorps %xmm0, %xmm0
movss %xmm0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
cmpl $0x3, -0x20(%rbp)
jge 0x11593
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
movss %xmm0, -0x2c(%rbp)
addq $0x50, %rdi
movslq -0x20(%rbp), %rsi
callq 0x10bb0
movss -0x2c(%rbp), %xmm1
movss (%rax), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x114d9
movq -0x28(%rbp), %rdi
movq %rdi, %rax
addq $0x90, %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
movss %xmm0, -0x34(%rbp)
addq $0x50, %rdi
movslq -0x20(%rbp), %rsi
callq 0x10bb0
movq -0x40(%rbp), %rdi
movss -0x34(%rbp), %xmm0
movss (%rax), %xmm1
movl -0x20(%rbp), %esi
callq 0x118a0
movss %xmm0, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movslq -0x20(%rbp), %rsi
callq 0x118d0
movss -0x30(%rbp), %xmm0
movss %xmm0, (%rax)
movq -0x18(%rbp), %rdi
movslq -0x20(%rbp), %rsi
callq 0x118d0
movss (%rax), %xmm0
addss -0x1c(%rbp), %xmm0
movss %xmm0, -0x1c(%rbp)
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
movss %xmm0, -0x44(%rbp)
addq $0x50, %rdi
movslq -0x20(%rbp), %rsi
callq 0x10bb0
movss -0x44(%rbp), %xmm0
ucomiss 0x4(%rax), %xmm0
jbe 0x11583
movq -0x28(%rbp), %rdi
movq %rdi, %rax
addq $0x90, %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
movss %xmm0, -0x4c(%rbp)
addq $0x50, %rdi
movslq -0x20(%rbp), %rsi
callq 0x10bb0
movq -0x58(%rbp), %rdi
movss -0x4c(%rbp), %xmm0
movss 0x4(%rax), %xmm1
movl -0x20(%rbp), %esi
callq 0x118a0
movss %xmm0, -0x48(%rbp)
movq -0x18(%rbp), %rdi
movslq -0x20(%rbp), %rsi
callq 0x118d0
movss -0x48(%rbp), %xmm0
movss %xmm0, (%rax)
movq -0x18(%rbp), %rdi
movslq -0x20(%rbp), %rsi
callq 0x118d0
movss (%rax), %xmm0
addss -0x1c(%rbp), %xmm0
movss %xmm0, -0x1c(%rbp)
jmp 0x11585
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x11423
movss -0x1c(%rbp), %xmm0
addq $0x60, %rsp
popq %rbp
retq
nop
// File: mitchellsayer[P]FastPointCloudSegmentation/src/./nanoflann.hpp
// Function: nanoflann::KNNResultSet<float, unsigned long, unsigned long>::addPoint(float, unsigned long)
inline void addPoint(DistanceType dist, IndexType index)
		{
			CountType i;
			for (i=count; i>0; --i) {
#ifdef NANOFLANN_FIRST_MATCH   // If defined and two points have the same distance, the one with the lowest-index will be returned first.
				if ( (dists[i-1]>dist) || ((dist==dists[i-1])&&(indices[i-1]>index)) ) {
#else
				if (dists[i-1]>dist) {
#endif
					if (i<capacity) {
						dists[i] = dists[i-1];
						indices[i] = indices[i-1];
					}
				}
				else break;
			}
			if (i<capacity) {
				dists[i] = dist;
				indices[i] = index;
			}
			if (count<capacity) count++;
		}

		inline DistanceType worstDist() const
		{
			return dists[capacity-1];
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jbe 0x11a11
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rcx
subq $0x1, %rcx
movss (%rax,%rcx,4), %xmm0
ucomiss -0xc(%rbp), %xmm0
jbe 0x119ff
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
cmpq 0x10(%rcx), %rax
jae 0x119fd
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x20(%rbp), %rdx
subq $0x1, %rdx
movss (%rcx,%rdx,4), %xmm0
movq 0x8(%rax), %rcx
movq -0x20(%rbp), %rdx
movss %xmm0, (%rcx,%rdx,4)
movq (%rax), %rcx
movq -0x20(%rbp), %rdx
subq $0x1, %rdx
movq (%rcx,%rdx,8), %rdx
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
jmp 0x11a01
jmp 0x11a11
jmp 0x11a03
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x11991
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
cmpq 0x10(%rcx), %rax
jae 0x11a44
movq -0x28(%rbp), %rax
movss -0xc(%rbp), %xmm0
movq 0x8(%rax), %rcx
movq -0x20(%rbp), %rdx
movss %xmm0, (%rcx,%rdx,4)
movq -0x18(%rbp), %rdx
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x28(%rbp), %rcx
movq 0x18(%rcx), %rax
cmpq 0x10(%rcx), %rax
jae 0x11a62
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x18(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: mitchellsayer[P]FastPointCloudSegmentation/src/./vec3.h
// Function: Vec3::distance_squared(float const*) const
float distance_squared(const float * v1) const {
      float x_new = this->x - v1[0];
      float y_new = this->y - v1[1];
      float z_new = this->z - v1[2];
      return x_new * x_new + y_new * y_new + z_new * z_new;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movss (%rax), %xmm0
movq -0x10(%rbp), %rcx
subss (%rcx), %xmm0
movss %xmm0, -0x14(%rbp)
movss 0x4(%rax), %xmm0
movq -0x10(%rbp), %rcx
subss 0x4(%rcx), %xmm0
movss %xmm0, -0x18(%rbp)
movss 0x8(%rax), %xmm0
movq -0x10(%rbp), %rax
subss 0x8(%rax), %xmm0
movss %xmm0, -0x1c(%rbp)
movss -0x14(%rbp), %xmm1
movss -0x14(%rbp), %xmm2
movss -0x18(%rbp), %xmm0
mulss -0x18(%rbp), %xmm0
mulss %xmm2, %xmm1
addss %xmm0, %xmm1
movss -0x1c(%rbp), %xmm0
movss -0x1c(%rbp), %xmm2
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
popq %rbp
retq
nopw (%rax,%rax)
// File: ddu1[P]polarizedtext/src/args.cc
// Function: fasttext::Args::Args()
Args::Args() {
  lr = 0.05;
  dim = 100;
  ws = 5;
  epoch = 5;
  minCount = 1;
  minCountLabel = 0;
  neg = 5;
  wordNgrams = 1;
  loss = loss_name::ns;
  model = model_name::sg;
  bucket = 2000000;
  minn = 3;
  maxn = 6;
  thread = 12;
  lrUpdateRate = 100;
  t = 1e-4;
  label = "__label__";
  verbose = 2;
  pretrainedVectors = "";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
callq 0x4480
movq -0x28(%rbp), %rdi
addq $0x20, %rdi
movq %rdi, -0x40(%rbp)
callq 0x4480
movq -0x28(%rbp), %rdi
addq $0x40, %rdi
movq %rdi, -0x38(%rbp)
callq 0x4480
movq -0x28(%rbp), %rdi
addq $0xa8, %rdi
movq %rdi, -0x20(%rbp)
callq 0x4480
movq -0x28(%rbp), %rdi
addq $0xd0, %rdi
movq %rdi, -0x30(%rbp)
callq 0x4480
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rdi
movabsq $0x3fa999999999999a, %rcx # imm = 0x3FA999999999999A
movq %rcx, 0x60(%rax)
movl $0x64, 0x6c(%rax)
movl $0x5, 0x70(%rax)
movl $0x5, 0x74(%rax)
movl $0x1, 0x78(%rax)
movl $0x0, 0x7c(%rax)
movl $0x5, 0x80(%rax)
movl $0x1, 0x84(%rax)
movl $0x2, 0x88(%rax)
movl $0x2, 0x8c(%rax)
movl $0x1e8480, 0x90(%rax)   # imm = 0x1E8480
movl $0x3, 0x94(%rax)
movl $0x6, 0x98(%rax)
movl $0xc, 0x9c(%rax)
movl $0x64, 0x68(%rax)
movabsq $0x3f1a36e2eb1c432d, %rcx # imm = 0x3F1A36E2EB1C432D
movq %rcx, 0xa0(%rax)
leaq 0x244ae(%rip), %rsi     # 0x29010
callq 0x4470
jmp 0x4b69
movq -0x48(%rbp), %rdi
movl $0x2, 0xc8(%rdi)
addq $0xd0, %rdi
leaq 0x255b7(%rip), %rsi     # 0x2a13c
callq 0x4470
jmp 0x4b8c
addq $0x50, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x4688
movq -0x20(%rbp), %rdi
callq 0x4688
movq -0x38(%rbp), %rdi
callq 0x4688
movq -0x40(%rbp), %rdi
callq 0x4688
movq -0x28(%rbp), %rdi
callq 0x4688
movq -0x10(%rbp), %rdi
callq 0x45b0
nopw %cs:(%rax,%rax)
// File: ddu1[P]polarizedtext/src/dictionary.cc
// Function: fasttext::Dictionary::Dictionary(std::shared_ptr<fasttext::Args>)
Dictionary::Dictionary(std::shared_ptr<Args> args) {
  args_ = args;
  size_ = 0;
  nwords_ = 0;
  nlabels_ = 0;
  ntokens_ = 0;
  word2int_.resize(MAX_VOCAB_SIZE);
  for (int32_t i = 0; i < MAX_VOCAB_SIZE; i++) {
    word2int_[i] = -1;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rsi, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
callq 0x9e20
movq -0x28(%rbp), %rdi
addq $0x10, %rdi
movq %rdi, -0x30(%rbp)
callq 0x9e40
movq -0x28(%rbp), %rdi
addq $0x28, %rdi
movq %rdi, -0x50(%rbp)
callq 0x9e60
movq -0x28(%rbp), %rdi
addq $0x40, %rdi
movq %rdi, -0x48(%rbp)
callq 0x9e80
movq -0x28(%rbp), %rdi
addq $0x70, %rdi
movq %rdi, -0x40(%rbp)
callq 0x4480
movq -0x38(%rbp), %rsi
movq -0x28(%rbp), %rdi
callq 0x9ea0
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rax
movl $0x0, 0x58(%rax)
movl $0x0, 0x5c(%rax)
movl $0x0, 0x60(%rax)
movq $0x0, 0x68(%rax)
movl $0x1c9c380, %esi        # imm = 0x1C9C380
callq 0x9ed0
jmp 0x663a
movl $0x0, -0x20(%rbp)
cmpl $0x1c9c380, -0x20(%rbp) # imm = 0x1C9C380
jge 0x66a7
movq -0x58(%rbp), %rdi
addq $0x10, %rdi
movslq -0x20(%rbp), %rsi
callq 0x9f60
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x6641
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x4688
movq -0x48(%rbp), %rdi
callq 0x9f80
movq -0x50(%rbp), %rdi
callq 0x9fe0
movq -0x30(%rbp), %rdi
callq 0xa040
movq -0x28(%rbp), %rdi
callq 0xa0a0
jmp 0x66ad
addq $0x60, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x45b0
nopw %cs:(%rax,%rax)
// File: ddu1[P]polarizedtext/src/dictionary.cc
// Function: fasttext::Dictionary::getLabels(int)
std::vector<int32_t> Dictionary::getLabels( int32_t i) {
  assert(i >= 0);
  assert(i < nwords_);
  auto labels = words_[i].labels;
  std::vector<int32_t> label_ids;
  for( auto label : labels) {
      int32_t wid = getId(label);
      assert( wid >= nwords_ );  // 
      label_ids.push_back( wid-nwords_);
  }
  std::sort( label_ids.begin(), label_ids.end());
  return label_ids;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0xb0(%rbp)
movq %rdi, %rax
movq %rax, -0xa8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xa0(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0x6c2a
jmp 0x6c49
leaq 0x229f6(%rip), %rdi     # 0x29627
leaq 0x229f6(%rip), %rsi     # 0x2962e
movl $0x66, %edx
leaq 0x229fc(%rip), %rcx     # 0x29640
callq 0x41d0
movq -0xa0(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x5c(%rcx), %eax
jge 0x6c5a
jmp 0x6c79
leaq 0x22a1d(%rip), %rdi     # 0x2967e
leaq 0x229c6(%rip), %rsi     # 0x2962e
movl $0x67, %edx
leaq 0x229cc(%rip), %rcx     # 0x29640
callq 0x41d0
movq -0xa0(%rbp), %rdi
addq $0x28, %rdi
movslq -0x14(%rbp), %rsi
callq 0xa2b0
movq %rax, %rsi
addq $0x50, %rsi
leaq -0x30(%rbp), %rdi
callq 0xa480
movq -0xb0(%rbp), %rdi
movb $0x0, -0x31(%rbp)
callq 0x9e40
leaq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0xa420
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rdi
callq 0xa450
movq %rax, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0xa570
testb $0x1, %al
jne 0x6ce5
jmp 0x6db9
leaq -0x48(%rbp), %rdi
callq 0xa5b0
movq %rax, %rsi
leaq -0x70(%rbp), %rdi
callq 0x4100
jmp 0x6cfc
movq -0xa0(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x6e50
movl %eax, -0xb4(%rbp)
jmp 0x6d14
movq -0xa0(%rbp), %rcx
movl -0xb4(%rbp), %eax
movl %eax, -0x80(%rbp)
movl -0x80(%rbp), %eax
cmpl 0x5c(%rcx), %eax
jl 0x6d2e
jmp 0x6d78
leaq 0x22955(%rip), %rdi     # 0x2968a
leaq 0x228f2(%rip), %rsi     # 0x2962e
movl $0x6c, %edx
leaq 0x228f8(%rip), %rcx     # 0x29640
callq 0x41d0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x6e23
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x4688
jmp 0x6e23
movq -0xb0(%rbp), %rdi
movq -0xa0(%rbp), %rcx
movl -0x80(%rbp), %eax
movl 0x5c(%rcx), %ecx
subl %ecx, %eax
movl %eax, -0x84(%rbp)
leaq -0x84(%rbp), %rsi
callq 0xa5d0
jmp 0x6da2
leaq -0x70(%rbp), %rdi
callq 0x4688
leaq -0x48(%rbp), %rdi
callq 0xa600
jmp 0x6ccf
movq -0xb0(%rbp), %rdi
callq 0xa660
movq -0xb0(%rbp), %rdi
movq %rax, -0x90(%rbp)
callq 0xa690
movq %rax, -0x98(%rbp)
movq -0x90(%rbp), %rdi
movq -0x98(%rbp), %rsi
callq 0xa620
jmp 0x6df4
movb $0x1, -0x31(%rbp)
testb $0x1, -0x31(%rbp)
jne 0x6e0a
movq -0xb0(%rbp), %rdi
callq 0xa040
leaq -0x30(%rbp), %rdi
callq 0xa6c0
movq -0xa8(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
movq -0xb0(%rbp), %rdi
callq 0xa040
leaq -0x30(%rbp), %rdi
callq 0xa6c0
movq -0x78(%rbp), %rdi
callq 0x45b0
nopw %cs:(%rax,%rax)
// File: ddu1[P]polarizedtext/src/dictionary.cc
// Function: fasttext::Dictionary::discard(int, float) const
bool Dictionary::discard(int32_t id, real rand) const {
  assert(id >= 0);
  assert(id < nwords_);
  if (args_->model == model_name::sup) return false;
  return rand > pdiscard_[id];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movss %xmm0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0x7344
jmp 0x7363
leaq 0x224c1(%rip), %rdi     # 0x2980c
leaq 0x222dc(%rip), %rsi     # 0x2962e
movl $0x84, %edx
leaq 0x22386(%rip), %rcx     # 0x296e4
callq 0x41d0
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x5c(%rcx), %eax
jge 0x7371
jmp 0x7390
leaq 0x223a4(%rip), %rdi     # 0x2971c
leaq 0x222af(%rip), %rsi     # 0x2962e
movl $0x85, %edx
leaq 0x22359(%rip), %rcx     # 0x296e4
callq 0x41d0
movq -0x20(%rbp), %rdi
callq 0xa170
cmpl $0x3, 0x8c(%rax)
jne 0x73a8
movb $0x0, -0x1(%rbp)
jmp 0x73d3
movq -0x20(%rbp), %rdi
movss -0x18(%rbp), %xmm0
movss %xmm0, -0x24(%rbp)
addq $0x40, %rdi
movslq -0x14(%rbp), %rsi
callq 0xa8e0
movss -0x24(%rbp), %xmm0
ucomiss (%rax), %xmm0
seta %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nop
// File: ddu1[P]polarizedtext/src/dictionary.cc
// Function: fasttext::Dictionary::initTableDiscard()
void Dictionary::initTableDiscard() {
  pdiscard_.resize(size_);
  for (size_t i = 0; i < size_; i++) {
    real f = real(words_[i].count) / real(ntokens_);
    pdiscard_[i] = sqrt(args_->t / f) + args_->t / f;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq %rax, %rdi
addq $0x40, %rdi
movslq 0x58(%rax), %rsi
callq 0xaad0
movq $0x0, -0x10(%rbp)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movslq 0x58(%rcx), %rcx
cmpq %rcx, %rax
jae 0x7dca
movq -0x20(%rbp), %rdi
addq $0x28, %rdi
movq -0x10(%rbp), %rsi
callq 0xa2b0
movq -0x20(%rbp), %rdi
cvtsi2ssq 0x20(%rax), %xmm0
cvtsi2ssq 0x68(%rdi), %xmm1
divss %xmm1, %xmm0
movss %xmm0, -0x14(%rbp)
callq 0xa170
movsd 0xa0(%rax), %xmm0
movss -0x14(%rbp), %xmm1
cvtss2sd %xmm1, %xmm1
divsd %xmm1, %xmm0
callq 0x4260
movq -0x20(%rbp), %rdi
movsd %xmm0, -0x30(%rbp)
callq 0xa170
movsd -0x30(%rbp), %xmm0
movq -0x20(%rbp), %rdi
movsd 0xa0(%rax), %xmm1
movss -0x14(%rbp), %xmm2
cvtss2sd %xmm2, %xmm2
divsd %xmm2, %xmm1
addsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x24(%rbp)
addq $0x40, %rdi
movq -0x10(%rbp), %rsi
callq 0xab60
movss -0x24(%rbp), %xmm0
movss %xmm0, (%rax)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x7d0c
addq $0x30, %rsp
popq %rbp
retq
// File: ddu1[P]polarizedtext/src/dictionary.cc
// Function: fasttext::Dictionary::save(std::ostream&) const
void Dictionary::save(std::ostream& out) const {
  out.write((char*) &size_, sizeof(int32_t));
  out.write((char*) &nwords_, sizeof(int32_t));
  out.write((char*) &nlabels_, sizeof(int32_t));
  out.write((char*) &ntokens_, sizeof(int64_t));
  for (int32_t i = 0; i < size_; i++) {
    entry e = words_[i];
    out.write(e.word.data(), e.word.size() * sizeof(char));
    out.put(0);
    out.write((char*) &(e.count), sizeof(int64_t));
    out.write((char*) &(e.type), sizeof(entry_type));
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x98(%rbp)
movq -0x10(%rbp), %rdi
addq $0x58, %rsi
movl $0x4, %edx
callq 0x4450
movq -0x98(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x5c, %rsi
movl $0x4, %edx
callq 0x4450
movq -0x98(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x60, %rsi
movl $0x4, %edx
callq 0x4450
movq -0x98(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x68, %rsi
movl $0x8, %edx
callq 0x4450
movl $0x0, -0x14(%rbp)
movq -0x98(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x58(%rcx), %eax
jge 0x8517
movq -0x98(%rbp), %rdi
addq $0x28, %rdi
movslq -0x14(%rbp), %rsi
callq 0xa110
movq %rax, %rsi
leaq -0x80(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0xa2d0
movq -0xb0(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0xa8(%rbp)
callq 0x41a0
movq -0xb0(%rbp), %rdi
movq %rax, -0xa0(%rbp)
callq 0x4200
movq -0xa8(%rbp), %rdi
movq -0xa0(%rbp), %rsi
movq %rax, %rdx
callq 0x4450
jmp 0x84ae
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x4040
jmp 0x84bb
movq -0x10(%rbp), %rdi
leaq -0x60(%rbp), %rsi
movl $0x8, %edx
callq 0x4450
jmp 0x84cf
movq -0x10(%rbp), %rdi
leaq -0x58(%rbp), %rsi
movl $0x1, %edx
callq 0x4450
jmp 0x84e3
leaq -0x80(%rbp), %rdi
callq 0xa270
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x8432
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0xa270
jmp 0x8520
addq $0xb0, %rsp
popq %rbp
retq
movq -0x88(%rbp), %rdi
callq 0x45b0
nopl (%rax)
// File: ddu1[P]polarizedtext/src/dictionary.cc
// Function: fasttext::Dictionary::load(std::istream&)
void Dictionary::load(std::istream& in) {
  words_.clear();
  for (int32_t i = 0; i < MAX_VOCAB_SIZE; i++) {
    word2int_[i] = -1;
  }
  in.read((char*) &size_, sizeof(int32_t));
  in.read((char*) &nwords_, sizeof(int32_t));
  in.read((char*) &nlabels_, sizeof(int32_t));
  in.read((char*) &ntokens_, sizeof(int64_t));
  for (int32_t i = 0; i < size_; i++) {
    char c;
    entry e;
    while ((c = in.get()) != 0) {
      e.word.push_back(c);
    }
    in.read((char*) &e.count, sizeof(int64_t));
    in.read((char*) &e.type, sizeof(entry_type));
    words_.push_back(e);
    word2int_[find(e.word)] = i;
  }
  initTableDiscard();
  initNgrams();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
addq $0x28, %rdi
callq 0xaf30
movl $0x0, -0x14(%rbp)
cmpl $0x1c9c380, -0x14(%rbp) # imm = 0x1C9C380
jge 0x858c
movq -0xa0(%rbp), %rdi
addq $0x10, %rdi
movslq -0x14(%rbp), %rsi
callq 0x9f60
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x855e
movq -0xa0(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x58, %rsi
movl $0x4, %edx
callq 0x43e0
movq -0xa0(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x5c, %rsi
movl $0x4, %edx
callq 0x43e0
movq -0xa0(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x60, %rsi
movl $0x4, %edx
callq 0x43e0
movq -0xa0(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x68, %rsi
movl $0x8, %edx
callq 0x43e0
movl $0x0, -0x18(%rbp)
movq -0xa0(%rbp), %rcx
movl -0x18(%rbp), %eax
cmpl 0x58(%rcx), %eax
jge 0x8719
leaq -0x88(%rbp), %rdi
callq 0xa130
movq -0x10(%rbp), %rdi
callq 0x4380
movl %eax, -0xa4(%rbp)
jmp 0x8627
movl -0xa4(%rbp), %eax
movb %al, -0x19(%rbp)
movsbl %al, %eax
cmpl $0x0, %eax
je 0x866f
movsbl -0x19(%rbp), %esi
leaq -0x88(%rbp), %rdi
callq 0x42a0
jmp 0x864a
jmp 0x8616
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0x88(%rbp), %rdi
callq 0xa270
jmp 0x873a
movq -0x10(%rbp), %rdi
leaq -0x68(%rbp), %rsi
movl $0x8, %edx
callq 0x43e0
jmp 0x8683
movq -0x10(%rbp), %rdi
leaq -0x60(%rbp), %rsi
movl $0x1, %edx
callq 0x43e0
jmp 0x8697
movq -0xa0(%rbp), %rdi
addq $0x28, %rdi
leaq -0x88(%rbp), %rsi
callq 0xa200
jmp 0x86b0
movq -0xa0(%rbp), %rdi
movl -0x18(%rbp), %eax
movl %eax, -0xb4(%rbp)
movq %rdi, %rax
addq $0x10, %rax
movq %rax, -0xb0(%rbp)
leaq -0x88(%rbp), %rsi
callq 0x66c0
movl %eax, -0xa8(%rbp)
jmp 0x86e2
movq -0xb0(%rbp), %rdi
movl -0xa8(%rbp), %eax
movslq %eax, %rsi
callq 0x9f60
movl -0xb4(%rbp), %ecx
movl %ecx, (%rax)
leaq -0x88(%rbp), %rdi
callq 0xa270
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x85f7
movq -0xa0(%rbp), %rdi
callq 0x7ce0
movq -0xa0(%rbp), %rdi
callq 0x7520
addq $0xc0, %rsp
popq %rbp
retq
movq -0x90(%rbp), %rdi
callq 0x45b0
nopw %cs:(%rax,%rax)
// File: ddu1[P]polarizedtext/src/matrix.cc
// Function: fasttext::Matrix::addRow(fasttext::Vector const&, long, float)
void Matrix::addRow(const Vector& vec, int64_t i, real a) {
  assert(i >= 0);
  assert(i < m_);
  assert(vec.m_ == n_);
  for (int64_t j = 0; j < n_; j++) {
    data_[i * n_ + j] += a * vec.data_[j];
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movss %xmm0, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x18(%rbp)
jl 0x12bca
jmp 0x12be9
leaq 0x16a56(%rip), %rdi     # 0x29627
leaq 0x16cea(%rip), %rsi     # 0x298c2
movl $0x45, %edx
leaq 0x16cec(%rip), %rcx     # 0x298d0
callq 0x41d0
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
cmpq 0x8(%rcx), %rax
jge 0x12bf9
jmp 0x12c18
leaq 0x16d0d(%rip), %rdi     # 0x2990d
leaq 0x16cbb(%rip), %rsi     # 0x298c2
movl $0x46, %edx
leaq 0x16cbd(%rip), %rcx     # 0x298d0
callq 0x41d0
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpq 0x10(%rcx), %rax
jne 0x12c2b
jmp 0x12c4a
leaq 0x16ce2(%rip), %rdi     # 0x29914
leaq 0x16c89(%rip), %rsi     # 0x298c2
movl $0x47, %edx
leaq 0x16c8b(%rip), %rcx     # 0x298d0
callq 0x41d0
movq $0x0, -0x28(%rbp)
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
cmpq 0x10(%rcx), %rax
jge 0x12caa
movq -0x30(%rbp), %rdx
movss -0x1c(%rbp), %xmm0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x28(%rbp), %rcx
movss (%rax,%rcx,4), %xmm2
movq (%rdx), %rax
movq -0x18(%rbp), %rcx
imulq 0x10(%rdx), %rcx
addq -0x28(%rbp), %rcx
movss (%rax,%rcx,4), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, (%rax,%rcx,4)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x12c52
addq $0x30, %rsp
popq %rbp
retq
// File: ddu1[P]polarizedtext/src/matrix.cc
// Function: fasttext::Matrix::dotRow(fasttext::Vector const&, long)
real Matrix::dotRow(const Vector& vec, int64_t i) {
  assert(i >= 0);
  assert(i < m_);
  assert(vec.m_ == n_);
  real d = 0.0;
  for (int64_t j = 0; j < n_; j++) {
    d += data_[i * n_ + j] * vec.data_[j];
  }
  return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x18(%rbp)
jl 0x12cd5
jmp 0x12cf4
leaq 0x1694b(%rip), %rdi     # 0x29627
leaq 0x16bdf(%rip), %rsi     # 0x298c2
movl $0x4e, %edx
leaq 0x16c32(%rip), %rcx     # 0x29921
callq 0x41d0
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
cmpq 0x8(%rcx), %rax
jge 0x12d04
jmp 0x12d23
leaq 0x16c02(%rip), %rdi     # 0x2990d
leaq 0x16bb0(%rip), %rsi     # 0x298c2
movl $0x4f, %edx
leaq 0x16c03(%rip), %rcx     # 0x29921
callq 0x41d0
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpq 0x10(%rcx), %rax
jne 0x12d36
jmp 0x12d55
leaq 0x16bd7(%rip), %rdi     # 0x29914
leaq 0x16b7e(%rip), %rsi     # 0x298c2
movl $0x50, %edx
leaq 0x16bd1(%rip), %rcx     # 0x29921
callq 0x41d0
xorps %xmm0, %xmm0
movss %xmm0, -0x1c(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
cmpq 0x10(%rcx), %rax
jge 0x12dbd
movq -0x30(%rbp), %rdx
movq (%rdx), %rax
movq -0x18(%rbp), %rcx
imulq 0x10(%rdx), %rcx
addq -0x28(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x28(%rbp), %rcx
movss (%rax,%rcx,4), %xmm2
movss -0x1c(%rbp), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x1c(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x12d65
movss -0x1c(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: ddu1[P]polarizedtext/src/vector.cc
// Function: fasttext::Vector::Vector(long, std::vector<int, std::allocator<int>> const&)
Vector::Vector(int64_t m, const std::vector<int32_t>& lbs) 
  : m_(m), data_(new real[m])
{
  zero();
  for( auto l : lbs) {
    assert( l < m_);
    data_[l] = 1.0;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x4030
movq -0x40(%rbp), %rdi
movq %rax, 0x8(%rdi)
callq 0x13180
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0xd9b0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0xd9e0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x13840
testb $0x1, %al
jne 0x1311a
jmp 0x1317a
leaq -0x28(%rbp), %rdi
callq 0x13880
movq -0x40(%rbp), %rcx
movl (%rax), %eax
movl %eax, -0x34(%rbp)
movslq -0x34(%rbp), %rax
cmpq (%rcx), %rax
jge 0x13137
jmp 0x13156
leaq 0x1681e(%rip), %rdi     # 0x2995c
leaq 0x1681e(%rip), %rsi     # 0x29963
movl $0x21, %edx
leaq 0x16820(%rip), %rcx     # 0x29971
callq 0x41d0
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x34(%rbp), %rcx
movss 0x167ee(%rip), %xmm0    # 0x29958
movss %xmm0, (%rax,%rcx,4)
leaq -0x28(%rbp), %rdi
callq 0x138a0
jmp 0x13107
addq $0x40, %rsp
popq %rbp
retq
// File: ddu1[P]polarizedtext/src/vector.cc
// Function: fasttext::Vector::addRow(fasttext::Matrix const&, long)
void Vector::addRow(const Matrix& A, int64_t i) {
  assert(i >= 0);
  assert(i < A.m_);
  assert(m_ == A.n_);
  for (int64_t j = 0; j < A.n_; j++) {
    data_[j] += A.data_[i * A.n_ + j];
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
jl 0x132f5
jmp 0x13314
leaq 0x1632b(%rip), %rdi     # 0x29627
leaq 0x16660(%rip), %rsi     # 0x29963
movl $0x41, %edx
leaq 0x166a2(%rip), %rcx     # 0x299b1
callq 0x41d0
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jge 0x13324
jmp 0x13343
leaq 0x166bd(%rip), %rdi     # 0x299e8
leaq 0x16631(%rip), %rsi     # 0x29963
movl $0x42, %edx
leaq 0x16673(%rip), %rcx     # 0x299b1
callq 0x41d0
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jne 0x13356
jmp 0x13375
leaq 0x16694(%rip), %rdi     # 0x299f1
leaq 0x165ff(%rip), %rsi     # 0x29963
movl $0x43, %edx
leaq 0x16641(%rip), %rcx     # 0x299b1
callq 0x41d0
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jge 0x133cc
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rsi
imulq 0x10(%rsi), %rdx
addq -0x20(%rbp), %rdx
movss (%rcx,%rdx,4), %xmm0
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rcx
addss (%rax,%rcx,4), %xmm0
movss %xmm0, (%rax,%rcx,4)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x1337d
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ddu1[P]polarizedtext/src/vector.cc
// Function: fasttext::Vector::addRow(fasttext::Matrix const&, long, float)
void Vector::addRow(const Matrix& A, int64_t i, real a) {
  assert(i >= 0);
  assert(i < A.m_);
  assert(m_ == A.n_);
  for (int64_t j = 0; j < A.n_; j++) {
    data_[j] += a * A.data_[i * A.n_ + j];
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movss %xmm0, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x18(%rbp)
jl 0x1340a
jmp 0x13429
leaq 0x16216(%rip), %rdi     # 0x29627
leaq 0x1654b(%rip), %rsi     # 0x29963
movl $0x4a, %edx
leaq 0x165d8(%rip), %rcx     # 0x299fc
callq 0x41d0
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jge 0x13439
jmp 0x13458
leaq 0x165a8(%rip), %rdi     # 0x299e8
leaq 0x1651c(%rip), %rsi     # 0x29963
movl $0x4b, %edx
leaq 0x165a9(%rip), %rcx     # 0x299fc
callq 0x41d0
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jne 0x1346b
jmp 0x1348a
leaq 0x1657f(%rip), %rdi     # 0x299f1
leaq 0x164ea(%rip), %rsi     # 0x29963
movl $0x4c, %edx
leaq 0x16577(%rip), %rcx     # 0x299fc
callq 0x41d0
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jge 0x134ee
movq -0x30(%rbp), %rax
movss -0x1c(%rbp), %xmm0
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rsi
imulq 0x10(%rsi), %rdx
addq -0x28(%rbp), %rdx
movss (%rcx,%rdx,4), %xmm2
movq 0x8(%rax), %rax
movq -0x28(%rbp), %rcx
movss (%rax,%rcx,4), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, (%rax,%rcx,4)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x13492
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ddu1[P]polarizedtext/src/vector.cc
// Function: fasttext::Vector::mul(fasttext::Matrix const&, fasttext::Vector const&)
void Vector::mul(const Matrix& A, const Vector& vec) {
  assert(A.m_ == m_);
  assert(A.n_ == vec.m_);
  for (int64_t i = 0; i < m_; i++) {
    data_[i] = 0.0;
    for (int64_t j = 0; j < A.n_; j++) {
      data_[i] += A.data_[i * A.n_ + j] * vec.data_[j];
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpq (%rcx), %rax
jne 0x135ab
jmp 0x135ca
leaq 0x16487(%rip), %rdi     # 0x29a39
leaq 0x163aa(%rip), %rsi     # 0x29963
movl $0x5a, %edx
leaq 0x1647f(%rip), %rcx     # 0x29a44
callq 0x41d0
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x135dd
jmp 0x135fc
leaq 0x1649b(%rip), %rdi     # 0x29a7f
leaq 0x16378(%rip), %rsi     # 0x29963
movl $0x5b, %edx
leaq 0x1644d(%rip), %rcx     # 0x29a44
callq 0x41d0
movq $0x0, -0x20(%rbp)
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
cmpq (%rcx), %rax
jge 0x136ac
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rcx
xorps %xmm0, %xmm0
movss %xmm0, (%rax,%rcx,4)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jge 0x13699
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rsi
imulq 0x10(%rsi), %rdx
addq -0x28(%rbp), %rdx
movss (%rcx,%rdx,4), %xmm0
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq -0x28(%rbp), %rdx
movss (%rcx,%rdx,4), %xmm2
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rcx
movss (%rax,%rcx,4), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, (%rax,%rcx,4)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x13631
jmp 0x1369b
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x13604
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ddu1[P]polarizedtext/src/model.cc
// Function: fasttext::Model::polarization(int, float)
real Model::polarization(int32_t w, real lr) {

  real score = 0.0;
  Vector vec = Vector(hsz_, hidden_labels_);
  score = wo_->dotRow( vec, w);
  score = sigmoid(score);
  real alpha = lr * (1.0 - score);
  grad_.addRow(*wo_, w, alpha);
  wo_->addRow(vec, w, alpha);
  return -log(score);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movss %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rdx
movq %rdx, -0x50(%rbp)
movl $0x0, -0x14(%rbp)
movslq 0x78(%rdx), %rsi
addq $0x40, %rdx
leaq -0x28(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x13090
movq -0x50(%rbp), %rdi
addq $0x10, %rdi
callq 0x15820
movq -0x48(%rbp), %rsi
movq %rax, %rdi
movslq -0xc(%rbp), %rdx
callq 0x12cb0
movss %xmm0, -0x3c(%rbp)
jmp 0x140ac
movq -0x50(%rbp), %rdi
movss -0x3c(%rbp), %xmm0
movss %xmm0, -0x14(%rbp)
movss -0x14(%rbp), %xmm0
callq 0x13f30
movss %xmm0, -0x54(%rbp)
jmp 0x140cb
movq -0x50(%rbp), %rdi
movss -0x54(%rbp), %xmm0
movss %xmm0, -0x14(%rbp)
movss -0x10(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movss -0x14(%rbp), %xmm1
cvtss2sd %xmm1, %xmm2
movsd 0x154d5(%rip), %xmm1    # 0x295c8
subsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x38(%rbp)
movq %rdi, %rax
addq $0x68, %rax
movq %rax, -0x60(%rbp)
addq $0x10, %rdi
callq 0x15a10
movq -0x60(%rbp), %rdi
movq %rax, %rsi
movslq -0xc(%rbp), %rdx
movss -0x38(%rbp), %xmm0
callq 0x133e0
jmp 0x1412f
movq -0x50(%rbp), %rdi
addq $0x10, %rdi
callq 0x15820
movq %rax, %rdi
movslq -0xc(%rbp), %rdx
movss -0x38(%rbp), %xmm0
leaq -0x28(%rbp), %rsi
callq 0x12ba0
jmp 0x14153
movq -0x50(%rbp), %rdi
movss -0x14(%rbp), %xmm0
callq 0x13fe0
movss %xmm0, -0x64(%rbp)
jmp 0x14168
movss -0x64(%rbp), %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
movss %xmm0, -0x68(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x131d0
movss -0x68(%rbp), %xmm0
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x131d0
movq -0x30(%rbp), %rdi
callq 0x45b0
nopw %cs:(%rax,%rax)