name string | code string | asm string | file string |
|---|---|---|---|
console::init(bool, bool) | void init(bool use_simple_io, bool use_advanced_display) {
advanced_display = use_advanced_display;
simple_io = use_simple_io;
#if defined(_WIN32)
// Windows-specific console initialization
DWORD dwMode = 0;
hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
if (hConsole == INVA... | subq $0x48, %rsp
movb %sil, 0x68f6e(%rip) # 0x16a7f1
movb %dil, 0x686f6(%rip) # 0x169f80
testl %edi, %edi
jne 0x101903
leaq 0x68f5f(%rip), %rsi # 0x16a7f4
xorl %edi, %edi
callq 0x21a40
movups 0x68f51(%rip), %xmm0 # 0x16a7f4
movq %rsp, %rdx
movaps %xmm0, (%rdx)
movups 0x68f54(%rip), %xmm0 # 0x16a804
mo... | /ggerganov[P]llama/common/console.cpp |
build_repetition(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | static std::string build_repetition(const std::string & item_rule, int min_items, int max_items, const std::string & separator_rule = "") {
auto has_max = max_items != std::numeric_limits<int>::max();
if (min_items == 0 && max_items == 1) {
return item_rule + "?";
}
if (separator_rule.empty())... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rsi, %r12
movq %rdi, %rbx
movl %ecx, %eax
xorl $0x1, %eax
orl %edx, %eax
jne 0x102552
leaq 0x10(%rbx), %r15
movq %r15, (%rbx)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x2d528
leaq 0x292cb(%rip), ... | /ggerganov[P]llama/common/json-schema-to-grammar.cpp |
format_literal(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | static std::string format_literal(const std::string & literal) {
std::string escaped = replacePattern(literal, GRAMMAR_LITERAL_ESCAPE_RE, [&](const std::smatch & match) {
char c = match.str()[0];
return GRAMMAR_LITERAL_ESCAPES.at(c);
});
return "\"" + escaped + "\"";
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
xorps %xmm0, %xmm0
leaq 0x60(%rsp), %rcx
movaps %xmm0, (%rcx)
leaq 0x2f9(%rip), %rax # 0x104574
movq %rax, 0x18(%rcx)
leaq 0x35e(%rip), %rax # 0x1045e4
movq %rax, 0x10(%rcx)
movq %rsp, %r12
movaps %xmm0,... | /ggerganov[P]llama/common/json-schema-to-grammar.cpp |
SchemaConverter::format_grammar[abi:cxx11]() | std::string format_grammar() {
std::stringstream ss;
for (const auto & kv : _rules) {
ss << kv.first << " ::= " << kv.second << std::endl;
}
return ss.str();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x188, %rsp # imm = 0x188
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rdi
callq 0x214f0
movq 0x40(%r14), %r15
addq $0x30, %r14
cmpq %r14, %r15
je 0x105a15
leaq 0x10(%rsp), %r12
leaq 0x25d41(%rip), %r13 # 0x12b6e9
movq 0x20(%r15), %rs... | /ggerganov[P]llama/common/json-schema-to-grammar.cpp |
SchemaConverter::_generate_union_rule(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long... | std::string _generate_union_rule(const std::string & name, const std::vector<json> & alt_schemas) {
std::vector<std::string> rules;
for (size_t i = 0; i < alt_schemas.size(); i++) {
rules.push_back(visit(alt_schemas[i], name + (name.empty() ? "alternative-" : "-") + std::to_string(i)));
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdx, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movq %rdi, 0x98(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x80(%rsp)
movq $0x0, 0x90(%rsp)
movq (%rcx), %r12
movq %rcx, 0xa0(%rsp)
cmpq %r12, 0x8(%rcx)
je 0x10a920
leaq 0x50(%rsp), %rbp
xorl %r13d... | /ggerganov[P]llama/common/json-schema-to-grammar.cpp |
bool nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsig... | constexpr bool is_object() const noexcept
{
return m_data.m_type == value_t::object;
} | cmpb $0x1, (%rdi)
jne 0x10c772
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %r12
movq (%r12), %r15
movq 0x8(%r12), %rax
cmpq %rax, %r15
je 0x10c778
movq %rsi, %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0x22090
testl %eax, %eax
je 0x10c775
addq $0x30, %r15
movq 0x8(%r12), %rax
c... | /ggerganov[P]llama/common/json.hpp |
decltype(from_json_array_impl(fp, fp0, nlohmann::json_abi_v3_11_3::detail::priority_tag<3u>{}), fp.get<std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, doubl... | auto from_json(const BasicJsonType& j, ConstructibleArrayType& arr)
-> decltype(from_json_array_impl(j, arr, priority_tag<3> {}),
j.template get<typename ConstructibleArrayType::value_type>(),
void())
{
if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
{
JSON_THROW(type_error::create(302, concat("type must be ar... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %r14
cmpb $0x2, (%rdi)
jne 0x10cdad
movq 0x8(%r14), %rax
movq %rsi, %rdi
movq %rax, %rsi
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x10cece
movl $0x20, %edi
callq 0x216a0
movq %rax, %rbx
movq %r14, %rdi
callq 0x8f182
leaq 0x8(%rsp), %rdx
movq %rax, (... | /ggerganov[P]llama/common/json.hpp |
common_sampler_sample_and_accept_n(common_sampler*, llama_context*, std::vector<int, std::allocator<int>> const&, bool) | std::vector<llama_token> common_sampler_sample_and_accept_n(struct common_sampler * gsmpl, struct llama_context * ctx, const llama_tokens & draft, bool grammar_first) {
std::vector<int> idxs(draft.size() + 1);
for (size_t i = 0; i < idxs.size(); ++i) {
idxs[i] = i;
}
return common_sampler_sampl... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, %ebp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq 0x8(%rcx), %rsi
subq (%rcx), %rsi
sarq $0x2, %rsi
incq %rsi
leaq 0x10(%rsp), %r13
leaq 0xf(%rsp), %rdx
movq %r13, %rdi
callq 0xffde6
movq (%r13), %rax
m... | /ggerganov[P]llama/common/sampling.cpp |
common_sampler_type_to_chr(common_sampler_type) | char common_sampler_type_to_chr(enum common_sampler_type cnstr) {
switch (cnstr) {
case COMMON_SAMPLER_TYPE_DRY: return 'd';
case COMMON_SAMPLER_TYPE_TOP_K: return 'k';
case COMMON_SAMPLER_TYPE_TYPICAL_P: return 'y';
case COMMON_SAMPLER_TYPE_TOP_P: return 'p';
... | decl %edi
movb $0x3f, %al
cmpl $0x9, %edi
ja 0x115173
movl %edi, %eax
leaq 0x16da0(%rip), %rcx # 0x12bf10
movb (%rax,%rcx), %al
retq
| /ggerganov[P]llama/common/sampling.cpp |
common_sampler::set_logits(llama_context*, int) | void set_logits(struct llama_context * ctx, int idx) {
const auto * logits = llama_get_logits_ith(ctx, idx);
const llama_model * model = llama_get_model(ctx);
const llama_vocab * vocab = llama_model_get_vocab(model);
const int n_vocab = llama_vocab_n_tokens(vocab);
cur.resize(... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
movl %edx, %esi
callq 0x220e0
movq %rax, %r14
movq %r15, %rdi
callq 0x21e60
movq %rax, %rdi
callq 0x222d0
movq %rax, %rdi
callq 0x216c0
movl %eax, %ebp
leaq 0x168(%rbx), %r15
movslq %eax, %r12
movq %r15, %rdi
movq %r1... | /ggerganov[P]llama/common/sampling.cpp |
nsync_maybe_merge_conditions_ | void nsync_maybe_merge_conditions_ (nsync_dll_element_ *p, nsync_dll_element_ *n) {
if (p != NULL && n != NULL &&
WAIT_CONDITION_EQ (&DLL_WAITER (p)->cond, &DLL_WAITER (n)->cond)) {
nsync_dll_splice_after_ (&DLL_WAITER (p)->same_condition,
&DLL_WAITER (n)->same_condition);
}
} | pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x5824
movq %rdi, %r14
movq 0x10(%rdi), %rdi
movq 0x50(%rdi), %rax
testq %rax, %rax
je 0x5824
movq %rsi, %rbx
movq 0x10(%rsi), %rsi
cmpq 0x50(%rsi), %rax
je 0x582c
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x58(%rd... | /google[P]nsync/internal/mu.c |
main | int main (int /*argc*/, char** /*argv*/)
{
Variable x;
x.setValue(3);
assertOrExit(Kandinsky::sin(x).evaluate() == std::sin(3),
"sin(" + std::to_string(x.evaluate()) + ") != " + std::to_string(std::sin(3)));
return 0;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xd8, %rsp
xorl %eax, %eax
leaq 0x20(%rsp), %rcx
movq %rax, (%rcx)
leaq 0x8495(%rip), %r14 # 0x12810
addq $0x10, %r14
leaq 0x48(%rsp), %rsi
movq %r14, -0x8(%rsi)
movq %rax, (%rsi)
leaq 0x50(%rsp), %rbx
leaq 0x98(%rsp), %rdx
movq %rbx, %rdi
callq 0xa7d2
movq -0x8(%r... | /lgpasquale[P]kandinsky/src/test/expressions/evaluation/SineEvaluationTest.cpp |
Kandinsky::SineExpression Kandinsky::sin<Kandinsky::Variable, (void*)0>(Kandinsky::Variable const&) | SineExpression
sin(const ArgT& arg)
{
return SineExpression(BaseExpression::makePtr(arg));
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xaf3c
leaq 0x7ef8(%rip), %rax # 0x12658
movq %rax, (%rbx)
movq (%r14), %rax
movq %rax, 0x8(%rbx)
movq 0x8(%r14), %rdi
movq %rdi, 0x10(%rbx)
testq %rdi, %rdi
je 0xa796
movq 0x8852(%rip), %rax # 0x12fd0
cmpb $0x0,... | /lgpasquale[P]kandinsky/src/Kandinsky/expressions/SineExpression.hpp |
Kandinsky::BaseExpression::sizeOfAllNodes(std::shared_ptr<Kandinsky::BaseExpression> const&) const | size_t BaseExpression::sizeOfAllNodes(
const std::shared_ptr<BaseExpression>& thisSharedPtr) const
{
return sizeOfInternalNodes()
+ numberOfConstants() * sizeof(Constant)
+ variables(thisSharedPtr).size() * sizeof(VariableExpression);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
callq *0x38(%rax)
movq %rax, %r15
movq (%r14), %rax
movq %r14, %rdi
callq *0x48(%rax)
leaq (%rax,%rax,2), %r13
shlq $0x4, %r13
movq (%r14), %rax
movq %rsp, %r12
movq %r12, %rdi
movq %r14, %rsi
movq ... | /lgpasquale[P]kandinsky/src/Kandinsky/expressions/BaseExpression.cpp |
Kandinsky::SineExpression Kandinsky::sin<std::shared_ptr<Kandinsky::BaseExpression>, (void*)0>(std::shared_ptr<Kandinsky::BaseExpression> const&) | SineExpression
sin(const ArgT& arg)
{
return SineExpression(BaseExpression::makePtr(arg));
} | pushq %rbx
movq %rdi, %rbx
movq (%rsi), %rax
movq 0x8(%rsi), %rdi
testq %rdi, %rdi
je 0xcb10
movq 0x64d2(%rip), %rcx # 0x12fd0
cmpb $0x0, (%rcx)
je 0xcb2c
incl 0x8(%rdi)
movq %rax, 0x8(%rbx)
movq %rdi, 0x10(%rbx)
jmp 0xcb47
movq %rax, 0x8(%rbx)
movq $0x0, 0x10(%rbx)
leaq 0x5d6d(%rip), %rax # 0x12890
addq $0x1... | /lgpasquale[P]kandinsky/src/Kandinsky/expressions/SineExpression.hpp |
FIX43::MessageCracker::onMessage(FIX43::MassQuoteAcknowledgement const&, FIX::SessionID const&) | virtual void onMessage( const MassQuoteAcknowledgement&, const FIX::SessionID& )
{ throw FIX::UnsupportedMessageType(); } | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x1, -0x4d(%rbp)
movl $0x50, %edi
callq 0x55120
movq %rax, -0x60(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x554a0
movq -0x58(%rbp), %rdx
leaq 0x2bfcb(%rip), %rsi # 0x932f9
leaq -0x3... | /marlowa[P]quickfix/include/quickfix/fix43/MessageCracker.h |
boost::ext::di::v1_2_0::core::injector<boost::ext::di::v1_2_0::config, boost::ext::di::v1_2_0::core::pool<boost::ext::di::v1_2_0::aux::type_list<>>, boost::ext::di::v1_2_0::core::dependency<boost::ext::di::v1_2_0::scopes::deduce, ILogger, ConsoleLogger, boost::ext::di::v1_2_0::no_name, void, boost::ext::di::v1_2_0::cor... | operator T*() const {
using constraint_not_satisfied = is_not_bound;
return constraint_not_satisfied{}.error();
} | pushq %rbx
subq $0x20, %rsp
leaq 0x18(%rsp), %rbx
movups (%rdx), %xmm0
andq $0x0, 0x8(%rdx)
movaps %xmm0, -0x8(%rbx)
andq $0x0, (%rdx)
leaq 0xf(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq 0x2538
movq %rbx, %rdi
callq 0x25ea
addq $0x20, %rsp
popq %rbx
retq
| /stefanpantic[P]cpp-design-patterns/creational/SOLID/di.hpp |
boost::ext::di::v1_2_0::core::pool<boost::ext::di::v1_2_0::aux::type_list<boost::ext::di::v1_2_0::core::dependency<boost::ext::di::v1_2_0::scopes::deduce, ILogger, ConsoleLogger, boost::ext::di::v1_2_0::no_name, void, boost::ext::di::v1_2_0::core::none>, boost::ext::di::v1_2_0::core::dependency<boost::ext::di::v1_2_0::... | pool(const aux::type_list<Ts...>&, TPool p) noexcept : pool(static_cast<Ts&&>(p)...) {
(void)p;
} | subq $0x18, %rsp
leaq 0x10(%rsp), %rax
andq $0x0, (%rax)
movups 0x8(%rdx), %xmm0
xorps %xmm1, %xmm1
movups %xmm1, 0x8(%rdx)
movups %xmm0, 0x8(%rdi)
andq $0x0, -0x8(%rax)
movq %rax, %rdi
callq 0x25ea
addq $0x18, %rsp
retq
| /stefanpantic[P]cpp-design-patterns/creational/SOLID/di.hpp |
auto boost::ext::di::v1_2_0::core::injector<boost::ext::di::v1_2_0::config, boost::ext::di::v1_2_0::core::pool<boost::ext::di::v1_2_0::aux::type_list<>>, boost::ext::di::v1_2_0::core::dependency<boost::ext::di::v1_2_0::scopes::deduce, ILogger, ConsoleLogger, boost::ext::di::v1_2_0::no_name, void, boost::ext::di::v1_2_0... | auto create_successful_impl__() const {
auto&& dependency = binder::resolve<T, TName>((injector*)this);
using dependency_t = typename aux::remove_reference<decltype(dependency)>::type;
using ctor_t = typename type_traits::ctor_traits__<binder::resolve_template_t<injector, typename dependency_t::given>, T,
... | subq $0x18, %rsp
leaq 0x10(%rsp), %rsi
movq %rdi, (%rsi)
leaq 0xf(%rsp), %rdi
callq 0x27e8
addq $0x18, %rsp
retq
nop
| /stefanpantic[P]cpp-design-patterns/creational/SOLID/di.hpp |
Car::Car(std::shared_ptr<Engine>, std::shared_ptr<ILogger>) | explicit Car(std::shared_ptr<Engine> engine, std::shared_ptr<ILogger> logg)
: engine(std::move(engine)),
logger(std::move(logg))
{
logger->log("car is created");
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
andq $0x0, 0x8(%rdi)
movups (%rsi), %xmm0
andq $0x0, 0x8(%rsi)
movups %xmm0, (%rdi)
andq $0x0, (%rsi)
andq $0x0, 0x18(%rdi)
movups (%rdx), %xmm0
andq $0x0, 0x8(%rdx)
movups %xmm0, 0x10(%rdi)
andq $0x0, (%rdx)
movq 0x10(%rdi), %r14
leaq 0x65b(%rip), %rsi ... | /stefanpantic[P]cpp-design-patterns/creational/SOLID/DIP.cpp |
auto boost::ext::di::v1_2_0::core::injector<boost::ext::di::v1_2_0::config, boost::ext::di::v1_2_0::core::pool<boost::ext::di::v1_2_0::aux::type_list<>>, boost::ext::di::v1_2_0::core::dependency<boost::ext::di::v1_2_0::scopes::deduce, ILogger, ConsoleLogger, boost::ext::di::v1_2_0::no_name, void, boost::ext::di::v1_2_0... | auto create_successful_impl__() const {
auto&& dependency = binder::resolve<T, TName>((injector*)this);
using dependency_t = typename aux::remove_reference<decltype(dependency)>::type;
using ctor_t = typename type_traits::ctor_traits__<binder::resolve_template_t<injector, typename dependency_t::given>, T,
... | pushq %rax
movq %rsp, %rsi
movq %rdi, (%rsi)
callq 0x2a52
popq %rcx
retq
| /stefanpantic[P]cpp-design-patterns/creational/SOLID/di.hpp |
stbtt_GetGlyphHMetrics | STBTT_DEF void stbtt_GetGlyphHMetrics(const stbtt_fontinfo *info, int glyph_index, int *advanceWidth, int *leftSideBearing)
{
stbtt_uint16 numOfLongHorMetrics = ttUSHORT(info->data+info->hhea + 34);
if (glyph_index < numOfLongHorMetrics) {
if (advanceWidth) *advanceWidth = ttSHORT(info->data + info->... | pushq %rbp
movq %rsp, %rbp
movq 0x8(%rdi), %rax
movslq 0x24(%rdi), %r8
movzwl 0x22(%rax,%r8), %r8d
rolw $0x8, %r8w
movzwl %r8w, %r9d
movl %esi, %r8d
subl %r9d, %r8d
jge 0xefab
testq %rdx, %rdx
je 0xef88
movslq 0x28(%rdi), %r8
addq %rax, %r8
movslq %esi, %r9
movzbl 0x1(%r8,%r9,4), %r10d
movzbl (%r8,%r9,4), %r8d
shll $0x... | /CrimsonAS[P]rengine/3rdparty/stb_truetype.h |
stbi_load_from_file | STBIDEF stbi_uc *stbi_load_from_file(FILE *f, int *x, int *y, int *comp, int req_comp)
{
unsigned char *result;
stbi__context s;
stbi__start_file(&s,f);
result = stbi__load_flip(&s,x,y,comp,req_comp);
if (result) {
// need to 'unget' all the characters in the IO buffer
fseek(f, - (int) (s.img... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movl %r8d, -0x2c(%rbp)
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
movq 0x27537(%rip), %rax # 0x36808
leaq -0xc8(%rbp), %r14
movq %rax, -0x18(%r14)
movups 0x27515(%rip), %xmm0 # 0x367f8
movups %... | /CrimsonAS[P]rengine/3rdparty/stb_image.h |
stbi__loadf_main(stbi__context*, int*, int*, int*, int) | static float *stbi__loadf_main(stbi__context *s, int *x, int *y, int *comp, int req_comp)
{
unsigned char *data;
#ifndef STBI_NO_HDR
if (stbi__hdr_test(s)) {
float *hdr_data = stbi__hdr_load(s,x,y,comp,req_comp);
if (hdr_data)
stbi__float_postprocess(hdr_data,x,y,comp,req_comp);
retu... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %r8d, %ebx
movq %rcx, %r13
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
callq 0xfa41
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r13, %rcx
movl %ebx, %r8d
testl %eax, %eax
je 0xf6b1
callq 0x19b21
testq %... | /CrimsonAS[P]rengine/3rdparty/stb_image.h |
stbi__do_zlib(stbi__zbuf*, char*, int, int, int) | static int stbi__do_zlib(stbi__zbuf *a, char *obuf, int olen, int exp, int parse_header)
{
a->zout_start = obuf;
a->zout = obuf;
a->zout_end = obuf + olen;
a->z_expandable = exp;
return stbi__parse_zlib(a, parse_header);
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa08, %rsp # imm = 0xA08
movq %rdi, %rbx
movq %rsi, 0x20(%rdi)
movq %rsi, 0x18(%rdi)
movslq %edx, %rax
addq %rsi, %rax
movq %rax, 0x28(%rdi)
movl %ecx, 0x30(%rdi)
testl %r8d, %r8d
je 0xfdf2
movq (%rbx), %rdx
movq 0x8(%rb... | /CrimsonAS[P]rengine/3rdparty/stb_image.h |
stbi_zlib_decode_buffer | STBIDEF int stbi_zlib_decode_buffer(char *obuffer, int olen, char const *ibuffer, int ilen)
{
stbi__zbuf a;
a.zbuffer = (stbi_uc *) ibuffer;
a.zbuffer_end = (stbi_uc *) ibuffer + ilen;
if (stbi__do_zlib(&a, obuffer, olen, 0, 1))
return (int) (a.zout - a.zout_start);
else
return -1;
} | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x1000, %rsp # imm = 0x1000
movl %esi, %eax
movq %rdi, %rsi
leaq -0x1010(%rbp), %rbx
movq %rdx, (%rbx)
movslq %ecx, %rcx
addq %rdx, %rcx
movq %rcx, 0x8(%rbx)
xorl %r14d, %r14d
movq %rbx, %rdi
movl %eax, %edx
xorl %ecx, %ecx
movl $0x1, %r8d
callq 0xfd5a
mo... | /CrimsonAS[P]rengine/3rdparty/stb_image.h |
stbi_info_from_file | STBIDEF int stbi_info_from_file(FILE *f, int *x, int *y, int *comp)
{
int r;
stbi__context s;
long pos = ftell(f);
stbi__start_file(&s, f);
r = stbi__info_main(&s,x,y,comp);
fseek(f,pos,SEEK_SET);
return r;
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rcx, -0x30(%rbp)
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
callq 0xe200
movq %rax, %r15
movups 0x25db9(%rip), %xmm0 # 0x367f8
leaq -0xc8(%rbp), %r14
movups %xmm0, -0x28(%r14)
movq 0x25db6(%rip), %rax # ... | /CrimsonAS[P]rengine/3rdparty/stb_image.h |
stbtt__find_table(unsigned char*, unsigned int, char const*) | static stbtt_uint32 stbtt__find_table(stbtt_uint8 *data, stbtt_uint32 fontstart, const char *tag)
{
stbtt_int32 num_tables = ttUSHORT(data+fontstart+4);
stbtt_uint32 tabledir = fontstart + 12;
stbtt_int32 i;
for (i=0; i < num_tables; ++i) {
stbtt_uint32 loc = tabledir + 16*i;
if (stbtt_tag(data+... | pushq %rbp
movq %rsp, %rbp
movl %esi, %eax
movzwl 0x4(%rdi,%rax), %ecx
rolw $0x8, %cx
xorl %eax, %eax
testw %cx, %cx
je 0x1128f
movzwl %cx, %r8d
movsbl (%rdx), %ecx
movl %r8d, %r8d
addl $0xc, %esi
movl %esi, %esi
movzbl (%rdi,%rsi), %r9d
cmpl %ecx, %r9d
jne 0x11287
movzbl 0x1(%rdi,%rsi), %r9d
movsbl 0x1(%rdx), %r10d
cm... | /CrimsonAS[P]rengine/3rdparty/stb_truetype.h |
stbtt_GetGlyphBox | STBTT_DEF int stbtt_GetGlyphBox(const stbtt_fontinfo *info, int glyph_index, int *x0, int *y0, int *x1, int *y1)
{
int g = stbtt__GetGlyfOffset(info, glyph_index);
if (g < 0) return 0;
if (x0) *x0 = ttSHORT(info->data + g + 2);
if (y0) *y0 = ttSHORT(info->data + g + 4);
if (x1) *x1 = ttSHORT(info->data ... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r13
movq %rdi, %r14
callq 0x11b85
testl %eax, %eax
js 0x11b74
movl %eax, %ecx
testq %r13, %r13
je 0x11b17
movq 0x8(%r14), %rax
movzbl 0x3(%rax,%rcx), %edx
movzbl 0x2(%ra... | /CrimsonAS[P]rengine/3rdparty/stb_truetype.h |
stbtt_PackBegin | STBTT_DEF int stbtt_PackBegin(stbtt_pack_context *spc, unsigned char *pixels, int pw, int ph, int stride_in_bytes, int padding, void *alloc_context)
{
stbrp_context *context = (stbrp_context *) STBTT_malloc(sizeof(*context) ,alloc_context);
int num_nodes = pw - padding;
stbrp_node *nod... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, %r13d
movl %r8d, %ebx
movl %ecx, -0x34(%rbp)
movl %edx, %r15d
movq %rsi, -0x40(%rbp)
movq %rdi, %r14
movl $0x14, %edi
callq 0xe6e0
movq %rax, %r12
movl %r15d, -0x30(%rbp)
movl %r13d, -0x2c(%rbp)
subl %r13d, %r1... | /CrimsonAS[P]rengine/3rdparty/stb_truetype.h |
stbtt_GetPackedQuad | STBTT_DEF void stbtt_GetPackedQuad(stbtt_packedchar *chardata, int pw, int ph, int char_index, float *xpos, float *ypos, stbtt_aligned_quad *q, int align_to_integer)
{
float ipw = 1.0f / pw, iph = 1.0f / ph;
stbtt_packedchar *b = chardata + char_index;
if (align_to_integer) {
float x = (float) STBTT_ifl... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %r12
movq %r8, %rbx
movl %edx, %r15d
movq 0x10(%rbp), %r13
movslq %ecx, %rax
leaq (%rax,%rax,8), %rcx
leaq (%rcx,%rcx,2), %rcx
addq %rax, %rcx
cmpl $0x0, 0x18(%rbp)
leaq (%rdi,%rcx), %r14
movss 0x8(%rdi,%rcx), %... | /CrimsonAS[P]rengine/3rdparty/stb_truetype.h |
stbtt_GetFontNameString | STBTT_DEF const char *stbtt_GetFontNameString(const stbtt_fontinfo *font, int *length, int platformID, int encodingID, int languageID, int nameID)
{
stbtt_int32 i,count,stringOffset;
stbtt_uint8 *fc = font->data;
stbtt_uint32 offset = font->fontstart;
stbtt_uint32 nm = stbtt__find_table(fc, offset, "name");... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %r15d
movl %r8d, %r12d
movl %ecx, %r13d
movl %edx, %r14d
movq %rsi, -0x30(%rbp)
movq 0x8(%rdi), %rbx
movl 0x10(%rdi), %esi
leaq 0x1913d(%rip), %rdx # 0x2d9f8
movq %rbx, %rdi
callq 0x11228
testl %eax, %eax
je 0x14... | /CrimsonAS[P]rengine/3rdparty/stb_truetype.h |
main | RENGINE_DEFINE_GLOBALS
int main(int argc, char **argv) {
for (int i=0; i<argc; ++i) {
std::string arg(argv[i]);
if (i + 1 < argc && arg == "--count") {
nodeCount = atoi(argv[++i]);
} else if (arg == "--textures") {
useTextures = true;
} else if (arg == "-h" ... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x148, %rsp # imm = 0x148
testl %edi, %edi
jle 0x14dde
movq %rsi, %r13
movl %edi, %r14d
xorl %ebx, %ebx
leaq -0x170(%rbp), %r15
movl %edi, -0x2c(%rbp)
movslq %ebx, %rax
movq (%r13,%rax,8), %rsi
movq %r15, %rdi
leaq -0x68(... | /CrimsonAS[P]rengine/examples/benchmark_blend.cpp |
stbi__hdr_load(stbi__context*, int*, int*, int*, int) | static float *stbi__hdr_load(stbi__context *s, int *x, int *y, int *comp, int req_comp)
{
char buffer[STBI__HDR_BUFLEN];
char *token;
int valid = 0;
int width, height;
stbi_uc *scanline;
float *hdr_data;
int len;
unsigned char count, value;
int i, j, k, c1,c2, z;
// Check identifier
i... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x498, %rsp # imm = 0x498
movl %r8d, -0x30(%rbp)
movq %rcx, %r13
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq -0x4c0(%rbp), %r12
movq %r12, %rsi
callq 0x2004a
movabsq $0x4e41494441523f23, %rax # imm = 0x4E41494441... | /CrimsonAS[P]rengine/3rdparty/stb_image.h |
stbi__process_marker(stbi__jpeg*, int) | static int stbi__process_marker(stbi__jpeg *z, int m)
{
int L;
switch (m) {
case STBI__MARKER_none: // no marker found
return stbi__err("expected marker","Corrupt JPEG");
case 0xDD: // DRI - specify restart interval
if (stbi__get16be(z->s) != 4) return stbi__err("bad DRI len","Corru... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
cmpl $0xdc, %esi
jg 0x1b8e5
cmpl $0xc4, %esi
movq %rdi, -0x30(%rbp)
je 0x1b93e
cmpl $0xdb, %esi
jne 0x1b905
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x1c3bd
leal -0x2(%rax), %r15d
cmpl $0x3, %eax
jb 0x1bcac
leaq 0x3488(%rb... | /CrimsonAS[P]rengine/3rdparty/stb_image.h |
stbi__resample_row_generic(unsigned char*, unsigned char*, unsigned char*, int, int) | static stbi_uc *stbi__resample_row_generic(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)
{
// resample with nearest-neighbor
int i,j;
STBI_NOTUSED(in_far);
for (i=0; i < w; ++i)
for (j=0; j < hs; ++j)
out[i*hs+j] = in_near[i];
return out;
} | movq %rdi, %rax
testl %ecx, %ecx
jle 0x1c814
pushq %rbp
movq %rsp, %rbp
movl %r8d, %edx
movl %ecx, %ecx
xorl %edi, %edi
movq %rax, %r9
testl %r8d, %r8d
jle 0x1c808
movb (%rsi,%rdi), %r10b
xorl %r11d, %r11d
movb %r10b, (%r9,%r11)
incq %r11
cmpq %r11, %rdx
jne 0x1c7fc
incq %rdi
addq %rdx, %r9
cmpq %rcx, %rdi
jne 0x1c7f0
... | /CrimsonAS[P]rengine/3rdparty/stb_image.h |
stbi__get16le(stbi__context*) | static int stbi__get16le(stbi__context *s)
{
int z = stbi__get8(s);
return z + (stbi__get8(s) << 8);
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xb8(%rdi), %rcx
movq 0xc0(%rdi), %rax
cmpq %rax, %rcx
jae 0x1f1b3
leaq 0x1(%rcx), %rdx
movq %rdx, 0xb8(%rbx)
movb (%rcx), %r15b
movq %rdx, %rcx
jmp 0x1f201
cmpl $0x0, 0x30(%rbx)
je 0x1f1d8
movq 0x28(%rbx), %rdi
leaq 0x38(%rbx),... | /CrimsonAS[P]rengine/3rdparty/stb_image.h |
stbi__gif_header(stbi__context*, stbi__gif*, int*, int) | static int stbi__gif_header(stbi__context *s, stbi__gif *g, int *comp, int is_info)
{
stbi_uc version;
if (stbi__get8(s) != 'G' || stbi__get8(s) != 'I' || stbi__get8(s) != 'F' || stbi__get8(s) != '8')
return stbi__err("not GIF", "Corrupt GIF");
version = stbi__get8(s);
if (version != '7' && version !... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %r15d
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
movq 0xb8(%rdi), %rdx
movq 0xc0(%rdi), %rax
cmpq %rax, %rdx
jae 0x1f359
leaq 0x1(%rdx), %rcx
movq %rcx, 0xb8(%r14)
movb (%rdx), %dl
jmp 0x1f3ab
cmpl $0x0, 0x30(%r... | /CrimsonAS[P]rengine/3rdparty/stb_image.h |
stbi__gif_parse_colortable(stbi__context*, unsigned char (*) [4], int, int) | static void stbi__gif_parse_colortable(stbi__context *s, stbi_uc pal[256][4], int num_entries, int transp)
{
int i;
for (i=0; i < num_entries; ++i) {
pal[i][2] = stbi__get8(s);
pal[i][1] = stbi__get8(s);
pal[i][0] = stbi__get8(s);
pal[i][3] = transp == i ? 0 : 255;
}
} | testl %edx, %edx
jle 0x1f978
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x38(%rdi), %r15
leaq 0x39(%rdi), %r12
movl %ecx, %eax
movq %rax, -0x38(%rbp)
movl %edx, %eax
movq %rax, -0x30(%rbp)
xorl %r13d, %r13d
movq 0xb8(%r14), %ra... | /CrimsonAS[P]rengine/3rdparty/stb_image.h |
stbi__pnm_skip_whitespace(stbi__context*, char*) | static void stbi__pnm_skip_whitespace(stbi__context *s, char *c)
{
while (!stbi__at_eof(s) && stbi__pnm_isspace(*c))
*c = (char) stbi__get8(s);
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x38(%rdi), %r15
leaq 0x39(%rdi), %r12
cmpq $0x0, 0x10(%r14)
je 0x1feb5
movq 0x28(%r14), %rdi
callq *0x20(%r14)
testl %eax, %eax
je 0x1fec9
cmpl $0x0, 0x30(%r14)
je 0x1ff4a
movq 0xb8(%r14), %rax
cmpq 0xc0(%r14), ... | /CrimsonAS[P]rengine/3rdparty/stb_image.h |
stbi__hdr_convert(float*, unsigned char*, int) | static void stbi__hdr_convert(float *output, stbi_uc *input, int req_comp)
{
if ( input[3] != 0 ) {
float f1;
// Exponent
f1 = (float) ldexp(1.0f, input[3] - (int)(128 + 8));
if (req_comp <= 2)
output[0] = (input[0] + input[1] + input[2]) * f1 / 3;
else {
output[0] = i... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r14d
movq %rdi, %rbx
movzbl 0x3(%rsi), %edi
testl %edi, %edi
je 0x202d0
movq %rsi, %r15
addl $0xffffff78, %edi # imm = 0xFFFFFF78
movss 0xce43(%rip), %xmm0 # 0x2d0e0
callq 0xe840
movzbl (%r15), %eax
cmpl $0x2, %r14d
jg 0x202fc
... | /CrimsonAS[P]rengine/3rdparty/stb_image.h |
rengine::SDLBackend::dpi() const | inline vec2 SDLBackend::dpi() const
{
assert(m_window);
assert(m_surface);
int index = SDL_GetWindowDisplayIndex(m_window);
float d, h, v;
SDL_GetDisplayDPI(index, &d, &h, &v);
return vec2(h, v) * devicePixelRatio();
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
testq %rdi, %rdi
je 0x24c57
cmpq $0x0, 0x18(%rbx)
je 0x24c76
callq 0xe510
leaq -0x24(%rbp), %rsi
leaq -0x20(%rbp), %r14
leaq -0x1c(%rbp), %r15
movl %eax, %edi
movq %r14, %rdx
movq %r15, %rcx
callq 0xe4b0
m... | /CrimsonAS[P]rengine/include/backend/sdl/sdlbackend.h |
rengine::StandardSurface::onRender() | void onRender() override {
if (!beginRender())
return;
// Initialize the renderer if this is the first time around
if (!m_renderer) {
m_renderer.reset(createRenderer());
m_renderer->setSceneRoot(build());
}
// Update the scene graph...
... | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
testb %al, %al
je 0x2519b
movq 0x10(%rbx), %r14
testq %r14, %r14
jne 0x25132
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
callq *0x48(%rax)
movq 0x10(%rbx), %rdi
movq %rax, 0x10(%rbx)
testq %rdi, %rdi
je ... | /CrimsonAS[P]rengine/include/util/standardsurface.h |
rengine::Signal<>::connect(rengine::SignalEmitter*, rengine::SignalHandler<>*) | void connect(SignalEmitter *emitter, SignalHandler<Arguments ...> *handler)
{
Bucket *bucket = findBucket(emitter);
if (!bucket) {
bucket = new Bucket();
bucket->signal = this;
if (!emitter->m_buckets) {
emitter->m_buckets = new std::vector<SignalE... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r13
movq %rdx, -0x38(%rbp)
movq 0x8(%rsi), %r15
testq %r15, %r15
je 0x26722
movq (%r15), %rax
movq 0x8(%r15), %rcx
cmpq %rcx, %rax
je 0x26722
movq (%rax), %r14
cmpq %r13, 0x8(%r... | /CrimsonAS[P]rengine/include/object/signal.h |
rengine::AllocationPool<rengine::TextureNode>::deallocate(rengine::TextureNode*) | void deallocate(T *t) {
assert(m_memory);
assert(m_free);
assert(m_nextFree > 0);
assert(isAlloctated(t));
unsigned pos = t - m_memory;
--m_nextFree;
m_free[m_nextFree] = pos;
// Call the destructor...
t->~T();
} | pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rdx
testq %rdx, %rdx
je 0x28401
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x28420
movl 0x10(%rdi), %ecx
testl %ecx, %ecx
je 0x2843f
movq %rsi, %r8
subq %rdx, %r8
shrq $0x4, %r8
imull $0xcccccccd, %r8d, %edx # imm = 0xCCCCCCCD
cmpl %edx, 0x14(%rdi)
jbe 0x2845e
decl %ecx
movl %ecx,... | /CrimsonAS[P]rengine/include/common/allocationpool.h |
rengine::Animation<rengine::TransformNode, float, &rengine::TransformNode::setMatrix_rotateAroundZ(float), &rengine::AnimationCurves::linear(double)>::tick(double) | void tick(double time)
{
assert(isRunning());
assert(m_keyFrames.size()); // no animations without 'em.
// std::cout << "tick: time=" << time << std::endl;
bool stop = false;
int curIter = (int) (time / m_duration);
double timeInThisIteration = fmod(time, m_duration)... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
testb $0x1, 0x20(%rdi)
je 0x28d59
movq %rdi, %rbx
movq 0x38(%rdi), %rax
cmpq 0x30(%rdi), %rax
je 0x28d78
movsd 0x18(%rbx), %xmm1
movapd %xmm0, %xmm2
divsd %xmm1, %xmm2
cvttsd2si %xmm2, %r15d
callq 0xe690
movl 0x10(%rbx), %eax
testl %eax, %eax
... | /CrimsonAS[P]rengine/include/animationsystem/animation.h |
rengine::OpenGLRenderer::build(rengine::Node*) | inline void OpenGLRenderer::build(Node *n)
{
switch (n->type()) {
case Node::TextureNodeType:
case Node::RectangleNodeType: {
rect2d geometry = static_cast<RectangleNodeBase *>(n)->geometry();
// Skip if empty..
if (geometry.width() == 0 || geometry.height() == 0
|| (n->... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp # imm = 0x198
movq %rsi, %r14
movq %rdi, %rbx
movzbl 0x30(%rsi), %eax
leal -0x1(%rax), %ecx
cmpl $0x4, %ecx
ja 0x29d02
leaq 0x39c1(%rip), %rax # 0x2d694
movslq (%rax,%rcx,4), %rcx
addq %rax, %rcx
jmpq *%r... | /CrimsonAS[P]rengine/include/scenegraph/openglrenderer.h |
rengine::OpenGLRenderer::drawTextureQuad(unsigned int, unsigned int, float, rengine::Texture::Format) | inline void OpenGLRenderer::drawTextureQuad(unsigned offset, GLuint texId, float opacity, Texture::Format format)
{
if (opacity == 1) {
if (format == Texture::BGRA_32 || format == Texture::BGRx_32) {
activateShader(&prog_texture_bgr);
ensureMatrixUpdated(UpdateTextureBgrProgram, &pro... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %r14d
movl %esi, %r12d
movq %rdi, %r15
ucomiss 0x16eb(%rip), %xmm0 # 0x2d0e0
jne 0x2ba2d
jp 0x2ba2d
cmpl $0x1003, %ecx # imm = 0x1003
je 0x2ba06
cmpl $0x4, %ecx
jne 0x2ba60
leaq 0x34(%r15), %rbx
m... | /CrimsonAS[P]rengine/include/scenegraph/openglrenderer.h |
rengine::OpenGLRenderer::drawColorFilterQuad(unsigned int, unsigned int, rengine::mat4) | inline void OpenGLRenderer::drawColorFilterQuad(unsigned offset, GLuint texId, mat4 matrix)
{
activateShader(&prog_colorFilter);
ensureMatrixUpdated(UpdateColorFilterProgram, &prog_colorFilter);
glUniformMatrix4fv(prog_colorFilter.colorMatrix, 1, true, matrix.m);
// std::cout << prog_colorFilter.colorMa... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r14d
movl %esi, %r13d
movq %rdi, %r15
leaq 0x60(%rdi), %rbx
movq 0x1e0(%rdi), %rax
cmpq %rbx, %rax
je 0x2bd23
testq %rax, %rax
movl %r14d, -0x30(%rbp)
movl %r13d, -0x2c(%rbp)
je 0x2bcda
movl 0x4(%rax), %r12d
jmp 0x2... | /CrimsonAS[P]rengine/include/scenegraph/openglrenderer.h |
rengine::AnimationManager::tick() | inline void AnimationManager::tick()
{
// alternatively:
// time_point now = clock::now();
time_point now = m_nextTick;
m_nextTick += std::chrono::milliseconds(16);
// std::cout << "AnimationManager::tick: scheduled=" << m_scheduledAnimations.size()
// << ", running=" << m_runningAnim... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x10(%rdi), %rbx
movq 0x30(%rdi), %r15
leaq 0xf42400(%rbx), %rax
movq %rax, 0x10(%rdi)
movq %rdi, -0x30(%rbp)
leaq 0x30(%rdi), %r14
cmpq %r14, %r15
je 0x2c9fd
movq -0x30(%rbp), %rax
leaq 0x18(%rax), %r12
movq 0x18(%r15), %... | /CrimsonAS[P]rengine/include/animationsystem/animation.h |
qclab::qgates::QControlledGate2<std::complex<double>>::matrix() const | qclab::dense::SquareMatrix< T > matrix() const override {
using matrix_type = qclab::dense::SquareMatrix< T > ;
const matrix_type I2 = qclab::dense::eye< T >( 2 ) ;
const matrix_type E0( 1 , 0 ,
0 , 0 ) ;
const matrix_type E1( 0 , 0 ,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x48(%rsp), %rdi
movl $0x2, %esi
callq 0xa7b9
movq $0x2, 0x28(%rsp)
movl $0x40, %edi
callq 0x6030
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
movq %rax... | /QuantumComputingLab[P]qpixlpp/build_O1/_deps/qclabpp-src/include/qclab/qgates/QControlledGate2.hpp |
qclab::qgates::CPhase<std::complex<double>>::equals(qclab::QObject<std::complex<double>> const&) const | inline bool equals( const QObject< T >& other ) const override {
using CP = CPhase< T > ;
if ( const CP* p = dynamic_cast< const CP* >( &other ) ) {
if ( p->angle() != this->angle() ) return false ;
if ( p->controlState() != this->controlState() ) return false ;
r... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rax
movq %rdi, %rbx
leaq 0x1c420(%rip), %rsi # 0x27dd8
leaq 0x1c6f9(%rip), %rdx # 0x280b8
xorl %r15d, %r15d
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x61f0
testq %rax, %rax
je 0xba50
movq %rax, %r14
movq 0x10(%rax), %rax
movq 0x10(%rbx), %rcx
movsd... | /QuantumComputingLab[P]qpixlpp/build_O1/_deps/qclabpp-src/include/qclab/qgates/CPhase.hpp |
qclab::qgates::Phase<std::complex<double>>::matrix() const | qclab::dense::SquareMatrix< T > matrix() const override {
return qclab::dense::SquareMatrix< T >( T(1) , T(0) ,
T(0) , T( cos() , sin() ) ) ;
} | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movups 0x10(%rsi), %xmm0
movaps %xmm0, (%rsp)
movq $0x2, (%rdi)
movl $0x40, %edi
callq 0x6030
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x30(%rax)
movq %rax, 0x8(%rbx)
movabsq $0x3ff0000000000000, %rcx # imm = 0x3F... | /QuantumComputingLab[P]qpixlpp/build_O1/_deps/qclabpp-src/include/qclab/qgates/Phase.hpp |
void qclab::printMatrix4x4<qclab::dense::SquareMatrix<std::complex<double>>>(qclab::dense::SquareMatrix<std::complex<double>> const&) | void printMatrix4x4( const T& mat ) {
assert( mat.rows() == 4 ) ;
assert( mat.cols() == 4 ) ;
print( mat(0,0) ); print( mat(0,1) ); print( mat(0,2) ); print( mat(0,3) );
std::cout << std::endl ;
print( mat(1,0) ); print( mat(1,1) ); print( mat(1,2) ); print( mat(1,3) );
std::cout << std::endl ;
... | pushq %r14
pushq %rbx
pushq %rax
cmpq $0x4, (%rdi)
jne 0xc486
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movsd (%rax), %xmm0
movsd 0x8(%rax), %xmm1
callq 0xa978
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
shlq $0x4, %rax
movsd (%rcx,%rax), %xmm0
movsd 0x8(%rcx,%rax), %xmm1
callq 0xa978
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
shlq ... | /QuantumComputingLab[P]qpixlpp/build_O1/_deps/qclabpp-src/include/qclab/util.hpp |
auto qclab::qasm2<double>(char const*, int, int, double) | inline auto qasm2( const char type[] , const int qubit0 , const int qubit1 ,
const T angle ) {
std::stringstream stream ;
stream << type << "(" << qasm( angle ) << ") q[" << qubit0 << "], q["
<< qubit1 << "];\n" ;
return stream.str() ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1d8, %rsp # imm = 0x1D8
movsd %xmm0, 0x8(%rsp)
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x50(%rsp), %rdi
callq 0x6140
leaq 0x60(%rsp), %r15
testq %r12, %r12
je 0xc4f3
movq %r12, %rdi
callq 0x60e0
movq %r15,... | /QuantumComputingLab[P]qpixlpp/build_O1/_deps/qclabpp-src/include/qclab/qasm.hpp |
qclab::qgates::SWAP<std::complex<double>>::setQubits(int const*) | inline void setQubits( const int* qubits ) override {
assert( qubits[0] >= 0 ) ; assert( qubits[1] >= 0 ) ;
assert( qubits[0] != qubits[1] ) ;
qubits_[0] = std::min( qubits[0] , qubits[1] ) ;
qubits_[1] = std::max( qubits[0] , qubits[1] ) ;
} | pushq %rax
movl (%rsi), %eax
testl %eax, %eax
js 0xc74f
movl 0x4(%rsi), %ecx
testl %ecx, %ecx
js 0xc758
cmpl %ecx, %eax
je 0xc777
setg %al
movzbl %al, %eax
movl (%rsi,%rax,4), %eax
movl %eax, 0x8(%rdi)
movl (%rsi), %eax
movl 0x4(%rsi), %ecx
cmpl %ecx, %eax
cmovgl %eax, %ecx
movl %ecx, 0xc(%rdi)
popq %rax
retq
leaq 0xf0... | /QuantumComputingLab[P]qpixlpp/build_O1/_deps/qclabpp-src/include/qclab/qgates/SWAP.hpp |
qclab::qgates::QGate1<float>::apply(qclab::Op, int, std::vector<float, std::allocator<float>>&, int) const | void QGate1< T >::apply( Op op , const int nbQubits ,
std::vector< T >& vector , const int offset ) const {
const int qubit = this->qubit() + offset ;
auto f = lambda_QGate1( op , this->matrix() , vector.data() ) ;
apply2( nbQubits , qubit , f ) ;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %r8d, %ebp
movq %rcx, %r15
movl %edx, 0xc(%rsp)
movl %esi, %r12d
movq %rdi, %r13
movq (%rdi), %rax
callq *0x18(%rax)
movl %eax, %r14d
movq (%r13), %rax
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
movq %r13, %rsi
callq *0x38(%rax)
movq (%r... | /QuantumComputingLab[P]qpixlpp/build_O1/_deps/qclabpp-src/src/qgates/QGate1.cpp |
void qclab::dense::operateInPlace<qclab::dense::SquareMatrix<float>>(qclab::Op, qclab::dense::SquareMatrix<float>&) | void operateInPlace( Op op , T& A ) {
if ( op == Op::NoTrans ) return ;
const int64_t rows = A.rows() ;
const int64_t cols = A.cols() ;
if constexpr ( qclab::is_complex_v< typename T::value_type > ) {
if ( op == Op::ConjTrans ) {
// conjugate
#pragma omp parallel for
... | cmpb $0x4e, %dil
je 0xd20f
movq (%rsi), %rax
cmpq $0x2, %rax
jl 0xd20f
pushq %r14
pushq %rbx
movq 0x8(%rsi), %rcx
leaq -0x2(%rax), %rdx
leaq (,%rax,4), %rsi
leaq 0x4(,%rax,4), %rdi
leaq (%rcx,%rax,4), %r8
addq $0x4, %rcx
xorl %r9d, %r9d
movq %r9, %r10
incq %r9
movl $0x1, %r11d
movq %r8, %rbx
movss -0x4(%rcx,%r11,4), %x... | /QuantumComputingLab[P]qpixlpp/build_O1/_deps/qclabpp-src/include/qclab/dense/transpose.hpp |
void qclab::qgates::apply2<auto qclab::qgates::lambda_QGate1<double>(qclab::Op, qclab::dense::SquareMatrix<double>, double*)::'lambda'(unsigned long, unsigned long)>(int, int, double&) | void apply2( const int nbQubits , const int qubit , F& lambda ) {
// masks
const auto [ mL , mR ] = masks( nbQubits , qubit ) ;
// indices
const uint64_t n = 1ULL << ( nbQubits - 1 ) ;
const uint64_t b1 = 1ULL << ( nbQubits - qubit - 1 ) ;
// matvec
#pragma omp parallel for
for ( uint64... | pushq %rbx
testl %edi, %edi
jle 0xd849
cmpl %edi, %esi
jge 0xd868
movl %esi, %eax
notl %eax
movq $-0x1, %r8
movl %esi, %ecx
shlq %cl, %r8
addl %edi, %eax
movq $-0x1, %rsi
notq %r8
movl %eax, %ecx
shlq %cl, %r8
shlq %cl, %rsi
notq %rsi
decl %edi
movl $0x1, %r9d
movl $0x1, %r10d
shlq %cl, %r10
movq (%rdx), %rax
leaq -0x1... | /QuantumComputingLab[P]qpixlpp/build_O1/_deps/qclabpp-src/src/qgates/apply.hpp |
void qclab::qgates::apply2<auto qclab::qgates::lambda_Hadamard<std::complex<float>>(qclab::Op, std::complex<float>*)::'lambda'(unsigned long, unsigned long)>(int, int, std::complex<float>&) | void apply2( const int nbQubits , const int qubit , F& lambda ) {
// masks
const auto [ mL , mR ] = masks( nbQubits , qubit ) ;
// indices
const uint64_t n = 1ULL << ( nbQubits - 1 ) ;
const uint64_t b1 = 1ULL << ( nbQubits - qubit - 1 ) ;
// matvec
#pragma omp parallel for
for ( uint64... | pushq %rax
testl %edi, %edi
jle 0x1083f
cmpl %edi, %esi
jge 0x1085e
movl %esi, %eax
notl %eax
addl %edi, %eax
movq $-0x1, %r8
movq $-0x1, %r9
movl %esi, %ecx
shlq %cl, %r9
notq %r9
movl %eax, %ecx
shlq %cl, %r9
shlq %cl, %r8
notq %r8
decl %edi
movl $0x1, %esi
movl $0x1, %r10d
shlq %cl, %r10
leaq -0x1(%rsi), %rcx
movq %... | /QuantumComputingLab[P]qpixlpp/build_O1/_deps/qclabpp-src/src/qgates/apply.hpp |
void qclab::qgates::apply2<auto qclab::qgates::lambda_Hadamard<std::complex<double>>(qclab::Op, std::complex<double>*)::'lambda'(unsigned long, unsigned long)>(int, int, std::complex<double>&) | void apply2( const int nbQubits , const int qubit , F& lambda ) {
// masks
const auto [ mL , mR ] = masks( nbQubits , qubit ) ;
// indices
const uint64_t n = 1ULL << ( nbQubits - 1 ) ;
const uint64_t b1 = 1ULL << ( nbQubits - qubit - 1 ) ;
// matvec
#pragma omp parallel for
for ( uint64... | pushq %rbx
testl %edi, %edi
jle 0x10a12
cmpl %edi, %esi
jge 0x10a31
movl %esi, %eax
notl %eax
addl %edi, %eax
movq $-0x1, %r8
movq $-0x1, %r9
movl %esi, %ecx
shlq %cl, %r9
notq %r9
movl %eax, %ecx
shlq %cl, %r9
shlq %cl, %r8
notq %r8
decl %edi
movl $0x1, %esi
movl $0x1, %r10d
shlq %cl, %r10
leaq -0x1(%rsi), %rcx
movq %... | /QuantumComputingLab[P]qpixlpp/build_O1/_deps/qclabpp-src/src/qgates/apply.hpp |
qclab::qgates::Phase<std::complex<float>>::Phase(int, qclab::QAngle<float> const&, bool) | QGate1( const int qubit )
: qubit_( qubit )
{
assert( qubit >= 0 ) ;
} | leaq 0x16edd(%rip), %rax # 0x279f0
movq %rax, (%rdi)
movl %esi, 0x8(%rdi)
testl %esi, %esi
js 0x10b32
movb %cl, 0xc(%rdi)
leaq 0x170d9(%rip), %rax # 0x27c00
movq %rax, (%rdi)
movq (%rdx), %rax
movq %rax, 0x10(%rdi)
retq
pushq %rax
leaq 0xab50(%rip), %rdi # 0x1b68a
leaq 0xab54(%rip), %rsi # 0x1b695
lea... | /QuantumComputingLab[P]qpixlpp/build_O1/_deps/qclabpp-src/include/qclab/qgates/QGate1.hpp |
qclab::qgates::Phase<std::complex<float>>::Phase(int, float, bool) | Phase()
: QGate1< T >( 0 )
, angle_( 0 )
, QAdjustable( false )
{ } | pushq %rbx
subq $0x10, %rsp
leaq 0x16e92(%rip), %rax # 0x279f0
movq %rax, (%rdi)
movl %esi, 0x8(%rdi)
testl %esi, %esi
js 0x10b9e
movq %rdi, %rbx
movb %dl, 0xc(%rdi)
leaq 0x1708b(%rip), %rax # 0x27c00
movq %rax, (%rdi)
movss %xmm0, 0xc(%rsp)
callq 0x6170
movss %xmm0, 0x10(%rbx)
movss 0xc(%rsp), %xmm0
callq 0x61... | /QuantumComputingLab[P]qpixlpp/build_O1/_deps/qclabpp-src/include/qclab/qgates/Phase.hpp |
qclab::qgates::Phase<std::complex<float>>::Phase(int, float, float, bool) | QGate1( const int qubit )
: qubit_( qubit )
{
assert( qubit >= 0 ) ;
} | leaq 0x16e2b(%rip), %rax # 0x279f0
movq %rax, (%rdi)
movl %esi, 0x8(%rdi)
testl %esi, %esi
js 0x10be7
movb %dl, 0xc(%rdi)
leaq 0x17027(%rip), %rax # 0x27c00
movq %rax, (%rdi)
movss %xmm0, 0x10(%rdi)
movss %xmm1, 0x14(%rdi)
retq
pushq %rax
leaq 0xaa9b(%rip), %rdi # 0x1b68a
leaq 0xaa9f(%rip), %rsi # 0x1... | /QuantumComputingLab[P]qpixlpp/build_O1/_deps/qclabpp-src/include/qclab/qgates/QGate1.hpp |
qclab::qgates::Phase<std::complex<float>>::apply(qclab::Op, int, std::vector<std::complex<float>, std::allocator<std::complex<float>>>&, int) const | void Phase< T >::apply( Op op , const int nbQubits ,
std::vector< T >& vector , const int offset ) const {
const int qubit = this->qubit() + offset ;
T lambda = T( cos() , sin() ) ;
auto f = lambda_Phase( op , lambda , vector.data() ) ;
apply2b( nbQubits , qubit , f ) ;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %r8d, %ebp
movq %rcx, %r15
movl %edx, %ebx
movl %esi, %r12d
movq %rdi, %r14
movq (%rdi), %rax
callq *0x18(%rax)
addl %ebp, %eax
movq (%r15), %rcx
cmpb $0x43, %r12b
je 0x10c47
movsd 0x10(%r14), %xmm0
jmp 0x10c5d
movss 0x10(%r14), %xmm0
movss 0x... | /QuantumComputingLab[P]qpixlpp/build_O1/_deps/qclabpp-src/src/qgates/Phase.cpp |
void qclab::qgates::apply2b<auto qclab::qgates::lambda_Phase<std::complex<float>>(qclab::Op, std::complex<float>&, std::complex<float>*)::'lambda'(unsigned long)>(int, int, std::complex<float>&) | void apply2b( const int nbQubits , const int qubit , F& lambda ) {
// masks
const auto [ mL , mR ] = masks( nbQubits , qubit ) ;
// indices
const uint64_t n = 1ULL << ( nbQubits - 1 ) ;
const uint64_t b1 = 1ULL << ( nbQubits - qubit - 1 ) ;
// matvec
#pragma omp parallel for
for ( uint6... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testl %edi, %edi
jle 0x10d26
movq %rdi, %r13
cmpl %r13d, %esi
jge 0x10d45
movq %rdx, %r14
movl %esi, %eax
notl %eax
movq $-0x1, %rdi
movl %esi, %ecx
shlq %cl, %rdi
addl %r13d, %eax
movq $-0x1, %r12
notq %rdi
movl %eax, %ecx
shlq %cl, %rdi
movq... | /QuantumComputingLab[P]qpixlpp/build_O1/_deps/qclabpp-src/src/qgates/apply.hpp |
qclab::qgates::Phase<std::complex<float>>::update(qclab::QAngle<float> const&) | void update( const angle_type& angle ) {
assert( !fixed() ) ;
angle_.update( angle ) ;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x8(%rax)
testb %al, %al
jne 0x10db1
movss (%r14), %xmm0
movss %xmm0, 0x10(%rbx)
movss 0x4(%r14), %xmm0
movss %xmm0, 0x14(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0xcb60(%rip), %rdi # 0x1d918
leaq 0xcb62(%rip), %rs... | /QuantumComputingLab[P]qpixlpp/build_O1/_deps/qclabpp-src/include/qclab/qgates/Phase.hpp |
qclab::qgates::Phase<std::complex<float>>::update(float) | void update( const real_type theta ) {
assert( !fixed() ) ;
angle_.update( theta ) ;
} | pushq %rbx
subq $0x10, %rsp
movss %xmm0, 0xc(%rsp)
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x8(%rax)
testb %al, %al
jne 0x10e0e
movss 0xc(%rsp), %xmm0
callq 0x6170
movss %xmm0, 0x10(%rbx)
movss 0xc(%rsp), %xmm0
callq 0x61a0
movss %xmm0, 0x14(%rbx)
addq $0x10, %rsp
popq %rbx
retq
leaq 0xcb03(%rip), %rdi # 0x1d918
... | /QuantumComputingLab[P]qpixlpp/build_O1/_deps/qclabpp-src/include/qclab/qgates/Phase.hpp |
qclab::qgates::Phase<std::complex<double>>::Phase(double) | Phase( const real_type theta )
: QGate1< T >( 0 )
, angle_( theta )
, QAdjustable( false )
{ } | pushq %rbx
subq $0x10, %rsp
movsd %xmm0, 0x8(%rsp)
movq %rdi, %rbx
movl $0x0, 0x8(%rdi)
movb $0x0, 0xc(%rdi)
leaq 0x1728e(%rip), %rax # 0x28180
movq %rax, (%rdi)
callq 0x62e0
movsd %xmm0, 0x10(%rbx)
movsd 0x8(%rsp), %xmm0
callq 0x60a0
movsd %xmm0, 0x18(%rbx)
addq $0x10, %rsp
popq %rbx
retq
nop
| /QuantumComputingLab[P]qpixlpp/build_O1/_deps/qclabpp-src/include/qclab/qgates/Phase.hpp |
qclab::qgates::Phase<std::complex<double>>::Phase(int, qclab::QAngle<double> const&, bool) | QGate1( const int qubit )
: qubit_( qubit )
{
assert( qubit >= 0 ) ;
} | leaq 0x17033(%rip), %rax # 0x27f70
movq %rax, (%rdi)
movl %esi, 0x8(%rdi)
testl %esi, %esi
js 0x10f5c
movb %cl, 0xc(%rdi)
leaq 0x1722f(%rip), %rax # 0x28180
movq %rax, (%rdi)
movups (%rdx), %xmm0
movups %xmm0, 0x10(%rdi)
retq
pushq %rax
leaq 0xa726(%rip), %rdi # 0x1b68a
leaq 0xa72a(%rip), %rsi # 0x1b6... | /QuantumComputingLab[P]qpixlpp/build_O1/_deps/qclabpp-src/include/qclab/qgates/QGate1.hpp |
qclab::qgates::Phase<std::complex<double>>::Phase(int, double, bool) | Phase()
: QGate1< T >( 0 )
, angle_( 0 )
, QAdjustable( false )
{ } | pushq %rbx
subq $0x10, %rsp
leaq 0x16fe8(%rip), %rax # 0x27f70
movq %rax, (%rdi)
movl %esi, 0x8(%rdi)
testl %esi, %esi
js 0x10fc8
movq %rdi, %rbx
movb %dl, 0xc(%rdi)
leaq 0x171e1(%rip), %rax # 0x28180
movq %rax, (%rdi)
movsd %xmm0, 0x8(%rsp)
callq 0x62e0
movsd %xmm0, 0x10(%rbx)
movsd 0x8(%rsp), %xmm0
callq 0x60... | /QuantumComputingLab[P]qpixlpp/build_O1/_deps/qclabpp-src/include/qclab/qgates/Phase.hpp |
qclab::qgates::Phase<std::complex<double>>::Phase(int, double, double, bool) | QGate1( const int qubit )
: qubit_( qubit )
{
assert( qubit >= 0 ) ;
} | leaq 0x16f81(%rip), %rax # 0x27f70
movq %rax, (%rdi)
movl %esi, 0x8(%rdi)
testl %esi, %esi
js 0x11011
movb %dl, 0xc(%rdi)
leaq 0x1717d(%rip), %rax # 0x28180
movq %rax, (%rdi)
movsd %xmm0, 0x10(%rdi)
movsd %xmm1, 0x18(%rdi)
retq
pushq %rax
leaq 0xa671(%rip), %rdi # 0x1b68a
leaq 0xa675(%rip), %rsi # 0x1... | /QuantumComputingLab[P]qpixlpp/build_O1/_deps/qclabpp-src/include/qclab/qgates/QGate1.hpp |
qclab::qgates::Phase<std::complex<double>>::apply(qclab::Op, int, std::vector<std::complex<double>, std::allocator<std::complex<double>>>&, int) const | void Phase< T >::apply( Op op , const int nbQubits ,
std::vector< T >& vector , const int offset ) const {
const int qubit = this->qubit() + offset ;
T lambda = T( cos() , sin() ) ;
auto f = lambda_Phase( op , lambda , vector.data() ) ;
apply2b( nbQubits , qubit , f ) ;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %r8d, %ebp
movq %rcx, %r14
movl %edx, %ebx
movl %esi, %r15d
movq %rdi, %r12
movq (%rdi), %rax
callq *0x18(%rax)
addl %ebp, %eax
movsd 0x10(%r12), %xmm0
movsd 0x18(%r12), %xmm1
movq (%r14), %rcx
cmpb $0x43, %r15b
jne 0x1107e
xorps 0xbcb2(%rip),... | /QuantumComputingLab[P]qpixlpp/build_O1/_deps/qclabpp-src/src/qgates/Phase.cpp |
void qclab::qgates::apply2b<auto qclab::qgates::lambda_Phase<std::complex<double>>(qclab::Op, std::complex<double>&, std::complex<double>*)::'lambda'(unsigned long)>(int, int, std::complex<double>&) | void apply2b( const int nbQubits , const int qubit , F& lambda ) {
// masks
const auto [ mL , mR ] = masks( nbQubits , qubit ) ;
// indices
const uint64_t n = 1ULL << ( nbQubits - 1 ) ;
const uint64_t b1 = 1ULL << ( nbQubits - qubit - 1 ) ;
// matvec
#pragma omp parallel for
for ( uint6... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testl %edi, %edi
jle 0x1114f
movq %rdi, %r13
cmpl %r13d, %esi
jge 0x1116e
movq %rdx, %r14
movl %esi, %eax
notl %eax
movq $-0x1, %rdi
movl %esi, %ecx
shlq %cl, %rdi
addl %r13d, %eax
movq $-0x1, %r12
notq %rdi
movl %eax, %ecx
shlq %cl, %rdi
movq... | /QuantumComputingLab[P]qpixlpp/build_O1/_deps/qclabpp-src/src/qgates/apply.hpp |
qclab::qgates::Phase<std::complex<double>>::update(qclab::QAngle<double> const&) | void update( const angle_type& angle ) {
assert( !fixed() ) ;
angle_.update( angle ) ;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x8(%rax)
testb %al, %al
jne 0x111db
movsd (%r14), %xmm0
movsd %xmm0, 0x10(%rbx)
movsd 0x8(%r14), %xmm0
movsd %xmm0, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0xc736(%rip), %rdi # 0x1d918
leaq 0xc738(%rip), %rs... | /QuantumComputingLab[P]qpixlpp/build_O1/_deps/qclabpp-src/include/qclab/qgates/Phase.hpp |
qclab::qgates::QControlledGate2<float>::QControlledGate2(int, int) | QControlledGate2( const int control , const int controlState = 1 )
: control_( control )
, controlState_( controlState )
{
assert( control >= 0 ) ;
assert( ( controlState == 0 ) || ( controlState == 1 ) ) ;
} | pushq %rax
leaq 0x17264(%rip), %rax # 0x28580
movq %rax, (%rdi)
movl %esi, 0x8(%rdi)
movl %edx, 0xc(%rdi)
testl %esi, %esi
js 0x11330
cmpl $0x2, %edx
jae 0x1134f
popq %rax
retq
leaq 0xa615(%rip), %rdi # 0x1b94c
leaq 0xa743(%rip), %rsi # 0x1ba81
leaq 0xc8fb(%rip), %rcx # 0x1dc40
movl $0x22, %edx
callq... | /QuantumComputingLab[P]qpixlpp/build_O1/_deps/qclabpp-src/include/qclab/qgates/QControlledGate2.hpp |
qclab::qgates::QControlledGate2<float>::setQubits(int const*) | inline void setQubits( const int* qubits ) override {
assert( qubits[0] >= 0 ) ; assert( qubits[1] >= 0 ) ;
assert( qubits[0] != qubits[1] ) ;
control_ = qubits[0] ;
this->setTarget( qubits[1] ) ;
} | pushq %rax
movl (%rsi), %eax
testl %eax, %eax
js 0x113fd
movl 0x4(%rsi), %ecx
testl %ecx, %ecx
js 0x11406
cmpl %ecx, %eax
je 0x11425
movl %eax, 0x8(%rdi)
movl 0x4(%rsi), %esi
movq (%rdi), %rax
movq 0x88(%rax), %rax
popq %rcx
jmpq *%rax
leaq 0xa3db(%rip), %rdi # 0x1b7df
jmp 0x1140d
leaq 0xa922(%rip), %rdi # 0x... | /QuantumComputingLab[P]qpixlpp/build_O1/_deps/qclabpp-src/include/qclab/qgates/QControlledGate2.hpp |
qclab::qgates::QControlledGate2<float>::matrix() const | qclab::dense::SquareMatrix< T > matrix() const override {
using matrix_type = qclab::dense::SquareMatrix< T > ;
const matrix_type I2 = qclab::dense::eye< T >( 2 ) ;
const matrix_type E0( 1 , 0 ,
0 , 0 ) ;
const matrix_type E1( 0 , 0 ,
... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq $0x2, 0x40(%rsp)
movl $0x10, %edi
callq 0x6030
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq %rax, 0x48(%rsp)
xorl %ecx, %ecx
movl $0x3f800000, (%rax) # imm = 0x3F800000
incq %rcx
addq $0xc, %rax
cmpq $0x2, %rcx
jne 0x11475
movq $... | /QuantumComputingLab[P]qpixlpp/build_O1/_deps/qclabpp-src/include/qclab/qgates/QControlledGate2.hpp |
qclab::dense::operator+(qclab::dense::SquareMatrix<float>, qclab::dense::SquareMatrix<float> const&) | inline int64_t rows() const { return size_ ; } | pushq %rbx
movq (%rdx), %rax
movq (%rsi), %rcx
cmpq %rcx, %rax
jne 0x11877
movq %rdi, %rbx
testq %rcx, %rcx
jle 0x1186a
movq 0x8(%rdx), %rdx
movq 0x8(%rsi), %rdi
leaq (,%rcx,4), %r8
shlq $0x2, %rax
xorl %r9d, %r9d
xorl %r10d, %r10d
movss (%rdx,%r10,4), %xmm0
addss (%rdi,%r10,4), %xmm0
movss %xmm0, (%rdi,%r10,4)
incq %r... | /QuantumComputingLab[P]qpixlpp/build_O1/_deps/qclabpp-src/include/qclab/dense/SquareMatrix.hpp |
qclab::dense::SquareMatrix<float> qclab::dense::kron<float>(qclab::dense::SquareMatrix<float> const&, qclab::dense::SquareMatrix<float> const&) | SquareMatrix< T > kron( const SquareMatrix< T >& A ,
const SquareMatrix< T >& B ) {
SquareMatrix< T > kronAB( A.rows() * B.rows() ) ;
kron( A , B , kronAB ) ;
return kronAB ;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdx), %rsi
imulq (%r15), %rsi
callq 0x162f8
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1637e
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x118d8
callq 0x62... | /QuantumComputingLab[P]qpixlpp/build_O1/_deps/qclabpp-src/include/qclab/dense/kron.hpp |
qclab::qgates::QControlledGate2<float>::apply(qclab::Op, int, std::vector<float, std::allocator<float>>&, int) const | void QControlledGate2< T >::apply( Op op ,
const int nbQubits ,
std::vector< T >& vector ,
const int offset ) const {
auto qubits = this->qubits() ;
qubits[0] += offset ;
qubits[1] += offset ;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %r8d, %r12d
movq %rcx, %rbx
movl %edx, 0x14(%rsp)
movl %esi, %r13d
movq %rdi, %r14
movq (%rdi), %rax
leaq 0x28(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq *0x28(%rax)
movq (%r15), %rax
addl %r12d, (%rax)
addl %r12d, 0x4(%rax)
... | /QuantumComputingLab[P]qpixlpp/build_O1/_deps/qclabpp-src/src/qgates/QControlledGate2.cpp |
void qclab::qgates::apply4<auto qclab::qgates::lambda_QGate1<float>(qclab::Op, qclab::dense::SquareMatrix<float>, float*)::'lambda'(unsigned long, unsigned long)>(int, int, int, int, int, int, float&) | void apply4( const int nbQubits , const int qubit0 , const int qubit1 ,
const int control , const int target , const int controlState ,
F& lambda ) {
// masks
const auto [ mL , mC , mR ] = masks( nbQubits , qubit0 , qubit1 ) ;
// control / target
const uint64_t n = 1ULL <<... | pushq %r15
pushq %r14
pushq %rbx
cmpl $0x1, %edi
jle 0x11b25
cmpl %edi, %esi
jge 0x11b44
cmpl %edi, %edx
jge 0x11b4d
movl %ecx, %eax
movl %esi, %r10d
notl %r10d
addl %edx, %r10d
notl %edx
movq $-0x1, %r11
movl %esi, %ecx
shlq %cl, %r11
addl %edi, %edx
movq $-0x1, %rsi
xorq %rsi, %r11
leal (%rdx,%r10), %ecx
shlq %cl, %r... | /QuantumComputingLab[P]qpixlpp/build_O1/_deps/qclabpp-src/src/qgates/apply.hpp |
qclab::qgates::QControlledGate2<float>::apply(qclab::Side, qclab::Op, int, qclab::dense::SquareMatrix<float>&, int) const | void QControlledGate2< T >::apply( Side side , Op op , const int nbQubits ,
qclab::dense::SquareMatrix< T >& matrix ,
const int offset ) const {
using matrix_type = qclab::dense::SquareMatrix< T > ;
assert( nbQubits >= 2 ) ;
assert( m... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
cmpl $0x1, %ecx
jle 0x1229d
movq %r8, %rbx
movl %ecx, %r12d
movl %esi, (%rsp)
movl $0x1, %eax
shll %cl, %eax
cltq
cmpq %rax, (%r8)
jne 0x122bc
movl %r9d, %r13d
movl %edx, %ebp
movq %rdi, %r14
movq (%rdi), %rax
leaq 0x60(%rsp), %r15
movq ... | /QuantumComputingLab[P]qpixlpp/build_O1/_deps/qclabpp-src/src/qgates/QControlledGate2.cpp |
qclab::qgates::QControlledGate2<double>::QControlledGate2(int, int) | QControlledGate2( const int control , const int controlState = 1 )
: control_( control )
, controlState_( controlState )
{
assert( control >= 0 ) ;
assert( ( controlState == 0 ) || ( controlState == 1 ) ) ;
} | pushq %rax
leaq 0x16256(%rip), %rax # 0x28620
movq %rax, (%rdi)
movl %esi, 0x8(%rdi)
movl %edx, 0xc(%rdi)
testl %esi, %esi
js 0x123de
cmpl $0x2, %edx
jae 0x123fd
popq %rax
retq
leaq 0x9567(%rip), %rdi # 0x1b94c
leaq 0x9695(%rip), %rsi # 0x1ba81
leaq 0xbb08(%rip), %rcx # 0x1defb
movl $0x22, %edx
callq... | /QuantumComputingLab[P]qpixlpp/build_O1/_deps/qclabpp-src/include/qclab/qgates/QControlledGate2.hpp |
qclab::qgates::QControlledGate2<double>::setQubits(int const*) | inline void setQubits( const int* qubits ) override {
assert( qubits[0] >= 0 ) ; assert( qubits[1] >= 0 ) ;
assert( qubits[0] != qubits[1] ) ;
control_ = qubits[0] ;
this->setTarget( qubits[1] ) ;
} | pushq %rax
movl (%rsi), %eax
testl %eax, %eax
js 0x124ab
movl 0x4(%rsi), %ecx
testl %ecx, %ecx
js 0x124b4
cmpl %ecx, %eax
je 0x124d3
movl %eax, 0x8(%rdi)
movl 0x4(%rsi), %esi
movq (%rdi), %rax
movq 0x88(%rax), %rax
popq %rcx
jmpq *%rax
leaq 0x932d(%rip), %rdi # 0x1b7df
jmp 0x124bb
leaq 0x9874(%rip), %rdi # 0x... | /QuantumComputingLab[P]qpixlpp/build_O1/_deps/qclabpp-src/include/qclab/qgates/QControlledGate2.hpp |
qclab::qgates::QControlledGate2<double>::matrix() const | qclab::dense::SquareMatrix< T > matrix() const override {
using matrix_type = qclab::dense::SquareMatrix< T > ;
const matrix_type I2 = qclab::dense::eye< T >( 2 ) ;
const matrix_type E0( 1 , 0 ,
0 , 0 ) ;
const matrix_type E1( 0 , 0 ,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq $0x2, 0x48(%rsp)
movl $0x20, %edi
callq 0x6030
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movq %rax, 0x50(%rsp)
xorl %ecx, %ecx
movabsq $0x3ff0000000000000, %r15 # imm = 0x3FF0000000000000
movq %r15, ... | /QuantumComputingLab[P]qpixlpp/build_O1/_deps/qclabpp-src/include/qclab/qgates/QControlledGate2.hpp |
qclab::dense::SquareMatrix<double> qclab::dense::kron<double>(qclab::dense::SquareMatrix<double> const&, qclab::dense::SquareMatrix<double> const&) | SquareMatrix< T > kron( const SquareMatrix< T >& A ,
const SquareMatrix< T >& B ) {
SquareMatrix< T > kronAB( A.rows() * B.rows() ) ;
kron( A , B , kronAB ) ;
return kronAB ;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdx), %rsi
imulq (%r15), %rsi
callq 0x164c8
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1654b
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x129bd
callq 0x62... | /QuantumComputingLab[P]qpixlpp/build_O1/_deps/qclabpp-src/include/qclab/dense/kron.hpp |
qclab::qgates::QControlledGate2<double>::apply(qclab::Op, int, std::vector<double, std::allocator<double>>&, int) const | void QControlledGate2< T >::apply( Op op ,
const int nbQubits ,
std::vector< T >& vector ,
const int offset ) const {
auto qubits = this->qubits() ;
qubits[0] += offset ;
qubits[1] += offset ;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %r8d, %r12d
movq %rcx, %rbx
movl %edx, 0x14(%rsp)
movl %esi, %r13d
movq %rdi, %r14
movq (%rdi), %rax
leaq 0x28(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq *0x28(%rax)
movq (%r15), %rax
addl %r12d, (%rax)
addl %r12d, 0x4(%rax)
... | /QuantumComputingLab[P]qpixlpp/build_O1/_deps/qclabpp-src/src/qgates/QControlledGate2.cpp |
void qclab::qgates::apply4<auto qclab::qgates::lambda_QGate1<double>(qclab::Op, qclab::dense::SquareMatrix<double>, double*)::'lambda'(unsigned long, unsigned long)>(int, int, int, int, int, int, double&) | void apply4( const int nbQubits , const int qubit0 , const int qubit1 ,
const int control , const int target , const int controlState ,
F& lambda ) {
// masks
const auto [ mL , mC , mR ] = masks( nbQubits , qubit0 , qubit1 ) ;
// control / target
const uint64_t n = 1ULL <<... | pushq %r15
pushq %r14
pushq %rbx
cmpl $0x1, %edi
jle 0x12c0b
cmpl %edi, %esi
jge 0x12c2a
cmpl %edi, %edx
jge 0x12c33
movl %ecx, %eax
movl %esi, %r10d
notl %r10d
addl %edx, %r10d
notl %edx
movq $-0x1, %r11
movl %esi, %ecx
shlq %cl, %r11
addl %edi, %edx
movq $-0x1, %rsi
xorq %rsi, %r11
leal (%rdx,%r10), %ecx
shlq %cl, %r... | /QuantumComputingLab[P]qpixlpp/build_O1/_deps/qclabpp-src/src/qgates/apply.hpp |
qclab::qgates::QControlledGate2<std::complex<float>>::setControlState(int) | QControlledGate2( const int control , const int controlState = 1 )
: control_( control )
, controlState_( controlState )
{
assert( control >= 0 ) ;
assert( ( controlState == 0 ) || ( controlState == 1 ) ) ;
} | cmpl $0x2, %esi
jae 0x1503b
movl %esi, 0xc(%rdi)
retq
pushq %rax
leaq 0x6b4a(%rip), %rdi # 0x1bb8d
leaq 0x6a37(%rip), %rsi # 0x1ba81
leaq 0x91ad(%rip), %rcx # 0x1e1fe
movl $0x8e, %edx
callq 0x6120
nop
pushq %rax
leaq 0x1307c(%rip), %rax # 0x280e0
movq %rax, (%rdi)
movl %esi, 0x8(%rdi)
movl %edx, 0xc(... | /QuantumComputingLab[P]qpixlpp/build_O1/_deps/qclabpp-src/include/qclab/qgates/QControlledGate2.hpp |
qclab::qgates::CX<double>::toQASM(std::ostream&, int) const | int toQASM( std::ostream& stream ,
const int offset = 0 ) const override {
if ( this->controlState() == 0 ) {
stream << qasmX( this->control() + offset ) ;
}
stream << qasmCX( this->control() + offset ,
this->target() + offset ) ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %edx, %r14d
movq %rsi, %rbx
movq %rdi, %r15
cmpl $0x0, 0xc(%rdi)
jne 0x191ee
movl 0x8(%r15), %edx
addl %r14d, %edx
leaq 0x5c37(%rip), %rsi # 0x1edee
movq %rsp, %r12
movq %r12, %rdi
callq 0x8704
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq ... | /QuantumComputingLab[P]qpixlpp/build_O1/_deps/qclabpp-src/include/qclab/qgates/CX.hpp |
qclab::qgates::CX<std::complex<float>>::toQASM(std::ostream&, int) const | int toQASM( std::ostream& stream ,
const int offset = 0 ) const override {
if ( this->controlState() == 0 ) {
stream << qasmX( this->control() + offset ) ;
}
stream << qasmCX( this->control() + offset ,
this->target() + offset ) ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %edx, %r14d
movq %rsi, %rbx
movq %rdi, %r15
cmpl $0x0, 0xc(%rdi)
jne 0x19460
movl 0x8(%r15), %edx
addl %r14d, %edx
leaq 0x59c5(%rip), %rsi # 0x1edee
movq %rsp, %r12
movq %r12, %rdi
callq 0x8704
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq ... | /QuantumComputingLab[P]qpixlpp/build_O1/_deps/qclabpp-src/include/qclab/qgates/CX.hpp |
qclab::qgates::CX<std::complex<float>>::equals(qclab::QObject<std::complex<float>> const&) const | inline bool equals( const QObject< T >& other ) const override {
using CG = CX< T > ;
if ( const CG* p = dynamic_cast< const CG* >( &other ) ) {
if ( p->controlState() != this->controlState() ) return false ;
return ( ( p->control() < p->target() ) &&
( t... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rax
movq %rdi, %rbx
leaq 0xe2c0(%rip), %rsi # 0x27848
leaq 0xf4d1(%rip), %rdx # 0x28a60
xorl %r15d, %r15d
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x61f0
testq %rax, %rax
je 0x195f8
movq %rax, %r14
movl 0xc(%rax), %eax
cmpl 0xc(%rbx), %eax
jne 0x... | /QuantumComputingLab[P]qpixlpp/build_O1/_deps/qclabpp-src/include/qclab/qgates/CX.hpp |
qclab::qgates::PauliX<std::complex<float>>::toQASM(std::ostream&, int) const | int toQASM( std::ostream& stream ,
const int offset = 0 ) const override {
stream << qasmX( this->qubit_ + offset ) ;
return 0 ;
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
addl 0x8(%rdi), %edx
leaq 0x525c(%rip), %rsi # 0x1edee
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x8704
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x6200
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x19bc9
movq 0x18(%rsp)... | /QuantumComputingLab[P]qpixlpp/build_O1/_deps/qclabpp-src/include/qclab/qgates/PauliX.hpp |
void qclab::qgates::apply2<auto qclab::qgates::lambda_PauliX<std::complex<double>>(qclab::Op, std::complex<double>*)::'lambda'(unsigned long, unsigned long)>(int, int, std::complex<double>&) | void apply2( const int nbQubits , const int qubit , F& lambda ) {
// masks
const auto [ mL , mR ] = masks( nbQubits , qubit ) ;
// indices
const uint64_t n = 1ULL << ( nbQubits - 1 ) ;
const uint64_t b1 = 1ULL << ( nbQubits - qubit - 1 ) ;
// matvec
#pragma omp parallel for
for ( uint64... | pushq %rbx
subq $0x10, %rsp
testl %edi, %edi
jle 0x1a251
cmpl %edi, %esi
jge 0x1a270
movl %esi, %eax
notl %eax
addl %edi, %eax
movq $-0x1, %r8
movq $-0x1, %r9
movl %esi, %ecx
shlq %cl, %r9
notq %r9
movl %eax, %ecx
shlq %cl, %r9
shlq %cl, %r8
notq %r8
decl %edi
movl $0x1, %esi
movl $0x1, %r10d
shlq %cl, %r10
leaq -0x1(%... | /QuantumComputingLab[P]qpixlpp/build_O1/_deps/qclabpp-src/src/qgates/apply.hpp |
qclab::qgates::CX<float>::CX() | CX()
: QControlledGate2< T >( 0 )
, gate_( std::make_unique< PauliX< T > >( 1 ) )
{ } | pushq %rbx
movq %rdi, %rbx
movabsq $0x100000000, %rax # imm = 0x100000000
movq %rax, 0x8(%rdi)
leaq 0xe5af(%rip), %rax # 0x28860
movq %rax, (%rdi)
movl $0x10, %edi
callq 0x61d0
movl $0x1, 0x8(%rax)
leaq 0xe874(%rip), %rcx # 0x28b40
movq %rcx, (%rax)
movq %rax, 0x10(%rbx)
popq %rbx
retq
nop
| /QuantumComputingLab[P]qpixlpp/build_O1/_deps/qclabpp-src/include/qclab/qgates/CX.hpp |
qclab::qgates::CX<float>::apply(qclab::Op, int, std::vector<float, std::allocator<float>>&, int) const | void CX< T >::apply( Op op , const int nbQubits , std::vector< T >& vector ,
const int offset ) const {
auto qubits = this->qubits() ;
qubits[0] += offset ;
qubits[1] += offset ;
const int control = this->control() + offset ;
const int target = this->target() + offset ;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, %r12d
movq %rcx, %r15
movl %edx, %ebx
movq %rdi, %r14
movq (%rdi), %rax
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %r14, %rsi
callq *0x28(%rax)
movq (%r13), %rax
addl %r12d, (%rax)
addl %r12d, 0x4(%rax)
movl 0x8(%r14), %ebp
mov... | /QuantumComputingLab[P]qpixlpp/build_O1/_deps/qclabpp-src/src/qgates/CX.cpp |
qclab::qgates::CX<std::complex<float>>::CX() | CX()
: QControlledGate2< T >( 0 )
, gate_( std::make_unique< PauliX< T > >( 1 ) )
{ } | pushq %rbx
movq %rdi, %rbx
movabsq $0x100000000, %rax # imm = 0x100000000
movq %rax, 0x8(%rdi)
leaq 0xe143(%rip), %rax # 0x289d0
movq %rax, (%rdi)
movl $0x10, %edi
callq 0x61d0
movl $0x1, 0x8(%rax)
leaq 0xe3d8(%rip), %rcx # 0x28c80
movq %rcx, (%rax)
movq %rax, 0x10(%rbx)
popq %rbx
retq
nop
| /QuantumComputingLab[P]qpixlpp/build_O1/_deps/qclabpp-src/include/qclab/qgates/CX.hpp |
SVGChart::DummyData::DummyData(long) | DummyData::DummyData (long inSize) {
for (int theI=0;theI<inSize;theI++) {
mRealPlotData.push_back (theI);// simple ascending data
}
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
leaq 0xf076(%rip), %rax # 0x12758
movq %rax, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movq $0x0, 0x18(%rdi)
testq %rsi, %rsi
jle 0x3744
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rdi), %r15
xorl %r13d, %r13d
leaq 0xc(%rsp), %r12
xorps ... | /davecom[P]SVGChart/PPlot.cpp |
SVGChart::PlotDataContainer::GetPlotIndexByName(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | int PlotDataContainer::GetPlotIndexByName (const string &inName) const {
if (CheckState ()) {
for (int theI = 0; theI < int(mLegendDataList.size());theI++) {
LegendData *theLegendData = mLegendDataList[theI];
if (theLegendData->mName == inName) {
return theI;
}
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
callq 0x491a
movl $0xffffffff, %ebx # imm = 0xFFFFFFFF
testb %al, %al
je 0x4aba
movq 0x30(%r14), %r12
movq 0x38(%r14), %r13
subq %r12, %r13
shrq $0x3, %r13
testl %r13d, %r13d
jle 0x4aba
movq (%r15), %r14
m... | /davecom[P]SVGChart/PPlot.cpp |
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.