name string | code string | asm string | file string |
|---|---|---|---|
testing::UnitTest::GetTestCase(int) const | inline E GetElementOr(const std::vector<E>& v, int i, E default_value) {
return (i < 0 || i >= static_cast<int>(v.size())) ? default_value
: v[static_cast<size_t>(i)];
} | testl %esi, %esi
js 0x47527
movq 0x40(%rdi), %rax
movq 0xd0(%rax), %rcx
movq 0xd8(%rax), %rdx
subq %rcx, %rdx
shrq $0x2, %rdx
cmpl %esi, %edx
jle 0x47527
movl %esi, %edx
cmpl $0x0, (%rcx,%rdx,4)
js 0x47527
movq 0xb8(%rax), %rax
movq (%rax,%rdx,8), %rax
retq
xorl %eax, %eax
retq
| /ckerr[P]buffy/extern/googletest/googletest/src/gtest-internal-inl.h |
testing::UnitTest::Run() | int UnitTest::Run() {
const bool in_death_test_child_process =
internal::GTEST_FLAG(internal_run_death_test).length() > 0;
// Google Test implements this protocol for catching that a test
// program exits before returning control to Google Test:
//
// 1. Upon start, Google Test creates a file whose a... | pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
cmpq $0x0, 0x43290(%rip) # 0x8a948
je 0x476be
xorl %esi, %esi
jmp 0x476cd
leaq 0x20f21(%rip), %rdi # 0x685e6
callq 0x10600
movq %rax, %rsi
movq %rsp, %rdi
callq 0x56478
movq 0x40(%rbx), %rdi
movb 0x43126(%rip), %al # 0x8a805
movb %al, 0x258(%rdi)
leaq 0x36(%rip),... | /ckerr[P]buffy/extern/googletest/googletest/src/gtest.cc |
testing::UnitTest::current_test_suite() const | GTEST_LOCK_EXCLUDED_(mutex_) {
internal::MutexLock lock(&mutex_);
return impl_->current_test_suite();
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
movq %r14, %rdi
callq 0x58578
movq 0x40(%rbx), %rax
movq 0x168(%rax), %rbx
movq %r14, %rdi
callq 0x58616
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
callq 0x2dd16
nop
| /ckerr[P]buffy/extern/googletest/googletest/src/gtest.cc |
testing::UnitTest::current_test_info() const | GTEST_LOCK_EXCLUDED_(mutex_) {
internal::MutexLock lock(&mutex_);
return impl_->current_test_info();
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
movq %r14, %rdi
callq 0x58578
movq 0x40(%rbx), %rax
movq 0x170(%rax), %rbx
movq %r14, %rdi
callq 0x58616
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
callq 0x2dd16
nop
| /ckerr[P]buffy/extern/googletest/googletest/src/gtest.cc |
testing::UnitTest::PopGTestTrace() | GTEST_LOCK_EXCLUDED_(mutex_) {
internal::MutexLock lock(&mutex_);
impl_->gtest_trace_stack().pop_back();
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x8(%rdi), %rbx
movq %rbx, %rdi
callq 0x58578
movl $0x248, %edi # imm = 0x248
addq 0x40(%r14), %rdi
callq 0x58f7a
movq 0x8(%rax), %rcx
leaq -0x30(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq -0x20(%rcx), %rdi
addq $-0x10, %rcx
cmpq %rcx, %rdi
je 0x47ea1
movq (%r... | /ckerr[P]buffy/extern/googletest/googletest/src/gtest.cc |
testing::internal::UnitTestImpl::GetTestSuite(char const*, char const*, void (*)(), void (*)()) | TestSuite* UnitTestImpl::GetTestSuite(
const char* test_suite_name, const char* type_param,
internal::SetUpTestSuiteFunc set_up_tc,
internal::TearDownTestSuiteFunc tear_down_tc) {
// Can we find a TestSuite with the given name?
const auto test_suite =
std::find_if(test_suites_.rbegin(), test_suite... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %r8, %r12
movq %rcx, %r13
movq %rdx, %rbp
movq %rsi, %r14
movq %rdi, %rbx
movq 0xc0(%rdi), %rax
movq %rax, 0x50(%rsp)
movq 0xb8(%rdi), %rax
movq %rax, 0x48(%rsp)
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x5424e
leaq 0x68(%rs... | /ckerr[P]buffy/extern/googletest/googletest/src/gtest.cc |
testing::internal::UnitTestImpl::UnshuffleTests() | void UnitTestImpl::UnshuffleTests() {
for (size_t i = 0; i < test_suites_.size(); i++) {
// Unshuffles the tests in each test suite.
test_suites_[i]->UnshuffleTests();
// Resets the index of each test suite.
test_suite_indices_[i] = static_cast<int>(i);
}
} | movq 0xb8(%rdi), %rax
movq 0xc0(%rdi), %rcx
subq %rax, %rcx
je 0x4929b
sarq $0x3, %rcx
movq 0xd0(%rdi), %rdx
cmpq $0x1, %rcx
adcq $0x0, %rcx
xorl %esi, %esi
movq (%rax,%rsi,8), %r8
movq 0x48(%r8), %rdi
movq 0x50(%r8), %r8
subq %rdi, %r8
je 0x49290
sarq $0x2, %r8
cmpq $0x1, %r8
adcq $0x0, %r8
xorl %r9d, %r9d
movl %r9d, ... | /ckerr[P]buffy/extern/googletest/googletest/src/gtest.cc |
testing::internal::InDeathTestChild() | bool InDeathTestChild() {
# if GTEST_OS_WINDOWS || GTEST_OS_FUCHSIA
// On Windows and Fuchsia, death tests are thread-safe regardless of the value
// of the death_test_style flag.
return !GTEST_FLAG(internal_run_death_test).empty();
# else
if (GTEST_FLAG(death_test_style) == "threadsafe")
return !GTEST_F... | pushq %rax
leaq 0x40f8e(%rip), %rdi # 0x8a960
leaq 0x1eee4(%rip), %rsi # 0x688bd
callq 0x328de
xorl %ecx, %ecx
cmpq $0x0, 0x40f60(%rip) # 0x8a948
setne %cl
testl %eax, %eax
movzbl 0x40f8d(%rip), %eax # 0x8a981
cmovel %ecx, %eax
andb $0x1, %al
popq %rcx
retq
nop
| /ckerr[P]buffy/extern/googletest/googletest/src/gtest-death-test.cc |
testing::internal::DeathTestAbort(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | static void DeathTestAbort(const std::string& message) {
// On a POSIX system, this function may be called from a threadsafe-style
// death test child process, which operates on a very small stack. Use
// the heap for any additional non-minuscule memory requirements.
const InternalRunDeathTestFlag* const flag ... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x3435e
movq 0x40e2a(%rip), %rax # 0x8a930
movq 0x238(%rax), %rax
testq %rax, %rax
jne 0x49b31
movq 0x404af(%rip), %r14 # 0x89fc8
movq (%r14), %rsi
movq (%rbx), %rdi
callq 0x10540
movq (%r14), %rdi
callq 0x105a0
callq 0x556f1
movl 0x28(%rax), %edi
leaq 0x1e... | /ckerr[P]buffy/extern/googletest/googletest/src/gtest-death-test.cc |
testing::internal::DeathTestImpl::ReadAndInterpretStatusByte() | void DeathTestImpl::ReadAndInterpretStatusByte() {
char flag;
int bytes_read;
// The read() here blocks until data is available (signifying the
// failure of the death test) or until the pipe is closed (signifying
// its success), so it's okay to call this in the parent before
// the child process has exit... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1f8, %rsp # imm = 0x1F8
movq %rdi, %rbx
leaq 0x7(%rsp), %r14
movl 0x34(%rbx), %edi
movl $0x1, %edx
movq %r14, %rsi
callq 0x10730
movq %rax, %r15
cmpl $-0x1, %r15d
jne 0x49c8d
callq 0x10060
cmpl $0x4, (%rax)
je 0x49c59
leaq 0x34(%rbx), ... | /ckerr[P]buffy/extern/googletest/googletest/src/gtest-death-test.cc |
testing::internal::DeathTestImpl::Passed(bool) | bool DeathTestImpl::Passed(bool status_ok) {
if (!spawned())
return false;
const std::string error_message = GetErrorLogs();
bool success = false;
Message buffer;
buffer << "Death test: " << statement() << "\n";
switch (outcome()) {
case LIVED:
buffer << " Result: failed to die.\n"
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1e8, %rsp # imm = 0x1E8
cmpb $0x1, 0x28(%rdi)
jne 0x4a92d
movl %esi, %ebp
movq %rdi, %r14
movq (%rdi), %rax
leaq 0x30(%rsp), %rdi
movq %r14, %rsi
callq *0x30(%rax)
leaq 0x28(%rsp), %rdi
callq 0x37e78
movq 0x28(%rsp), %rbx
addq $0x10, %rbx
leaq 0x1e13c(%rip)... | /ckerr[P]buffy/extern/googletest/googletest/src/gtest-death-test.cc |
bfy_buffer_remove_ntoh_u64 | uint64_t
bfy_buffer_remove_ntoh_u64(struct bfy_buffer* buf) {
uint64_t val = 0;
size_t const len = bfy_buffer_remove(buf, sizeof(val), &val);
if (len == sizeof(val)) {
val = ntoh64(val);
} else {
errno = ENOMSG;
}
return val;
} | pushq %rax
movq %rsp, %rcx
movq $0x0, (%rcx)
movl $0x8, %edx
xorl %esi, %esi
callq 0x5f552
cmpq $0x8, %rax
jne 0x5f987
movq (%rsp), %rax
bswapq %rax
movq %rax, (%rsp)
jmp 0x5f992
callq 0x10060
movl $0x2a, (%rax)
movq (%rsp), %rax
popq %rcx
retq
| /ckerr[P]buffy/src/buffer.c |
bfy_buffer_make_contiguous | void*
bfy_buffer_make_contiguous(bfy_buffer* buf, size_t wanted) {
struct bfy_pos const pos = buffer_get_pos(buf, wanted);
// if the first page already holds wanted, then we're done
if ((pos.page_idx == 0) || (pos.page_idx == 1 && pos.page_pos == 0)) {
return buffer_read_begin(buf);
}
bfy_... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb0, %rsp
movq %rsi, %rdx
movq %rdi, %rbx
leaq 0x38(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5e59a
movq (%r14), %rax
testq %rax, %rax
je 0x5fb32
cmpq $0x1, %rax
jne 0x5f9dc
cmpq $0x0, 0x40(%rsp)
je 0x5fb32
incl 0x84(%rbx)
movq 0x38(%rbx), %rcx
mov... | /ckerr[P]buffy/src/buffer.c |
buffer_insert_pages | static int
buffer_insert_pages(bfy_buffer* buf, size_t pos,
struct bfy_page const* new_pages,
size_t new_len) {
if (new_len == 0 || new_pages == NULL) {
return 0;
}
// if we have nothing, use buf->page
if (new_len == 1 && buf->pages == NULL && buf->page.d... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
testq %rcx, %rcx
sete %al
testq %rdx, %rdx
sete %cl
xorl %r13d, %r13d
orb %al, %cl
jne 0x6014c
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
cmpq $0x1, %r15
jne 0x5ffe5
cmpq $0x0, 0x38(%rbx)
jne 0x5ffe5
cmpq $0x0, (%rbx)
je 0... | /ckerr[P]buffy/src/buffer.c |
page_release | static void
page_release(struct bfy_page* page) {
if (page->unref_cb != NULL) {
page->unref_cb(page->data, page->size, page->unref_arg);
}
if (page_can_realloc(page)) {
page_realloc(page, 0);
}
*page = InitPage;
} | pushq %rbx
movq %rdi, %rbx
movq 0x28(%rdi), %rax
testq %rax, %rax
je 0x60178
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
movq 0x30(%rbx), %rdx
callq *%rax
testb $0x3, 0x20(%rbx)
jne 0x60188
movq %rbx, %rdi
xorl %esi, %esi
callq 0x5ff0d
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)... | /ckerr[P]buffy/src/buffer.c |
iter_advance_n_bytes | static bool
iter_advance_n_bytes(struct bfy_iter* const iter, size_t n) {
while (iter->io.iov_len < n) { // make sure we're on the right page
n -= iter->io.iov_len;
if (!iter_next_page(iter)) {
return false;
}
}
iter->io = iov_drain(iter->io, n);
iter->cur.page_pos +=... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %r14, %r15
movq 0x28(%rbx), %r12
movq %r12, %rax
subq %r14, %rax
jae 0x601d1
movq %r15, %r14
subq %r12, %r14
movq %rbx, %rdi
callq 0x5e7c0
testb %al, %al
jne 0x601ae
jmp 0x601e1
addq %r15, 0x20(%rbx)
movq %rax, 0x28(%rbx)
addq %... | /ckerr[P]buffy/src/buffer.c |
linkedList<transaction*>::operator=(linkedList<transaction*>&) | linkedList<T> & linkedList<T>::operator=( linkedList<T> &rhs)
{
// linkedList *tmp = new linkedList;
this->clear(); // the function at the start of this review
// if (rhs.isEmpty()) {
// // short cut, since the other list is empty
// linkedList<T> tmp = new linkedList<T>();
... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x4b44
movq 0x8(%rbx), %rbx
movq (%rbx), %rsi
movq %r14, %rdi
callq 0x3c7e
jmp 0x6017
| /DimitrisGan[P]transactionBitCoinSystem/mylinkedList.h |
pipeline_2P_SP(unsigned long, unsigned int) | void pipeline_2P_SP(size_t L, unsigned w) {
tf::Executor executor(w);
const size_t maxN = 100;
std::vector<int> source(maxN);
std::iota(source.begin(), source.end(), 0);
std::vector<std::array<int, 2>> mybuffer(L);
for(size_t N = 0; N <= maxN; N++) {
tf::Taskflow taskflow;
size_t j1 = 0;
s... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x508, %rsp # imm = 0x508
movq %rdi, %rbx
movl %esi, %esi
pxor %xmm0, %xmm0
leaq 0x2c0(%rsp), %rdx
movdqa %xmm0, (%rdx)
leaq 0x3d0(%rsp), %rdi
callq 0x569ca
movq 0x2c8(%rsp), %rdi
testq %rdi, %rdi
je 0x1e166
callq 0x5ac28
movq %rbx, 0x48... | /taskflow[P]taskflow/unittests/test_pipelines.cpp |
doctest::(anonymous namespace)::(anonymous namespace)::hexEscapeChar(std::ostream&, unsigned char) | void hexEscapeChar(std::ostream& os, unsigned char c) {
std::ios_base::fmtflags f(os.flags());
os << "\\x"
<< std::uppercase << std::hex << std::setfill('0') << std::setw(2)
<< static_cast<int>(c);
os.flags(f);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movq (%rdi), %rax
movq -0x18(%rax), %rax
movl 0x18(%rdi,%rax), %r15d
leaq 0x3ab6c(%rip), %rsi # 0x6d848
movl $0x2, %edx
callq 0x7550
movq (%rbx), %rax
movq -0x18(%rax), %rcx
orl $0x4000, 0x18(%rbx,%rcx) # imm = 0x4000
movq -0x18(... | /taskflow[P]taskflow/3rd-party/doctest/doctest.h |
void tf::SmallVectorImpl<tf::Node*>::append<tf::Node**>(tf::Node**, tf::Node**) | void append(in_iter in_start, in_iter in_end) {
size_type NumInputs = std::distance(in_start, in_end);
// Grow allocated space if needed.
if (NumInputs > size_type(this->capacity_ptr()-this->end()))
this->grow(this->size()+NumInputs);
// Copy the new elements over.
this->uninitialized_copy(in... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
movq %rdx, %r14
subq %rsi, %r14
movq 0x8(%rdi), %rdx
movq 0x10(%rdi), %rax
subq %rdx, %rax
cmpq %rax, %r14
jbe 0x5b29e
addq %r14, %rdx
subq (%rbx), %rdx
andq $-0x8, %rdx
leaq 0x18(%rbx), %rsi
movl $0x8, %ecx
movq %rbx... | /taskflow[P]taskflow/taskflow/core/../utility/small_vector.hpp |
void tf::SmallVectorImpl<tf::Node*>::append<std::move_iterator<tf::Node**>>(std::move_iterator<tf::Node**>, std::move_iterator<tf::Node**>) | void append(in_iter in_start, in_iter in_end) {
size_type NumInputs = std::distance(in_start, in_end);
// Grow allocated space if needed.
if (NumInputs > size_type(this->capacity_ptr()-this->end()))
this->grow(this->size()+NumInputs);
// Copy the new elements over.
this->uninitialized_copy(in... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
movq %rdx, %r14
subq %rsi, %r14
movq 0x8(%rdi), %rdx
movq 0x10(%rdi), %rax
subq %rdx, %rax
cmpq %rax, %r14
jbe 0x5b304
addq %r14, %rdx
subq (%rbx), %rdx
andq $-0x8, %rdx
leaq 0x18(%rbx), %rsi
movl $0x8, %ecx
movq %rbx... | /taskflow[P]taskflow/taskflow/core/../utility/small_vector.hpp |
main | int main()
{
int m,N,R,now;
std::cin >> N >> R;
if(N < 0){
std::cout << "-";
N = -N;
}
m = 0;
while (N) //转换进制，先求余在，在除，最后倒序输出
{
now = N % R;
if(now <= 9)
{
num[m++] = '0' + now; //'0'表示把数字转换成char类型的数字
}else
{
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq 0x2e04(%rip), %rdi # 0x3fe0
leaq 0x8(%rsp), %rbx
movq %rbx, %rsi
callq 0x1040
leaq 0xc(%rsp), %rsi
movq %rax, %rdi
callq 0x1040
movl (%rbx), %eax
testl %eax, %eax
jns 0x1219
movq 0x2dcd(%rip), %rdi # 0x3fd0
leaq 0xdfa(%rip), %rsi # 0x2004
callq 0x10... | /joiln[P]Bilibili_lanqiao_codes_1/question_7.cpp |
MX_EQ | uint8_t MX_EQ(uint32_t **a, uint32_t a_rows, uint32_t a_cols,
uint32_t **b, uint32_t b_rows, uint32_t b_cols)
{
if (a_rows != b_rows)
return 0;
if (a_cols != b_cols)
return 0;
for (uint32_t i = 0; i < a_rows; i++)
for (uint32_t j = 0; j < a_cols; j++)
if (a[i][... | xorl %esi, %r8d
xorl %edx, %r9d
orl %r8d, %r9d
jne 0x1a81
movl %esi, %eax
movl %edx, %edx
xorl %esi, %esi
cmpq %rax, %rsi
je 0x1a84
xorl %r8d, %r8d
cmpq %r8, %rdx
je 0x1a7c
movq (%rdi,%rsi,8), %r9
movl (%r9,%r8,4), %r9d
movq (%rcx,%rsi,8), %r10
leaq 0x1(%r8), %r11
cmpl (%r10,%r8,4), %r9d
movq %r11, %r8
je 0x1a5c
jmp 0x... | /Warchant[P]reed-solomon_syndrome_gf256/test.h |
HermiteSpline<5u, 2u>::walk(double, void (*)(Eigen::Matrix<double, 2, 1, 0, 2, 1>, HermiteSpline<5u, 2u>&, double, UnitBoundedPolynomial<5u, 2u>&, void*), void*) | void HermiteSpline<Order, Dims>::walk(const double deltatau, void (*fn)(VectorNd, HermiteSpline<Order, Dims>&, double, UnitBoundedPolynomial<Order, Dims>&, void *), void *payload)
{
double tau = 0.0;
int m = 0;
while (m < children.size())
{
double reltau = tau / children[m].length;
Vect... | subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movsd %xmm0, 0x78(%rsp)
movq %rsi, 0x70(%rsp)
movq %rdx, 0x68(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x28(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x60(%rsp)
movl $0x0, 0x5c(%rsp)
movq 0x28(%rsp), %rdi
movslq 0x5c(%rsp), %rax
movq %rax, 0x20(%rsp)
callq 0xe390
movq %rax, %rcx
movq 0x... | /janhuenermann[P]quintic-spline-solver/src/spline.cpp |
UnitBoundedPolynomial1<3u>::interpolate(double) const | double UnitBoundedPolynomial1<Order>::interpolate(double t) const
{
double y = 0.0, tt = 1;
for (int k = 0; k <= Order; ++k)
{
y += coeffs[k] * tt;
tt *= t;
}
return y;
} | movq %rdi, -0x8(%rsp)
movsd %xmm0, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x30(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rsp)
movsd 0x7584a(%rip), %xmm0 # 0x91010
movsd %xmm0, -0x20(%rsp)
movl $0x0, -0x24(%rsp)
cmpl $0x3, -0x24(%rsp)
ja 0x1b823
movq -0x30(%rsp), %rax
movslq -0x24(%rsp), %rcx
movsd (%rax,%r... | /janhuenermann[P]quintic-spline-solver/src/spline.cpp |
HermiteSpline<3u, 1u>::interpolate(double) | typename HermiteSpline<Order, Dims>::VectorNd HermiteSpline<Order, Dims>::interpolate(double s)
{
int m = 0;
double s_ = s;
while (s_ > children[m].length && m < children.size())
{
s_ -= children[m].length;
}
if (s_ >= 1.0)
{
s_ = 1.0;
}
return children[m].interpol... | subq $0x68, %rsp
movq %rdi, 0x28(%rsp)
movq %rdi, %rax
movq %rax, 0x30(%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movsd %xmm0, 0x50(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x38(%rsp)
movl $0x0, 0x4c(%rsp)
movsd 0x50(%rsp), %xmm0
movsd %xmm0, 0x40(%rsp)
movq 0x38(%rsp), %rdi
movsd 0x40(%rsp), %xmm0
movsd %xmm0, 0x... | /janhuenermann[P]quintic-spline-solver/src/spline.cpp |
UnitBoundedPolynomial<3u, 2u>::walk(double, void (*)(Eigen::Matrix<double, 2, 1, 0, 2, 1>, double, UnitBoundedPolynomial<3u, 2u> const&, void*), void*, double, double) const | void UnitBoundedPolynomial<Order, Dims>::walk(const double deltatau, void (*fn)(VectorNd, double, const UnitBoundedPolynomial<Order, Dims>&, void *), void *payload, double a, double b) const
{
double tau = a;
while (tau <= b)
{
if (b - tau < deltatau)
{
tau = b;
}
... | subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movsd %xmm0, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movsd %xmm1, 0x30(%rsp)
movsd %xmm2, 0x28(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movsd 0x30(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x20(%rsp), %xmm1
movsd 0x28(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jb 0x... | /janhuenermann[P]quintic-spline-solver/src/spline.cpp |
HermiteSpline<3u, 2u>::walk(double, void (*)(Eigen::Matrix<double, 2, 1, 0, 2, 1>, HermiteSpline<3u, 2u>&, double, UnitBoundedPolynomial<3u, 2u>&, void*), void*) | void HermiteSpline<Order, Dims>::walk(const double deltatau, void (*fn)(VectorNd, HermiteSpline<Order, Dims>&, double, UnitBoundedPolynomial<Order, Dims>&, void *), void *payload)
{
double tau = 0.0;
int m = 0;
while (m < children.size())
{
double reltau = tau / children[m].length;
Vect... | subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movsd %xmm0, 0x78(%rsp)
movq %rsi, 0x70(%rsp)
movq %rdx, 0x68(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x28(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x60(%rsp)
movl $0x0, 0x5c(%rsp)
movq 0x28(%rsp), %rdi
movslq 0x5c(%rsp), %rax
movq %rax, 0x20(%rsp)
callq 0x100b0
movq %rax, %rcx
movq 0... | /janhuenermann[P]quintic-spline-solver/src/spline.cpp |
main | int main(void)
{
bool tests_ok = true;
size_t index;
size_t miniscript_ref_max = sizeof(g_miniscript_ref_test_table) / sizeof(struct wally_miniscript_ref_test);
size_t miniscript_max = sizeof(g_miniscript_test_table) / sizeof(struct wally_miniscript_test);
size_t miniscript_tr_max = sizeof(g_miniscr... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x248, %rsp # imm = 0x248
movb $0x1, %r12b
xorl %r14d, %r14d
leaq 0x79746(%rip), %r15 # 0x800c0
leaq 0x5c2f7(%rip), %rbx # 0x62c78
movq (%r14,%r15), %rdi
movq 0x8(%r14,%r15), %rdx
movq %rdi, %rsi
xorl %ecx, %ecx
callq 0x7160
test... | /p2pderivatives[P]cfd-go/external/libwally-core/src/ctest/test_descriptor.c |
check_parse_miniscript | static bool check_parse_miniscript(const char *function, const char *descriptor,
const char *expected,
const char **key_name_list,
const char **key_value_list, size_t list_num,
uin... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x220, %rsp # imm = 0x220
movl %ecx, %r9d
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %eax, %eax
leaq 0x8(%rsp), %r10
movq %rax, (%r10)
movq %rax, (%rsp)
subq $0x8, %rsp
leaq 0x18(%rsp), %rax
movq %rsi, %rdi
xorl %esi, %esi
xorl %edx, %edx... | /p2pderivatives[P]cfd-go/external/libwally-core/src/ctest/test_descriptor.c |
check_type_properties | int check_type_properties(uint32_t property)
{
/* K, V, B, W all conflict with each other */
switch (property & MINISCRIPT_TYPE_MASK) {
case MINISCRIPT_TYPE_B:
case MINISCRIPT_TYPE_V:
case MINISCRIPT_TYPE_K:
case MINISCRIPT_TYPE_W:
break;
default:
return WALLY_EINVAL;
}
... | movl %edi, %ecx
andl $0xf, %ecx
movl $0xfffffffe, %eax # imm = 0xFFFFFFFE
cmpl $0x8, %ecx
ja 0x7309
movl $0x116, %edx # imm = 0x116
btl %ecx, %edx
jae 0x7309
movl %edi, %ecx
notl %ecx
testl $0x802, %ecx # imm = 0x802
je 0x7309
movl %edi, %edx
andl $0x300, %edx # imm = 0x300
cmpl $... | /p2pderivatives[P]cfd-go/external/libwally-core/src/descriptor.c |
free_descriptor_address_item | static void free_descriptor_address_item(
struct wally_descriptor_address_item *item, size_t item_len)
{
size_t index;
if (item) {
for (index = 0; index < item_len; ++index) {
if (item[index].address) {
wally_clear((void *)item[index].address, item[index].address_len);
... | testq %rdi, %rdi
je 0x73a8
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
testq %rsi, %rsi
je 0x7385
movq %rbx, %r15
movq %r14, %r12
movq 0x8(%r15), %rdi
testq %rdi, %rdi
je 0x736f
movq 0x10(%r15), %rsi
callq 0xba8b
movq 0x8(%r15), %rdi
callq 0xba94
movl $0x18, %esi
movq %r15, %r... | /p2pderivatives[P]cfd-go/external/libwally-core/src/descriptor.c |
wally_descriptor_parse_miniscript | int wally_descriptor_parse_miniscript(
const char *miniscript,
const char **key_name_array,
const char **key_value_array,
size_t array_len,
uint32_t derive_child_num,
uint32_t flags,
unsigned char *script,
size_t script_len,
size_t *written)
{
int ret;
struct wally_descriptor... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl $0xfffffffe, %eax # imm = 0xFFFFFFFE
cmpq $0x0, 0x68(%rsp)
je 0x745f
cmpq $0x0, 0x60(%rsp)
je 0x745f
movq %rsi, %r13
movq 0x70(%rsp), %rsi
testq %rsi, %rsi
je 0x745f
xorl %eax, %eax
movq %rax, (%rsi)
leaq 0x10(%rsp), %rbx
movl... | /p2pderivatives[P]cfd-go/external/libwally-core/src/descriptor.c |
parse_miniscript | static int parse_miniscript(
const char *miniscript,
const char **key_name_array,
const char **key_value_array,
size_t array_len,
uint32_t flags,
uint32_t target,
uint32_t *network,
uint32_t descriptor_depth,
uint32_t descriptor_index,
struct wally_descriptor_script_item *script_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %r9d, %ebp
movq $0x0, 0x30(%rsp)
cmpl $0x2, %r8d
setae %al
testq %rdi, %rdi
sete %r9b
movl $0xfffffffe, %ebx # imm = 0xFFFFFFFE
orb %al, %r9b
jne 0x75ff
testq %rcx, %rcx
je 0x74c0
testq %rdx, %rdx
setne %al
testq %rsi, %rsi
se... | /p2pderivatives[P]cfd-go/external/libwally-core/src/descriptor.c |
wally_descriptor_to_addresses | int wally_descriptor_to_addresses(
const char *descriptor,
const char **key_name_array,
const char **key_value_array,
size_t array_len,
uint32_t start_child_num,
uint32_t end_child_num,
uint32_t network,
uint32_t flags,
struct wally_descriptor_addresses *addresses)
{
int ret;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %r9d, %r12d
movl $0xfffffffe, %ebp # imm = 0xFFFFFFFE
subl %r8d, %r12d
jb 0x7d6d
testq %rdi, %rdi
je 0x7d6d
cmpq $0x0, 0x80(%rsp)
je 0x7d6d
movl %r9d, %ebx
movl %r8d, %r15d
movl 0x70(%rsp), %eax
cmpl $0xff, %eax
jne 0x7bb9
mov... | /p2pderivatives[P]cfd-go/external/libwally-core/src/descriptor.c |
wally_descriptor_create_checksum | int wally_descriptor_create_checksum(
const char *descriptor,
const char **key_name_array,
const char **key_value_array,
size_t array_len,
uint32_t flags,
char **output)
{
int ret = WALLY_OK;
char checksum[9];
char *ignore_checksum_descriptor = NULL;
if (!descriptor || !output |... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq $0x0, 0x30(%rsp)
movl $0xfffffffe, %ebp # imm = 0xFFFFFFFE
testl %r8d, %r8d
jne 0x7e57
movq %rdi, %r13
testq %rdi, %rdi
je 0x7e57
movq %r9, %rbx
testq %r9, %r9
je 0x7e57
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
leaq 0x3... | /p2pderivatives[P]cfd-go/external/libwally-core/src/descriptor.c |
generate_descriptor_checksum | static int generate_descriptor_checksum(const char *descriptor, char *checksum)
{
/*
* base:
* bitcoin/src/script/descriptor.cpp
* std::string DescriptorChecksum(const Span<const char>& span)
*/
/** A character set designed such that:
* - The most common 'unprotected' descriptor chara... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x5070
testq %rax, %rax
je 0x7f3c
movq %rax, %rdx
xorl %r13d, %r13d
movl $0x1, %eax
leaq 0x5b29b(%rip), %rbp # 0x63137
xorl %ecx, %ecx
xorl %r15d, %r15d
movl %ecx, %esi
movb (%r14,%r13), %cl
xorl... | /p2pderivatives[P]cfd-go/external/libwally-core/src/descriptor.c |
analyze_miniscript | static int analyze_miniscript(
const char *miniscript,
const char **key_name_array,
const char **key_value_array,
size_t array_len,
uint32_t target,
uint32_t *network,
uint32_t flags,
struct miniscript_node_t *prev_node,
struct miniscript_node_t *parent_node,
struct miniscript_no... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x288, %rsp # imm = 0x288
movq %r9, %rbx
movl %r8d, %r15d
movq %rcx, 0x48(%rsp)
movq %rdx, %r14
movq %rsi, 0x78(%rsp)
movq %rdi, %r13
xorl %eax, %eax
movq %rax, 0x38(%rsp)
movq %rax, 0x58(%rsp)
movq %rax, 0x50(%rsp)
callq 0x5070
movq %ra... | /p2pderivatives[P]cfd-go/external/libwally-core/src/descriptor.c |
free_miniscript_node | static void free_miniscript_node(struct miniscript_node_t *node)
{
if (!node)
return;
if (node->child) {
struct miniscript_node_t *child = node->child;
struct miniscript_node_t *next;
while (child) {
next = child->next;
free_miniscript_node(child);
... | testq %rdi, %rdi
je 0x8e11
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x8d98
movq 0x8(%rdi), %r14
callq 0x8d6e
movq %r14, %rdi
testq %r14, %r14
jne 0x8d87
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x8db7
movl 0x68(%rbx), %esi
testq %rsi, %rsi
je 0x8db7
callq 0xba9a
movq 0... | /p2pderivatives[P]cfd-go/external/libwally-core/src/descriptor.c |
realloc_substr_buffer | static int realloc_substr_buffer(size_t need_len, char **buffer, size_t *buffer_len)
{
size_t need_size = ((need_len / 64) + 2) * 64;
if ((*buffer == NULL) || (need_size > *buffer_len)) {
if (*buffer != NULL)
wally_free(*buffer);
*buffer = (char *) wally_malloc(need_size);
i... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
andq $-0x40, %r14
subq $-0x80, %r14
movq (%rsi), %rdi
testq %rdi, %rdi
je 0x8e3c
xorl %eax, %eax
cmpq (%rbx), %r14
jbe 0x8e58
callq 0xba94
movq %r14, %rdi
callq 0xbd35
movq %rax, (%r15)
testq %rax, %rax
je 0x8e53
movq %r14, (%rbx)
xorl %ea... | /p2pderivatives[P]cfd-go/external/libwally-core/src/descriptor.c |
verify_descriptor_sh | static int verify_descriptor_sh(struct miniscript_node_t *node, struct miniscript_node_t *parent)
{
if (parent || (get_child_list_count(node) != node->info->inner_num) || !node->child->info)
return WALLY_EINVAL;
node->type_properties = node->child->type_properties;
return WALLY_OK;
} | movl $0xfffffffe, %eax # imm = 0xFFFFFFFE
testq %rsi, %rsi
je 0x8e69
retq
movq 0x18(%rdi), %rcx
xorl %edx, %edx
testq %rcx, %rcx
je 0x8e82
movq %rcx, %rsi
incl %edx
movq 0x8(%rsi), %rsi
testq %rsi, %rsi
jne 0x8e77
movq (%rdi), %rsi
cmpl 0x10(%rsi), %edx
jne 0x8e68
cmpq $0x0, (%rcx)
je 0x8e68
movl 0x3c(%rcx), %eax... | /p2pderivatives[P]cfd-go/external/libwally-core/src/descriptor.c |
generate_by_descriptor_sh | static int generate_by_descriptor_sh(
struct miniscript_node_t *node,
struct miniscript_node_t *parent,
int32_t derive_child_num,
unsigned char *script,
size_t script_len,
size_t *write_len)
{
int ret;
size_t child_write_len = *write_len;
unsigned char buf[WALLY_SCRIPTPUBKEY_P2SH_LEN... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %r9, %r14
movq %rcx, %rbx
movq %rdi, %rax
movq (%r9), %rcx
movq %rcx, 0x8(%rsp)
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
sete %cl
cmpq $0x17, %r8
setb %r9b
orb %cl, %r9b
movl $0xfffffffe, %ebp # imm = 0xFFFFFFFE
jne 0x8f30
testq %rsi, %rsi
je 0x8ed9
cmpq $0x0, ... | /p2pderivatives[P]cfd-go/external/libwally-core/src/descriptor.c |
verify_descriptor_wsh | static int verify_descriptor_wsh(struct miniscript_node_t *node, struct miniscript_node_t *parent)
{
if (parent && (!parent->info || (parent->info->kind != DESCRIPTOR_KIND_DESCRIPTOR_SH)))
return WALLY_EINVAL;
if ((get_child_list_count(node) != node->info->inner_num) || !node->child->info)
retur... | pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
testq %rsi, %rsi
je 0x8f5d
movq (%rsi), %rax
movl $0xfffffffe, %ebp # imm = 0xFFFFFFFE
testq %rax, %rax
je 0x8f9e
cmpl $0x502, 0x8(%rax) # imm = 0x502
jne 0x8f9e
movq 0x18(%rbx), %r14
xorl %eax, %eax
testq %r14, %r14
je 0x8f76
movq %r14, %rcx
incl %eax
movq 0... | /p2pderivatives[P]cfd-go/external/libwally-core/src/descriptor.c |
generate_by_descriptor_wsh | static int generate_by_descriptor_wsh(
struct miniscript_node_t *node,
struct miniscript_node_t *parent,
int32_t derive_child_num,
unsigned char *script,
size_t script_len,
size_t *write_len)
{
int ret;
size_t child_write_len = *write_len;
unsigned char output[WALLY_SCRIPTPUBKEY_P2WS... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %r9, %r14
movq %rcx, %rbx
movq %rdi, %rax
movq (%r9), %rcx
movq %rcx, 0x8(%rsp)
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
sete %cl
cmpq $0x22, %r8
setb %r9b
orb %cl, %r9b
movl $0xfffffffe, %ebp # imm = 0xFFFFFFFE
jne 0x903c
testq %rsi, %rsi
je 0x8fe5
cmpq $0x0, ... | /p2pderivatives[P]cfd-go/external/libwally-core/src/descriptor.c |
verify_descriptor_pk | static int verify_descriptor_pk(struct miniscript_node_t *node, struct miniscript_node_t *parent)
{
(void)parent;
if ((get_child_list_count(node) != node->info->inner_num) || node->child->info ||
((node->child->kind & DESCRIPTOR_KIND_KEY) != DESCRIPTOR_KIND_KEY))
return WALLY_EINVAL;
node->... | movq 0x18(%rdi), %rcx
xorl %edx, %edx
testq %rcx, %rcx
je 0x9060
movq %rcx, %rax
incl %edx
movq 0x8(%rax), %rax
testq %rax, %rax
jne 0x9055
movq (%rdi), %rsi
movl $0xfffffffe, %eax # imm = 0xFFFFFFFE
cmpl 0x10(%rsi), %edx
jne 0x9073
cmpq $0x0, (%rcx)
je 0x9074
retq
testb $0x20, 0x38(%rcx)
je 0x9073
movl 0xc(%rsi)... | /p2pderivatives[P]cfd-go/external/libwally-core/src/descriptor.c |
generate_by_descriptor_pk | static int generate_by_descriptor_pk(
struct miniscript_node_t *node,
struct miniscript_node_t *parent,
int32_t derive_child_num,
unsigned char *script,
size_t script_len,
size_t *write_len)
{
int ret;
ret = generate_by_miniscript_pk_k(node, parent, derive_child_num, script, script_len,... | pushq %r15
pushq %r14
pushq %rbx
movq %r9, %rbx
movq %r8, %r15
movq %rcx, %r14
callq 0x94a5
testl %eax, %eax
je 0x90a0
popq %rbx
popq %r14
popq %r15
retq
movq (%rbx), %rcx
movl $0xfffffffe, %eax # imm = 0xFFFFFFFE
testq %rcx, %rcx
je 0x909a
leaq 0x1(%rcx), %rdx
cmpq %r15, %rdx
seta %sil
cmpq $0x2711, %rdx ... | /p2pderivatives[P]cfd-go/external/libwally-core/src/descriptor.c |
generate_by_descriptor_pkh | static int generate_by_descriptor_pkh(
struct miniscript_node_t *node,
struct miniscript_node_t *parent,
int32_t derive_child_num,
unsigned char *script,
size_t script_len,
size_t *write_len)
{
int ret;
if (script_len < WALLY_SCRIPTPUBKEY_P2PKH_LEN)
return WALLY_EINVAL;
ret... | cmpq $0x19, %r8
jae 0x90e5
movl $0xfffffffe, %eax # imm = 0xFFFFFFFE
retq
pushq %r15
pushq %r14
pushq %rbx
movq %r9, %rbx
movq %r8, %r15
movq %rcx, %r14
callq 0x9551
testl %eax, %eax
je 0x9102
popq %rbx
popq %r14
popq %r15
retq
movq (%rbx), %rcx
testq %rcx, %rcx
je 0x9135
leaq 0x1(%rcx), %rdx
cmpq %r15, %rdx
seta... | /p2pderivatives[P]cfd-go/external/libwally-core/src/descriptor.c |
verify_descriptor_wpkh | static int verify_descriptor_wpkh(struct miniscript_node_t *node, struct miniscript_node_t *parent)
{
struct miniscript_node_t *parent_item = parent;
if (parent && (!parent->info || (parent->info->kind & DESCRIPTOR_KIND_MINISCRIPT)))
return WALLY_EINVAL;
if ((get_child_list_count(node) != node->info... | pushq %rax
testq %rsi, %rsi
je 0x9155
movq (%rsi), %rcx
movl $0xfffffffe, %eax # imm = 0xFFFFFFFE
testq %rcx, %rcx
je 0x91ad
testb $0x1, 0x8(%rcx)
jne 0x91ad
movq 0x18(%rdi), %rcx
xorl %edx, %edx
testq %rcx, %rcx
je 0x916e
movq %rcx, %rax
incl %edx
movq 0x8(%rax), %rax
testq %rax, %rax
jne 0x9163
movq (%rdi), %r8... | /p2pderivatives[P]cfd-go/external/libwally-core/src/descriptor.c |
scriptsig_to_witness | static int scriptsig_to_witness(unsigned char *bytes, size_t bytes_len, struct wally_tx_witness_stack **output)
{
unsigned char *p = bytes, *end = p + bytes_len;
struct wally_tx_witness_stack *result = NULL;
int ret = WALLY_OK;
if (!bytes || !output || !bytes_len) {
return WALLY_EINVAL;
}
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq $0x0, (%rsp)
movl $0xfffffffe, %ebp # imm = 0xFFFFFFFE
testq %rsi, %rsi
je 0xdbfc
movq %rdi, %r15
testq %rdi, %rdi
je 0xdbfc
movq %rdx, %rbx
testq %rdx, %rdx
je 0xdbfc
movq %rsi, %r13
movq %rsp, %rsi
movl $0x2, %edi
callq 0xec... | /p2pderivatives[P]cfd-go/external/libwally-core/src/script.c |
wally_witness_p2wpkh_from_sig | int wally_witness_p2wpkh_from_sig(
const unsigned char *pub_key,
size_t pub_key_len,
const unsigned char *sig,
size_t sig_len,
uint32_t sighash,
struct wally_tx_witness_stack **witness)
{
unsigned char scriptsig[WALLY_SCRIPTSIG_P2PKH_MAX_LEN];
size_t written;
int ret;
ret = wall... | pushq %rbx
subq $0xa0, %rsp
movq %r9, %rbx
leaq 0x8(%rsp), %rax
leaq 0x10(%rsp), %r9
pushq %rax
pushq $0x8c
callq 0xc705
addq $0x10, %rsp
testl %eax, %eax
jne 0xdc47
movq 0x8(%rsp), %rsi
leaq 0x10(%rsp), %rdi
movq %rbx, %rdx
callq 0xdb30
addq $0xa0, %rsp
popq %rbx
retq
| /p2pderivatives[P]cfd-go/external/libwally-core/src/script.c |
wally_ec_public_key_decompress | int wally_ec_public_key_decompress(const unsigned char *pub_key, size_t pub_key_len,
unsigned char *bytes_out, size_t len)
{
secp256k1_pubkey pub;
size_t len_in_out = EC_PUBLIC_KEY_UNCOMPRESSED_LEN;
bool ok;
ok = pub_key && pub_key_len == EC_PUBLIC_KEY_LEN &&
... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq $0x41, 0x8(%rsp)
xorl %ebp, %ebp
testq %rdx, %rdx
je 0xdf41
movq %rdi, %rax
testq %rdi, %rdi
je 0xdf41
cmpq $0x21, %rsi
jne 0xdf41
cmpq $0x41, %rbx
jne 0xdf41
leaq 0x10(%rsp), %rdi
movl $0x21, %edx
movq %rax, %rsi
callq 0xb9cb
testl ... | /p2pderivatives[P]cfd-go/external/libwally-core/src/sign.c |
wally_ec_public_key_negate | int wally_ec_public_key_negate(const unsigned char *pub_key, size_t pub_key_len,
unsigned char *bytes_out, size_t len)
{
secp256k1_pubkey pub;
size_t len_in_out = EC_PUBLIC_KEY_LEN;
bool ok;
ok = pub_key && pub_key_len == EC_PUBLIC_KEY_LEN &&
bytes_out && len == ... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq $0x21, 0x8(%rsp)
xorl %ebp, %ebp
testq %rdx, %rdx
je 0xdff9
movq %rdi, %rax
testq %rdi, %rdi
je 0xdff9
cmpq $0x21, %rsi
jne 0xdff9
cmpq $0x21, %rbx
jne 0xdff9
leaq 0x10(%rsp), %rdi
movl $0x21, %edx
movq %rax, %rsi
callq 0xb9cb
testl ... | /p2pderivatives[P]cfd-go/external/libwally-core/src/sign.c |
wally_ec_sig_normalize | int wally_ec_sig_normalize(const unsigned char *sig, size_t sig_len,
unsigned char *bytes_out, size_t len)
{
secp256k1_ecdsa_signature sig_secp, sig_low;
const secp256k1_context *ctx = secp256k1_context_no_precomp;
bool ok;
ok = sig && sig_len == EC_SIGNATURE_LEN &&
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x80, %rsp
movq %rcx, %rbx
movq %rdx, %r14
xorl %ebp, %ebp
testq %rdx, %rdx
je 0xe0a6
movq %rdi, %rdx
testq %rdi, %rdi
je 0xe0a6
cmpq $0x40, %rsi
jne 0xe0a6
cmpq $0x40, %rbx
jne 0xe0a6
leaq 0x732ff(%rip), %rax # 0x81368
movq (%rax), %r15
movq %rsp, %rsi
m... | /p2pderivatives[P]cfd-go/external/libwally-core/src/sign.c |
wally_ec_sig_to_der | int wally_ec_sig_to_der(const unsigned char *sig, size_t sig_len,
unsigned char *bytes_out, size_t len, size_t *written)
{
secp256k1_ecdsa_signature sig_secp;
size_t len_in_out = len;
const secp256k1_context *ctx = secp256k1_context_no_precomp;
bool ok;
if (written)
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rdx
movq %rcx, (%rsp)
leaq 0x73255(%rip), %rax # 0x81368
movq (%rax), %r12
testq %r8, %r8
je 0xe122
movq $0x0, (%rbx)
testq %r12, %r12
je 0xe171
xorl %r13d, %r13d
testq %rbx,... | /p2pderivatives[P]cfd-go/external/libwally-core/src/sign.c |
wally_ec_sig_from_der | int wally_ec_sig_from_der(const unsigned char *bytes, size_t bytes_len,
unsigned char *bytes_out, size_t len)
{
secp256k1_ecdsa_signature sig_secp;
const secp256k1_context *ctx = secp256k1_context_no_precomp;
bool ok;
ok = bytes && bytes_len && bytes_out && len == EC_SIGNATURE... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rcx, %rbx
movq %rdx, %r14
xorl %ebp, %ebp
testq %rdx, %rdx
je 0xe226
movq %rdi, %rdx
testq %rdi, %rdi
je 0xe226
movq %rsi, %rcx
testq %rsi, %rsi
je 0xe226
cmpq $0x40, %rbx
jne 0xe226
leaq 0x73170(%rip), %rax # 0x81368
movq (%rax), %r15
leaq 0x8(%rsp... | /p2pderivatives[P]cfd-go/external/libwally-core/src/sign.c |
wally_ec_sig_from_bytes | int wally_ec_sig_from_bytes(const unsigned char *priv_key, size_t priv_key_len,
const unsigned char *bytes, size_t bytes_len,
uint32_t flags,
unsigned char *bytes_out, size_t len)
{
wally_ec_nonce_t nonce_fn = wally_ops()->ec_nonce_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %r9, %r12
movl %r8d, %ebp
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %r14
callq 0xbda4
movq 0x20(%rax), %rax
movq %rax, 0x8(%rsp)
callq 0xba16
movq %rax, %rdi
testq %r14, %r14
sete %al
cmpq $0x20, %r13
setne %cl
test... | /p2pderivatives[P]cfd-go/external/libwally-core/src/sign.c |
wally_ec_sig_verify | int wally_ec_sig_verify(const unsigned char *pub_key, size_t pub_key_len,
const unsigned char *bytes, size_t bytes_len,
uint32_t flags,
const unsigned char *sig, size_t sig_len)
{
secp256k1_pubkey pub;
secp256k1_ecdsa_signature sig_secp;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %r9, %r15
movl %r8d, %r12d
movq %rcx, %rbp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r13
callq 0xba16
testq %r13, %r13
sete %sil
cmpq $0x21, %r14
setne %cl
testq %rbx, %rbx
sete %dl
orb %sil, %dl
cmpq $0x20, %rbp
setne %sil
orb %c... | /p2pderivatives[P]cfd-go/external/libwally-core/src/sign.c |
wally_ec_sig_to_public_key | int wally_ec_sig_to_public_key(const unsigned char *bytes, size_t bytes_len,
const unsigned char *sig, size_t sig_len,
unsigned char *bytes_out, size_t len)
{
secp256k1_pubkey pub;
secp256k1_ecdsa_recoverable_signature sig_secp;
const secp256k1_c... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %r9, (%rsp)
movq %r8, %r14
movq %rcx, %rbp
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r13
callq 0xba16
movq $0x21, 0x8(%rsp)
testq %rax, %rax
je 0xe636
movq %rax, %r15
testq %r13, %r13
sete %al
cmpq $0x20, %rbx
setne %cl
testq %r12... | /p2pderivatives[P]cfd-go/external/libwally-core/src/sign.c |
wally_format_bitcoin_message | int wally_format_bitcoin_message(const unsigned char *bytes, size_t bytes_len,
uint32_t flags,
unsigned char *bytes_out, size_t len,
size_t *written)
{
unsigned char buf[256], *msg_buf = bytes_out, *out;
const boo... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp # imm = 0x118
movq %r9, %r13
movq %rcx, %r14
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r12
testq %r9, %r9
je 0xe67b
movq $0x0, (%r13)
testq %r12, %r12
sete %al
leaq -0xffc1(%r15), %rcx
cmpq $-0xffc0, %rcx # imm = 0... | /p2pderivatives[P]cfd-go/external/libwally-core/src/sign.c |
wally_s2c_sig_from_bytes | int wally_s2c_sig_from_bytes(const unsigned char *priv_key, size_t priv_key_len,
const unsigned char *bytes, size_t bytes_len,
const unsigned char *s2c_data, size_t s2c_data_len,
uint32_t flags,
unsigned ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %r9, %r15
movq %r8, %r12
movq %rcx, %rbx
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %rbp
callq 0xba16
movq %r13, %xmm0
movq %rbp, %r8
movq %rbp, %xmm1
punpcklqdq %xmm0, %xmm1 # xmm1 = xmm1[0],xmm0[0]
movq 0xd8(%rsp), %xmm0
movq %... | /p2pderivatives[P]cfd-go/external/libwally-core/src/sign.c |
wally_s2c_commitment_verify | int wally_s2c_commitment_verify(const unsigned char *sig, size_t sig_len,
const unsigned char *s2c_data, size_t s2c_data_len,
const unsigned char *s2c_opening, size_t s2c_opening_len,
uint32_t flags)
{
secp256k1_ecdsa_si... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %r9, %r13
movq %r8, %r15
movq %rcx, %rbp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r12
callq 0xba16
testq %r12, %r12
sete %sil
cmpq $0x40, %rbx
setne %cl
testq %r14, %r14
sete %dl
orb %sil, %dl
cmpq $0x20, %rbp
setne %sil
orb %cl,... | /p2pderivatives[P]cfd-go/external/libwally-core/src/sign.c |
clone_bytes | bool clone_bytes(unsigned char **dst, const unsigned char *src, size_t len)
{
if (!len) {
*dst = NULL;
return true;
}
*dst = wally_malloc(len);
if (*dst)
memcpy(*dst, src, len);
return *dst != NULL;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
testq %rdx, %rdx
je 0xea92
movq %rdx, %r14
movq %rsi, %r15
movq %rdx, %rdi
callq 0xbd35
movq %rax, (%rbx)
testq %rax, %rax
je 0xea9d
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x5100
cmpq $0x0, (%rbx)
setne %al
jmp 0xea9f
movq $0x0, (%rbx)
movb $0x1, %al
jmp 0... | /p2pderivatives[P]cfd-go/external/libwally-core/src/transaction.c |
realloc_array | void *realloc_array(const void *src, size_t old_n, size_t new_n, size_t size)
{
unsigned char *p = wally_malloc(new_n * size);
if (!p)
return NULL;
if (src)
memcpy(p, src, old_n * size);
wally_clear(p + old_n * size, (new_n - old_n) * size);
return p;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r13
movq %rcx, %rdi
imulq %rdx, %rdi
callq 0xbd35
movq %rax, %r15
testq %rax, %rax
je 0xeaff
movq %r14, %rbp
imulq %r12, %rbp
testq %r13, %r13
je 0xeaea
movq %r15, %rdi
movq %r13, %rs... | /p2pderivatives[P]cfd-go/external/libwally-core/src/transaction.c |
replace_bytes | int replace_bytes(const unsigned char *bytes, size_t bytes_len,
unsigned char **bytes_out, size_t *bytes_len_out)
{
unsigned char *new_bytes = NULL;
if (BYTES_INVALID(bytes, bytes_len) || BYTES_INVALID(*bytes_out, *bytes_len_out))
return WALLY_EINVAL;
/* TODO: Avoid reallocation ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
testq %rdi, %rdi
setne %al
testq %rsi, %rsi
sete %cl
movl $0xfffffffe, %ebx # imm = 0xFFFFFFFE
cmpb %cl, %al
je 0xeb96
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %r13
movq (%rdx), %rdi
testq %rdi, %rdi
setne %al
movq (%r1... | /p2pderivatives[P]cfd-go/external/libwally-core/src/transaction.c |
wally_tx_witness_stack_clone_alloc | int wally_tx_witness_stack_clone_alloc(const struct wally_tx_witness_stack *stack,
struct wally_tx_witness_stack **output)
{
struct wally_tx_witness_stack *result;
size_t i;
int ret;
TX_CHECK_OUTPUT;
if (!stack)
return WALLY_EINVAL;
ret = wally_tx... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl $0xfffffffe, %ebp # imm = 0xFFFFFFFE
testq %rsi, %rsi
je 0xec20
movq %rsi, %rbx
movq %rdi, %r14
movq $0x0, (%rsi)
testq %rdi, %rdi
je 0xec20
movq 0x10(%r14), %rdi
leaq 0x8(%rsp), %rsi
callq 0xec36
testl %eax, %eax
jne 0xec14
movl $0x8, %... | /p2pderivatives[P]cfd-go/external/libwally-core/src/transaction.c |
wally_tx_witness_stack_init_alloc | int wally_tx_witness_stack_init_alloc(size_t allocation_len,
struct wally_tx_witness_stack **output)
{
struct wally_tx_witness_stack *result;
TX_CHECK_OUTPUT;
TX_OUTPUT_ALLOC(struct wally_tx_witness_stack);
if (allocation_len) {
result->items = wally_callo... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0xec96
movq %rsi, %r14
movq %rdi, %r15
movq $0x0, (%rsi)
movl $0x18, %edi
callq 0xbd3b
movq %rax, (%r14)
movl $0xfffffffd, %ebx # imm = 0xFFFFFFFD
testq %rax, %rax
je 0xec9b
movq %rax, %r12
testq %r15, %r15
je 0xec84
movq %r15, %rdi
shlq $... | /p2pderivatives[P]cfd-go/external/libwally-core/src/transaction.c |
wally_tx_witness_stack_set | int wally_tx_witness_stack_set(struct wally_tx_witness_stack *stack, size_t index,
const unsigned char *witness, size_t witness_len)
{
unsigned char *new_witness = NULL;
if (!is_valid_witness_stack(stack) || (!witness && witness_len))
return WALLY_EINVAL;
if (!clone_... | movl $0xfffffffe, %eax # imm = 0xFFFFFFFE
testq %rdi, %rdi
je 0xeddd
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rcx
movq 0x10(%rdi), %rdx
movq %rcx, %rsi
orq %rdx, %rsi
je 0xed03
testq %rdx, %rdx
setne ... | /p2pderivatives[P]cfd-go/external/libwally-core/src/transaction.c |
tx_witness_stack_free | static int tx_witness_stack_free(struct wally_tx_witness_stack *stack,
bool free_parent)
{
size_t i;
if (stack) {
if (stack->items) {
for (i = 0; i < stack->num_items; ++i) {
if (stack->items[i].witness)
clear_and_free(sta... | testq %rdi, %rdi
je 0xee3e
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0xee46
movq 0x8(%rbx), %rsi
testq %rsi, %rsi
je 0xee3f
movl $0x8, %r14d
xorl %r15d, %r15d
movq (%rbx), %rax
movq -0x8(%rax,%r14), %rdi
testq %rdi, %rdi
je 0xee29
movq (%rax,%r14), %rsi
callq 0xbf25
movq 0x8... | /p2pderivatives[P]cfd-go/external/libwally-core/src/transaction.c |
wally_tx_witness_stack_set_dummy | int wally_tx_witness_stack_set_dummy(struct wally_tx_witness_stack *stack,
size_t index, uint32_t flags)
{
const unsigned char *p = NULL;
size_t len = 0;
if (flags == WALLY_TX_DUMMY_SIG) {
p = DUMMY_SIG;
len = sizeof(DUMMY_SIG);
} else if (flags == W... | cmpl $0x1, %edx
je 0xeeea
movl %edx, %eax
leaq 0x544d4(%rip), %rdx # 0x633a0
cmpl $0x2, %eax
je 0xeee0
cmpl $0x4, %eax
jne 0xeef3
movl $0x48, %ecx
jmp 0xecba
movl $0x49, %ecx
jmp 0xecba
xorl %edx, %edx
xorl %ecx, %ecx
jmp 0xecba
movl $0xfffffffe, %eax # imm = 0xFFFFFFFE
retq
| /p2pderivatives[P]cfd-go/external/libwally-core/src/transaction.c |
wally_tx_elements_input_issuance_set | int wally_tx_elements_input_issuance_set(
struct wally_tx_input *input,
const unsigned char *nonce,
size_t nonce_len,
const unsigned char *entropy,
size_t entropy_len,
const unsigned char *issuance_amount,
size_t issuance_amount_len,
const unsigned char *inflation_keys,
size_t inflat... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movaps 0x90(%rsp), %xmm0
movaps 0xa0(%rsp), %xmm1
movaps 0xb0(%rsp), %xmm2
movq 0xc0(%rsp), %rax
movq 0x88(%rdi), %rbx
movq 0x90(%rdi), %r14
movq 0x98(%rdi), %r13
movq 0xa0(%rdi), %rbp
movq 0xa8(%rdi), %r10
movq %r10, 0x40(%rsp)
movq 0xb... | /p2pderivatives[P]cfd-go/external/libwally-core/src/transaction.c |
tx_elements_input_issuance_init | static int tx_elements_input_issuance_init(
struct wally_tx_input *input,
const unsigned char *nonce,
size_t nonce_len,
const unsigned char *entropy,
size_t entropy_len,
const unsigned char *issuance_amount,
size_t issuance_amount_len,
const unsigned char *inflation_keys,
size_t infl... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl $0xfffffffe, %ebp # imm = 0xFFFFFFFE
testq %rdi, %rdi
je 0xf163
movq %rcx, %r14
movq %rsi, %r15
testq %rsi, %rsi
setne %al
cmpq $0x20, %rdx
setne %cl
cmpb %cl, %al
je 0xf163
testq %r14, %r14
setne %al
cmpq $0x20, %r8
setne %cl
cmpb ... | /p2pderivatives[P]cfd-go/external/libwally-core/src/transaction.c |
wally_tx_elements_input_issuance_free | int wally_tx_elements_input_issuance_free(
struct wally_tx_input *input)
{
(void) input;
#ifdef BUILD_ELEMENTS
if (input) {
input->features &= ~(WALLY_TX_IS_ELEMENTS | WALLY_TX_IS_ISSUANCE);
wally_clear(input->blinding_nonce, sizeof(input->blinding_nonce));
wally_clear(input->entropy... | testq %rdi, %rdi
je 0xf2ab
pushq %rbx
movq %rdi, %rbx
andb $-0x4, 0x40(%rdi)
addq $0x41, %rdi
movl $0x20, %esi
callq 0xba8b
leaq 0x61(%rbx), %rdi
movl $0x20, %esi
callq 0xba8b
movq 0x88(%rbx), %rdi
movq 0x90(%rbx), %rsi
callq 0xbf25
xorps %xmm0, %xmm0
movups %xmm0, 0x88(%rbx)
movq 0x98(%rbx), %rdi
movq 0xa0(%rbx), %rsi... | /p2pderivatives[P]cfd-go/external/libwally-core/src/transaction.c |
wally_tx_elements_input_init | int wally_tx_elements_input_init(
const unsigned char *txhash, size_t txhash_len,
uint32_t utxo_index, uint32_t sequence,
const unsigned char *script, size_t script_len,
const struct wally_tx_witness_stack *witness,
const unsigned char *nonce, size_t nonce_len,
const unsigned char *entropy, size... | subq $0x88, %rsp
movaps 0x90(%rsp), %xmm0
movaps 0xa0(%rsp), %xmm1
movaps 0xb0(%rsp), %xmm2
movaps 0xc0(%rsp), %xmm3
movaps 0xd0(%rsp), %xmm4
movaps 0xe0(%rsp), %xmm5
movaps 0xf0(%rsp), %xmm6
movq 0x100(%rsp), %rax
movq %rax, 0x70(%rsp)
movups %xmm6, 0x60(%rsp)
movups %xmm5, 0x50(%rsp)
movups %xmm4, 0x40(%rsp)
movups %... | /p2pderivatives[P]cfd-go/external/libwally-core/src/transaction.c |
tx_elements_input_init | static int tx_elements_input_init(
const unsigned char *txhash, size_t txhash_len,
uint32_t utxo_index, uint32_t sequence,
const unsigned char *script, size_t script_len,
const struct wally_tx_witness_stack *witness,
const unsigned char *nonce, size_t nonce_len,
const unsigned char *entropy, siz... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %r15d
xorl %eax, %eax
movq %rax, 0x20(%rsp)
movq %rax, 0x18(%rsp)
testq %rdi, %rdi
sete %al
cmpq $0x20, %rsi
setne %dl
orb %al, %dl
movl $0xfffffffe, %r14d # imm = 0xFFFFFFFE
jne 0xf4e5
movq %r9, %rbx
movq %r8, %r13
movq ... | /p2pderivatives[P]cfd-go/external/libwally-core/src/transaction.c |
wally_tx_input_init | int wally_tx_input_init(const unsigned char *txhash, size_t txhash_len,
uint32_t utxo_index, uint32_t sequence,
const unsigned char *script, size_t script_len,
const struct wally_tx_witness_stack *witness,
struct wally_tx_in... | subq $0x88, %rsp
movq 0x90(%rsp), %rax
movq 0x98(%rsp), %r10
movq %r10, 0x70(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x58(%rsp)
movups %xmm0, 0x48(%rsp)
movups %xmm0, 0x38(%rsp)
movups %xmm0, 0x28(%rsp)
movups %xmm0, 0x18(%rsp)
movups %xmm0, 0x8(%rsp)
movq %rax, (%rsp)
movl $0x0, 0x78(%rsp)
movq $0x0, 0x68(%rsp)
callq 0... | /p2pderivatives[P]cfd-go/external/libwally-core/src/transaction.c |
wally_tx_elements_input_init_alloc | int wally_tx_elements_input_init_alloc(
const unsigned char *txhash, size_t txhash_len,
uint32_t utxo_index, uint32_t sequence,
const unsigned char *script, size_t script_len,
const struct wally_tx_witness_stack *witness,
const unsigned char *nonce, size_t nonce_len,
const unsigned char *entropy... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0xb0(%rsp), %rbx
testq %rbx, %rbx
je 0xf717
movq %r8, %r15
movl %ecx, %ebp
movl %edx, %r12d
movq %rsi, %r13
movq %rdi, %r14
movq %r9, (%rsp)
movq $0x0, (%rbx)
movl $0xd0, %edi
callq 0xbd3b
movq %rax, (%rbx)
testq %rax, %rax
je 0xf71e
movq... | /p2pderivatives[P]cfd-go/external/libwally-core/src/transaction.c |
wally_tx_input_init_alloc | int wally_tx_input_init_alloc(const unsigned char *txhash, size_t txhash_len,
uint32_t utxo_index, uint32_t sequence,
const unsigned char *script, size_t script_len,
const struct wally_tx_witness_stack *witness,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq 0xd8(%rsp), %r14
testq %r14, %r14
je 0xf814
movl %ecx, %ebp
movl %edx, %r12d
movq %rsi, %r13
movq %rdi, %rbx
movq %r8, 0x88(%rsp)
movq %r9, 0x90(%rsp)
movq $0x0, (%r14)
movl $0xd0, %edi
callq 0xbd3b
movq %rax, (%r14)
testq %rax, %ra... | /p2pderivatives[P]cfd-go/external/libwally-core/src/transaction.c |
tx_input_free | static int tx_input_free(struct wally_tx_input *input, bool free_parent)
{
if (input) {
clear_and_free(input->script, input->script_len);
tx_witness_stack_free(input->witness, true);
wally_tx_elements_input_issuance_free(input);
wally_clear(input, sizeof(*input));
if (free_pa... | pushq %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xf892
movl %esi, %ebp
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
movq 0x30(%rbx), %rsi
callq 0xbf25
movq 0x38(%rbx), %rdi
callq 0xede8
movq %rbx, %rdi
callq 0xf1f2
movl $0xd0, %esi
movq %rbx, %rdi
callq 0xba8b
testb %bpl, %bpl
je 0xf892
movq %rbx, %rdi
addq $0x8, %rsp
po... | /p2pderivatives[P]cfd-go/external/libwally-core/src/transaction.c |
wally_tx_output_clone_alloc | int wally_tx_output_clone_alloc(const struct wally_tx_output *src,
struct wally_tx_output **output)
{
struct wally_tx_output *result;
int ret;
TX_CHECK_OUTPUT;
TX_OUTPUT_ALLOC(struct wally_tx_output);
ret = wally_tx_output_clone(src, result);
if (ret != WALLY_OK... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0xfb3c
movq %rsi, %rbx
movq %rdi, %r15
movq $0x0, (%rsi)
movl $0x70, %edi
callq 0xbd3b
movq %rax, (%rbx)
testq %rax, %rax
je 0xfb43
movq %rax, %r14
movq %r15, %rdi
movq %rax, %rsi
callq 0xf899
testl %eax, %eax
je 0xfb4a
movl %eax, %ebp
movq %r14... | /p2pderivatives[P]cfd-go/external/libwally-core/src/transaction.c |
wally_tx_elements_output_commitment_set | int wally_tx_elements_output_commitment_set(
struct wally_tx_output *output,
const unsigned char *asset,
size_t asset_len,
const unsigned char *value,
size_t value_len,
const unsigned char *nonce,
size_t nonce_len,
const unsigned char *surjectionproof,
size_t surjectionproof_len,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movaps 0x90(%rsp), %xmm0
movaps 0xa0(%rsp), %xmm1
movq 0xb0(%rsp), %rax
movq 0x20(%rdi), %r12
movq 0x28(%rdi), %r13
movq 0x30(%rdi), %rbx
movq 0x38(%rdi), %r14
movq 0x40(%rdi), %r10
movq %r10, 0x30(%rsp)
movq 0x48(%rdi), %rbp
movq 0x50(%... | /p2pderivatives[P]cfd-go/external/libwally-core/src/transaction.c |
tx_elements_output_commitment_init | static int tx_elements_output_commitment_init(
struct wally_tx_output *output,
const unsigned char *asset,
size_t asset_len,
const unsigned char *value,
size_t value_len,
const unsigned char *nonce,
size_t nonce_len,
const unsigned char *surjectionproof,
size_t surjectionproof_len,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl $0xfffffffe, %ebp # imm = 0xFFFFFFFE
testq %rdi, %rdi
je 0xfe4e
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %rbx
testq %rsi, %rsi
setne %al
cmpq $0x21, %rdx
setne %cl
cmpb %cl, %al
je 0xfe4e
testq %r15, %r15
setne %al
cmpq $0x2... | /p2pderivatives[P]cfd-go/external/libwally-core/src/transaction.c |
wally_tx_elements_output_commitment_free | int wally_tx_elements_output_commitment_free(
struct wally_tx_output *output)
{
(void) output;
#ifdef BUILD_ELEMENTS
if (output) {
output->features &= ~WALLY_TX_IS_ELEMENTS;
clear_and_free(output->asset, output->asset_len);
clear_and_free(output->value, output->value_len);
cl... | testq %rdi, %rdi
je 0xfeae
pushq %rbx
movq %rdi, %rbx
andb $-0x2, 0x18(%rdi)
movq 0x20(%rdi), %rdi
movq 0x28(%rbx), %rsi
callq 0xbf25
movq 0x30(%rbx), %rdi
movq 0x38(%rbx), %rsi
callq 0xbf25
movq 0x40(%rbx), %rdi
movq 0x48(%rbx), %rsi
callq 0xbf25
movq 0x50(%rbx), %rdi
movq 0x58(%rbx), %rsi
callq 0xbf25
movq 0x60(%rbx)... | /p2pderivatives[P]cfd-go/external/libwally-core/src/transaction.c |
tx_elements_output_init | static int tx_elements_output_init(
uint64_t satoshi,
const unsigned char *script,
size_t script_len,
const unsigned char *asset,
size_t asset_len,
const unsigned char *value,
size_t value_len,
const unsigned char *nonce,
size_t nonce_len,
const unsigned char *surjectionproof,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r13
movq %rdi, %r15
movb 0x90(%rsp), %dil
movq 0x88(%rsp), %r14
testq %rsi, %rsi
setne %al
testq %rdx, %rdx
sete %sil
xorb %al, %sil
testq %r14, %r14
setne %al
movabsq $0x775f05a074001, %rdx # imm = 0x775F05A... | /p2pderivatives[P]cfd-go/external/libwally-core/src/transaction.c |
wally_tx_elements_output_init_alloc | int wally_tx_elements_output_init_alloc(
const unsigned char *script,
size_t script_len,
const unsigned char *asset,
size_t asset_len,
const unsigned char *value,
size_t value_len,
const unsigned char *nonce,
size_t nonce_len,
const unsigned char *surjectionproof,
size_t surjecti... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x70(%rsp), %r14
testq %r14, %r14
je 0x10100
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %rbx
movq %r9, (%rsp)
movq $0x0, (%r14)
movl $0x70, %edi
callq 0xbd3b
movq %rax, (%r14)
testq %rax, %rax
je 0x10107
mov... | /p2pderivatives[P]cfd-go/external/libwally-core/src/transaction.c |
wally_tx_output_init_alloc | int wally_tx_output_init_alloc(uint64_t satoshi,
const unsigned char *script, size_t script_len,
struct wally_tx_output **output)
{
struct wally_tx_output *result;
int ret;
TX_CHECK_OUTPUT;
TX_OUTPUT_ALLOC(struct wally_tx_output);
ret =... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
testq %rcx, %rcx
je 0x101fc
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
movq $0x0, (%rcx)
movl $0x70, %edi
callq 0xbd3b
movq %rax, (%rbx)
testq %rax, %rax
je 0x10203
movq %rax, %r14
movq %rax, 0x38(%rsp)
xorps %xmm0, ... | /p2pderivatives[P]cfd-go/external/libwally-core/src/transaction.c |
add | static void add(struct sha256_ctx *ctx, const void *p, size_t len)
{
const unsigned char *data = p;
size_t bufsize = ctx->bytes % 64;
if (bufsize + len >= 64) {
/* Fill the buffer, and process it. */
memcpy(ctx->buf.u8 + bufsize, data, 64 - bufsize);
ctx->bytes += 64 - bufsize;
data += 64 - bufsize;
len -... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x60(%rdi), %rbp
andl $0x3f, %ebp
leaq (%rdx,%rbp), %rax
cmpq $0x40, %rax
jb 0x1731f
leaq 0x20(%r14), %r12
leaq (%r14,%rbp), %rdi
addq $0x20, %rdi
movl $0x40, %r13d
subq %rbp, %r13
movq %r15... | /p2pderivatives[P]cfd-go/external/libwally-core/src/ccan/ccan/crypto/sha256/sha256.c |
sha256_done | void sha256_done(struct sha256_ctx *ctx, struct sha256 *res)
{
static const unsigned char pad[64] = {0x80};
uint64_t sizedesc;
size_t i;
sizedesc = cpu_to_be64((uint64_t)ctx->bytes << 3);
/* Add '1' bit to terminate, then all 0 bits, up to next block - 8. */
add(ctx, pad, 1 + ((128 - 8 - (ctx->bytes % 64) - 1) %... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x60(%rdi), %rax
leaq (,%rax,8), %rcx
bswapq %rcx
leaq 0x8(%rsp), %r15
movq %rcx, (%r15)
movl $0x37, %edx
subl %eax, %edx
andl $0x3f, %edx
incq %rdx
leaq 0x4c323(%rip), %rsi # 0x636d0
callq 0x172be
movl $0x8, %edx
movq %rbx, %rdi... | /p2pderivatives[P]cfd-go/external/libwally-core/src/ccan/ccan/crypto/sha256/sha256.c |
Transform | static inline void Transform(uint32_t *s, const uint32_t *chunk, size_t blocks)
{
#if defined(__x86_64__) || defined(__amd64__)
if (use_optimized_transform) {
TransformSSE4(s, chunk, blocks);
return;
}
#endif
TransformDefault(s, chunk, blocks);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
cmpb $0x1, 0x69e4f(%rip) # 0x8138c
jne 0x18209
movq %rdi, %r15
shlq $0x6, %rdx
je 0x18204
addq %rsi, %rdx
movq %rdx, 0xa8(%rsp)
movl (%r15), %eax
movl 0x4(%r15), %ecx
movl 0x8(%r15), %ebp
movl 0xc(%r15), %r12d
movl 0x10(%r15), %edx
m... | /p2pderivatives[P]cfd-go/external/libwally-core/src/ccan/ccan/crypto/sha256/sha256.c |
sha512_done | void sha512_done(struct sha512_ctx *ctx, struct sha512 *res)
{
static const unsigned char pad[128] = { 0x80 };
uint64_t sizedesc[2] = { 0, 0 };
size_t i;
sizedesc[1] = cpu_to_be64((uint64_t)ctx->bytes << 3);
/* Add '1' bit to terminate, then all 0 bits, up to next block - 16. */
add(ctx, pad, 1 + ((256 - 16 - (... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %r15
movaps %xmm0, (%r15)
movq 0xc0(%rdi), %rax
leaq (,%rax,8), %rcx
bswapq %rcx
movq %rcx, 0x8(%r15)
movl $0x6f, %edx
subl %eax, %edx
andl $0x7f, %edx
incq %rdx
leaq 0x48ede(%rip), %rsi # 0x638b0
callq 0... | /p2pderivatives[P]cfd-go/external/libwally-core/src/ccan/ccan/crypto/sha512/sha512.c |
secp256k1_fe_normalizes_to_zero_var | static int secp256k1_fe_normalizes_to_zero_var(secp256k1_fe *r) {
uint64_t t0, t1, t2, t3, t4;
uint64_t z0, z1;
uint64_t x;
t0 = r->n[0];
t4 = r->n[4];
/* Reduce t4 at the start so there will be at most a single carry from the first pass */
x = t4 >> 48;
/* The first pass ensures the ... | movabsq $0xfffffffffffff, %rcx # imm = 0xFFFFFFFFFFFFF
movabsq $0x1000003d0, %r8 # imm = 0x1000003D0
movq 0x20(%rdi), %rsi
movq %rsi, %rax
shrq $0x30, %rax
leaq 0x1(%r8), %rdx
imulq %rax, %rdx
addq (%rdi), %rdx
movq %rdx, %r9
andq %rcx, %r9
movabsq $0xffffefffffc2f, %rax # imm = 0xFFFFEFFFFFC2F
cmpq %rax, %r9
j... | /p2pderivatives[P]cfd-go/external/libwally-core/src/secp256k1/src/field_5x52_impl.h |
secp256k1_pedersen_ecmult_small | static void secp256k1_pedersen_ecmult_small(secp256k1_gej *r, uint64_t gn, const secp256k1_ge* genp) {
secp256k1_scalar s;
secp256k1_pedersen_scalar_set_u64(&s, gn);
secp256k1_ecmult_const(r, genp, &s, 64);
secp256k1_scalar_clear(&s);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdx, %rbx
movq %rdi, %r14
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movl $0x18, %eax
movq %rsi, %rcx
shrq $0x38, %rcx
movb %cl, (%rsp,%rax)
shlq $0x8, %rsi
incq %rax
cmpq $0x20, %rax
jne 0x547a0
leaq 0x20(%rsp), %r15
movq %rsp, %rsi
movq %r15, ... | /p2pderivatives[P]cfd-go/external/libwally-core/src/secp256k1/src/modules/rangeproof/pedersen_impl.h |
secp256k1_rangeproof_pub_expand | SECP256K1_INLINE static void secp256k1_rangeproof_pub_expand(secp256k1_gej *pubs,
int exp, size_t *rsizes, size_t rings, const secp256k1_ge* genp) {
secp256k1_gej base;
size_t i;
size_t j;
size_t npub;
VERIFY_CHECK(exp < 19);
if (exp < 0) {
exp = 0;
}
secp256k1_gej_set_ge(&base,... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp # imm = 0x128
movq %rcx, 0x8(%rsp)
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, 0x10(%rsp)
movl 0x50(%r8), %eax
leaq 0x20(%rsp), %rdi
movl %eax, 0x78(%rdi)
movups (%r8), %xmm0
movups 0x10(%r8), %xmm1
movaps %xmm0, (%rdi)
movaps... | /p2pderivatives[P]cfd-go/external/libwally-core/src/secp256k1/src/modules/rangeproof/rangeproof_impl.h |
secp256k1_whitelist_hash_pubkey | static int secp256k1_whitelist_hash_pubkey(secp256k1_scalar* output, secp256k1_gej* pubkey) {
unsigned char h[32];
unsigned char c[33];
secp256k1_sha256 sha;
int overflow = 0;
size_t size = 33;
secp256k1_ge ge;
secp256k1_ge_set_gej(&ge, pubkey);
secp256k1_sha256_initialize(&sha);
i... | pushq %r15
pushq %r14
pushq %rbx
subq $0x130, %rsp # imm = 0x130
movq %rdi, %rbx
movl $0x0, 0x4(%rsp)
leaq 0x8(%rsp), %r14
movq $0x21, (%r14)
leaq 0xd8(%rsp), %r15
movq %r15, %rdi
callq 0x2422d
movaps 0xb2fe(%rip), %xmm0 # 0x639f0
movaps %xmm0, 0x40(%rsp)
movaps 0xb302(%rip), %xmm0 # 0x63a00
movaps %... | /p2pderivatives[P]cfd-go/external/libwally-core/src/secp256k1/src/modules/whitelist/whitelist_impl.h |
key_is_valid | static bool key_is_valid(const struct ext_key *hdkey)
{
bool is_private = key_is_private(hdkey);
bool is_master = !hdkey->depth;
uint8_t ver_flags = is_private ? BIP32_FLAG_KEY_PRIVATE : BIP32_FLAG_KEY_PUBLIC;
if (!version_is_valid(hdkey->version, ver_flags))
return false;
if (mem_is_zero(... | movb 0x34(%rdi), %al
movb 0x3f(%rdi), %cl
movl 0x78(%rdi), %edx
cmpl $0x4358394, %edx # imm = 0x4358394
je 0x59297
cmpl $0x488ade4, %edx # imm = 0x488ADE4
jne 0x592b4
cmpb $0x0, (%rdi)
je 0x592ca
movb 0x7f(%rdi), %dl
andb $-0x2, %dl
cmpb $0x2, %dl
jne 0x59319
cmpb $0x0, 0x80(%rdi)
je 0x592ed
xorl %edx, %e... | /p2pderivatives[P]cfd-go/external/libwally-core/src/bip32.c |
bip32_key_unserialize | int bip32_key_unserialize(const unsigned char *bytes, size_t bytes_len,
struct ext_key *key_out)
{
if (!bytes || bytes_len != BIP32_SERIALIZED_LEN || !key_out)
return WALLY_EINVAL;
wally_clear(key_out, sizeof(*key_out));
bytes = copy_in(&key_out->version, bytes, sizeof(ke... | pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
testq %rdi, %rdi
sete %al
cmpq $0x4e, %rsi
setne %cl
testq %rdx, %rdx
sete %dl
orb %al, %dl
movl $0xfffffffe, %ebp # imm = 0xFFFFFFFE
orb %cl, %dl
jne 0x594c1
movq %rdi, %r14
movl $0xc0, %esi
movq %rbx, %rdi
callq 0xba8b
movl (%r14), %eax
bswapl %eax
movl %eax, 0x7... | /p2pderivatives[P]cfd-go/external/libwally-core/src/bip32.c |
bip32_key_from_parent_alloc | int bip32_key_from_parent_alloc(const struct ext_key *hdkey,
uint32_t child_num, uint32_t flags,
struct ext_key **output)
{
int ret;
ALLOC_KEY();
ret = bip32_key_from_parent(hdkey, child_num, flags, *output);
if (ret != WALLY_OK) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rcx, %rcx
je 0x598d4
movq %rcx, %rbx
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %r15
movl $0xc0, %edi
callq 0xbd3b
movq %rax, (%rbx)
testq %rax, %rax
je 0x598db
movq %r15, %rdi
movl %r14d, %esi
movl %ebp, %edx
movq %rax, %rcx
callq 0x59556
testl %eax, %eax
... | /p2pderivatives[P]cfd-go/external/libwally-core/src/bip32.c |
bip32_key_from_parent_path | int bip32_key_from_parent_path(const struct ext_key *hdkey,
const uint32_t *child_path, size_t child_path_len,
uint32_t flags, struct ext_key *key_out)
{
/* Optimization: We can skip hash calculations for internal nodes */
uint32_t derivation_flags =... | movl $0xfffffffe, %eax # imm = 0xFFFFFFFE
cmpl $0x7, %ecx
ja 0x59a14
testq %rdi, %rdi
sete %r10b
testq %rsi, %rsi
sete %r9b
orb %r10b, %r9b
testq %rdx, %rdx
sete %r11b
testq %r8, %r8
sete %r10b
orb %r11b, %r10b
orb %r9b, %r10b
jne 0x59a14
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1... | /p2pderivatives[P]cfd-go/external/libwally-core/src/bip32.c |
bip32_key_from_parent_path_alloc | int bip32_key_from_parent_path_alloc(const struct ext_key *hdkey,
const uint32_t *child_path, size_t child_path_len,
uint32_t flags,
struct ext_key **output)
{
int ret;
ALLOC_KEY();
ret = bip32_ke... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %r8, %r8
je 0x59a6c
movq %r8, %rbx
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movl $0xc0, %edi
callq 0xbd3b
movq %rax, (%rbx)
testq %rax, %rax
je 0x59a73
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %ebp, %ecx
movq %rax, %r8
callq... | /p2pderivatives[P]cfd-go/external/libwally-core/src/bip32.c |
bip32_key_with_tweak_from_parent_path | int bip32_key_with_tweak_from_parent_path(const struct ext_key *hdkey,
const uint32_t *child_path,
size_t child_path_len,
uint32_t flags,
struct ext_key... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, %rbx
movl %ecx, %ebp
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r15
movq $0x21, (%rsp)
callq 0xba16
testq %rax, %rax
je 0x59b46
movq %rax, %r14
movl $0xfffffffe, %eax # imm = 0xFFFFFFFE
testb $0x5, %bpl
je 0x59b4b
movq %... | /p2pderivatives[P]cfd-go/external/libwally-core/src/bip32.c |
bip32_key_with_tweak_from_parent_path_alloc | int bip32_key_with_tweak_from_parent_path_alloc(const struct ext_key *hdkey,
const uint32_t *child_path, size_t child_path_len,
uint32_t flags,
struct ext_key **output)
{
i... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %r8, %r8
je 0x59bb1
movq %r8, %rbx
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movl $0xc0, %edi
callq 0xbd3b
movq %rax, (%rbx)
testq %rax, %rax
je 0x59bb8
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %ebp, %ecx
movq %rax, %r8
callq... | /p2pderivatives[P]cfd-go/external/libwally-core/src/bip32.c |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.