LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/sergiosvieira[P]ptd2ns2/rng.cc
// Function: RNG::set_package_seed(unsigned long const*)
void RNG::set_package_seed(const unsigned long seed[6]) {
	if (CheckSeed(seed))
		abort();
	for (int i = 0; i < 6; ++i)
		next_seed_[i] = seed[i];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x48d5
testl %eax, %eax
jne 0x46b9
xorl %eax, %eax
movsd 0x1db4(%rip), %xmm0     # 0x6430
movapd 0x1dbc(%rip), %xmm1     # 0x6440
leaq 0x5bd5(%rip), %rcx      # 0xa260
movsd (%rbx,%rax), %xmm2
unpcklps %xmm0, %xmm2            # xmm2 = xmm2[0],xmm0[0],xmm2[1],xmm0[1]
subpd %xmm1, %xmm2
movapd %xmm2, %xmm3
unpckhpd %xmm2, %xmm3            # xmm3 = xmm3[1],xmm2[1]
addsd %xmm2, %xmm3
movsd %xmm3, (%rax,%rcx)
addq $0x8, %rax
cmpq $0x30, %rax
jne 0x468b
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x20e0
// File: /workspace/github_cpp_makefile_star2_O1/sergiosvieira[P]ptd2ns2/rng.cc
// Function: RNG::rand_u01()
double RNG::rand_u01() {
	if (inc_prec_)
		return U01d();
	else
		return U01();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpb $0x1, 0x91(%rdi)
jne 0x47df
popq %rbp
jmp 0x4436
popq %rbp
jmp 0x4304
nop
// File: /workspace/github_cpp_makefile_star2_O1/sergiosvieira[P]ptd2ns2/rng.cc
// Function: RNG::RNG(char const*)
RNG::RNG(const char *s) {
	if (strlen(s) > 99) {
		strncpy(name_, s, 99);
		name_[100] = 0;
	} else
		strcpy(name_, s);

	init();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x20b0
leaq 0x92(%rbx), %rdi
cmpq $0x64, %rax
jb 0x481e
movl $0x63, %edx
movq %r14, %rsi
callq 0x20d0
movb $0x0, 0xf6(%rbx)
jmp 0x4826
movq %r14, %rsi
callq 0x2160
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x44fa
// File: /workspace/github_cpp_makefile_star2_O1/sergiosvieira[P]ptd2ns2/rng.cc
// Function: RNG::reset_next_substream()
void RNG::reset_next_substream() {
	MatVecModM(A1p76, Bg_, Bg_, m1);
	MatVecModM(A2p76, &Bg_[3], &Bg_[3], m2);
	for (int i = 0; i < 6; ++i)
		Cg_[i] = Bg_[i];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x30(%rdi), %rdx
leaq 0x1e74(%rip), %rdi      # 0x6700
movsd 0x1b54(%rip), %xmm0     # 0x63e8
movq %rdx, %rsi
callq 0x45a0
leaq 0x48(%rbx), %rdx
leaq 0x1ea9(%rip), %rdi      # 0x6750
movsd 0x1b51(%rip), %xmm0     # 0x6400
movq %rdx, %rsi
callq 0x45a0
movups 0x30(%rbx), %xmm0
movups 0x40(%rbx), %xmm1
movups 0x50(%rbx), %xmm2
movups %xmm2, 0x20(%rbx)
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/sergiosvieira[P]ptd2ns2/rng.cc
// Function: (anonymous namespace)::CheckSeed(unsigned long const*)
int CheckSeed(const unsigned long seed[6]) {
	int i;
	for (i = 0; i < 3; ++i) {
		if (seed[i] >= m1) {
			fprintf(stderr, "****************************************\n\n");
			fprintf(stderr, "ERROR: Seed[%d] >= 4294967087, Seed is not set.",
					i);
			fprintf(stderr, "\n\n****************************************\n\n");
			return (-1);
		}
	}
	for (i = 3; i < 6; ++i) {
		if (seed[i] >= m2) {
			fprintf(stderr, "****************************************\n\n");
			fprintf(stderr, "ERROR: Seed[%d] >= 429444443, Seed is not set.", i);
			fprintf(stderr, "\n\n****************************************\n\n");
			return (-1);
		}
	}
	if (seed[0] == 0 && seed[1] == 0 && seed[2] == 0) {
		fprintf(stderr, "****************************************\n\n");
		fprintf(stderr, "ERROR: First 3 seeds = 0.\n\n");
		fprintf(stderr, "****************************************\n\n");
		return (-1);
	}
	if (seed[3] == 0 && seed[4] == 0 && seed[5] == 0) {
		fprintf(stderr, "****************************************\n\n");
		fprintf(stderr, "ERROR: Last 3 seeds = 0.\n\n");
		fprintf(stderr, "****************************************\n\n");
		return (-1);
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0xffffa6ba, %ecx       # imm = 0xFFFFA6BA
xorl %eax, %eax
leaq 0x5874(%rcx), %rdx
cmpq %rdx, (%rdi,%rax,8)
ja 0x493c
incq %rax
cmpq $0x3, %rax
jne 0x48e7
movl $0x3, %eax
cmpq %rcx, (%rdi,%rax,8)
ja 0x4946
incq %rax
cmpq $0x6, %rax
jne 0x48fb
cmpq $0x0, (%rdi)
jne 0x491e
cmpq $0x0, 0x8(%rdi)
jne 0x491e
cmpq $0x0, 0x10(%rdi)
je 0x4955
xorl %eax, %eax
cmpq $0x0, 0x18(%rdi)
jne 0x4953
cmpq $0x0, 0x20(%rdi)
jne 0x4953
cmpq $0x0, 0x28(%rdi)
jne 0x4953
callq 0x23c5
jmp 0x494e
movq %rax, %rdi
callq 0x24ea
jmp 0x494e
movq %rax, %rdi
callq 0x248b
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbp
retq
callq 0x2428
jmp 0x494e
// File: /workspace/github_cpp_makefile_star2_O1/sergiosvieira[P]ptd2ns2/rng.cc
// Function: RNG::set_seed(unsigned long const*)
void RNG::set_seed(const unsigned long seed[6]) {
	if (CheckSeed(seed))
		abort();
	for (int i = 0; i < 6; ++i)
		Cg_[i] = Bg_[i] = Ig_[i] = seed[i];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x48d5
testl %eax, %eax
jne 0x49c1
xorl %eax, %eax
movsd 0x1ab1(%rip), %xmm0     # 0x6430
movapd 0x1ab9(%rip), %xmm1     # 0x6440
movsd (%rbx,%rax,8), %xmm2
unpcklps %xmm0, %xmm2            # xmm2 = xmm2[0],xmm0[0],xmm2[1],xmm0[1]
subpd %xmm1, %xmm2
movapd %xmm2, %xmm3
unpckhpd %xmm2, %xmm3            # xmm3 = xmm3[1],xmm2[1]
addsd %xmm2, %xmm3
movsd %xmm3, 0x60(%r14,%rax,8)
movsd %xmm3, 0x30(%r14,%rax,8)
movsd %xmm3, (%r14,%rax,8)
incq %rax
cmpq $0x6, %rax
jne 0x4987
popq %rbx
popq %r14
popq %rbp
retq
callq 0x20e0
// File: /workspace/github_cpp_makefile_star2_O1/sergiosvieira[P]ptd2ns2/rng.cc
// Function: RNG::advance_state(long, long)
void RNG::advance_state(long e, long c) {
	double B1[3][3], C1[3][3], B2[3][3], C2[3][3];
	if (e > 0) {
		MatTwoPowModM(A1p0, B1, m1, e);
		MatTwoPowModM(A2p0, B2, m2, e);
	} else if (e < 0) {
		MatTwoPowModM(InvA1, B1, m1, -e);
		MatTwoPowModM(InvA2, B2, m2, -e);
	}
	if (c >= 0) {
		MatPowModM(A1p0, C1, m1, c);
		MatPowModM(A2p0, C2, m2, c);
	} else {
		MatPowModM(InvA1, C1, m1, -c);
		MatPowModM(InvA2, C2, m2, -c);
	}
	if (e) {
		MatMatModM(B1, C1, C1, m1);
		MatMatModM(B2, C2, C2, m2);
	}
	MatVecModM(C1, Cg_, Cg_, m1);
	MatVecModM(C2, &Cg_[3], &Cg_[3], m2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x140, %rsp            # imm = 0x140
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
testq %rsi, %rsi
jle 0x4a24
leaq 0x1db3(%rip), %rdi      # 0x67a0
leaq -0x160(%rbp), %rsi
movsd 0x19ec(%rip), %xmm0     # 0x63e8
movq %r14, %rdx
callq 0x4b57
leaq 0x1de5(%rip), %rdi      # 0x67f0
leaq -0x110(%rbp), %rsi
movsd 0x19e6(%rip), %xmm0     # 0x6400
movq %r14, %rdx
callq 0x4b57
jmp 0x4a2a
js 0x4b15
testq %r15, %r15
js 0x4a56
leaq 0x1d6a(%rip), %rdi      # 0x67a0
leaq -0xc0(%rbp), %rsi
movsd 0x19a3(%rip), %xmm0     # 0x63e8
movq %r15, %rdx
callq 0x4bc3
leaq 0x1d9c(%rip), %rdi      # 0x67f0
jmp 0x4a7e
negq %r15
leaq 0x1de0(%rip), %rdi      # 0x6840
leaq -0xc0(%rbp), %rsi
movsd 0x1979(%rip), %xmm0     # 0x63e8
movq %r15, %rdx
callq 0x4bc3
leaq 0x1e12(%rip), %rdi      # 0x6890
leaq -0x70(%rbp), %rsi
movsd 0x1976(%rip), %xmm0     # 0x6400
movq %r15, %rdx
callq 0x4bc3
testq %r14, %r14
je 0x4ad0
leaq -0x160(%rbp), %rdi
leaq -0xc0(%rbp), %rdx
movsd 0x193b(%rip), %xmm0     # 0x63e8
movq %rdx, %rsi
callq 0x4c7e
leaq -0x110(%rbp), %rdi
leaq -0x70(%rbp), %rdx
movsd 0x1938(%rip), %xmm0     # 0x6400
movq %rdx, %rsi
callq 0x4c7e
leaq -0xc0(%rbp), %rdi
movsd 0x1909(%rip), %xmm0     # 0x63e8
movq %rbx, %rsi
movq %rbx, %rdx
callq 0x45a0
addq $0x18, %rbx
leaq -0x70(%rbp), %rdi
movsd 0x1906(%rip), %xmm0     # 0x6400
movq %rbx, %rsi
movq %rbx, %rdx
callq 0x45a0
addq $0x140, %rsp            # imm = 0x140
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %r12
negq %r12
leaq 0x1d1e(%rip), %rdi      # 0x6840
leaq -0x160(%rbp), %rsi
movsd 0x18b7(%rip), %xmm0     # 0x63e8
movq %r12, %rdx
callq 0x4b57
leaq 0x1d50(%rip), %rdi      # 0x6890
leaq -0x110(%rbp), %rsi
movsd 0x18b1(%rip), %xmm0     # 0x6400
movq %r12, %rdx
jmp 0x4a1d
// File: /workspace/github_cpp_makefile_star2_O1/sergiosvieira[P]ptd2ns2/rng.cc
// Function: (anonymous namespace)::MatTwoPowModM(double const (*) [3], double (*) [3], double, long)
void MatTwoPowModM(const double A[3][3], double B[3][3], double m, long e) {
	int i, j;
	/* initialize: B = A */
	if (A != B) {
		for (i = 0; i < 3; ++i)
			for (j = 0; j < 3; ++j)
				B[i][j] = A[i][j];
	}
	/* Compute B = A^(2^e) mod m */
	for (i = 0; i < e; i++)
		MatMatModM(B, B, B, m);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
cmpq %rsi, %rdi
je 0x4b98
xorl %eax, %eax
movq %r14, %rcx
xorl %edx, %edx
movsd (%rdi,%rdx,8), %xmm1
movsd %xmm1, (%rcx,%rdx,8)
incq %rdx
cmpq $0x3, %rdx
jne 0x4b74
incq %rax
addq $0x18, %rcx
addq $0x18, %rdi
cmpq $0x3, %rax
jne 0x4b72
testq %rbx, %rbx
jle 0x4bba
movsd %xmm0, -0x18(%rbp)
movq %r14, %rdi
movq %r14, %rsi
movq %r14, %rdx
callq 0x4c7e
movsd -0x18(%rbp), %xmm0
decq %rbx
jne 0x4ba2
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/sergiosvieira[P]ptd2ns2/rng.cc
// Function: (anonymous namespace)::MatPowModM(double const (*) [3], double (*) [3], double, long)
void MatPowModM(const double A[3][3], double B[3][3], double m, long n) {
	int i, j;
	double W[3][3];
	/* initialize: W = A; B = I */
	for (i = 0; i < 3; ++i)
		for (j = 0; j < 3; ++j) {
			W[i][j] = A[i][j];
			B[i][j] = 0.0;
		}
	for (j = 0; j < 3; ++j)
		B[j][j] = 1.0;
	/* Compute B = A^n mod m using the binary decomposition of n */
	while (n > 0) {
		if (n % 2)
			MatMatModM(W, B, B, m);
		MatMatModM(W, W, W, m);

		n /= 2;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rdx, %rbx
movsd %xmm0, -0x20(%rbp)
movq %rsi, %r14
leaq -0x70(%rbp), %rax
xorl %ecx, %ecx
movq %rsi, %rdx
xorl %esi, %esi
movsd (%rdi,%rsi,8), %xmm0
movsd %xmm0, (%rax,%rsi,8)
movq $0x0, (%rdx,%rsi,8)
incq %rsi
cmpq $0x3, %rsi
jne 0x4be6
incq %rcx
addq $0x18, %rdx
addq $0x18, %rdi
addq $0x18, %rax
cmpq $0x3, %rcx
jne 0x4be4
xorl %eax, %eax
movabsq $0x3ff0000000000000, %rcx # imm = 0x3FF0000000000000
movq %rcx, (%r14,%rax)
addq $0x20, %rax
cmpq $0x60, %rax
jne 0x4c22
testq %rbx, %rbx
jle 0x4c73
leaq -0x70(%rbp), %r15
testb $0x1, %bl
je 0x4c51
movq %r15, %rdi
movq %r14, %rsi
movq %r14, %rdx
movsd -0x20(%rbp), %xmm0
callq 0x4c7e
movq %r15, %rdi
movq %r15, %rsi
movq %r15, %rdx
movsd -0x20(%rbp), %xmm0
callq 0x4c7e
movq %rbx, %rax
shrq %rax
cmpq $0x1, %rbx
movq %rax, %rbx
ja 0x4c39
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/sergiosvieira[P]ptd2ns2/rng.cc
// Function: (anonymous namespace)::MatMatModM(double const (*) [3], double const (*) [3], double (*) [3], double)
void MatMatModM(const double A[3][3], const double B[3][3], double C[3][3],
		double m) {
	int i, j;
	double V[3], W[3][3];
	for (i = 0; i < 3; ++i) {
		for (j = 0; j < 3; ++j)
			V[j] = B[j][i];
		MatVecModM(A, V, V, m);
		for (j = 0; j < 3; ++j)

			W[j][i] = V[j];
	}
	for (i = 0; i < 3; ++i)
		for (j = 0; j < 3; ++j)
			C[i][j] = W[i][j];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movsd %xmm0, -0x38(%rbp)
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, -0x30(%rbp)
leaq -0xa0(%rbp), %r13
xorl %r15d, %r15d
leaq -0x50(%rbp), %r12
movq %r14, %rax
xorl %ecx, %ecx
movsd (%rax), %xmm0
movsd %xmm0, -0x50(%rbp,%rcx,8)
incq %rcx
addq $0x18, %rax
cmpq $0x3, %rcx
jne 0x4cb1
movq -0x30(%rbp), %rdi
movq %r12, %rsi
movq %r12, %rdx
movsd -0x38(%rbp), %xmm0
callq 0x45a0
movq %r13, %rax
xorl %ecx, %ecx
movsd -0x50(%rbp,%rcx,8), %xmm0
movsd %xmm0, (%rax)
incq %rcx
addq $0x18, %rax
cmpq $0x3, %rcx
jne 0x4ce1
incq %r15
addq $0x8, %r14
addq $0x8, %r13
cmpq $0x3, %r15
jne 0x4cac
xorl %eax, %eax
movq -0x90(%rbp,%rax), %rcx
movq %rcx, 0x10(%rbx,%rax)
movups -0xa0(%rbp,%rax), %xmm0
movups %xmm0, (%rbx,%rax)
addq $0x18, %rax
cmpq $0x48, %rax
jne 0x4d0b
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/sergiosvieira[P]ptd2ns2/rng.cc
// Function: RNG::write_state() const
void RNG::write_state() const {
	printf("The current state of the Rngstream %s:\n", name_);
	printf(" Cg_ = { ");
	for (int i = 0; i < 5; i++) {
		printf("%lu, ", (unsigned long) Cg_[i]);
	}
	printf("%lu }\n\n", (unsigned long) Cg_[5]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x92(%rdi), %rsi
leaq 0x1c11(%rip), %rdi      # 0x696a
xorl %eax, %eax
callq 0x2050
leaq 0x1c2b(%rip), %rdi      # 0x6992
xorl %eax, %eax
callq 0x2050
leaq 0x1c27(%rip), %r14      # 0x699c
xorl %r15d, %r15d
movsd (%rbx,%r15,8), %xmm0
cvttsd2si %xmm0, %rax
movq %rax, %rcx
sarq $0x3f, %rcx
subsd 0x163e(%rip), %xmm0     # 0x63d0
cvttsd2si %xmm0, %rsi
andq %rcx, %rsi
orq %rax, %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0x2050
incq %r15
cmpq $0x5, %r15
jne 0x4d78
movsd 0x28(%rbx), %xmm0
cvttsd2si %xmm0, %rax
movq %rax, %rcx
sarq $0x3f, %rcx
subsd 0x1607(%rip), %xmm0     # 0x63d0
cvttsd2si %xmm0, %rsi
andq %rcx, %rsi
orq %rax, %rsi
leaq 0x1bc7(%rip), %rdi      # 0x69a2
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2050
// File: /workspace/github_cpp_makefile_star2_O1/sergiosvieira[P]ptd2ns2/rng.cc
// Function: RNG::write_state_full() const
void RNG::write_state_full() const {
	int i;
	printf("The RNG %s:\n", name_);
	printf(" anti_ = %s", (anti_ ? "true" : "false"));
	printf(" inc_prec_ = %s\n", (inc_prec_ ? "true" : "false"));

	printf(" Ig_ = { ");
	for (i = 0; i < 5; i++) {
		printf("%lu, ", (unsigned long) Ig_[i]);
	}
	printf("%lu }\n", (unsigned long) Ig_[5]);

	printf(" Bg_ = { ");
	for (i = 0; i < 5; i++) {
		printf("%lu, ", (unsigned long) Bg_[i]);
	}
	printf("%lu }\n", (unsigned long) Bg_[5]);

	printf(" Cg_ = { ");
	for (i = 0; i < 5; i++) {
		printf("%lu, ", (unsigned long) Cg_[i]);
	}
	printf("%lu }\n\n", (unsigned long) Cg_[5]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x92(%rdi), %rsi
leaq 0x1ba3(%rip), %rdi      # 0x69aa
xorl %eax, %eax
callq 0x2050
leaq 0x1bae(%rip), %r15      # 0x69c3
cmpb $0x0, 0x90(%rbx)
leaq 0x1ba5(%rip), %r14      # 0x69c8
movq %r14, %rsi
cmovneq %r15, %rsi
leaq 0x1b86(%rip), %rdi      # 0x69b7
xorl %eax, %eax
callq 0x2050
cmpb $0x0, 0x91(%rbx)
cmovneq %r15, %r14
leaq 0x1b84(%rip), %rdi      # 0x69ce
movq %r14, %rsi
xorl %eax, %eax
callq 0x2050
leaq 0x1b84(%rip), %rdi      # 0x69df
xorl %eax, %eax
callq 0x2050
leaq 0x1b33(%rip), %r14      # 0x699c
xorl %r15d, %r15d
movsd 0x60(%rbx,%r15,8), %xmm0
cvttsd2si %xmm0, %rax
movq %rax, %rcx
sarq $0x3f, %rcx
subsd 0x1549(%rip), %xmm0     # 0x63d0
cvttsd2si %xmm0, %rsi
andq %rcx, %rsi
orq %rax, %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0x2050
incq %r15
cmpq $0x5, %r15
jne 0x4e6c
movsd 0x88(%rbx), %xmm0
cvttsd2si %xmm0, %rax
movq %rax, %rcx
sarq $0x3f, %rcx
subsd 0x150f(%rip), %xmm0     # 0x63d0
cvttsd2si %xmm0, %rsi
andq %rcx, %rsi
orq %rax, %rsi
leaq 0x1b16(%rip), %rdi      # 0x69e9
xorl %eax, %eax
callq 0x2050
leaq 0x1b0f(%rip), %rdi      # 0x69f0
xorl %eax, %eax
callq 0x2050
leaq 0x1aad(%rip), %r14      # 0x699c
xorl %r15d, %r15d
movsd 0x30(%rbx,%r15,8), %xmm0
cvttsd2si %xmm0, %rax
movq %rax, %rcx
sarq $0x3f, %rcx
subsd 0x14c3(%rip), %xmm0     # 0x63d0
cvttsd2si %xmm0, %rsi
andq %rcx, %rsi
orq %rax, %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0x2050
incq %r15
cmpq $0x5, %r15
jne 0x4ef2
movsd 0x58(%rbx), %xmm0
cvttsd2si %xmm0, %rax
movq %rax, %rcx
sarq $0x3f, %rcx
subsd 0x148c(%rip), %xmm0     # 0x63d0
cvttsd2si %xmm0, %rsi
andq %rcx, %rsi
orq %rax, %rsi
leaq 0x1a93(%rip), %rdi      # 0x69e9
xorl %eax, %eax
callq 0x2050
leaq 0x1a2e(%rip), %rdi      # 0x6992
xorl %eax, %eax
callq 0x2050
leaq 0x1a2a(%rip), %r14      # 0x699c
xorl %r15d, %r15d
movsd (%rbx,%r15,8), %xmm0
cvttsd2si %xmm0, %rax
movq %rax, %rcx
sarq $0x3f, %rcx
subsd 0x1441(%rip), %xmm0     # 0x63d0
cvttsd2si %xmm0, %rsi
andq %rcx, %rsi
orq %rax, %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0x2050
incq %r15
cmpq $0x5, %r15
jne 0x4f75
movsd 0x28(%rbx), %xmm0
cvttsd2si %xmm0, %rax
movq %rax, %rcx
sarq $0x3f, %rcx
subsd 0x140a(%rip), %xmm0     # 0x63d0
cvttsd2si %xmm0, %rsi
andq %rcx, %rsi
orq %rax, %rsi
leaq 0x19ca(%rip), %rdi      # 0x69a2
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2050
nop
// File: /workspace/github_cpp_makefile_star2_O1/sergiosvieira[P]ptd2ns2/rng.cc
// Function: (anonymous namespace)::MultModM(double, double, double, double)
double MultModM(double a, double s, double c, double m) {
	double v;
	long a1;
	v = a * s + c;

	if (v >= two53 || v <= -two53) {
		a1 = static_cast<long> (a / two17);
		a -= a1 * two17;
		v = a1 * s;
		a1 = static_cast<long> (v / m);
		v -= a1 * m;
		v = v * two17 + a * s + c;
	}
	a1 = static_cast<long> (v / m);
	/* in case v < 0)*/
	if ((v -= a1 * m) < 0.0)
		return v += m;
	else
		return v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movapd %xmm0, %xmm4
mulsd %xmm1, %xmm4
addsd %xmm2, %xmm4
movapd 0x1433(%rip), %xmm5     # 0x6450
andpd %xmm4, %xmm5
ucomisd 0x13ef(%rip), %xmm5     # 0x6418
jb 0x5089
movsd 0x13ed(%rip), %xmm4     # 0x6420
mulsd %xmm0, %xmm4
cvttsd2si %xmm4, %rax
xorps %xmm4, %xmm4
cvtsi2sd %rax, %xmm4
movsd 0x13dc(%rip), %xmm5     # 0x6428
movapd %xmm4, %xmm6
mulsd %xmm5, %xmm6
subsd %xmm6, %xmm0
mulsd %xmm1, %xmm4
movapd %xmm4, %xmm6
divsd %xmm3, %xmm6
cvttsd2si %xmm6, %rax
xorps %xmm6, %xmm6
cvtsi2sd %rax, %xmm6
mulsd %xmm3, %xmm6
subsd %xmm6, %xmm4
mulsd %xmm1, %xmm0
mulsd %xmm5, %xmm4
addsd %xmm0, %xmm4
addsd %xmm2, %xmm4
movapd %xmm4, %xmm0
divsd %xmm3, %xmm0
cvttsd2si %xmm0, %rax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
mulsd %xmm3, %xmm0
subsd %xmm0, %xmm4
addsd %xmm4, %xmm3
xorpd %xmm1, %xmm1
movapd %xmm4, %xmm0
cmpltsd %xmm1, %xmm0
andpd %xmm0, %xmm3
andnpd %xmm4, %xmm0
orpd %xmm3, %xmm0
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/NinjaDevelper[P]ReedSolomon/cxx/ReedSolomon.cpp
// Function: ReedSolomon::ReedSolomon()
ReedSolomon::ReedSolomon(){
    int i=0;
    unsigned int x=1;
    expTable[0]=1;
    for(i=1;i<255;i++){
        x<<=1;
        if(x>0xff) x^=0x11d;
        unsigned char c=x&0xff;
        expTable[i]=c;
        logTable[c]=i;
    }
    for(i=255;i<512;i++){
        expTable[i]=expTable[i-255];
    }
    logTable[expTable[255]]=255;
}

// Assembly:
movb $0x1, (%rdi)
movl $0x1, %eax
movl $0x1, %ecx
addl %eax, %eax
movl %eax, %edx
xorl $0x11d, %edx            # imm = 0x11D
cmpl $0x100, %eax            # imm = 0x100
cmovael %edx, %eax
movb %al, (%rdi,%rcx)
movzbl %al, %edx
movb %cl, 0x200(%rdi,%rdx)
incq %rcx
cmpq $0xff, %rcx
jne 0x2379
movq $-0x101, %rax           # imm = 0xFEFF
movb 0x101(%rdi,%rax), %cl
movb %cl, 0x200(%rdi,%rax)
incq %rax
jne 0x23ab
movzbl 0xff(%rdi), %eax
movb $-0x1, 0x200(%rdi,%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O1/NinjaDevelper[P]ReedSolomon/cxx/ReedSolomon.cpp
// Function: ReedSolomon::multiplyPoly(POLY&, POLY&, unsigned char*)
POLY& ReedSolomon::multiplyPoly(POLY& x,POLY& y,unsigned char* tmp){
    int i=0,j=0;
    int n=x.n+y.n-1;

    for(j=0;j<n;j++) tmp[j]=0;
    for(i=0;i<x.n;i++){
        for(j=0;j<y.n;j++){
            tmp[i+j]^=multiply(x.data[i],y.data[j]);
        }
    }
    for(j=0;j<n;j++) x.data[j]=tmp[j];
    x.n+=y.n-1;
    return x;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r12
movl 0x8(%rsi), %eax
movl 0x8(%rdx), %ecx
leal (%rax,%rcx), %ebp
decl %ebp
testl %ebp, %ebp
jle 0x2404
leal (%rax,%rcx), %edx
addl $-0x2, %edx
incq %rdx
movq %r15, %rdi
xorl %esi, %esi
callq 0x20b0
cmpl $0x0, 0x8(%rbx)
jle 0x246c
xorl %eax, %eax
movq %r15, %rcx
cmpl $0x0, 0x8(%r14)
jle 0x245d
xorl %edx, %edx
movq (%rbx), %rsi
movzbl (%rsi,%rax), %esi
testq %rsi, %rsi
je 0x244b
movq (%r14), %rdi
movzbl (%rdi,%rdx), %edi
testq %rdi, %rdi
je 0x244b
movzbl 0x200(%r12,%rsi), %esi
movzbl 0x200(%r12,%rdi), %edi
addq %rsi, %rdi
movb (%r12,%rdi), %sil
jmp 0x244d
xorl %esi, %esi
xorb %sil, (%rcx,%rdx)
incq %rdx
movslq 0x8(%r14), %rsi
cmpq %rsi, %rdx
jl 0x2418
incq %rax
movslq 0x8(%rbx), %rdx
incq %rcx
cmpq %rdx, %rax
jl 0x240f
testl %ebp, %ebp
jle 0x2486
movl %ebp, %eax
xorl %ecx, %ecx
movb (%r15,%rcx), %dl
movq (%rbx), %rsi
movb %dl, (%rsi,%rcx)
incq %rcx
cmpq %rcx, %rax
jne 0x2474
movl 0x8(%r14), %eax
movl 0x8(%rbx), %ecx
addl %ecx, %eax
decl %eax
movl %eax, 0x8(%rbx)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/NinjaDevelper[P]ReedSolomon/cxx/ReedSolomon.cpp
// Function: ReedSolomon::evaluatePoly(POLY&, unsigned char)
unsigned char ReedSolomon::evaluatePoly(POLY& x,unsigned char y){
    int i=0;
    unsigned char r=x.data[0];
    for(i=1;i<x.n;i++){
        r=multiply(r,y) ^ x.data[i];
    }
    return r;
}

// Assembly:
movq (%rsi), %rcx
movb (%rcx), %r10b
movslq 0x8(%rsi), %rsi
cmpq $0x2, %rsi
jl 0x24f1
movzbl %dl, %r8d
movl $0x1, %r9d
xorl %eax, %eax
testb %dl, %dl
je 0x24e1
testb %r10b, %r10b
je 0x24e1
movzbl %r10b, %eax
movzbl 0x200(%rdi,%rax), %eax
movzbl 0x200(%rdi,%r8), %r10d
addq %rax, %r10
movb (%rdi,%r10), %al
xorb (%rcx,%r9), %al
incq %r9
movl %eax, %r10d
cmpq %r9, %rsi
jne 0x24ba
retq
movl %r10d, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/NinjaDevelper[P]ReedSolomon/cxx/ReedSolomon.cpp
// Function: ReedSolomon::calcGenerator(POLY&)
POLY& ReedSolomon::calcGenerator(POLY& result){
    int i=0;
    int num=result.n-1;

    unsigned char *tmp=(unsigned char *)malloc(num+1);

    result.data[0]=1;
    result.n=1;
    unsigned char c[2]={0x1,0};
    POLY p={c,2};
    for(i=0;i<num;i++){
        c[1]=expTable[i];
        multiplyPoly(result,p,tmp);
    }
    free(tmp);
    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movslq 0x8(%rsi), %r15
movq %r15, %rdi
callq 0x2190
movq %rax, %r12
movq (%rbx), %rax
movb $0x1, (%rax)
movl $0x1, 0x8(%rbx)
leaq 0x6(%rsp), %rax
movw $0x1, (%rax)
movq %rax, 0x8(%rsp)
movl $0x2, 0x10(%rsp)
cmpq $0x2, %r15
jl 0x256e
decl %r15d
xorl %ebp, %ebp
leaq 0x8(%rsp), %r13
movb (%r14,%rbp), %al
movb %al, 0x7(%rsp)
movq %r14, %rdi
movq %rbx, %rsi
movq %r13, %rdx
movq %r12, %rcx
callq 0x23ce
incq %rbp
cmpq %rbp, %r15
jne 0x254d
movq %r12, %rdi
callq 0x2180
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/NinjaDevelper[P]ReedSolomon/cxx/ReedSolomon.cpp
// Function: ReedSolomon::encodeMessage(POLY&, POLY&)
unsigned char* ReedSolomon::encodeMessage(POLY& msgIn,POLY& generator){
    int i=0;
    int j=0;
    unsigned char coef=0;

    for(i=0;i<msgIn.n;i++){
        coef=msgIn.data[i];
        if(coef!=0){
            for(j=0;j<generator.n;j++){
                msgIn.data[i+j] ^= multiply(generator.data[j], coef);
            }
        }
    }
    return msgIn.data+msgIn.n;
}

// Assembly:
movl 0x8(%rsi), %ecx
testl %ecx, %ecx
jle 0x25f3
xorl %eax, %eax
movq (%rsi), %rcx
movzbl (%rcx,%rax), %ecx
testq %rcx, %rcx
je 0x25e7
cmpl $0x0, 0x8(%rdx)
jle 0x25e7
xorl %r8d, %r8d
movq (%rdx), %r9
movzbl (%r9,%r8), %r9d
testq %r9, %r9
je 0x25ce
movzbl 0x200(%rdi,%r9), %r9d
movzbl 0x200(%rdi,%rcx), %r10d
addq %r9, %r10
movb (%rdi,%r10), %r9b
jmp 0x25d1
xorl %r9d, %r9d
movq (%rsi), %r10
addq %rax, %r10
xorb %r9b, (%r8,%r10)
incq %r8
movslq 0x8(%rdx), %r9
cmpq %r9, %r8
jl 0x25a6
incq %rax
movslq 0x8(%rsi), %rcx
cmpq %rcx, %rax
jl 0x2591
movslq %ecx, %rax
addq (%rsi), %rax
retq
// File: /workspace/github_cpp_makefile_star2_O1/NinjaDevelper[P]ReedSolomon/cxx/ReedSolomon.cpp
// Function: ReedSolomon::calcSyndrome(POLY&, POLY&)
POLY& ReedSolomon::calcSyndrome(POLY& msg, POLY& result){
    int i=0;
    for(i=0;i<result.n;i++){
        result.data[i] = evaluatePoly(msg, expTable[i]);
    }
    return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
cmpl $0x0, 0x8(%rdx)
jle 0x2637
movq %rsi, %r14
movq %rdi, %r15
xorl %r12d, %r12d
movzbl (%r15,%r12), %edx
movq %r15, %rdi
movq %r14, %rsi
callq 0x24a0
movq (%rbx), %rcx
movb %al, (%rcx,%r12)
incq %r12
movslq 0x8(%rbx), %rax
cmpq %rax, %r12
jl 0x2614
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/epfml[P]sent2vec/src/args.cc
// Function: fasttext::Args::Args()
Args::Args() {
  lr = 0.05;
  boostNgrams = 1.0;
  dim = 100;
  ws = 5;
  dropoutK = 0;
  epoch = 5;
  minCount = 5;
  minCountLabel = 0;
  neg = 5;
  wordNgrams = 1;
  loss = loss_name::ns;
  model = model_name::sg;
  bucket = 2000000;
  bucketChar = 1;
  minn = 3;
  maxn = 6;
  thread = 12;
  lrUpdateRate = 100;
  t = 1e-4;
  label = "__label__";
  verbose = 2;
  pretrainedVectors = "";
  saveOutput = 0;
  maxVocabSize = -1;
  numCheckPoints = 1;
  qout = false;
  retrain = false;
  qnorm = false;
  cutoff = 0;
  dsub = 2;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, 0x18(%rsp)
movq %rax, (%rdi)
xorl %eax, %eax
movq %rax, 0x8(%rdi)
movb %al, 0x10(%rdi)
leaq 0x30(%rdi), %rcx
movq %rcx, 0x10(%rsp)
movq %rcx, 0x20(%rdi)
movq %rax, 0x28(%rdi)
movb %al, 0x30(%rdi)
leaq 0x50(%rdi), %rcx
movq %rcx, 0x8(%rsp)
movq %rcx, 0x40(%rdi)
movq %rax, 0x48(%rdi)
movb %al, 0x50(%rdi)
leaq 0x70(%rdi), %r13
movq %r13, 0x60(%rdi)
movq %rax, 0x68(%rdi)
movb %al, 0x70(%rdi)
leaq 0xe0(%rdi), %r15
leaq 0xf0(%rdi), %rbp
movq %rbp, 0xe0(%rdi)
movq %rax, 0xe8(%rdi)
movb %al, 0xf0(%rdi)
leaq 0x108(%rdi), %r12
leaq 0x118(%rdi), %r14
movq %r14, 0x108(%rdi)
movq %rax, 0x110(%rdi)
movb %al, 0x118(%rdi)
movabsq $0x3fa999999999999a, %rax # imm = 0x3FA999999999999A
movq %rax, 0x80(%rdi)
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, 0x88(%rdi)
movaps 0x192ea(%rip), %xmm0    # 0x1e010
movups %xmm0, 0x94(%rdi)
movaps 0x192ec(%rip), %xmm0    # 0x1e020
movups %xmm0, 0xa8(%rdi)
movaps 0x192ee(%rip), %xmm0    # 0x1e030
movups %xmm0, 0xbc(%rdi)
movabsq $0x600000003, %rax      # imm = 0x600000003
movq %rax, 0xcc(%rdi)
movl $0xc, 0xd4(%rdi)
movl $0x64, 0x90(%rdi)
movabsq $0x3f1a36e2eb1c432d, %rax # imm = 0x3F1A36E2EB1C432D
movq %rax, 0xd8(%rdi)
leaq 0x192ba(%rip), %rcx     # 0x1e040
movl $0x9, %r8d
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x44b0
movl $0x2, 0x100(%rbx)
movq 0x110(%rbx), %rdx
leaq 0x1ad19(%rip), %rcx     # 0x1fac9
movq %r12, %rdi
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x44b0
movl $0x0, 0x128(%rbx)
movl $0xffffffff, 0xa4(%rbx) # imm = 0xFFFFFFFF
movl $0x1, 0xb8(%rbx)
movw $0x0, 0x12c(%rbx)
movb $0x0, 0x12e(%rbx)
movq $0x0, 0x130(%rbx)
movq $0x2, 0x138(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, 0x20(%rsp)
movq (%r12), %rdi
cmpq %r14, %rdi
je 0x4e29
movq (%r14), %rsi
incq %rsi
callq 0x4300
movq (%r15), %rdi
cmpq %rbp, %rdi
je 0x4e3d
movq (%rbp), %rsi
incq %rsi
callq 0x4300
movq 0x60(%rbx), %rdi
cmpq %r13, %rdi
je 0x4e52
movq (%r13), %rsi
incq %rsi
callq 0x4300
movq 0x40(%rbx), %rdi
cmpq 0x8(%rsp), %rdi
je 0x4e6d
movq 0x8(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x4300
movq 0x20(%rbx), %rdi
cmpq 0x10(%rsp), %rdi
je 0x4e88
movq 0x10(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x4300
movq (%rbx), %rdi
cmpq 0x18(%rsp), %rdi
je 0x4ea2
movq 0x18(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x4300
movq 0x20(%rsp), %rdi
callq 0x45b0
// File: /workspace/github_cpp_makefile_star2_O1/epfml[P]sent2vec/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 || args_->model == model_name::sent2vec || args_->model == model_name::cbowCWNgrams) return false;
  return rand > pdiscard_[id];
}

// Assembly:
pushq %rax
testl %esi, %esi
js 0x6e56
cmpl %esi, 0x5c(%rdi)
jle 0x6e75
movq (%rdi), %rax
movl 0xc0(%rax), %eax
addl $-0x3, %eax
cmpl $0x3, %eax
jae 0x6e47
xorl %eax, %eax
jmp 0x6e54
movl %esi, %eax
movq 0x40(%rdi), %rcx
ucomiss (%rcx,%rax,4), %xmm0
seta %al
popq %rcx
retq
leaq 0x17dbc(%rip), %rdi     # 0x1ec19
leaq 0x17b4b(%rip), %rsi     # 0x1e9af
leaq 0x17bad(%rip), %rcx     # 0x1ea18
movl $0x62, %edx
callq 0x41d0
leaq 0x17bd4(%rip), %rdi     # 0x1ea50
leaq 0x17b2c(%rip), %rsi     # 0x1e9af
leaq 0x17b8e(%rip), %rcx     # 0x1ea18
movl $0x63, %edx
callq 0x41d0
// File: /workspace/github_cpp_makefile_star2_O1/epfml[P]sent2vec/src/dictionary.cc
// Function: fasttext::Dictionary::getLine(std::istream&, std::vector<int, std::allocator<int>>&, std::vector<int, std::allocator<int>>&, std::linear_congruential_engine<unsigned long, 48271ul, 0ul, 2147483647ul>&) const
int32_t Dictionary::getLine(std::istream& in,
                            std::vector<int32_t>& words,
                            std::vector<int32_t>& labels,
                            std::minstd_rand& rng) const {
  std::vector<int32_t> word_hashes;
  int32_t ntokens = getLine(in, words, word_hashes, labels, rng);
  if (args_->model == model_name::sup) {
    addNgrams(words, word_hashes, args_->wordNgrams);
  }
  return ntokens;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %r8, %r9
movq %rcx, %r8
movq %rdx, %r14
movq %rdi, %r15
xorps %xmm0, %xmm0
movq %rsp, %rcx
movaps %xmm0, (%rcx)
movq $0x0, 0x10(%rcx)
callq 0x8590
movl %eax, %ebx
movq (%r15), %rax
cmpl $0x3, 0xc0(%rax)
jne 0x8917
movl 0xb4(%rax), %ecx
movq %rsp, %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x7d5e
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x892d
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x4300
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x8952
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x4300
movq %rbx, %rdi
callq 0x45b0
// File: /workspace/github_cpp_makefile_star2_O1/epfml[P]sent2vec/src/model.cc
// Function: fasttext::Model::update(std::vector<int, std::allocator<int>> const&, int, float)
void Model::update(const std::vector<int32_t>& input, int32_t target, real lr) {
  assert(target >= 0);
  assert(target < osz_);
  if (input.size() == 0) return;
  computeHidden(input, hidden_);
  if (args_->loss == loss_name::ns) {
    loss_ += negativeSampling(target, lr);
  } else if (args_->loss == loss_name::hs) {
    loss_ += hierarchicalSoftmax(target, lr);
  } else {
    loss_ += softmax(target, lr);
  }
  nexamples_ += 1;

  if (args_->model == model_name::sup || args_->model == model_name::sent2vec) {
    grad_.mul(1.0 / input.size());
  }
  for (auto it = input.cbegin(); it != input.cend(); ++it) {
    wi_->addRow(grad_, *it, 1.0);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
testl %edx, %edx
js 0x10916
movl %edx, %ebp
movq %rdi, %r14
cmpl %edx, 0x88(%rdi)
jle 0x10935
movq %rsi, %rbx
movq 0x8(%rsi), %rax
cmpq (%rsi), %rax
je 0x10909
movss %xmm0, 0xc(%rsp)
leaq 0x50(%r14), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x10054
movq 0x40(%r14), %rax
movl 0xbc(%rax), %eax
cmpl $0x1, %eax
je 0x10854
cmpl $0x2, %eax
movss 0xc(%rsp), %xmm0
movq %r14, %rdi
movl %ebp, %esi
jne 0x10866
callq 0xfc36
jmp 0x1086b
movq %r14, %rdi
movl %ebp, %esi
movss 0xc(%rsp), %xmm0
callq 0xfd30
jmp 0x1086b
callq 0xff50
addss 0x8c(%r14), %xmm0
movss %xmm0, 0x8c(%r14)
incq 0x90(%r14)
movq 0x40(%r14), %rax
movl 0xc0(%rax), %eax
addl $-0x3, %eax
cmpl $0x1, %eax
ja 0x108db
movq 0x8(%rbx), %rax
subq (%rbx), %rax
sarq $0x2, %rax
movq %rax, %xmm0
punpckldq 0xe0d2(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0xe0da(%rip), %xmm0     # 0x1e990
leaq 0x70(%r14), %rdi
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movsd 0xe092(%rip), %xmm0     # 0x1e960
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
callq 0xf220
movq (%rbx), %r12
cmpq 0x8(%rbx), %r12
je 0x10909
leaq 0x70(%r14), %r15
movq (%r14), %rdi
movslq (%r12), %rdx
movq %r15, %rsi
movss 0xe8e6(%rip), %xmm0     # 0x1f1e0
callq 0xe158
addq $0x4, %r12
cmpq 0x8(%rbx), %r12
jne 0x108e8
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0xed06(%rip), %rdi      # 0x1f623
leaq 0xec12(%rip), %rsi      # 0x1f536
leaq 0xed04(%rip), %rcx      # 0x1f62f
movl $0xcc, %edx
callq 0x41d0
leaq 0xed3d(%rip), %rdi      # 0x1f679
leaq 0xebf3(%rip), %rsi      # 0x1f536
leaq 0xece5(%rip), %rcx      # 0x1f62f
movl $0xcd, %edx
callq 0x41d0
// File: /workspace/github_cpp_makefile_star2_O1/epfml[P]sent2vec/src/fasttext.cc
// Function: fasttext::FastText::loadModel(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool, bool, int)
void FastText::loadModel(const std::string& filename,
                         const bool inference_mode /* = false */,
                         const bool shared_mem_enabled /* = true */,
                         const int timeout_sec /* = -1 */) {
  std::ifstream ifs(filename, std::ifstream::binary);
  if (!ifs.is_open()) {
    std::cerr << "Model file cannot be opened for loading!" << std::endl;
    exit(EXIT_FAILURE);
  }
  if (!checkModel(ifs)) {
    std::cerr << "Model file has wrong file format!" << std::endl;
    exit(EXIT_FAILURE);
  }
  if (inference_mode) {
    if (shared_mem_enabled) {
      loadModelWithSharedMemory(ifs, filename, timeout_sec);
    } else {
      loadModel(ifs, false);
    }
  } else {
    loadModel(ifs, true);
  }
  ifs.close();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x210, %rsp            # imm = 0x210
movl %r8d, %ebp
movl %ecx, %r12d
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
movl $0x4, %edx
callq 0x44f0
leaq 0x80(%rsp), %rdi
callq 0x40b0
testb %al, %al
je 0x12ee2
leaq 0x8(%rsp), %rsi
callq 0x12486
testb %al, %al
je 0x12f08
andb %r15b, %r12b
cmpb $0x1, %r12b
jne 0x12ea9
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
movq %r14, %rdx
movl %ebp, %ecx
callq 0x12f4c
jmp 0x12ebe
xorb $0x1, %r15b
movzbl %r15b, %edx
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x133ee
leaq 0x8(%rsp), %rdi
callq 0x4090
leaq 0x8(%rsp), %rdi
callq 0x40c0
addq $0x210, %rsp            # imm = 0x210
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x17107(%rip), %rdi     # 0x29ff0
leaq 0xcb12(%rip), %rsi      # 0x1fa02
movl $0x28, %edx
callq 0x4350
movq 0x170ef(%rip), %rdi     # 0x29ff0
callq 0x4170
jmp 0x12f2c
movq 0x170e1(%rip), %rdi     # 0x29ff0
leaq 0xcb15(%rip), %rsi      # 0x1fa2b
movl $0x21, %edx
callq 0x4350
movq 0x170c9(%rip), %rdi     # 0x29ff0
callq 0x4170
movl $0x1, %edi
callq 0x4380
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x40c0
movq %rbx, %rdi
callq 0x45b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/epfml[P]sent2vec/src/fasttext.cc
// Function: fasttext::FastText::skipgram(fasttext::Model&, float, std::vector<int, std::allocator<int>> const&)
void FastText::skipgram(Model& model, real lr,
                        const std::vector<int32_t>& line) {
  std::uniform_int_distribution<> uniform(1, args_->ws);
  for (int32_t w = 0; w < line.size(); w++) {
    int32_t boundary = uniform(model.rng);
    const std::vector<int32_t>& ngrams = dict_->getNgrams(line[w]);
    for (int32_t c = -boundary; c <= boundary; c++) {
      if (c != 0 && w + c >= 0 && w + c < line.size()) {
        model.update(ngrams, line[w + c], lr);
      }
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movss %xmm0, 0xc(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdi, 0x28(%rsp)
movq (%rdi), %rax
movl 0x98(%rax), %eax
movl $0x1, 0x18(%rsp)
movl %eax, 0x1c(%rsp)
movq 0x8(%rdx), %rax
cmpq (%rdx), %rax
je 0x141fa
movq %rdx, %rbx
movq 0x10(%rsp), %rax
addq $0x110, %rax            # imm = 0x110
movq %rax, 0x20(%rsp)
xorl %r12d, %r12d
leaq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq %rdi, %rdx
callq 0xc2dc
movl %eax, %ebp
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rdi
movq (%rbx), %rax
movl (%rax,%r12,4), %esi
callq 0x66b6
movq %rax, 0x30(%rsp)
testl %ebp, %ebp
js 0x141e3
leal 0x1(,%rbp,2), %r13d
movl %r12d, %r14d
subl %ebp, %r14d
xorl %r15d, %r15d
cmpl %r15d, %ebp
je 0x141db
movl %r14d, %eax
addl %r15d, %eax
js 0x141db
movl %eax, %eax
movq (%rbx), %rcx
movq 0x8(%rbx), %rdx
subq %rcx, %rdx
sarq $0x2, %rdx
cmpq %rax, %rdx
jbe 0x141db
movl (%rcx,%rax,4), %edx
movq 0x10(%rsp), %rdi
movq 0x30(%rsp), %rsi
movss 0xc(%rsp), %xmm0
callq 0x107e4
incl %r15d
cmpl %r15d, %r13d
jne 0x141a1
incq %r12
movq 0x8(%rbx), %rax
subq (%rbx), %rax
sarq $0x2, %rax
cmpq %r12, %rax
ja 0x1415e
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/epfml[P]sent2vec/src/fasttext.cc
// Function: fasttext::FastText::sent2vec(fasttext::Model&, float, std::vector<int, std::allocator<int>> const&)
void FastText::sent2vec(Model& model, real lr, const std::vector<int32_t>& line){
  if (line.size() <= 1) return;
  std::vector<int32_t> context;
  std::uniform_real_distribution<> uniform(0, 1);
  for (int32_t i=0; i<line.size(); ++i){
    if (uniform(model.rng) > dict_->getPDiscard(line[i]) || dict_->getTokenCount(line[i]) < args_->minCountLabel)
      continue;
    context = line;
    context[i] = 0;
    dict_->addNgrams(context, args_->wordNgrams, args_->dropoutK, model.rng);
    model.update(context, line[i], lr);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movss %xmm0, 0xc(%rsp)
movq 0x8(%rdx), %rax
subq (%rdx), %rax
cmpq $0x5, %rax
jb 0x14877
movq %rdx, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
movq 0x8(%rdx), %rax
cmpq (%rdx), %rax
je 0x14860
movq %rsi, %r14
movq %rdi, %r15
leaq 0x110(%rsi), %r12
xorl %ebp, %ebp
leaq 0x10(%rsp), %r13
movq %r12, %rdi
callq 0xc464
movsd %xmm0, 0x30(%rsp)
movq 0x10(%r15), %rdi
movq (%rbx), %rax
movl (%rax,%rbp,4), %esi
callq 0x7010
cvtss2sd %xmm0, %xmm0
movsd 0x30(%rsp), %xmm1
ucomisd %xmm0, %xmm1
ja 0x14849
movq 0x10(%r15), %rdi
movq (%rbx), %rax
movl (%rax,%rbp,4), %esi
callq 0x6fb6
movq (%r15), %rcx
movslq 0xac(%rcx), %rcx
cmpq %rcx, %rax
jl 0x14849
movq %r13, %rdi
movq %rbx, %rsi
callq 0xa990
movq 0x10(%rsp), %rax
movl $0x0, (%rax,%rbp,4)
movq (%r15), %rax
movq 0x10(%r15), %rdi
movl 0x9c(%rax), %ecx
movl 0xb4(%rax), %edx
movq %r13, %rsi
movq %r12, %r8
callq 0x8206
movq (%rbx), %rax
movl (%rax,%rbp,4), %edx
movq %r14, %rdi
movq %r13, %rsi
movss 0xc(%rsp), %xmm0
callq 0x107e4
incq %rbp
movq 0x8(%rbx), %rax
subq (%rbx), %rax
sarq $0x2, %rax
cmpq %rbp, %rax
ja 0x147b2
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x14877
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x4300
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x148a0
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x4300
movq %rbx, %rdi
callq 0x45b0
// File: /workspace/github_cpp_makefile_star2_O1/superblocks[P]superblocks/set-elp.cpp
// Function: Superblocks::init()
void Superblocks::init() {

	coin = "ELP"; 
	coin_name = "Elephantcoin";

	hash_length = 64;

	// normal (step 0)
	reward[0] = 50;

	// superblock (step 1)
	seed_type[1] = SEED_WITH_PREVIOUS_BLOCK_HASH;
	cutout_start[1] = 5;
	cutout_length[1] = 7;
	rnd_range_low[1] = 1;
	rnd_range_high[1] = 600000;
	luck_type[1] = LUCK_WITH_MORE_THAN_X_AND_LESS_THAN_Y;
	luck_x[1] = 300000;
	luck_y[1] = 300021;
	//reward[1] = "rand1 = generateMTRandom(rand, 10001); nSubsidy = (10000 + rand1 - 1) * COIN;";
		secondary_rand[1] = 1;
		secondary_rand_type[1] = SECONDARY_REWARD_PLUS_RAND_MINUS_X;
		secondary_rand_low[1] = 1;
		secondary_rand_high[1] = 10001;
		secondary_rand_x[1] = 1;
	reward[1] = 10000;

	// superblock (step 2+)

	luck_type[2] = LUCK_WITH_MORE_THAN_X_AND_LESS_THAN_Y;
	luck_x[2] = 100000;
	luck_y[2] = 100301;
	//reward[2] = "rand1 = generateMTRandom(rand, 4001); nSubsidy = (1000 + rand1 - 1) * COIN;";
		secondary_rand[2] = 1;
		secondary_rand_type[2] = SECONDARY_REWARD_PLUS_RAND_MINUS_X;
		secondary_rand_low[2] = 1;
		secondary_rand_high[2] = 4001;
		secondary_rand_x[2] = 1;
	reward[2] = 1000;

	luck_type[3] = LUCK_WITH_MORE_THAN_X_AND_LESS_THAN_Y;
	luck_x[3] = 500000;
	luck_y[3] = 506001;
	//reward[3] = "rand1 = generateMTRandom(rand, 401); nSubsidy = (100 + rand1 - 1) * COIN;";
		secondary_rand[3] = 1;
		secondary_rand_type[3] = SECONDARY_REWARD_PLUS_RAND_MINUS_X;
		secondary_rand_low[3] = 1;
		secondary_rand_high[3] = 401;
		secondary_rand_x[3] = 1;
	reward[3] = 100;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x18, %rdi
movq 0x20(%rbx), %rdx
leaq 0x134c(%rip), %rcx      # 0x3e80
movl $0x3, %r8d
xorl %esi, %esi
callq 0x1120
leaq 0x38(%rbx), %rdi
movq 0x40(%rbx), %rdx
leaq 0x1334(%rip), %rcx      # 0x3e84
movl $0xc, %r8d
xorl %esi, %esi
callq 0x1120
movl $0x40, 0x58(%rbx)
movl $0x2, 0x60(%rbx)
movl $0x5, 0x70(%rbx)
movl $0x7, 0x80(%rbx)
movl $0x1, %eax
movl %eax, 0x90(%rbx)
movl $0x927c0, 0xa0(%rbx)    # imm = 0x927C0
movabsq $0x300000003, %rcx      # imm = 0x300000003
movq %rcx, 0x120(%rbx)
movabsq $0x186a0000493e0, %rcx  # imm = 0x186A0000493E0
movq %rcx, 0x130(%rbx)
movabsq $0x187cd000493f5, %rcx  # imm = 0x187CD000493F5
movq %rcx, 0x140(%rbx)
movabsq $0x100000001, %rcx      # imm = 0x100000001
movq %rcx, 0xb0(%rbx)
movq %rcx, 0xc0(%rbx)
movq %rcx, 0xd0(%rbx)
movabsq $0xfa100002711, %rdx    # imm = 0xFA100002711
movq %rdx, 0xe0(%rbx)
movq %rcx, 0xf0(%rbx)
movabsq $0x3e800002710, %rcx    # imm = 0x3E800002710
movq %rcx, 0x150(%rbx)
movl $0x3, 0x128(%rbx)
movl $0x7a120, 0x138(%rbx)   # imm = 0x7A120
movabsq $0x320007b891, %rcx     # imm = 0x320007B891
movq %rcx, 0x148(%rbx)
movl %eax, 0xb8(%rbx)
movl %eax, 0xc8(%rbx)
movl %eax, 0xd8(%rbx)
movl $0x191, 0xe8(%rbx)      # imm = 0x191
movl %eax, 0xf8(%rbx)
movl $0x64, 0x158(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/DimitriDaSilva[P]42_ft_containers/containers/utils/red_black_tree.hpp
// Function: ft::red_black_tree<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, ft::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, custom_allocator<ft::red_black_tree_node<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::clear_helper(ft::red_black_tree_node<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>* const&)
void
		clear_helper(node_pointer const& node)
		{
			// Base case of recursion
			if (node == _nil)
				return;

			// Clear all nodes to the left and right of it
			clear_helper(node->left);
			clear_helper(node->right);

			// Clear the node itself
			_alloc.destroy(node);
			_alloc.deallocate(node, 1);

			_size--;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq (%rsi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x7374
movq %rdi, %rbx
addq $0x28, %rsi
callq 0x7326
movq (%r14), %rsi
addq $0x30, %rsi
movq %rbx, %rdi
callq 0x7326
movq (%r14), %rax
movq (%rax), %rdi
addq $0x10, %rax
cmpq %rax, %rdi
je 0x7368
callq 0x5190
movq (%r14), %rdi
callq 0x5190
decq 0x18(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/DimitriDaSilva[P]42_ft_containers/containers/utils/red_black_tree.hpp
// Function: ft::red_black_tree<int, int, ft::less<int>, custom_allocator<ft::red_black_tree_node<int>>>::find(int const&)
iterator
		find(key_type const& key)
		{
			node_pointer position = find_helper(key, _root);

			if (!position)
				return end();
			else
				return iterator(position, _root, _nil);
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rsi), %r14
movq %rsi, %rdi
movq %rdx, %rsi
movq %r14, %rdx
callq 0x6dec
testq %rax, %rax
je 0x6d1f
movq 0x10(%r15), %rcx
jmp 0x6d35
cmpq $0x0, 0x18(%r15)
je 0x6d2f
movq 0x10(%r15), %rax
movq %rax, %rcx
jmp 0x6d35
movq 0x10(%r15), %rcx
xorl %eax, %eax
movq (%r14), %rdx
leaq 0x432b1(%rip), %rsi     # 0x49ff0
movq %rsi, (%rbx)
movq %rax, 0x8(%rbx)
movq %rdx, 0x10(%rbx)
movq %rcx, 0x18(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/DimitriDaSilva[P]42_ft_containers/containers/utils/red_black_tree.hpp
// Function: ft::red_black_tree<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, greater<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<ft::red_black_tree_node<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::insert_helper(ft::red_black_tree_node<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>*, ft::red_black_tree_node<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>*)
node_pointer
		insert_helper(node_pointer node, node_pointer hint)
		{
			node->parent = find_right_position(node, hint);

			// Set node in the position found. Either left or right
			// If parent NULL then it means we are at the root of the tree
			// so we can retrun
			if (node->parent == NULL)
			{
				_root = node;
				_root->color = black;

				return _root;
			}
			else if (_comp(get_key_from_val(node->data), get_key_from_val(node->parent->data)))
				node->parent->left = node;
			else
				node->parent->right = node;

			// If parent is _root then we are at level 1 of the tree
			// so we can't be unbalancing the tree
			// Else the new node could have unbalanced the red-black tree
			// so we need to check after each insert
			if (node->parent != _root)
				check_insert(node);

			return node;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
movq %rsi, -0x28(%rbp)
callq 0xaa52
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x20(%rax)
testq %rcx, %rcx
je 0xa8a3
movq (%rbx), %rcx
leaq -0x48(%rbp), %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq *0x10(%rcx)
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rdx
movq (%rbx), %rax
leaq -0x68(%rbp), %rdi
movq %rbx, %rsi
callq *0x10(%rax)
movq -0x40(%rbp), %r15
movq -0x60(%rbp), %r12
cmpq %r15, %r12
movq %r15, %rdx
cmovbq %r12, %rdx
testq %rdx, %rdx
je 0xa8b3
movq -0x68(%rbp), %rsi
movq -0x48(%rbp), %rdi
callq 0x50c0
movl %eax, %r14d
jmp 0xa8b6
movq %rax, 0x8(%rbx)
movl $0x1, 0x38(%rax)
jmp 0xa933
xorl %r14d, %r14d
testl %r14d, %r14d
jne 0xa8dc
subq %r12, %r15
cmpq $-0x7fffffff, %r15      # imm = 0x80000001
movq $-0x80000000, %r14      # imm = 0x80000000
cmovgeq %r15, %r14
movl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
cmpq %rax, %r14
cmovgeq %rax, %r14
leaq -0x58(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa8ee
callq 0x5190
leaq -0x38(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa900
callq 0x5190
xorl %eax, %eax
testl %r14d, %r14d
setle %al
movq -0x28(%rbp), %rcx
movq 0x20(%rcx), %rdx
movq %rcx, 0x28(%rdx,%rax,8)
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
cmpq 0x8(%rbx), %rax
je 0xa92f
leaq -0x28(%rbp), %rsi
movq %rbx, %rdi
callq 0xab5c
movq -0x28(%rbp), %rax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa955
callq 0x5190
movq %rbx, %rdi
callq 0x52f0
nop