name string | code string | asm string | file string |
|---|---|---|---|
stbi_load_from_file_16 | STBIDEF stbi__uint16 *stbi_load_from_file_16(FILE *f, int *x, int *y, int *comp, int req_comp)
{
stbi__uint16 *result;
stbi__context s;
stbi__start_file(&s,f);
result = stbi__load_and_postprocess_16bit(&s,x,y,comp,req_comp);
if (result) {
// need to 'unget' all the characters in the IO buffer
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movl %r8d, %ebp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq 0x15e9e2(%rip), %rax # 0x18da40
leaq 0x40(%rsp), %rcx
movq %rax, -0x18(%rcx)
movups 0x15e9c2(%rip), %xmm0 # 0x18da30
movups %xmm0, -0x28(%rcx)
movq... | /ggerganov[P]llama/examples/llava/../../common/stb_image.h |
stbi_load_16 | STBIDEF stbi_us *stbi_load_16(char const *filename, int *x, int *y, int *comp, int req_comp)
{
FILE *f = stbi__fopen(filename, "rb");
stbi__uint16 *result;
if (!f) return (stbi_us *) stbi__errpuc("can't fopen", "Unable to open file");
result = stbi_load_from_file_16(f,x,y,comp,req_comp);
fclose(f);
re... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %r8d, %ebx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
leaq 0x10bae8(%rip), %rsi # 0x13ad23
callq 0x24b60
testq %rax, %rax
je 0x2f26c
movq %rax, %r13
movq %rax, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
movl %ebx, %r8d
callq 0x2f037
movq %rax... | /ggerganov[P]llama/examples/llava/../../common/stb_image.h |
stbi_load_16_from_callbacks | STBIDEF stbi_us *stbi_load_16_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *channels_in_file, int desired_channels)
{
stbi__context s;
stbi__start_callbacks(&s, (stbi_io_callbacks *)clbk, user);
return stbi__load_and_postprocess_16bit(&s,x,y,channels_in_file,desired_channels);
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe0, %rsp
movl %r9d, %ebx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq 0x10(%rdi), %rax
leaq 0x38(%rsp), %rcx
movq %rax, -0x18(%rcx)
movups (%rdi), %xmm0
movups %xmm0, -0x28(%rcx)
movq %rsi, -0x10(%rcx)
movabsq $0x8000000001, %rax # imm = 0x800000... | /ggerganov[P]llama/examples/llava/../../common/stb_image.h |
stbi_loadf_from_memory | STBIDEF float *stbi_loadf_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp)
{
stbi__context s;
stbi__start_mem(&s,buffer,len);
return stbi__loadf_main(&s,x,y,comp,req_comp);
} | subq $0xe8, %rsp
leaq 0x8(%rsp), %rax
movq $0x0, 0x10(%rax)
xorl %r10d, %r10d
movl %r10d, 0x30(%rax)
movl %r10d, 0xb8(%rax)
movq %rdi, 0xd0(%rax)
movq %rdi, 0xc0(%rax)
movslq %esi, %rsi
addq %rdi, %rsi
movq %rsi, 0xd8(%rax)
movq %rsi, 0xc8(%rax)
movq %rax, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
movq %r8, %rcx
movl %r9d, ... | /ggerganov[P]llama/examples/llava/../../common/stb_image.h |
stbi_is_hdr_from_file | STBIDEF int stbi_is_hdr_from_file(FILE *f)
{
#ifndef STBI_NO_HDR
long pos = ftell(f);
int res;
stbi__context s;
stbi__start_file(&s,f);
res = stbi__hdr_test(&s);
fseek(f, pos, SEEK_SET);
return res;
#else
STBI_NOTUSED(f);
return 0;
#endif
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xe8, %rsp
movq %rdi, %rbx
callq 0x23520
movq %rax, %r14
movq 0x15dd40(%rip), %rax # 0x18da40
leaq 0x40(%rsp), %rcx
movq %rax, -0x18(%rcx)
movups 0x15dd20(%rip), %xmm0 # 0x18da30
movups %xmm0, -0x28(%rcx)
movq %rbx, -0x10(%rcx)
movabsq $0x8000000001, %rax # imm... | /ggerganov[P]llama/examples/llava/../../common/stb_image.h |
stbi__de_iphone(stbi__png*) | static void stbi__de_iphone(stbi__png *z)
{
stbi__context *s = z->s;
stbi__uint32 i, pixel_count = s->img_x * s->img_y;
stbi_uc *p = z->out;
if (s->img_out_n == 3) { // convert bgr to rgb
for (i=0; i < pixel_count; ++i) {
stbi_uc t = p[0];
p[0] = p[2];
p[2] = t;
p... | pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl 0x4(%rdi), %ebp
imull (%rdi), %ebp
cmpl $0x3, 0xc(%rdi)
jne 0x3ddc7
testl %ebp, %ebp
je 0x3de8c
movb (%rbx), %al
movb 0x2(%rbx), %cl
movb %cl, (%rbx)
movb %al, 0x2(%rbx)
addq $0x3, %rbx
decl %ebp
jne 0x3ddb0
jmp 0x3de8c
movq %fs:0x0, %rax
cmpl $0x0, -0xc(%rax)
leaq ... | /ggerganov[P]llama/examples/llava/../../common/stb_image.h |
stbi__create_png_image_raw(stbi__png*, unsigned char*, unsigned int, int, unsigned int, unsigned int, int, int) | static int stbi__create_png_image_raw(stbi__png *a, stbi_uc *raw, stbi__uint32 raw_len, int out_n, stbi__uint32 x, stbi__uint32 y, int depth, int color)
{
int bytes = (depth == 16 ? 2 : 1);
stbi__context *s = a->s;
stbi__uint32 i,j,stride = x*out_n*bytes;
stbi__uint32 img_len, img_width_bytes;
stbi_uc *f... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movl %r9d, %ebp
movl %r8d, %ebx
movl %ecx, %r8d
movl %edx, 0x18(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdi, %r12
movl 0xe0(%rsp), %r15d
cmpl $0x10, %r15d
sete %cl
movl %ebx, %eax
imull %r8d, %eax
shll %cl, %eax
movl %eax, 0x4c(%rsp)
movq (%rd... | /ggerganov[P]llama/examples/llava/../../common/stb_image.h |
stbi__mad3sizes_valid(int, int, int, int) | static int stbi__mad3sizes_valid(int a, int b, int c, int add)
{
return stbi__mul2sizes_valid(a, b) && stbi__mul2sizes_valid(a*b, c) &&
stbi__addsizes_valid(a*b*c, add);
} | xorl %r9d, %r9d
movl %esi, %eax
orl %edi, %eax
js 0x3e63d
movl %edx, %r8d
testl %esi, %esi
je 0x3e604
xorl %r9d, %r9d
movl $0x7fffffff, %eax # imm = 0x7FFFFFFF
xorl %edx, %edx
divl %esi
cmpl %edi, %eax
jl 0x3e63d
imull %edi, %esi
movl %esi, %eax
orl %r8d, %eax
movl $0x0, %r9d
js 0x3e63d
testl %r8d, %r8d
je 0x3e62... | /ggerganov[P]llama/examples/llava/../../common/stb_image.h |
stbi__create_png_alpha_expand8(unsigned char*, unsigned char*, unsigned int, int) | static void stbi__create_png_alpha_expand8(stbi_uc *dest, stbi_uc *src, stbi__uint32 x, int img_n)
{
int i;
// must process data backwards since we allow dest==src
if (img_n == 1) {
for (i=x-1; i >= 0; --i) {
dest[i*2+1] = 255;
dest[i*2+0] = src[i];
}
} else {
STBI_ASSERT... | decl %edx
cmpl $0x1, %ecx
jne 0x3e695
testl %edx, %edx
js 0x3e6c8
movl %edx, %eax
movb $-0x1, 0x1(%rdi,%rax,2)
movb (%rsi,%rax), %cl
movb %cl, (%rdi,%rax,2)
addq $-0x1, %rax
jb 0x3e682
jmp 0x3e6c8
testl %edx, %edx
js 0x3e6c8
movl %edx, %eax
leaq (%rax,%rax,2), %rcx
addq %rsi, %rcx
addq $0x2, %rcx
movb $-0x1, 0x3(%rdi,%... | /ggerganov[P]llama/examples/llava/../../common/stb_image.h |
stbi__out_gif_code(stbi__gif*, unsigned short) | static void stbi__out_gif_code(stbi__gif *g, stbi__uint16 code)
{
stbi_uc *p, *c;
int idx;
// recurse to decode the prefixes, since the linked-list is backwards,
// and working backwards through an interleaved image would be nasty
if (g->codes[code].prefix >= 0)
stbi__out_gif_code(g, g->codes[code... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %esi, %r14d
movzwl 0x834(%rdi,%r14,4), %eax
testw %ax, %ax
js 0x3f96a
movzwl %ax, %esi
movq %rbx, %rdi
callq 0x3f947
movslq 0x8860(%rbx), %rcx
cmpl 0x8858(%rbx), %ecx
jge 0x3fa4d
movslq 0x885c(%rbx), %rax
addq %rcx, %rax
movq 0x8(%rbx), %rcx
leal 0x3(%rax), %edx
tes... | /ggerganov[P]llama/examples/llava/../../common/stb_image.h |
stbi__psd_decode_rle(stbi__context*, unsigned char*, int) | static int stbi__psd_decode_rle(stbi__context *s, stbi_uc *p, int pixelCount)
{
int count, nleft, len;
count = 0;
while ((nleft = pixelCount - count) > 0) {
len = stbi__get8(s);
if (len == 128) {
// No-op.
} else if (len < 128) {
// Copy next len+1 bytes literally.
... | movl $0x1, %eax
testl %edx, %edx
jle 0x3fb9b
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
xorl %r12d, %r12d
movl %edx, %ebp
movl %edx, 0x4(%rsp)
movq 0xc0(%r15), %rcx
cmpq 0xc8(%r15), %rcx
jb 0x3faa4
cmpl $0x0, 0x30(%r15)
je 0x3facf
movq %r... | /ggerganov[P]llama/examples/llava/../../common/stb_image.h |
stbi__pic_is4(stbi__context*, char const*) | static int stbi__pic_is4(stbi__context *s,const char *str)
{
int i;
for (i=0; i<4; ++i)
if (stbi__get8(s) != (stbi_uc)str[i])
return 0;
return 1;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0xc0(%rdi), %rax
xorl %r15d, %r15d
cmpq 0xc8(%r14), %rax
jb 0x3fbd0
cmpl $0x0, 0x30(%r14)
je 0x3fbf1
movq %r14, %rdi
callq 0x3c3a4
movq 0xc0(%r14), %rax
leaq 0x1(%rax), %rdx
movq %rdx, 0xc0(%r14)
movb (%rax), %cl
movq %rdx, %rax
cmpb (%rbx,%r15), %cl... | /ggerganov[P]llama/examples/llava/../../common/stb_image.h |
stbi__readval(stbi__context*, int, unsigned char*) | static stbi_uc *stbi__readval(stbi__context *s, int channel, stbi_uc *dest)
{
int mask=0x80, i;
for (i=0; i<4; ++i, mask>>=1) {
if (channel & mask) {
if (stbi__at_eof(s)) return stbi__errpuc("bad file","PIC file too short");
dest[i]=stbi__get8(s);
}
}
return dest;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movl $0x80, %r15d
xorl %r12d, %r12d
testl %ebp, %r15d
je 0x3fc8b
cmpq $0x0, 0x10(%r14)
je 0x3fc3c
movq 0x28(%r14), %rdi
callq *0x20(%r14)
testl %eax, %eax
je 0x3fc51
cmpl $0x0, 0x30(%r14)
je 0x3fc9d
movq 0xc0(%r14), %... | /ggerganov[P]llama/examples/llava/../../common/stb_image.h |
stbi__decode_jpeg_header(stbi__jpeg*, int) | static int stbi__decode_jpeg_header(stbi__jpeg *z, int scan)
{
int m;
z->jfif = 0;
z->app14_color_transform = -1; // valid values are 0,1,2
z->marker = STBI__MARKER_none; // initialize cached marker to empty
m = stbi__get_marker(z);
if (!stbi__SOI(m)) return stbi__err("no SOI","Corrupt JPEG");
if (... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movabsq $-0x100000000, %rax # imm = 0xFFFFFFFF00000000
movq %rax, 0x4848(%rdi)
movb $-0x1, 0x4828(%rdi)
callq 0x408f2
cmpb $-0x28, %al
jne 0x3fdab
movl $0x1, %ebp
cmpl $0x1, %ebx
je 0x3fdc7
movq %r14, %rdi
callq 0x408f2
movzbl %a... | /ggerganov[P]llama/examples/llava/../../common/stb_image.h |
stbi__get_marker(stbi__jpeg*) | static stbi_uc stbi__get_marker(stbi__jpeg *j)
{
stbi_uc x;
if (j->marker != STBI__MARKER_none) { x = j->marker; j->marker = STBI__MARKER_none; return x; }
x = stbi__get8(j->s);
if (x != 0xff) return STBI__MARKER_none;
while (x == 0xff)
x = stbi__get8(j->s); // consume repeated 0xff fill bytes
r... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb 0x4828(%rdi), %al
cmpb $-0x1, %al
je 0x4090c
movb $-0x1, 0x4828(%rbx)
jmp 0x40989
movq (%rbx), %r14
movq 0xc0(%r14), %rcx
cmpq 0xc8(%r14), %rcx
jb 0x40935
cmpl $0x0, 0x30(%r14)
je 0x40983
movq %r14, %rdi
callq 0x3c3a4
movq 0xc0(%r14), %rcx
leaq 0x1(%rcx), %rax
movq ... | /ggerganov[P]llama/examples/llava/../../common/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movl %esi, %r14d
movq %rdi, %rbx
cmpl $0xdc, %esi
jg 0x40af9
cmpl $0xc4, %r14d
je 0x40b84
cmpl $0xdb, %r14d
jne 0x40b27
movq (%rbx), %rdi
callq 0x3dbaa
leal -0x2(%rax), %r15d
cmpl $0x3, %eax
jb 0x40e24
leaq 0x3488(%rbx), %rax
movq %rax, ... | /ggerganov[P]llama/examples/llava/../../common/stb_image.h |
stbi__grow_buffer_unsafe(stbi__jpeg*) | static void stbi__grow_buffer_unsafe(stbi__jpeg *j)
{
do {
unsigned int b = j->nomore ? 0 : stbi__get8(j->s);
if (b == 0xff) {
int c = stbi__get8(j->s);
while (c == 0xff) c = stbi__get8(j->s); // consume fill bytes
if (c != 0) {
j->marker = (unsigned char) c;
... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0x482c(%rbx)
je 0x42325
xorl %eax, %eax
jmp 0x423ce
movq (%rbx), %r14
movq 0xc0(%r14), %rax
cmpq 0xc8(%r14), %rax
jb 0x4234e
cmpl $0x0, 0x30(%r14)
je 0x4231e
movq %r14, %rdi
callq 0x3c3a4
movq 0xc0(%r14), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0xc0(%r14)
movb (%... | /ggerganov[P]llama/examples/llava/../../common/stb_image.h |
stbi__zbuild_huffman(stbi__zhuffman*, unsigned char const*, int) | static int stbi__zbuild_huffman(stbi__zhuffman *z, const stbi_uc *sizelist, int num)
{
int i,k=0;
int code, next_code[16], sizes[17];
// DEFLATE spec for generating codes
memset(sizes, 0, sizeof(sizes));
memset(z->fast, 0, sizeof(z->fast));
for (i=0; i < num; ++i)
++sizes[sizelist[i]];
sizes... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r14
pxor %xmm0, %xmm0
movdqa %xmm0, 0x50(%rsp)
movdqa %xmm0, 0x40(%rsp)
movdqa %xmm0, 0x30(%rsp)
movdqa %xmm0, 0x20(%rsp)
movl $0x0, 0x60(%rsp)
movl $0x400, %edx # imm = 0x400
xorl %... | /ggerganov[P]llama/examples/llava/../../common/stb_image.h |
stbi__fill_bits(stbi__zbuf*) | static void stbi__fill_bits(stbi__zbuf *z)
{
do {
if (z->code_buffer >= (1U << z->num_bits)) {
z->zbuffer = z->zbuffer_end; /* treat this as EOF so we fail. */
return;
}
z->code_buffer |= (unsigned int) stbi__zget8(z) << z->num_bits;
z->num_bits += 8;
} while (z->num_bits ... | movl 0x10(%rdi), %ecx
movl 0x18(%rdi), %eax
movl %eax, %edx
shrl %cl, %edx
testl %edx, %edx
jne 0x43390
movq (%rdi), %rsi
xorl %edx, %edx
cmpq 0x8(%rdi), %rsi
jae 0x4337b
leaq 0x1(%rsi), %rdx
movq %rdx, (%rdi)
movzbl (%rsi), %edx
shll %cl, %edx
orl %edx, %eax
movl %eax, 0x18(%rdi)
leal 0x8(%rcx), %edx
movl %edx, 0x10(%... | /ggerganov[P]llama/examples/llava/../../common/stb_image.h |
stbi__load_gif_main_outofmem(stbi__gif*, unsigned char*, int**) | static void *stbi__load_gif_main_outofmem(stbi__gif *g, stbi_uc *out, int **delays)
{
STBI_FREE(g->out);
STBI_FREE(g->history);
STBI_FREE(g->background);
if (out) STBI_FREE(out);
if (delays && *delays) STBI_FREE(*delays);
return stbi__errpuc("outofmem", "Out of memory");
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x8(%rdi), %rdi
callq 0x232f0
movq 0x18(%r15), %rdi
callq 0x232f0
movq 0x10(%r15), %rdi
callq 0x232f0
testq %r14, %r14
je 0x43463
movq %r14, %rdi
callq 0x232f0
testq %rbx, %rbx
je 0x43475
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x43475
... | /ggerganov[P]llama/examples/llava/../../common/stb_image.h |
stbi__hdr_test_core(stbi__context*, char const*) | static int stbi__hdr_test_core(stbi__context *s, const char *signature)
{
int i;
for (i=0; signature[i]; ++i)
if (stbi__get8(s) != signature[i])
return 0;
stbi__rewind(s);
return 1;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb (%rsi), %cl
testb %cl, %cl
je 0x434f9
movq %rsi, %r14
movq 0xc0(%rbx), %rax
incq %r14
cmpq 0xc8(%rbx), %rax
jb 0x434cd
cmpl $0x0, 0x30(%rbx)
je 0x434f5
movq %rbx, %rdi
callq 0x3c3a4
movq 0xc0(%rbx), %rax
leaq 0x1(%rax), %rsi
movq %rsi, 0xc0(%rbx)
movzbl (%rax), %edx... | /ggerganov[P]llama/examples/llava/../../common/stb_image.h |
nlohmann::json_abi_v3_11_3::basic_json<std::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<unsigned char>>, void>::update(nlohmann::... | void update(const_reference j, bool merge_objects = false)
{
update(j.begin(), j.end(), merge_objects);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x28(%rsp), %r12
movq %rsi, (%r12)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%r12)
movabsq $-0x8000000000000000, %rbp # imm = 0x8000000000000000
movq %rbp, 0x18(%r12)
movq %r12, %rdi
callq ... | /ggerganov[P]llama/common/json.hpp |
nlohmann::json_abi_v3_11_3::detail::exception::name(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int) | static std::string name(const std::string& ename, int id_)
{
return concat("[json.exception.", ename, '.', std::to_string(id_), "] ");
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %edx, %r15d
movq %rsi, 0x10(%rsp)
movq %rdi, %rbx
movb $0x2e, 0xf(%rsp)
movl %edx, %ebp
negl %ebp
cmovsl %edx, %ebp
movl $0x1, %r12d
cmpl $0xa, %ebp
jb 0x9940b
movl $0x4, %r12d
movl $0xd1b71759, %eax # imm = 0xD1B71759
movl %e... | /ggerganov[P]llama/common/json.hpp |
nlohmann::json_abi_v3_11_3::detail::parser<nlohmann::json_abi_v3_11_3::basic_json<std::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::allocato... | static ::nlohmann::detail::parser<basic_json, InputAdapterType> parser(
InputAdapterType adapter,
detail::parser_callback_t<basic_json>cb = nullptr,
const bool allow_exceptions = true,
const bool ignore_comments = false
)
{
return ::nlohmann::... | pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movq 0x18(%rdx), %rax
movq %rax, 0x18(%rsp)
movq 0x10(%rdx), %rax
testq %rax, %rax
je 0x996b9
movups (%rdx), %xmm1
addq $0x10, %rdx
movaps %xmm1, (%rsp)
movq %rax, 0x10(%rsp)
movups %xmm0, (%rdx)
movzbl %cl, %ecx
m... | /ggerganov[P]llama/common/json.hpp |
nlohmann::json_abi_v3_11_3::detail::parser<nlohmann::json_abi_v3_11_3::basic_json<std::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::allocato... | void parse(const bool strict, BasicJsonType& result)
{
if (callback)
{
json_sax_dom_callback_parser<BasicJsonType> sdp(result, callback, allow_exceptions);
sax_parse_internal(&sdp);
// in strict mode, input must be completely read
if (strict && (get_t... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1b0, %rsp # imm = 0x1B0
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
cmpq $0x0, 0x10(%rdi)
je 0x99925
leaq 0xa8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x99e24
movzbl 0xc0(%r14), %ecx
leaq 0xc8(%rsp), %rdi
movq %rbx, %rsi
movq %r15, ... | /ggerganov[P]llama/common/json.hpp |
nlohmann::json_abi_v3_11_3::detail::input_stream_adapter::~input_stream_adapter() | ~input_stream_adapter()
{
// clear stream flags; we use underlying streambuf I/O, do not
// maintain ifstream flags, except eof
if (is != nullptr)
{
is->clear(is->rdstate() & std::ios::eofbit);
}
} | pushq %rax
movq (%rdi), %rax
testq %rax, %rax
je 0x99d38
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
leaq (%rax,%rcx), %rdi
movl 0x20(%rax,%rcx), %esi
andl $0x2, %esi
callq 0x249d0
popq %rax
retq
movq %rax, %rdi
callq 0x2c89f
| /ggerganov[P]llama/common/json.hpp |
nlohmann::json_abi_v3_11_3::detail::parser<nlohmann::json_abi_v3_11_3::basic_json<std::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::allocato... | explicit parser(InputAdapterType&& adapter,
const parser_callback_t<BasicJsonType> cb = nullptr,
const bool allow_exceptions_ = true,
const bool skip_comments = false)
: callback(cb)
, m_lexer(std::move(adapter), skip_comments)
, allow_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %r15d
movl %ecx, %ebp
movq %rsi, %r12
movq %rdi, %rbx
movq %rdx, %rsi
callq 0x99e24
movl $0x0, 0x20(%rbx)
leaq 0x28(%rbx), %r14
movups (%r12), %xmm0
movups %xmm0, 0x28(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%r12)
movb %r15b, 0x38(%rbx)
movl $0xffffffff,... | /ggerganov[P]llama/common/json.hpp |
nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<std::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... | token_type scan()
{
// initially, skip the BOM
if (position.chars_read_total == 0 && !skip_bom())
{
error_message = "invalid BOM; must be 0xEF 0xBB 0xBF if given";
return token_type::parse_error;
}
// read next character and ignore whitespace
... | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
cmpq $0x0, 0x20(%rdi)
jne 0x99f21
movq %rbx, %rdi
callq 0x9a0b8
testb %al, %al
je 0x99fe3
movabsq $0x100002600, %r14 # imm = 0x100002600
movq %rbx, %rdi
callq 0x252ac
movl 0x14(%rbx), %eax
cmpq $0x20, %rax
ja 0x99f6b
btq %rax, %r14
jb 0x99f2b
jmp 0x99f6b
movq ... | /ggerganov[P]llama/common/json.hpp |
nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<std::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... | bool scan_comment()
{
switch (get())
{
// single-line comments skip input until a newline or EOF is read
case '/':
{
while (true)
{
switch (get())
{
case '\n':
... | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x252ac
cmpl $0x2f, %eax
je 0x9a13b
cmpl $0x2a, %eax
jne 0x9a158
movq %rbx, %rdi
callq 0x252ac
leal 0x1(%rax), %ecx
cmpl $0x2, %ecx
jb 0x9a161
cmpl $0x2a, %eax
jne 0x9a10f
movq %rbx, %rdi
callq 0x252ac
cmpl $0x2f, %eax
je 0x9a154
movq %rbx, %rdi
callq 0x9a9ca
jmp 0... | /ggerganov[P]llama/common/json.hpp |
nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<std::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... | void unget()
{
next_unget = true;
--position.chars_read_total;
// in case we "unget" a newline, we have to also decrement the lines_read
if (position.chars_read_current_line == 0)
{
if (position.lines_read > 0)
{
--position.lines_read... | movb $0x1, 0x18(%rdi)
decq 0x20(%rdi)
movq 0x28(%rdi), %rax
testq %rax, %rax
je 0x9a9e1
leaq 0x28(%rdi), %rcx
jmp 0x9a9ee
movq 0x30(%rdi), %rax
testq %rax, %rax
je 0x9a9f4
leaq 0x30(%rdi), %rcx
decq %rax
movq %rax, (%rcx)
cmpl $-0x1, 0x14(%rdi)
je 0x9aa0b
movq 0x40(%rdi), %rax
cmpq %rax, 0x38(%rdi)
je 0x9aa0c
decq %rax... | /ggerganov[P]llama/common/json.hpp |
bool nlohmann::json_abi_v3_11_3::detail::parser<nlohmann::json_abi_v3_11_3::basic_json<std::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::all... | bool sax_parse_internal(SAX* sax)
{
// stack to remember the hierarchy of structured values we are parsing
// true = array; false = object
std::vector<bool> states;
// value to avoid a goto (see comment where set to true)
bool skip_to_state_evaluation = false;
while ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorl %eax, %eax
leaq 0xa8(%rsp), %rdx
movq %rax, (%rdx)
movl %eax, 0x8(%rdx)
movq %rax, 0x10(%rdx)
movl %eax, 0x18(%rdx)
movq %rax, 0x20(%rdx)
... | /ggerganov[P]llama/common/json.hpp |
nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<std::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<unsign... | bool end_array()
{
bool keep = true;
if (ref_stack.back())
{
keep = callback(static_cast<int>(ref_stack.size()) - 1, parse_event_t::array_end, *ref_stack.back());
if (keep)
{
ref_stack.back()->set_parents();
}
else
... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %rax
movq -0x8(%rax), %rcx
movb $0x1, %bpl
testq %rcx, %rcx
je 0x9da25
subq 0x8(%rbx), %rax
shrq $0x3, %rax
decl %eax
movl %eax, 0xc(%rsp)
movb $0x3, 0xb(%rsp)
cmpq $0x0, 0x90(%rbx)
je 0x9daed
leaq 0x80(%rbx), %rdi
leaq 0xc(%rsp), %rsi
l... | /ggerganov[P]llama/common/json.hpp |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char const (&) [26], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char>(char const ... | inline OutStringType concat(Args && ... args)
{
OutStringType str;
str.reserve(concat_length(args...));
concat_into(str, std::forward<Args>(args)...);
return str;
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x10(%rdi), %r13
movq %r13, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %rsi, %rdi
callq 0x238c0
movq 0x8(%r15), %rcx
leaq (%rax,%rcx), %rsi
incq %rsi
movq %rbx, %rdi
callq 0x24320
movq... | /ggerganov[P]llama/common/json.hpp |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char const (&) [25], char const*>(char const (&) [25], char const*&&) | inline OutStringType concat(Args && ... args)
{
OutStringType str;
str.reserve(concat_length(args...));
concat_into(str, std::forward<Args>(args)...);
return str;
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %r13
movq %r13, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %rsi, %rdi
callq 0x238c0
movq %rax, %r12
movq (%r14), %rdi
callq 0x238c0
addq %rax, %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x... | /ggerganov[P]llama/common/json.hpp |
std::pair<bool, nlohmann::json_abi_v3_11_3::basic_json<std::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<unsigned char>>, void>*> ... | std::pair<bool, BasicJsonType*> handle_value(Value&& v, const bool skip_callback = false)
{
JSON_ASSERT(!keep_stack.empty());
// do not handle this value if we know it would be added to a discarded
// container
if (!keep_stack.back())
{
return {false, nullptr};
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movl %edx, %ebp
movq 0x30(%rdi), %rax
movl 0x38(%rdi), %ecx
cmpq %rax, 0x20(%rdi)
sete %dl
testl %ecx, %ecx
sete %sil
andb %dl, %sil
cmpb $0x1, %sil
je 0xa0d3b
movl %ecx, %ecx
movabsq $-0x8000000000000000, %r15 # imm = 0x8000000000000000
leaq -0x1(%rcx), %rdx... | /ggerganov[P]llama/common/json.hpp |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char const (&) [12], std::__cxx11::bas... | inline OutStringType concat(Args && ... args)
{
OutStringType str;
str.reserve(concat_length(args...));
concat_into(str, std::forward<Args>(args)...);
return str;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r13
movq %r8, %r14
movq %rcx, %r12
movq %rsi, %rbp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rsp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x8(%rsi), %r15
movq %rdx, 0x10(%rsp)
movq %rdx, %rdi... | /ggerganov[P]llama/common/json.hpp |
nlohmann::json_abi_v3_11_3::detail::serializer<nlohmann::json_abi_v3_11_3::basic_json<std::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::allo... | serializer(output_adapter_t<char> s, const char ichar,
error_handler_t error_handler_ = error_handler_t::strict)
: o(std::move(s))
, loc(std::localeconv())
, thousands_sep(loc->thousands_sep == nullptr ? '\0' : std::char_traits<char>::to_char_type(* (loc->thousands_sep)))
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movl %edx, %r14d
movq %rdi, %rbx
xorl %r15d, %r15d
movq %r15, 0x8(%rdi)
movups (%rsi), %xmm0
movq %r15, 0x8(%rsi)
movups %xmm0, (%rdi)
movq %r15, (%rsi)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
mo... | /ggerganov[P]llama/common/json.hpp |
void nlohmann::json_abi_v3_11_3::detail::serializer<nlohmann::json_abi_v3_11_3::basic_json<std::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:... | void dump_integer(NumberType x)
{
static constexpr std::array<std::array<char, 2>, 100> digits_to_99
{
{
{{'0', '0'}}, {{'0', '1'}}, {{'0', '2'}}, {{'0', '3'}}, {{'0', '4'}}, {{'0', '5'}}, {{'0', '6'}}, {{'0', '7'}}, {{'0', '8'}}, {{'0', '9'}},
{{'1', '0'}... | pushq %rbx
testq %rsi, %rsi
je 0xa4020
movq %rsi, %rcx
leaq 0x10(%rdi), %rsi
cmpq $0xa, %rcx
jae 0xa4031
leaq 0x11(%rdi), %r9
movl $0x1, %r8d
jmp 0xa40fc
movq (%rdi), %rdi
movq (%rdi), %rax
movq (%rax), %rax
movl $0x30, %esi
popq %rbx
jmpq *%rax
movl $0x4, %r9d
movabsq $0x346dc5d63886594b, %r10 # imm = 0x346DC5D6388659... | /ggerganov[P]llama/common/json.hpp |
nlohmann::json_abi_v3_11_3::detail::serializer<nlohmann::json_abi_v3_11_3::basic_json<std::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::allo... | void dump_float(number_float_t x)
{
// NaN / inf
if (!std::isfinite(x))
{
o->write_characters("null", 4);
return;
}
// If number_float_t is an IEEE-754 single or double precision number,
// use the Grisu2 algorithm to produce short numbers whi... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %xmm0, %rax
btrq $0x3f, %rax
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
cmpq %rcx, %rax
jl 0xa4329
movq (%rbx), %rdi
movq (%rdi), %rax
movq 0x8(%rax), %rax
leaq 0xa3b12(%rip), %rsi # 0x147e2d
movl $0x4, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
... | /ggerganov[P]llama/common/json.hpp |
nlohmann::json_abi_v3_11_3::detail::type_error nlohmann::json_abi_v3_11_3::detail::type_error::create<std::nullptr_t, 0>(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::nullptr_t) | static type_error create(int id_, const std::string& what_arg, BasicJsonContext context)
{
const std::string w = concat(exception::name("type_error", id_), exception::diagnostics(context), what_arg);
return {id_, w.c_str()};
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x9d623(%rip), %rsi # 0x141a22
leaq 0x9d626(%rip), %rdx # 0x141a2c
leaq 0x28(%rsp), %rdi
callq 0x2cc94
leaq 0x48(%rsp), %rdi
leaq 0... | /ggerganov[P]llama/common/json.hpp |
void nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2<double>(char*, int&, int&, double) | JSON_HEDLEY_NON_NULL(1)
void grisu2(char* buf, int& len, int& decimal_exponent, FloatType value)
{
static_assert(diyfp::kPrecision >= std::numeric_limits<FloatType>::digits + 3,
"internal error: not enough precision");
JSON_ASSERT(std::isfinite(value));
JSON_ASSERT(value > 0);
// If ... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %xmm0, %rax
btrq $0x3f, %rax
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
cmpq %rcx, %rax
jge 0xa490f
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0xa492b
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x28(%rsp), %r12
movq %r12, %rd... | /ggerganov[P]llama/common/json.hpp |
nlohmann::json_abi_v3_11_3::detail::dtoa_impl::boundaries nlohmann::json_abi_v3_11_3::detail::dtoa_impl::compute_boundaries<double>(double) | boundaries compute_boundaries(FloatType value)
{
JSON_ASSERT(std::isfinite(value));
JSON_ASSERT(value > 0);
// Convert the IEEE representation into a diyfp.
//
// If v is denormal:
// value = 0.F * 2^(1 - bias) = ( F) * 2^(1 - bias - (p-1))
// If v is normalized:
// v... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %xmm0, %rax
movq %rax, %rcx
btrq $0x3f, %rcx
movabsq $0x7ff0000000000000, %rdx # imm = 0x7FF0000000000000
cmpq %rdx, %rcx
jge 0xa4ce4
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0xa4d00
movq %rdi, %rbx
movabsq $0x10000000000000, %r1... | /ggerganov[P]llama/common/json.hpp |
nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::normalize(nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp) | static diyfp normalize(diyfp x) noexcept
{
JSON_ASSERT(x.f != 0);
while ((x.f >> 63u) == 0)
{
x.f <<= 1u;
x.e--;
}
return x;
} | pushq %rax
testq %rdi, %rdi
je 0xa4e69
js 0xa4e62
addq %rdi, %rdi
decl %esi
testq %rdi, %rdi
jns 0xa4e58
movq %rdi, %rax
movl %esi, %edx
popq %rcx
retq
leaq 0x9ba78(%rip), %rdi # 0x1408e8
leaq 0x929b2(%rip), %rdx # 0x137829
leaq 0x9cfc2(%rip), %rcx # 0x141e40
movl $0x42a1, %esi # imm = 0x42A1
xorl... | /ggerganov[P]llama/common/json.hpp |
nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::mul(nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp const&, nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp const&) | static diyfp mul(const diyfp& x, const diyfp& y) noexcept
{
static_assert(kPrecision == 64, "internal error");
// Computes:
// f = round((x.f * y.f) / 2^q)
// e = x.e + y.e + q
// Emulate the 64-bit * 64-bit multiplication:
//
// p = u * v
// = (... | movq (%rdi), %rax
movl %eax, %ecx
shrq $0x20, %rax
movq (%rsi), %r8
movl %r8d, %edx
shrq $0x20, %r8
movq %rdx, %r9
imulq %rcx, %r9
imulq %r8, %rcx
imulq %rax, %rdx
imulq %rax, %r8
shrq $0x20, %r9
movl %ecx, %r10d
addq %r9, %r10
shrq $0x20, %rcx
movl %edx, %eax
addq %r10, %rax
shrq $0x20, %rdx
addq %r8, %rdx
addq %rcx, ... | /ggerganov[P]llama/common/json.hpp |
nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2_round(char*, int, unsigned long, unsigned long, unsigned long, unsigned long) | inline void grisu2_round(char* buf, int len, std::uint64_t dist, std::uint64_t delta,
std::uint64_t rest, std::uint64_t ten_k)
{
JSON_ASSERT(len >= 1);
JSON_ASSERT(dist <= delta);
JSON_ASSERT(rest <= delta);
JSON_ASSERT(ten_k > 0);
// <------------------------... | pushq %rax
testl %esi, %esi
jle 0xa547a
cmpq %rcx, %rdx
ja 0xa5496
movq %rcx, %r10
subq %r8, %r10
jb 0xa54b2
testq %r9, %r9
je 0xa54ce
movq %rdx, %rax
subq %r8, %rax
setbe %r11b
cmpq %r9, %r10
setb %r10b
orb %r11b, %r10b
jne 0xa5457
movl %esi, %esi
addq %r9, %r8
subq %r8, %rcx
movq %rdx, %r10
negq %r10
cmpq %rdx, %r8
j... | /ggerganov[P]llama/common/json.hpp |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char const (&) [6], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char const (&) [12... | inline OutStringType concat(Args && ... args)
{
OutStringType str;
str.reserve(concat_length(args...));
concat_into(str, std::forward<Args>(args)...);
return str;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x10(%rdi), %rbp
movq %rbp, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %rsi, %rdi
callq 0x238c0
movq %rax, %r13
addq 0x8(%r15), %r13
movq %r14, %rdi
callq 0x238c0... | /ggerganov[P]llama/common/json.hpp |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> nlohmann::json_abi_v3_11_3::basic_json<std::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:... | const noexcept(noexcept(
JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>(), std::declval<ValueType&>())))
{
auto ret = ValueType();
JSONSerializer<ValueType>::from_json(*this, ret);
return ret;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %rsi, %rdi
movq %rbx, %rsi
callq 0xa56cf
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0xa56c7
movq (%r15), %rsi
incq %rsi
ca... | /ggerganov[P]llama/common/json.hpp |
void nlohmann::json_abi_v3_11_3::detail::from_json<nlohmann::json_abi_v3_11_3::basic_json<std::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::... | inline void from_json(const BasicJsonType& j, typename BasicJsonType::string_t& s)
{
if (JSON_HEDLEY_UNLIKELY(!j.is_string()))
{
JSON_THROW(type_error::create(302, concat("type must be string, but is ", j.type_name()), &j));
}
s = *j.template get_ptr<const typename BasicJsonType::string_t*>();
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %r14
cmpb $0x3, (%rdi)
jne 0xa56f6
movq 0x8(%r14), %rax
movq %rsi, %rdi
movq %rax, %rsi
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x24a00
movl $0x20, %edi
callq 0x23880
movq %rax, %rbx
movq %r14, %rdi
callq 0x9fce2
leaq 0x8(%rsp), %rdx
movq %rax, (%r... | /ggerganov[P]llama/common/json.hpp |
nlohmann::json_abi_v3_11_3::detail::type_error nlohmann::json_abi_v3_11_3::detail::type_error::create<nlohmann::json_abi_v3_11_3::basic_json<std::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_... | static type_error create(int id_, const std::string& what_arg, BasicJsonContext context)
{
const std::string w = concat(exception::name("type_error", id_), exception::diagnostics(context), what_arg);
return {id_, w.c_str()};
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x9c26d(%rip), %rsi # 0x141a22
leaq 0x9c270(%rip), %rdx # 0x141a2c
leaq 0x28(%rsp), %rdi
callq 0x2cc94
leaq 0x48(%rsp), %rdi
leaq 0... | /ggerganov[P]llama/common/json.hpp |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char const (&) [29], char const*>(char const (&) [29], char const*&&) | inline OutStringType concat(Args && ... args)
{
OutStringType str;
str.reserve(concat_length(args...));
concat_into(str, std::forward<Args>(args)...);
return str;
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %r13
movq %r13, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %rsi, %rdi
callq 0x238c0
movq %rax, %r12
movq (%r14), %rdi
callq 0x238c0
addq %rax, %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x... | /ggerganov[P]llama/common/json.hpp |
nlohmann::json_abi_v3_11_3::basic_json<std::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<unsigned char>>, void>::update(nlohmann::... | void update(const_iterator first, const_iterator last, bool merge_objects = false)
{
// implicitly convert null value to an empty object
if (is_null())
{
m_data.m_type = value_t::object;
m_data.m_value.object = create<object_t>();
assert_invariant();
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movb (%rdi), %al
testb %al, %al
jne 0xa5b17
movb $0x1, (%rbx)
movl $0x30, %edi
callq 0x23280
leaq 0x8(%rax), %rcx
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
xorl %edx, %edx
mov... | /ggerganov[P]llama/common/json.hpp |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char const (&) [26], char const*>(char const (&) [26], char const*&&) | inline OutStringType concat(Args && ... args)
{
OutStringType str;
str.reserve(concat_length(args...));
concat_into(str, std::forward<Args>(args)...);
return str;
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %r13
movq %r13, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %rsi, %rdi
callq 0x238c0
movq %rax, %r12
movq (%r14), %rdi
callq 0x238c0
addq %rax, %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x... | /ggerganov[P]llama/common/json.hpp |
nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::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::alloc... | iter_impl& operator++()
{
JSON_ASSERT(m_object != nullptr);
switch (m_object->m_data.m_type)
{
case value_t::object:
{
std::advance(m_it.object_iterator, 1);
break;
}
case value_t::array:
{
... | pushq %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0xa5f48
movq %rdi, %rbx
movzbl (%rax), %eax
cmpl $0x2, %eax
je 0xa5f38
cmpl $0x1, %eax
jne 0xa5f3f
movq 0x8(%rbx), %rdi
callq 0x246a0
movq %rax, 0x8(%rbx)
jmp 0xa5f43
addq $0x10, 0x10(%rbx)
jmp 0xa5f43
incq 0x18(%rbx)
movq %rbx, %rax
popq %rbx
retq
leaq 0x9a999(%rip), %r... | /ggerganov[P]llama/common/json.hpp |
bool nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::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::... | bool operator==(const IterImpl& other) const
{
// if objects are not the same, the comparison is undefined
if (JSON_HEDLEY_UNLIKELY(m_object != other.m_object))
{
JSON_THROW(invalid_iterator::create(212, "cannot compare iterators of different containers", m_object));
}
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
movq (%rdi), %rax
cmpq (%rsi), %rax
jne 0xa5fbf
testq %rax, %rax
je 0xa601d
movzbl (%rax), %eax
cmpl $0x2, %eax
je 0xa5f9f
cmpl $0x1, %eax
jne 0xa5fa9
movq 0x8(%r14), %rax
cmpq 0x8(%rsi), %rax
jmp 0xa5fb1
movq 0x10(%r14), %rax
cmpq 0x10(%rsi),... | /ggerganov[P]llama/common/json.hpp |
nlohmann::json_abi_v3_11_3::detail::invalid_iterator nlohmann::json_abi_v3_11_3::detail::invalid_iterator::create<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::jso... | static invalid_iterator create(int id_, const std::string& what_arg, BasicJsonContext context)
{
const std::string w = concat(exception::name("invalid_iterator", id_), exception::diagnostics(context), what_arg);
return {id_, w.c_str()};
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x9b896(%rip), %rsi # 0x141931
leaq 0x9b89f(%rip), %rdx # 0x141941
leaq 0x28(%rsp), %rdi
callq 0x2cc94
leaq 0x48(%rsp), %rdi
leaq 0... | /ggerganov[P]llama/common/json.hpp |
nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<std::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::alloca... | value_type moved_or_copied() const
{
if (value_ref == nullptr)
{
return std::move(owned_value);
}
return *value_ref;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %rsi
testq %rsi, %rsi
je 0xa67df
movq %rbx, %rdi
callq 0x9e7d0
jmp 0xa6809
movups (%r14), %xmm0
movups %xmm0, (%rbx)
movq %r14, %rdi
xorl %esi, %esi
callq 0x99206
movb $0x0, (%r14)
movq $0x0, 0x8(%r14)
movq %rbx, %rdi
movl $0x1, %esi
call... | /ggerganov[P]llama/common/json.hpp |
nlohmann::json_abi_v3_11_3::basic_json<std::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<unsigned char>>, void>::operator[](unsign... | const_reference operator[](size_type idx) const
{
// const operator[] only works for arrays
if (JSON_HEDLEY_LIKELY(is_array()))
{
return m_data.m_value.array->operator[](idx);
}
JSON_THROW(type_error::create(305, detail::concat("cannot use operator[] with a numer... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %r14
cmpb $0x2, (%rdi)
jne 0xa69e3
movq 0x8(%r14), %rax
shlq $0x4, %rsi
addq (%rax), %rsi
movq %rsi, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x20, %edi
callq 0x23880
movq %rax, %rbx
movq %r14, %rdi
callq 0x9fce2
leaq 0x8(%rsp), %rdx
mov... | /ggerganov[P]llama/common/json.hpp |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char const (&) [52], char const*>(char const (&) [52], char const*&&) | inline OutStringType concat(Args && ... args)
{
OutStringType str;
str.reserve(concat_length(args...));
concat_into(str, std::forward<Args>(args)...);
return str;
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %r13
movq %r13, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %rsi, %rdi
callq 0x238c0
movq %rax, %r12
movq (%r14), %rdi
callq 0x238c0
addq %rax, %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x... | /ggerganov[P]llama/common/json.hpp |
nlohmann::json_abi_v3_11_3::basic_json<std::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<unsigned char>>, void>::basic_json<nlohma... | basic_json(const JsonRef& ref) : basic_json(ref.moved_or_copied()) {} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xa67c2
movups (%r14), %xmm0
movups %xmm0, (%rbx)
movq %r14, %rdi
xorl %esi, %esi
callq 0x99206
movb $0x0, (%r14)
movq $0x0, 0x8(%r14)
movq %rbx, %rdi
movl $0x1, %esi
callq 0x99206
movq %r14, %rdi
xorl %esi, %esi
callq 0x9... | /ggerganov[P]llama/common/json.hpp |
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<unsigned c... | JSON_HEDLEY_WARN_UNUSED_RESULT
static basic_json parse(InputType&& i,
const parser_callback_t cb = nullptr,
const bool allow_exceptions = true,
const bool ignore_comments = false)
{
basic_json result;
parser(deta... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r13
movq %rsi, %r12
movq %rdi, %rbx
movb $0x0, (%rdi)
movq $0x0, 0x8(%rdi)
movl $0x1, %esi
callq 0xaa84a
movq %rbx, %rdi
movl $0x1, %esi
callq 0xaa84a
movq (%r12), %r15
movq 0x8(%r12), %r12
mo... | /ggerganov[P]llama/common/json.hpp |
nlohmann::json_abi_v3_11_3::detail::parser<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::vect... | static ::nlohmann::detail::parser<basic_json, InputAdapterType> parser(
InputAdapterType adapter,
detail::parser_callback_t<basic_json>cb = nullptr,
const bool allow_exceptions = true,
const bool ignore_comments = false
)
{
return ::nlohmann::... | pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq %rsi, 0x20(%rsp)
movq %rdx, 0x28(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movq 0x18(%rcx), %rax
movq %rax, 0x18(%rsp)
movq 0x10(%rcx), %rax
testq %rax, %rax
je 0xaa187
movups (%rcx), %xmm1
addq $0x10, %rcx
movaps %xmm1, (%rsp)
movq %rax, 0x10(%... | /ggerganov[P]llama/common/json.hpp |
nlohmann::json_abi_v3_11_3::detail::parser<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::vect... | void parse(const bool strict, BasicJsonType& result)
{
if (callback)
{
json_sax_dom_callback_parser<BasicJsonType> sdp(result, callback, allow_exceptions);
sax_parse_internal(&sdp);
// in strict mode, input must be completely read
if (strict && (get_t... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1b0, %rsp # imm = 0x1B0
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
cmpq $0x0, 0x10(%rdi)
je 0xaa457
leaq 0xa8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xaa1ec
movzbl 0xc0(%r14), %ecx
leaq 0xc8(%rsp), %rdi
movq %rbx, %rsi
movq %r15, ... | /ggerganov[P]llama/common/json.hpp |
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<unsigned c... | json_value(value_t t)
{
switch (t)
{
case value_t::object:
{
object = create<object_t>();
break;
}
case value_t::array:
{
array = create<array_t>()... | pushq %rbx
movq %rdi, %rbx
cmpl $0x8, %esi
ja 0xaa905
movl %esi, %eax
leaq 0x8f64c(%rip), %rcx # 0x139f48
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq $0x0, (%rbx)
jmp 0xaa95d
movl $0x20, %edi
jmp 0xaa91f
movb $0x0, (%rbx)
jmp 0xaa95d
movl $0x18, %edi
callq 0x23280
xorps %xmm0, %xmm0
movups %xmm0, (%r... | /ggerganov[P]llama/common/json.hpp |
nlohmann::json_abi_v3_11_3::detail::parser<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::vect... | explicit parser(InputAdapterType&& adapter,
const parser_callback_t<BasicJsonType> cb = nullptr,
const bool allow_exceptions_ = true,
const bool skip_comments = false)
: callback(cb)
, m_lexer(std::move(adapter), skip_comments)
, allow_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %r15d
movl %ecx, %ebp
movq %rsi, %r12
movq %rdi, %rbx
movq %rdx, %rsi
callq 0xaa1ec
movl $0x0, 0x20(%rbx)
leaq 0x28(%rbx), %r14
movups (%r12), %xmm0
movups %xmm0, 0x28(%rbx)
movb %r15b, 0x38(%rbx)
movl $0xffffffff, 0x3c(%rbx) # imm = 0xFFFFFFFF
xorl %eax... | /ggerganov[P]llama/common/json.hpp |
nlohmann::json_abi_v3_11_3::detail::lexer<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::vecto... | ~lexer() = default; | pushq %rbx
movq %rdi, %rbx
movq 0x50(%rdi), %rdi
leaq 0x60(%rbx), %rax
cmpq %rax, %rdi
je 0xaaaae
movq (%rax), %rsi
incq %rsi
callq 0x231e0
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0xaaac4
movq 0x48(%rbx), %rsi
subq %rdi, %rsi
popq %rbx
jmp 0x231e0
popq %rbx
retq
| /ggerganov[P]llama/common/json.hpp |
nlohmann::json_abi_v3_11_3::detail::lexer<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::vecto... | token_type scan()
{
// initially, skip the BOM
if (position.chars_read_total == 0 && !skip_bom())
{
error_message = "invalid BOM; must be 0xEF 0xBB 0xBF if given";
return token_type::parse_error;
}
// read next character and ignore whitespace
... | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
cmpq $0x0, 0x20(%rdi)
jne 0xaab2b
movq %rbx, %rdi
callq 0xaacc2
testb %al, %al
je 0xaabed
movabsq $0x100002600, %r14 # imm = 0x100002600
movq %rbx, %rdi
callq 0x2535c
movl 0x14(%rbx), %eax
cmpq $0x20, %rax
ja 0xaab75
btq %rax, %r14
jb 0xaab35
jmp 0xaab75
movq ... | /ggerganov[P]llama/common/json.hpp |
nlohmann::json_abi_v3_11_3::detail::lexer<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::vecto... | bool skip_bom()
{
if (get() == 0xEF)
{
// check if we completely parse the BOM
return get() == 0xBB && get() == 0xBF;
}
// the first character is not the beginning of the BOM; unget it to
// process is later
unget();
return true;
} | pushq %rbx
movq %rdi, %rbx
callq 0x2535c
cmpl $0xef, %eax
je 0xaacde
movq %rbx, %rdi
callq 0xab5d4
movb $0x1, %al
popq %rbx
retq
movq %rbx, %rdi
callq 0x2535c
cmpl $0xbb, %eax
je 0xaacf1
xorl %eax, %eax
jmp 0xaacdc
movq %rbx, %rdi
callq 0x2535c
cmpl $0xbf, %eax
sete %al
jmp 0xaacdc
nop
| /ggerganov[P]llama/common/json.hpp |
nlohmann::json_abi_v3_11_3::detail::lexer<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::vecto... | bool scan_comment()
{
switch (get())
{
// single-line comments skip input until a newline or EOF is read
case '/':
{
while (true)
{
switch (get())
{
case '\n':
... | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x2535c
cmpl $0x2f, %eax
je 0xaad45
cmpl $0x2a, %eax
jne 0xaad62
movq %rbx, %rdi
callq 0x2535c
leal 0x1(%rax), %ecx
cmpl $0x2, %ecx
jb 0xaad6b
cmpl $0x2a, %eax
jne 0xaad19
movq %rbx, %rdi
callq 0x2535c
cmpl $0x2f, %eax
je 0xaad5e
movq %rbx, %rdi
callq 0xab5d4
jmp 0... | /ggerganov[P]llama/common/json.hpp |
nlohmann::json_abi_v3_11_3::detail::lexer<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::vecto... | token_type scan_string()
{
// reset token_buffer (ignore opening quote)
reset();
// we entered the function by reading an open quote
JSON_ASSERT(current == '\"');
while (true)
{
// get next character
switch (get())
{
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
callq 0xab638
cmpl $0x22, 0x14(%rbx)
jne 0xab231
leaq 0x50(%rbx), %r14
leaq 0x95ed5(%rip), %r12 # 0x140cfc
leaq 0x8f1a2(%rip), %r13 # 0x139fd0
movq %rbx, %rdi
callq 0x2535c
incl %eax
cmpl $0xf5, %eax
ja 0xab200
mo... | /ggerganov[P]llama/common/json.hpp |
nlohmann::json_abi_v3_11_3::detail::lexer<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::vecto... | token_type scan_number() // lgtm [cpp/use-of-goto]
{
// reset token_buffer to store the number's bytes
reset();
// the type of the parsed number; initially set to unsigned; will be
// changed if minus sign, decimal point or exponent is read
token_type number_type = token_ty... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0xab638
movl 0x14(%rbx), %eax
leal -0x31(%rax), %ecx
cmpl $0x9, %ecx
jae 0xab3b2
leaq 0x50(%rbx), %r14
movl $0x5, %ebp
movsbl %al, %esi
movq %r14, %rdi
callq 0x24ad0
leaq 0x50(%rbx), %r14
movq %rbx, %rdi
callq 0x2535c
leal -0x30(%rax), %ecx
cm... | /ggerganov[P]llama/common/json.hpp |
nlohmann::json_abi_v3_11_3::detail::lexer<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::vecto... | void unget()
{
next_unget = true;
--position.chars_read_total;
// in case we "unget" a newline, we have to also decrement the lines_read
if (position.chars_read_current_line == 0)
{
if (position.lines_read > 0)
{
--position.lines_read... | movb $0x1, 0x18(%rdi)
decq 0x20(%rdi)
movq 0x28(%rdi), %rax
testq %rax, %rax
je 0xab5eb
leaq 0x28(%rdi), %rcx
jmp 0xab5f8
movq 0x30(%rdi), %rax
testq %rax, %rax
je 0xab5fe
leaq 0x30(%rdi), %rcx
decq %rax
movq %rax, (%rcx)
cmpl $-0x1, 0x14(%rdi)
je 0xab615
movq 0x40(%rdi), %rax
cmpq %rax, 0x38(%rdi)
je 0xab616
decq %rax... | /ggerganov[P]llama/common/json.hpp |
nlohmann::json_abi_v3_11_3::detail::lexer<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::vecto... | void reset() noexcept
{
token_buffer.clear();
token_string.clear();
token_string.push_back(char_traits<char_type>::to_char_type(current));
} | pushq %rax
movq %rdi, %rax
movq $0x0, 0x58(%rdi)
movq 0x50(%rdi), %rcx
movb $0x0, (%rcx)
addq $0x38, %rdi
movq 0x38(%rax), %rcx
cmpq %rcx, 0x40(%rax)
je 0xab65d
movq %rcx, 0x40(%rax)
movb 0x14(%rax), %al
leaq 0x7(%rsp), %rsi
movb %al, (%rsi)
callq 0x576a8
popq %rax
retq
movq %rax, %rdi
callq 0x2c89f
| /ggerganov[P]llama/common/json.hpp |
nlohmann::json_abi_v3_11_3::detail::lexer<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::vecto... | int get_codepoint()
{
// this function only makes sense after reading `\u`
JSON_ASSERT(current == 'u');
int codepoint = 0;
const auto factors = { 12u, 8u, 4u, 0u };
for (const auto factor : factors)
{
get();
if (current >= '0' && current <= '... | pushq %rbx
subq $0x10, %rsp
cmpl $0x75, 0x14(%rdi)
jne 0xab69a
leaq 0x14(%rdi), %rsi
leaq 0xc(%rsp), %rbx
movq %rbx, %rdx
callq 0x25ad8
movl (%rbx), %eax
addq $0x10, %rsp
popq %rbx
retq
leaq 0x95247(%rip), %rdi # 0x1408e8
leaq 0x8c181(%rip), %rdx # 0x137829
leaq 0x95f5b(%rip), %rcx # 0x14160a
movl $0x1d79, ... | /ggerganov[P]llama/common/json.hpp |
nlohmann::json_abi_v3_11_3::detail::lexer<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::vecto... | bool next_byte_in_range(std::initializer_list<char_int_type> ranges)
{
JSON_ASSERT(ranges.size() == 2 || ranges.size() == 4 || ranges.size() == 6);
add(current);
for (auto range = ranges.begin(); range != ranges.end(); ++range)
{
get();
if (JSON_HEDLEY_LIKELY... | pushq %rbx
subq $0x10, %rsp
cmpq $0x6, %rdx
ja 0xab6e9
movl $0x54, %eax
btq %rdx, %rax
jae 0xab6e9
leaq 0xf(%rsp), %rbx
movq %rbx, %rcx
callq 0x25b86
movb (%rbx), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbx
retq
leaq 0x951f8(%rip), %rdi # 0x1408e8
leaq 0x8c132(%rip), %rdx # 0x137829
leaq 0x95f46(%rip), %rcx ... | /ggerganov[P]llama/common/json.hpp |
nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<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... | json_sax_dom_callback_parser(BasicJsonType& r,
const parser_callback_t cb,
const bool allow_exceptions_ = true)
: root(r), callback(cb), allow_exceptions(allow_exceptions_)
{
keep_stack.push_back(true);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdi, %rbx
movq %rsi, (%rdi)
leaq 0x20(%rdi), %r14
leaq 0x80(%rdi), %r12
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movups %xmm0, 0x18(%rdi)
movups %xmm0, 0x28(%rdi)
movups %xmm0, 0x38(%rdi)
movups %xmm0, 0x48(%rdi)
movups... | /ggerganov[P]llama/common/json.hpp |
nlohmann::json_abi_v3_11_3::detail::lexer<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::vecto... | std::string get_token_string() const
{
// escape control characters
std::string result;
for (const auto c : token_string)
{
if (static_cast<unsigned char>(c) <= '\x1F')
{
// escape control characters
std::array<char, 9> cs{{}};
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x38(%rsi), %r13
movq 0x40(%rsi), %rbp
cmpq %rbp, %r13
je 0xac68d
leaq 0x95426(%rip), %r14 # 0x141a64
leaq 0x8(%rsp), %r15
movzbl... | /ggerganov[P]llama/common/json.hpp |
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<unsigned c... | basic_json& operator=(basic_json other) noexcept (
std::is_nothrow_move_constructible<value_t>::value&&
std::is_nothrow_move_assignable<value_t>::value&&
std::is_nothrow_move_constructible<json_value>::value&&
std::is_nothrow_move_assignable<json_value>::value&&
std::is_nothrow_m... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
movl $0x1, %esi
callq 0xaa84a
movb (%r14), %al
movb (%rbx), %cl
movb %cl, (%r14)
movb %al, (%rbx)
movq 0x8(%r14), %rax
movq 0x8(%rbx), %rcx
movq %rcx, 0x8(%r14)
movq %rax, 0x8(%rbx)
movq %r14, %rdi
movl $0x1, %esi
callq 0xaa84a
movq %r14, ... | /ggerganov[P]llama/common/json.hpp |
nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<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... | ~json_sax_dom_callback_parser() = default; | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xa8(%rdi), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0xaa84a
movq %r14, %rdi
callq 0xaeed2
movq 0x90(%rbx), %rax
testq %rax, %rax
je 0xaca3d
leaq 0x80(%rbx), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
leaq 0x48(%rbx), %rdi
callq 0x9d0c4
leaq 0x20(%rbx), %rdi... | /ggerganov[P]llama/common/json.hpp |
bool nlohmann::json_abi_v3_11_3::detail::parser<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:... | bool sax_parse_internal(SAX* sax)
{
// stack to remember the hierarchy of structured values we are parsing
// true = array; false = object
std::vector<bool> states;
// value to avoid a goto (see comment where set to true)
bool skip_to_state_evaluation = false;
while ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorl %eax, %eax
leaq 0xb0(%rsp), %rdx
movq %rax, (%rdx)
movl %eax, 0x8(%rdx)
movq %rax, 0x10(%rdx)
movl %eax, 0x18(%rdx)
movq %rax, 0x20(%rdx)
... | /ggerganov[P]llama/common/json.hpp |
nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<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... | bool end_object()
{
if (ref_stack.back())
{
if (!callback(static_cast<int>(ref_stack.size()) - 1, parse_event_t::object_end, *ref_stack.back()))
{
// discard object
*ref_stack.back() = discarded;
}
else
{
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %rax
movq -0x8(%rax), %rcx
testq %rcx, %rcx
je 0xadb04
subq 0x8(%rbx), %rax
shrq $0x3, %rax
decl %eax
movl %eax, 0x28(%rsp)
movb $0x1, 0x8(%rsp)
cmpq $0x0, 0x90(%rbx)
je 0xadcaf
leaq 0x80(%rbx), %rdi
leaq... | /ggerganov[P]llama/common/json.hpp |
nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<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... | bool end_array()
{
bool keep = true;
if (ref_stack.back())
{
keep = callback(static_cast<int>(ref_stack.size()) - 1, parse_event_t::array_end, *ref_stack.back());
if (keep)
{
ref_stack.back()->set_parents();
}
else
... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %rax
movq -0x8(%rax), %rcx
movb $0x1, %bpl
testq %rcx, %rcx
je 0xae03d
subq 0x8(%rbx), %rax
shrq $0x3, %rax
decl %eax
movl %eax, 0xc(%rsp)
movb $0x3, 0xb(%rsp)
cmpq $0x0, 0x90(%rbx)
je 0xae105
leaq 0x80(%rbx), %rdi
leaq 0xc(%rsp), %rsi
l... | /ggerganov[P]llama/common/json.hpp |
std::pair<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::allo... | std::pair<bool, BasicJsonType*> handle_value(Value&& v, const bool skip_callback = false)
{
JSON_ASSERT(!keep_stack.empty());
// do not handle this value if we know it would be added to a discarded
// container
if (!keep_stack.back())
{
return {false, nullptr};
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movl %edx, %ebp
movq %rdi, %rbx
movq 0x30(%rdi), %rax
movl 0x38(%rdi), %ecx
cmpq %rax, 0x20(%rdi)
sete %dl
testl %ecx, %ecx
sete %dil
andb %dl, %dil
cmpb $0x1, %dil
je 0xae3ee
movl %ecx, %ecx
movabsq $-0x8000000000000000, %r14 # imm = 0x8000000000000000
leaq ... | /ggerganov[P]llama/common/json.hpp |
nlohmann::json_abi_v3_11_3::detail::out_of_range nlohmann::json_abi_v3_11_3::detail::out_of_range::create<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::a... | static out_of_range create(int id_, const std::string& what_arg, BasicJsonContext context)
{
const std::string w = concat(exception::name("out_of_range", id_), exception::diagnostics(context), what_arg);
return {id_, w.c_str()};
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x9341f(%rip), %rsi # 0x1418d0
leaq 0x93424(%rip), %rdx # 0x1418dc
leaq 0x28(%rsp), %rdi
callq 0x2cc94
leaq 0x48(%rsp), %rdi
leaq 0... | /ggerganov[P]llama/common/json.hpp |
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<unsigned c... | size_type size() const noexcept
{
switch (m_data.m_type)
{
case value_t::null:
{
// null values are empty
return 0;
}
case value_t::array:
{
// delegate call to array_t::size()
... | movzbl (%rdi), %eax
testl %eax, %eax
je 0xaea04
cmpl $0x1, %eax
je 0xae9e1
cmpl $0x2, %eax
jne 0xae9ff
movq 0x8(%rdi), %rcx
movq 0x8(%rcx), %rax
subq (%rcx), %rax
sarq $0x4, %rax
retq
movq 0x8(%rdi), %rax
movq 0x8(%rax), %rcx
subq (%rax), %rcx
sarq $0x4, %rcx
movabsq $-0x5555555555555555, %rax # imm = 0xAAAAAAAAAAAAAAA... | /ggerganov[P]llama/common/json.hpp |
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<unsigned c... | basic_json(const basic_json& other)
: json_base_class_t(other)
{
m_data.m_type = other.m_data.m_type;
// check of passed value is valid
other.assert_invariant();
switch (m_data.m_type)
{
case value_t::object:
{
m_data.m_value =... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movb (%rsi), %al
movb %al, (%rdi)
movq %rsi, %rdi
movl $0x1, %esi
callq 0xaa84a
movzbl (%rbx), %eax
decl %eax
cmpl $0x7, %eax
ja 0xaea7c
leaq 0x8ba08(%rip), %rcx # 0x13a440
movslq (%rcx,%rax,4), %rax
addq %rcx, ... | /ggerganov[P]llama/common/json.hpp |
nlohmann::json_abi_v3_11_3::detail::iter_impl<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::v... | pointer operator->() const
{
JSON_ASSERT(m_object != nullptr);
switch (m_object->m_data.m_type)
{
case value_t::object:
{
JSON_ASSERT(m_it.object_iterator != m_object->m_data.m_value.object->end());
return &(m_it.object_iterator->secon... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq (%rdi), %rax
testq %rax, %rax
je 0xaeb85
movq %rdi, %r14
movzbl (%rax), %ecx
cmpl $0x2, %ecx
je 0xaeae8
cmpl $0x1, %ecx
jne 0xaeb15
movq 0x8(%rax), %rcx
movq 0x8(%r14), %rax
cmpq 0x8(%rcx), %rax
je 0xaeba1
addq $0x20, %rax
jmp 0xaeb1c
movq 0x8(%rax), %rc... | /ggerganov[P]llama/common/json.hpp |
nlohmann::json_abi_v3_11_3::detail::iter_impl<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::v... | IteratorType erase(IteratorType pos)
{
// make sure iterator fits the current value
if (JSON_HEDLEY_UNLIKELY(this != pos.m_object))
{
JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value", this));
}
IteratorType result = end();
s... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
cmpq %rsi, (%rdx)
jne 0xaed15
movq %rdx, %r15
movq %rdi, %rbx
movq %r14, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
movq %rax, 0x18(%rdi)
callq 0xafbb8
movzbl (%r1... | /ggerganov[P]llama/common/json.hpp |
nlohmann::json_abi_v3_11_3::detail::iter_impl<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::v... | iter_impl& operator++()
{
JSON_ASSERT(m_object != nullptr);
switch (m_object->m_data.m_type)
{
case value_t::object:
{
std::advance(m_it.object_iterator, 1);
break;
}
case value_t::array:
{
... | movq (%rdi), %rax
testq %rax, %rax
je 0xaeeaf
movzbl (%rax), %eax
cmpl $0x2, %eax
je 0xaeea0
cmpl $0x1, %eax
jne 0xaeea7
addq $0x30, 0x8(%rdi)
jmp 0xaeeab
addq $0x10, 0x10(%rdi)
jmp 0xaeeab
incq 0x18(%rdi)
movq %rdi, %rax
retq
pushq %rax
leaq 0x91a31(%rip), %rdi # 0x1408e8
leaq 0x8896b(%rip), %rdx # 0x137829
le... | /ggerganov[P]llama/common/json.hpp |
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<unsigned c... | void destroy(value_t t)
{
if (
(t == value_t::object && object == nullptr) ||
(t == value_t::array && array == nullptr) ||
(t == value_t::string && string == nullptr) ||
(t == value_t::binary && binary == nullptr)
)
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
cmpl $0x1, %esi
sete %cl
movq (%rdi), %rax
testq %rax, %rax
sete %dl
testb %dl, %cl
jne 0xaf5c0
movl %esi, %r14d
testq %rax, %rax
sete %cl
movl %r14d, %edx
andb $-0x2, %dl
cmpb $0x2, %dl
sete %dl
cmpb $0x8, %r14b
sete %sil
orb %dl, %sil
... | /ggerganov[P]llama/common/json.hpp |
nlohmann::json_abi_v3_11_3::detail::type_error nlohmann::json_abi_v3_11_3::detail::type_error::create<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::alloc... | static type_error create(int id_, const std::string& what_arg, BasicJsonContext context)
{
const std::string w = concat(exception::name("type_error", id_), exception::diagnostics(context), what_arg);
return {id_, w.c_str()};
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x91ddb(%rip), %rsi # 0x141a22
leaq 0x91dde(%rip), %rdx # 0x141a2c
leaq 0x28(%rsp), %rdi
callq 0x2cc94
leaq 0x48(%rsp), %rdi
leaq 0... | /ggerganov[P]llama/common/json.hpp |
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<unsigned c... | JSON_HEDLEY_RETURNS_NON_NULL
const char* type_name() const noexcept
{
switch (m_data.m_type)
{
case value_t::null:
return "null";
case value_t::object:
return "object";
case value_t::array:
return "array";
... | movzbl (%rdi), %eax
cmpq $0x9, %rax
ja 0xafe03
leaq 0xde0a2(%rip), %rcx # 0x18dea0
movq (%rcx,%rax,8), %rax
retq
leaq 0x91c3c(%rip), %rax # 0x141a46
retq
nop
| /ggerganov[P]llama/common/json.hpp |
nlohmann::json_abi_v3_11_3::ordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 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, ... | iterator erase(iterator first, iterator last)
{
if (first == last)
{
return first;
}
const auto elements_affected = std::distance(first, last);
const auto offset = std::distance(Container::begin(), first);
// This is the start situation. We need to delet... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
cmpq %rdx, %rsi
je 0xafed6
movq %rdx, %r15
movq %rdi, %r14
movq %rdx, %rax
subq %rbx, %rax
sarq $0x4, %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %rax
movq %rax, 0x10(%rsp)
movq (%rdi), ... | /ggerganov[P]llama/common/json.hpp |
nlohmann::json_abi_v3_11_3::ordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 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, ... | T& operator[](const key_type& key)
{
return emplace(key, T{}).first->second;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsp, %r15
movb $0x0, (%r15)
movq $0x0, 0x8(%r15)
movq %r15, %rdi
movl $0x1, %esi
callq 0xaa84a
movq %r15, %rdi
movl $0x1, %esi
callq 0xaa84a
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0xb0444
movq %rax, %rbx
addq $0x20, %... | /ggerganov[P]llama/common/json.hpp |
std::pair<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::allo... | std::pair<bool, BasicJsonType*> handle_value(Value&& v, const bool skip_callback = false)
{
JSON_ASSERT(!keep_stack.empty());
// do not handle this value if we know it would be added to a discarded
// container
if (!keep_stack.back())
{
return {false, nullptr};
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movl %edx, %ebp
movq %rdi, %rbx
movq 0x30(%rdi), %rax
movl 0x38(%rdi), %ecx
cmpq %rax, 0x20(%rdi)
sete %dl
testl %ecx, %ecx
sete %dil
andb %dl, %dil
cmpb $0x1, %dil
je 0xb0a09
movl %ecx, %ecx
movabsq $-0x8000000000000000, %r15 # imm = 0x8000000000000000
leaq ... | /ggerganov[P]llama/common/json.hpp |
std::pair<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::allo... | std::pair<bool, BasicJsonType*> handle_value(Value&& v, const bool skip_callback = false)
{
JSON_ASSERT(!keep_stack.empty());
// do not handle this value if we know it would be added to a discarded
// container
if (!keep_stack.back())
{
return {false, nullptr};
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movl %edx, %ebp
movq %rdi, %rbx
movq 0x30(%rdi), %rax
movl 0x38(%rdi), %ecx
cmpq %rax, 0x20(%rdi)
sete %dl
testl %ecx, %ecx
sete %dil
andb %dl, %dil
cmpb $0x1, %dil
je 0xb0d88
movl %ecx, %ecx
movabsq $-0x8000000000000000, %r15 # imm = 0x8000000000000000
leaq ... | /ggerganov[P]llama/common/json.hpp |
std::pair<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::allo... | std::pair<bool, BasicJsonType*> handle_value(Value&& v, const bool skip_callback = false)
{
JSON_ASSERT(!keep_stack.empty());
// do not handle this value if we know it would be added to a discarded
// container
if (!keep_stack.back())
{
return {false, nullptr};
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movl %edx, %ebp
movq 0x30(%rdi), %rax
movl 0x38(%rdi), %ecx
cmpq %rax, 0x20(%rdi)
sete %dl
testl %ecx, %ecx
sete %sil
andb %dl, %sil
cmpb $0x1, %sil
je 0xb1105
movl %ecx, %ecx
movabsq $-0x8000000000000000, %r15 # imm = 0x8000000000000000
leaq -0x1(%rcx), %rdx... | /ggerganov[P]llama/common/json.hpp |
std::pair<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::allo... | std::pair<bool, BasicJsonType*> handle_value(Value&& v, const bool skip_callback = false)
{
JSON_ASSERT(!keep_stack.empty());
// do not handle this value if we know it would be added to a discarded
// container
if (!keep_stack.back())
{
return {false, nullptr};
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movl %edx, %ebp
movq %rdi, %rbx
movq 0x30(%rdi), %rax
movl 0x38(%rdi), %ecx
cmpq %rax, 0x20(%rdi)
sete %dl
testl %ecx, %ecx
sete %dil
andb %dl, %dil
cmpb $0x1, %dil
je 0xb1442
movl %ecx, %ecx
movabsq $-0x8000000000000000, %r15 # imm = 0x8000000000000000
leaq ... | /ggerganov[P]llama/common/json.hpp |
nlohmann::json_abi_v3_11_3::detail::lexer_base<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::... | static const char* token_type_name(const token_type t) noexcept
{
switch (t)
{
case token_type::uninitialized:
return "<uninitialized>";
case token_type::literal_true:
return "true literal";
case token_type::literal_false:
... | cmpl $0x10, %edi
ja 0xb1bc1
movl %edi, %eax
leaq 0xdc334(%rip), %rcx # 0x18def0
movq (%rcx,%rax,8), %rax
retq
leaq 0x8ffb8(%rip), %rax # 0x141b80
retq
nop
| /ggerganov[P]llama/common/json.hpp |
nlohmann::json_abi_v3_11_3::detail::json_sax_dom_parser<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_serializ... | bool end_object()
{
JSON_ASSERT(!ref_stack.empty());
JSON_ASSERT(ref_stack.back()->is_object());
ref_stack.back()->set_parents();
ref_stack.pop_back();
return true;
} | pushq %rax
movq 0x10(%rdi), %rax
cmpq %rax, 0x8(%rdi)
je 0xb1bea
movq -0x8(%rax), %rcx
cmpb $0x1, (%rcx)
jne 0xb1c06
addq $-0x8, %rax
movq %rax, 0x10(%rdi)
movb $0x1, %al
popq %rcx
retq
leaq 0x8ecf7(%rip), %rdi # 0x1408e8
leaq 0x85c31(%rip), %rdx # 0x137829
leaq 0x8fcde(%rip), %rcx # 0x1418dd
movl $0x1aeb, ... | /ggerganov[P]llama/common/json.hpp |
common_chat_verify_template(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool) | bool common_chat_verify_template(const std::string & tmpl, bool use_jinja) {
if (use_jinja) {
try {
common_chat_msg msg;
msg.role = "user";
msg.content = "test";
auto tmpls = common_chat_templates_init(/* model= */ nullptr, tmpl);
common_chat_tem... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x2c8, %rsp # imm = 0x2C8
movq %rdi, %rbx
testl %esi, %esi
je 0xb8a7b
leaq 0x170(%rsp), %rax
movq %rax, -0x10(%rax)
xorl %ecx, %ecx
movq %rcx, -0x8(%rax)
movb %cl, (%rax)
leaq 0x190(%rsp), %rax
movq %rax, -0x10(%rax)
movq %rcx, -0x8(%rax)
movb %cl, (%rax)
lea... | /ggerganov[P]llama/common/chat.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.