name
stringlengths 1
473k
| code
stringlengths 7
647k
| asm
stringlengths 4
3.39M
| file
stringlengths 8
196
|
|---|---|---|---|
unicode_to_utf16le
|
static size_t
unicode_to_utf16le(char *p, size_t remaining, uint32_t uc)
{
char *utf16 = p;
if (uc > 0xffff) {
/* We have a code point that won't fit into a
* wchar_t; convert it to a surrogate pair. */
if (remaining < 4)
return (0);
uc -= 0x10000;
archive_le16enc(utf16, ((uc >> 10) & 0x3ff) + 0xD800);
archive_le16enc(utf16+2, (uc & 0x3ff) + 0xDC00);
return (4);
} else {
if (remaining < 2)
return (0);
archive_le16enc(utf16, uc);
return (2);
}
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $0xffff, -0x1c(%rbp) # imm = 0xFFFF
jbe 0x93eaf3
cmpq $0x4, -0x18(%rbp)
jae 0x93eaa5
movq $0x0, -0x8(%rbp)
jmp 0x93eb1b
movl -0x1c(%rbp), %eax
subl $0x10000, %eax # imm = 0x10000
movl %eax, -0x1c(%rbp)
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %eax
shrl $0xa, %eax
andl $0x3ff, %eax # imm = 0x3FF
addl $0xd800, %eax # imm = 0xD800
movzwl %ax, %esi
callq 0x93eec0
movq -0x28(%rbp), %rdi
addq $0x2, %rdi
movl -0x1c(%rbp), %eax
andl $0x3ff, %eax # imm = 0x3FF
addl $0xdc00, %eax # imm = 0xDC00
movzwl %ax, %esi
callq 0x93eec0
movq $0x4, -0x8(%rbp)
jmp 0x93eb1b
cmpq $0x2, -0x18(%rbp)
jae 0x93eb04
movq $0x0, -0x8(%rbp)
jmp 0x93eb1b
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %eax
movzwl %ax, %esi
callq 0x93eec0
movq $0x2, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_string.c
|
archive_be16dec
|
static inline uint16_t
archive_be16dec(const void *pp)
{
unsigned char const *p = (unsigned char const *)pp;
/* Store into unsigned temporaries before left shifting, to avoid
promotion to signed int and then left shifting into the sign bit,
which is undefined behaviour. */
unsigned int p1 = p[1];
unsigned int p0 = p[0];
return ((p0 << 8) | p1);
}
|
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
shll $0x8, %eax
orl -0x14(%rbp), %eax
popq %rbp
retq
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_endian.h
|
get_nfd
|
static int
get_nfd(uint32_t *cp1, uint32_t *cp2, uint32_t uc)
{
int t, b;
/*
* These are not converted to NFD on Mac OS.
*/
if ((uc >= 0x2000 && uc <= 0x2FFF) ||
(uc >= 0xF900 && uc <= 0xFAFF) ||
(uc >= 0x2F800 && uc <= 0x2FAFF))
return (0);
/*
* Those code points are not converted to NFD on Mac OS.
* I do not know the reason because it is undocumented.
* NFC NFD
* 1109A ==> 11099 110BA
* 1109C ==> 1109B 110BA
* 110AB ==> 110A5 110BA
*/
if (uc == 0x1109A || uc == 0x1109C || uc == 0x110AB)
return (0);
t = 0;
b = sizeof(u_decomposition_table)/sizeof(u_decomposition_table[0]) -1;
while (b >= t) {
int m = (t + b) / 2;
if (u_decomposition_table[m].nfc < uc)
t = m + 1;
else if (u_decomposition_table[m].nfc > uc)
b = m - 1;
else {
*cp1 = u_decomposition_table[m].cp1;
*cp2 = u_decomposition_table[m].cp2;
return (1);
}
}
return (0);
}
|
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
cmpl $0x2000, -0x1c(%rbp) # imm = 0x2000
jb 0x93f271
cmpl $0x2fff, -0x1c(%rbp) # imm = 0x2FFF
jbe 0x93f295
cmpl $0xf900, -0x1c(%rbp) # imm = 0xF900
jb 0x93f283
cmpl $0xfaff, -0x1c(%rbp) # imm = 0xFAFF
jbe 0x93f295
cmpl $0x2f800, -0x1c(%rbp) # imm = 0x2F800
jb 0x93f2a1
cmpl $0x2faff, -0x1c(%rbp) # imm = 0x2FAFF
ja 0x93f2a1
movl $0x0, -0x4(%rbp)
jmp 0x93f388
cmpl $0x1109a, -0x1c(%rbp) # imm = 0x1109A
je 0x93f2bc
cmpl $0x1109c, -0x1c(%rbp) # imm = 0x1109C
je 0x93f2bc
cmpl $0x110ab, -0x1c(%rbp) # imm = 0x110AB
jne 0x93f2c8
movl $0x0, -0x4(%rbp)
jmp 0x93f388
movl $0x0, -0x20(%rbp)
movl $0x3a2, -0x24(%rbp) # imm = 0x3A2
movl -0x24(%rbp), %eax
cmpl -0x20(%rbp), %eax
jl 0x93f381
movl -0x20(%rbp), %eax
addl -0x24(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x28(%rbp)
movslq -0x28(%rbp), %rcx
leaq 0x280f02(%rip), %rax # 0xbc0200
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl (%rax), %eax
cmpl -0x1c(%rbp), %eax
jae 0x93f317
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x93f37c
movslq -0x28(%rbp), %rcx
leaq 0x280ede(%rip), %rax # 0xbc0200
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl (%rax), %eax
cmpl -0x1c(%rbp), %eax
jbe 0x93f33b
movl -0x28(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x93f37a
movslq -0x28(%rbp), %rcx
leaq 0x280eba(%rip), %rax # 0xbc0200
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl 0x4(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movslq -0x28(%rbp), %rcx
leaq 0x280e9f(%rip), %rax # 0xbc0200
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl 0x8(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x93f388
jmp 0x93f37c
jmp 0x93f2d6
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_string.c
|
get_nfc
|
static uint32_t
get_nfc(uint32_t uc, uint32_t uc2)
{
int t, b;
t = 0;
b = sizeof(u_composition_table)/sizeof(u_composition_table[0]) -1;
while (b >= t) {
int m = (t + b) / 2;
if (u_composition_table[m].cp1 < uc)
t = m + 1;
else if (u_composition_table[m].cp1 > uc)
b = m - 1;
else if (u_composition_table[m].cp2 < uc2)
t = m + 1;
else if (u_composition_table[m].cp2 > uc2)
b = m - 1;
else
return (u_composition_table[m].nfc);
}
return (0);
}
|
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl $0x3a2, -0x14(%rbp) # imm = 0x3A2
movl -0x14(%rbp), %eax
cmpl -0x10(%rbp), %eax
jl 0x93f47f
movl -0x10(%rbp), %eax
addl -0x14(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x18(%rbp)
movslq -0x18(%rbp), %rcx
leaq 0x2839e0(%rip), %rax # 0xbc2db0
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl (%rax), %eax
cmpl -0x8(%rbp), %eax
jae 0x93f3ec
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x93f47a
movslq -0x18(%rbp), %rcx
leaq 0x2839b9(%rip), %rax # 0xbc2db0
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl (%rax), %eax
cmpl -0x8(%rbp), %eax
jbe 0x93f410
movl -0x18(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x93f478
movslq -0x18(%rbp), %rcx
leaq 0x283995(%rip), %rax # 0xbc2db0
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
cmpl -0xc(%rbp), %eax
jae 0x93f435
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x93f476
movslq -0x18(%rbp), %rcx
leaq 0x283970(%rip), %rax # 0xbc2db0
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
cmpl -0xc(%rbp), %eax
jbe 0x93f45a
movl -0x18(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x93f474
movslq -0x18(%rbp), %rcx
leaq 0x28394b(%rip), %rax # 0xbc2db0
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x93f486
jmp 0x93f476
jmp 0x93f478
jmp 0x93f47a
jmp 0x93f3a8
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_string.c
|
best_effort_strncat_from_utf16
|
static int
best_effort_strncat_from_utf16(struct archive_string *as, const void *_p,
size_t bytes, struct archive_string_conv *sc, int be)
{
const char *utf16 = (const char *)_p;
char *mbs;
uint32_t uc;
int n, ret;
(void)sc; /* UNUSED */
/*
* Other case, we should do the best effort.
* If all character are ASCII(<0x7f), we can convert it.
* if not , we set a alternative character and return -1.
*/
ret = 0;
if (archive_string_ensure(as, as->length + bytes +1) == NULL)
return (-1);
mbs = as->s + as->length;
while ((n = utf16_to_unicode(&uc, utf16, bytes, be)) != 0) {
if (n < 0) {
n *= -1;
ret = -1;
}
bytes -= n;
utf16 += n;
if (uc > 127) {
/* We cannot handle it. */
*mbs++ = '?';
ret = -1;
} else
*mbs++ = (char)uc;
}
as->length = mbs - as->s;
as->s[as->length] = '\0';
return (ret);
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x4c(%rbp)
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
addq -0x20(%rbp), %rsi
addq $0x1, %rsi
callq 0x938530
cmpq $0x0, %rax
jne 0x93f4e6
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x93f5b4
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
addq 0x8(%rcx), %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0x2c(%rbp), %ecx
leaq -0x44(%rbp), %rdi
callq 0x93ef00
movl %eax, -0x48(%rbp)
cmpl $0x0, %eax
je 0x93f585
cmpl $0x0, -0x48(%rbp)
jge 0x93f529
imull $-0x1, -0x48(%rbp), %eax
movl %eax, -0x48(%rbp)
movl $0xffffffff, -0x4c(%rbp) # imm = 0xFFFFFFFF
movslq -0x48(%rbp), %rcx
movq -0x20(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x20(%rbp)
movl -0x48(%rbp), %ecx
movq -0x38(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
cmpl $0x7f, -0x44(%rbp)
jbe 0x93f56a
movq -0x40(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x40(%rbp)
movb $0x3f, (%rax)
movl $0xffffffff, -0x4c(%rbp) # imm = 0xFFFFFFFF
jmp 0x93f580
movl -0x44(%rbp), %eax
movb %al, %cl
movq -0x40(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x40(%rbp)
movb %cl, (%rax)
jmp 0x93f4f9
movq -0x40(%rbp), %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
subq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movb $0x0, (%rax,%rcx)
movl -0x4c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_string.c
|
invalid_mbs
|
static int
invalid_mbs(const void *_p, size_t n, struct archive_string_conv *sc)
{
const char *p = (const char *)_p;
size_t r;
#if HAVE_MBRTOWC
mbstate_t shift_state;
memset(&shift_state, 0, sizeof(shift_state));
#else
/* Clear the shift state before starting. */
mbtowc(NULL, NULL, 0);
#endif
while (n) {
wchar_t wc;
#if HAVE_MBRTOWC
r = mbrtowc(&wc, p, n, &shift_state);
#else
r = mbtowc(&wc, p, n);
#endif
if (r == (size_t)-1 || r == (size_t)-2)
return (-1);/* Invalid. */
if (r == 0)
break;
p += r;
n -= r;
}
(void)sc; /* UNUSED */
return (0); /* All Okey. */
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x38(%rbp), %rdi
xorl %esi, %esi
movl $0x8, %edx
callq 0x3b780
cmpq $0x0, -0x18(%rbp)
je 0x93f6a9
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x3c(%rbp), %rdi
leaq -0x38(%rbp), %rcx
callq 0x3c700
movq %rax, -0x30(%rbp)
cmpq $-0x1, -0x30(%rbp)
je 0x93f67a
cmpq $-0x2, -0x30(%rbp)
jne 0x93f683
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x93f6b0
cmpq $0x0, -0x30(%rbp)
jne 0x93f68c
jmp 0x93f6a9
movq -0x30(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x18(%rbp)
jmp 0x93f64c
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_string.c
|
archive_compressor_bzip2_options
|
static int
archive_compressor_bzip2_options(struct archive_write_filter *f,
const char *key, const char *value)
{
struct private_data *data = (struct private_data *)f->data;
if (strcmp(key, "compression-level") == 0) {
if (value == NULL || !(value[0] >= '0' && value[0] <= '9') ||
value[1] != '\0')
return (ARCHIVE_WARN);
data->compression_level = value[0] - '0';
/* Make '0' be a synonym for '1'. */
/* This way, bzip2 compressor supports the same 0..9
* range of levels as gzip. */
if (data->compression_level < 1)
data->compression_level = 1;
return (ARCHIVE_OK);
}
/* Note: The "warn" return is just to inform the options
* supervisor that we didn't handle it. It will generate
* a suitable error if no one used this option. */
return (ARCHIVE_WARN);
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x1fe1d8(%rip), %rsi # 0xb45593
callq 0x3dbb0
cmpl $0x0, %eax
jne 0x947426
cmpq $0x0, -0x20(%rbp)
je 0x9473f1
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x30, %eax
jl 0x9473f1
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x39, %eax
jg 0x9473f1
movq -0x20(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x0, %eax
je 0x9473fa
movl $0xffffffec, -0x4(%rbp) # imm = 0xFFFFFFEC
jmp 0x94742d
movq -0x20(%rbp), %rax
movsbl (%rax), %ecx
subl $0x30, %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movq -0x28(%rbp), %rax
cmpl $0x1, (%rax)
jge 0x94741d
movq -0x28(%rbp), %rax
movl $0x1, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x94742d
movl $0xffffffec, -0x4(%rbp) # imm = 0xFFFFFFEC
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_add_filter_bzip2.c
|
archive_compressor_bzip2_close
|
static int
archive_compressor_bzip2_close(struct archive_write_filter *f)
{
struct private_data *data = (struct private_data *)f->data;
int ret;
/* Finish compression cycle. */
ret = drive_compressor(f, data, 1);
if (ret == ARCHIVE_OK) {
/* Write the last block */
ret = __archive_write_filter(f->next_filter,
data->compressed,
data->compressed_buffer_size - data->stream.avail_out);
}
switch (BZ2_bzCompressEnd(&(data->stream))) {
case BZ_OK:
break;
default:
archive_set_error(f->archive, ARCHIVE_ERRNO_PROGRAMMER,
"Failed to clean up compressor");
ret = ARCHIVE_FATAL;
}
return ret;
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x1, %edx
callq 0x9477b0
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x94749d
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rdx
movq -0x10(%rbp), %rax
movl 0x28(%rax), %eax
subq %rax, %rdx
callq 0x940ff0
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x991950
testl %eax, %eax
jne 0x9474b2
jmp 0x9474b0
jmp 0x9474d4
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movl $0x16, %esi
leaq 0x27ef6b(%rip), %rdx # 0xbc6431
movb $0x0, %al
callq 0x9401f0
movl $0xffffffe2, -0x14(%rbp) # imm = 0xFFFFFFE2
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_add_filter_bzip2.c
|
archive_compressor_bzip2_open
|
static int
archive_compressor_bzip2_open(struct archive_write_filter *f)
{
struct private_data *data = (struct private_data *)f->data;
int ret;
if (data->compressed == NULL) {
size_t bs = 65536, bpb;
if (f->archive->magic == ARCHIVE_WRITE_MAGIC) {
/* Buffer size should be a multiple number of the of bytes
* per block for performance. */
bpb = archive_write_get_bytes_per_block(f->archive);
if (bpb > bs)
bs = bpb;
else if (bpb != 0)
bs -= bs % bpb;
}
data->compressed_buffer_size = bs;
data->compressed
= (char *)malloc(data->compressed_buffer_size);
if (data->compressed == NULL) {
archive_set_error(f->archive, ENOMEM,
"Can't allocate data for compression buffer");
return (ARCHIVE_FATAL);
}
}
memset(&data->stream, 0, sizeof(data->stream));
data->stream.next_out = data->compressed;
data->stream.avail_out = data->compressed_buffer_size;
f->write = archive_compressor_bzip2_write;
/* Initialize compression library */
ret = BZ2_bzCompressInit(&(data->stream),
data->compression_level, 0, 30);
if (ret == BZ_OK) {
f->data = data;
return (ARCHIVE_OK);
}
/* Library setup failed: clean up. */
archive_set_error(f->archive, ARCHIVE_ERRNO_MISC,
"Internal error initializing compression library");
/* Override the error message if we know what really went wrong. */
switch (ret) {
case BZ_PARAM_ERROR:
archive_set_error(f->archive, ARCHIVE_ERRNO_MISC,
"Internal error initializing compression library: "
"invalid setup parameter");
break;
case BZ_MEM_ERROR:
archive_set_error(f->archive, ENOMEM,
"Internal error initializing compression library: "
"out of memory");
break;
case BZ_CONFIG_ERROR:
archive_set_error(f->archive, ARCHIVE_ERRNO_MISC,
"Internal error initializing compression library: "
"mis-compiled library");
break;
}
return (ARCHIVE_FATAL);
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x60(%rax)
jne 0x947610
movq $0x10000, -0x28(%rbp) # imm = 0x10000
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0xb0c5c0de, (%rax) # imm = 0xB0C5C0DE
jne 0x9475b8
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x940da0
cltq
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x28(%rbp), %rax
jbe 0x947596
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x9475b6
cmpq $0x0, -0x30(%rbp)
je 0x9475b4
movq -0x28(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x30(%rbp)
movq -0x28(%rbp), %rax
subq %rdx, %rax
movq %rax, -0x28(%rbp)
jmp 0x9475b6
jmp 0x9475b8
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x68(%rax)
movq -0x18(%rbp), %rax
movq 0x68(%rax), %rdi
callq 0x3e578
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x60(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x60(%rax)
jne 0x94760e
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movl $0xc, %esi
leaq 0x27ed5e(%rip), %rdx # 0xbc6359
movb $0x0, %al
callq 0x9401f0
movl $0xffffffe2, -0x4(%rbp) # imm = 0xFFFFFFE2
jmp 0x947727
jmp 0x947610
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
xorl %esi, %esi
movl $0x50, %edx
callq 0x3b780
movq -0x18(%rbp), %rax
movq 0x60(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
movq 0x68(%rax), %rax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x28(%rax)
movq -0x10(%rbp), %rax
leaq 0xe0(%rip), %rcx # 0x947730
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
movq -0x18(%rbp), %rax
movl (%rax), %esi
xorl %edx, %edx
movl $0x1e, %ecx
callq 0x9910e0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x94768f
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x40(%rax)
movl $0x0, -0x4(%rbp)
jmp 0x947727
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x27ece6(%rip), %rdx # 0xbc6384
xorl %eax, %eax
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
callq 0x9401f0
movl -0x1c(%rbp), %eax
movl %eax, -0x34(%rbp)
subl $-0x9, %eax
je 0x947705
jmp 0x9476b7
movl -0x34(%rbp), %eax
subl $-0x3, %eax
je 0x9476e8
jmp 0x9476c1
movl -0x34(%rbp), %eax
subl $-0x2, %eax
jne 0x947720
jmp 0x9476cb
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
leaq 0x2729ff(%rip), %rdx # 0xbba0de
movb $0x0, %al
callq 0x9401f0
jmp 0x947720
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movl $0xc, %esi
leaq 0x272a2b(%rip), %rdx # 0xbba127
movb $0x0, %al
callq 0x9401f0
jmp 0x947720
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
leaq 0x27ec9b(%rip), %rdx # 0xbc63b4
movb $0x0, %al
callq 0x9401f0
movl $0xffffffe2, -0x4(%rbp) # imm = 0xFFFFFFE2
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_add_filter_bzip2.c
|
archive_compressor_compress_write
|
static int
archive_compressor_compress_write(struct archive_write_filter *f,
const void *buff, size_t length)
{
struct private_data *state = (struct private_data *)f->data;
int i;
int ratio;
int c, disp, ret;
const unsigned char *bp;
if (length == 0)
return ARCHIVE_OK;
bp = buff;
if (state->in_count == 0) {
state->cur_code = *bp++;
++state->in_count;
--length;
}
while (length--) {
c = *bp++;
state->in_count++;
state->cur_fcode = (c << 16) + state->cur_code;
i = ((c << HSHIFT) ^ state->cur_code); /* Xor hashing. */
if (state->hashtab[i] == state->cur_fcode) {
state->cur_code = state->codetab[i];
continue;
}
if (state->hashtab[i] < 0) /* Empty slot. */
goto nomatch;
/* Secondary hash (after G. Knott). */
if (i == 0)
disp = 1;
else
disp = HSIZE - i;
probe:
if ((i -= disp) < 0)
i += HSIZE;
if (state->hashtab[i] == state->cur_fcode) {
state->cur_code = state->codetab[i];
continue;
}
if (state->hashtab[i] >= 0)
goto probe;
nomatch:
ret = output_code(f, state->cur_code);
if (ret != ARCHIVE_OK)
return ret;
state->cur_code = c;
if (state->first_free < state->max_maxcode) {
state->codetab[i] = state->first_free++; /* code -> hashtable */
state->hashtab[i] = state->cur_fcode;
continue;
}
if (state->in_count < state->checkpoint)
continue;
state->checkpoint = state->in_count + CHECK_GAP;
if (state->in_count <= 0x007fffff && state->out_count != 0)
ratio = (int)(state->in_count * 256 / state->out_count);
else if ((ratio = (int)(state->out_count / 256)) == 0)
ratio = 0x7fffffff;
else
ratio = (int)(state->in_count / ratio);
if (ratio > state->compress_ratio)
state->compress_ratio = ratio;
else {
state->compress_ratio = 0;
memset(state->hashtab, 0xff, sizeof(state->hashtab));
state->first_free = FIRST;
ret = output_code(f, CLEAR);
if (ret != ARCHIVE_OK)
return ret;
}
}
return (ARCHIVE_OK);
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x947c33
movl $0x0, -0x4(%rbp)
jmp 0x947f50
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x947c7b
movq -0x48(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x48(%rbp)
movzbl (%rax), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x65164(%rax)
movq -0x28(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x947c7d
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x20(%rbp)
cmpq $0x0, %rax
je 0x947f49
movq -0x48(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x48(%rbp)
movzbl (%rax), %eax
movl %eax, -0x34(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movl -0x34(%rbp), %ecx
shll $0x10, %ecx
movq -0x28(%rbp), %rax
addl 0x65164(%rax), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x65168(%rax)
movl -0x34(%rbp), %eax
shll $0x8, %eax
movq -0x28(%rbp), %rcx
xorl 0x65164(%rcx), %eax
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movl 0x24(%rax,%rcx,4), %eax
movq -0x28(%rbp), %rcx
cmpl 0x65168(%rcx), %eax
jne 0x947d1d
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movzwl 0x43648(%rax,%rcx,2), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x65164(%rax)
jmp 0x947c7d
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
cmpl $0x0, 0x24(%rax,%rcx,4)
jge 0x947d31
jmp 0x947db2
cmpl $0x0, -0x2c(%rbp)
jne 0x947d40
movl $0x1, -0x38(%rbp)
jmp 0x947d4b
movl $0x10d89, %eax # imm = 0x10D89
subl -0x2c(%rbp), %eax
movl %eax, -0x38(%rbp)
jmp 0x947d4d
movl -0x38(%rbp), %ecx
movl -0x2c(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x2c(%rbp)
cmpl $0x0, %eax
jge 0x947d68
movl -0x2c(%rbp), %eax
addl $0x10d89, %eax # imm = 0x10D89
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movl 0x24(%rax,%rcx,4), %eax
movq -0x28(%rbp), %rcx
cmpl 0x65168(%rcx), %eax
jne 0x947d9f
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movzwl 0x43648(%rax,%rcx,2), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x65164(%rax)
jmp 0x947c7d
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
cmpl $0x0, 0x24(%rax,%rcx,4)
jl 0x947db0
jmp 0x947d4d
jmp 0x947db2
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rax
movl 0x65164(%rax), %esi
callq 0x948030
movl %eax, -0x3c(%rbp)
cmpl $0x0, -0x3c(%rbp)
je 0x947dd9
movl -0x3c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x947f50
movl -0x34(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x65164(%rax)
movq -0x28(%rbp), %rax
movl 0x6515c(%rax), %eax
movq -0x28(%rbp), %rcx
cmpl 0x20(%rcx), %eax
jge 0x947e3c
movq -0x28(%rbp), %rcx
movl 0x6515c(%rcx), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, 0x6515c(%rcx)
movw %ax, %dx
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movw %dx, 0x43648(%rax,%rcx,2)
movq -0x28(%rbp), %rax
movl 0x65168(%rax), %edx
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movl %edx, 0x24(%rax,%rcx,4)
jmp 0x947c7d
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq -0x28(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jge 0x947e52
jmp 0x947c7d
movq -0x28(%rbp), %rax
movq (%rax), %rcx
addq $0x2710, %rcx # imm = 0x2710
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rax
cmpq $0x7fffff, (%rax) # imm = 0x7FFFFF
jg 0x947e9a
movq -0x28(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x947e9a
movq -0x28(%rbp), %rax
movq (%rax), %rax
shlq $0x8, %rax
movq -0x28(%rbp), %rcx
cqto
idivq 0x8(%rcx)
movl %eax, -0x30(%rbp)
jmp 0x947ed2
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movl $0x100, %ecx # imm = 0x100
cqto
idivq %rcx
movl %eax, -0x30(%rbp)
cmpl $0x0, %eax
jne 0x947ebd
movl $0x7fffffff, -0x30(%rbp) # imm = 0x7FFFFFFF
jmp 0x947ed0
movq -0x28(%rbp), %rax
movq (%rax), %rax
movslq -0x30(%rbp), %rcx
cqto
idivq %rcx
movl %eax, -0x30(%rbp)
jmp 0x947ed2
movl -0x30(%rbp), %eax
movq -0x28(%rbp), %rcx
cmpl 0x65160(%rcx), %eax
jle 0x947ef0
movl -0x30(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x65160(%rax)
jmp 0x947f44
movq -0x28(%rbp), %rax
movl $0x0, 0x65160(%rax)
movq -0x28(%rbp), %rdi
addq $0x24, %rdi
movl $0xff, %esi
movl $0x43624, %edx # imm = 0x43624
callq 0x3b780
movq -0x28(%rbp), %rax
movl $0x101, 0x6515c(%rax) # imm = 0x101
movq -0x10(%rbp), %rdi
movl $0x100, %esi # imm = 0x100
callq 0x948030
movl %eax, -0x3c(%rbp)
cmpl $0x0, -0x3c(%rbp)
je 0x947f42
movl -0x3c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x947f50
jmp 0x947f44
jmp 0x947c7d
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_add_filter_compress.c
|
archive_write_set_format_cpio_binary
|
static int
archive_write_set_format_cpio_binary(struct archive *_a, int format)
{
struct archive_write *a = (struct archive_write *)_a;
struct cpio *cpio;
if (sizeof(struct cpio_binary_header) != HSIZE) {
archive_set_error(&a->archive, EINVAL,
"Binary cpio format not supported on this platform");
return (ARCHIVE_FATAL);
}
archive_check_magic(_a, ARCHIVE_WRITE_MAGIC,
ARCHIVE_STATE_NEW, "archive_write_set_format_cpio_binary");
/* If someone else was already registered, unregister them. */
if (a->format_free != NULL)
(a->format_free)(a);
cpio = (struct cpio *)calloc(1, sizeof(*cpio));
if (cpio == NULL) {
archive_set_error(&a->archive, ENOMEM, "Can't allocate cpio data");
return (ARCHIVE_FATAL);
}
a->format_data = cpio;
a->format_name = "cpio";
a->format_options = archive_write_binary_options;
a->format_write_header = archive_write_binary_header;
a->format_write_data = archive_write_binary_data;
a->format_finish_entry = archive_write_binary_finish_entry;
a->format_close = archive_write_binary_close;
a->format_free = archive_write_binary_free;
a->archive.archive_format = format;
switch (format) {
case ARCHIVE_FORMAT_CPIO_PWB:
a->archive.archive_format_name = "PWB cpio";
break;
case ARCHIVE_FORMAT_CPIO_BIN_LE:
a->archive.archive_format_name = "7th Edition cpio";
break;
default:
archive_set_error(&a->archive, EINVAL, "binary format must be 'pwb' or 'bin'");
return (ARCHIVE_FATAL);
}
return (ARCHIVE_OK);
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl $0xb0c5c0de, %esi # imm = 0xB0C5C0DE
movl $0x1, %edx
leaq 0x27c36a(%rip), %rcx # 0xbc6896
callq 0x9770c0
movl %eax, -0x2c(%rbp)
cmpl $-0x1e, -0x2c(%rbp)
jne 0x94a546
movl $0xffffffe2, -0x4(%rbp) # imm = 0xFFFFFFE2
jmp 0x94a69f
jmp 0x94a548
movq -0x20(%rbp), %rax
cmpq $0x0, 0x138(%rax)
je 0x94a567
movq -0x20(%rbp), %rax
movq 0x138(%rax), %rax
movq -0x20(%rbp), %rdi
callq *%rax
movl $0x1, %edi
movl $0x40, %esi
callq 0x3e570
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x94a5a4
movq -0x20(%rbp), %rdi
movl $0xc, %esi
leaq 0x270e22(%rip), %rdx # 0xbbb3b3
movb $0x0, %al
callq 0x9401f0
movl $0xffffffe2, -0x4(%rbp) # imm = 0xFFFFFFE2
jmp 0x94a69f
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0xf8(%rax)
movq -0x20(%rbp), %rax
leaq 0x27c4d5(%rip), %rcx # 0xbc6a93
movq %rcx, 0x100(%rax)
movq -0x20(%rbp), %rax
leaq 0x100(%rip), %rcx # 0x94a6d0
movq %rcx, 0x110(%rax)
movq -0x20(%rbp), %rax
leaq 0x1be(%rip), %rcx # 0x94a7a0
movq %rcx, 0x120(%rax)
movq -0x20(%rbp), %rax
leaq 0x2ec(%rip), %rcx # 0x94a8e0
movq %rcx, 0x128(%rax)
movq -0x20(%rbp), %rax
leaq 0x36a(%rip), %rcx # 0x94a970
movq %rcx, 0x118(%rax)
movq -0x20(%rbp), %rax
leaq 0x398(%rip), %rcx # 0x94a9b0
movq %rcx, 0x130(%rax)
movq -0x20(%rbp), %rax
leaq 0x3f6(%rip), %rcx # 0x94aa20
movq %rcx, 0x138(%rax)
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x10(%rax)
movl -0x14(%rbp), %eax
movl %eax, -0x30(%rbp)
subl $0x10002, %eax # imm = 0x10002
je 0x94a667
jmp 0x94a64a
movl -0x30(%rbp), %eax
subl $0x10007, %eax # imm = 0x10007
jne 0x94a678
jmp 0x94a656
movq -0x20(%rbp), %rax
leaq 0x27c42e(%rip), %rcx # 0xbc6a8f
movq %rcx, 0x18(%rax)
jmp 0x94a698
movq -0x20(%rbp), %rax
leaq 0x27c249(%rip), %rcx # 0xbc68bb
movq %rcx, 0x18(%rax)
jmp 0x94a698
movq -0x20(%rbp), %rdi
movl $0x16, %esi
leaq 0x27c244(%rip), %rdx # 0xbc68cc
movb $0x0, %al
callq 0x9401f0
movl $0xffffffe2, -0x4(%rbp) # imm = 0xFFFFFFE2
jmp 0x94a69f
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_cpio_binary.c
|
archive_write_odc_free
|
static int
archive_write_odc_free(struct archive_write *a)
{
struct cpio *cpio;
cpio = (struct cpio *)a->format_data;
free(cpio->ino_list);
free(cpio);
a->format_data = NULL;
return (ARCHIVE_OK);
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0xf8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x3e548
movq -0x10(%rbp), %rdi
callq 0x3e548
movq -0x8(%rbp), %rax
movq $0x0, 0xf8(%rax)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_cpio_odc.c
|
get_sconv
|
static struct archive_string_conv *
get_sconv(struct archive_write *a)
{
struct cpio *cpio;
struct archive_string_conv *sconv;
cpio = (struct cpio *)a->format_data;
sconv = cpio->opt_sconv;
if (sconv == NULL) {
if (!cpio->init_default_conversion) {
cpio->sconv_default =
archive_string_default_conversion_for_write(
&(a->archive));
cpio->init_default_conversion = 1;
}
sconv = cpio->sconv_default;
}
return (sconv);
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0xf8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x94c4d3
movq -0x10(%rbp), %rax
cmpl $0x0, 0x38(%rax)
jne 0x94c4c7
movq -0x8(%rbp), %rdi
callq 0x938ee0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rax
movl $0x1, 0x38(%rax)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_cpio_odc.c
|
format_octal
|
static int
format_octal(int64_t v, void *p, int digits)
{
int64_t max;
int ret;
max = (((int64_t)1) << (digits * 3)) - 1;
if (v >= 0 && v <= max) {
format_octal_recursive(v, (char *)p, digits);
ret = 0;
} else {
format_octal_recursive(max, (char *)p, digits);
ret = -1;
}
return (ret);
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
imull $0x3, -0x14(%rbp), %eax
movl %eax, %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
subq $0x1, %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x8(%rbp)
jl 0x94ca45
movq -0x8(%rbp), %rax
cmpq -0x20(%rbp), %rax
jg 0x94ca45
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x94cc20
movl $0x0, -0x24(%rbp)
jmp 0x94ca5c
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x94cc20
movl $0xffffffff, -0x24(%rbp) # imm = 0xFFFFFFFF
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_cpio_odc.c
|
archive_write_set_format_gnutar
|
int
archive_write_set_format_gnutar(struct archive *_a)
{
struct archive_write *a = (struct archive_write *)_a;
struct gnutar *gnutar;
gnutar = (struct gnutar *)calloc(1, sizeof(*gnutar));
if (gnutar == NULL) {
archive_set_error(&a->archive, ENOMEM,
"Can't allocate gnutar data");
return (ARCHIVE_FATAL);
}
a->format_data = gnutar;
a->format_name = "gnutar";
a->format_options = archive_write_gnutar_options;
a->format_write_header = archive_write_gnutar_header;
a->format_write_data = archive_write_gnutar_data;
a->format_close = archive_write_gnutar_close;
a->format_free = archive_write_gnutar_free;
a->format_finish_entry = archive_write_gnutar_finish_entry;
a->archive.archive_format = ARCHIVE_FORMAT_TAR_GNUTAR;
a->archive.archive_format_name = "GNU tar";
return (ARCHIVE_OK);
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x1, %edi
movl $0x68, %esi
callq 0x3e570
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x94cce1
movq -0x18(%rbp), %rdi
movl $0xc, %esi
leaq 0x279f0b(%rip), %rdx # 0xbc6bd9
movb $0x0, %al
callq 0x9401f0
movl $0xffffffe2, -0x4(%rbp) # imm = 0xFFFFFFE2
jmp 0x94cd8f
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0xf8(%rax)
movq -0x18(%rbp), %rax
leaq 0x271151(%rip), %rcx # 0xbbde4c
movq %rcx, 0x100(%rax)
movq -0x18(%rbp), %rax
leaq 0x93(%rip), %rcx # 0x94cda0
movq %rcx, 0x110(%rax)
movq -0x18(%rbp), %rax
leaq 0x151(%rip), %rcx # 0x94ce70
movq %rcx, 0x120(%rax)
movq -0x18(%rbp), %rax
leaq 0xbbf(%rip), %rcx # 0x94d8f0
movq %rcx, 0x128(%rax)
movq -0x18(%rbp), %rax
leaq 0xc3d(%rip), %rcx # 0x94d980
movq %rcx, 0x130(%rax)
movq -0x18(%rbp), %rax
leaq 0xc4b(%rip), %rcx # 0x94d9a0
movq %rcx, 0x138(%rax)
movq -0x18(%rbp), %rax
leaq 0xc79(%rip), %rcx # 0x94d9e0
movq %rcx, 0x118(%rax)
movq -0x18(%rbp), %rax
movl $0x30004, 0x10(%rax) # imm = 0x30004
movq -0x18(%rbp), %rax
leaq 0x279e70(%rip), %rcx # 0xbc6bf4
movq %rcx, 0x18(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_gnutar.c
|
archive_write_gnutar_header
|
static int
archive_write_gnutar_header(struct archive_write *a,
struct archive_entry *entry)
{
char buff[512];
int r, ret, ret2 = ARCHIVE_OK;
int tartype;
struct gnutar *gnutar;
struct archive_string_conv *sconv;
struct archive_entry *entry_main;
gnutar = (struct gnutar *)a->format_data;
/* Setup default string conversion. */
if (gnutar->opt_sconv == NULL) {
if (!gnutar->init_default_conversion) {
gnutar->sconv_default =
archive_string_default_conversion_for_write(
&(a->archive));
gnutar->init_default_conversion = 1;
}
sconv = gnutar->sconv_default;
} else
sconv = gnutar->opt_sconv;
/* Only regular files (not hardlinks) have data. */
if (archive_entry_hardlink(entry) != NULL ||
archive_entry_symlink(entry) != NULL ||
!(archive_entry_filetype(entry) == AE_IFREG))
archive_entry_set_size(entry, 0);
if (AE_IFDIR == archive_entry_filetype(entry)) {
const char *p;
size_t path_length;
/*
* Ensure a trailing '/'. Modify the entry so
* the client sees the change.
*/
#if defined(_WIN32) && !defined(__CYGWIN__)
const wchar_t *wp;
wp = archive_entry_pathname_w(entry);
if (wp != NULL && wp[wcslen(wp) -1] != L'/') {
struct archive_wstring ws;
archive_string_init(&ws);
path_length = wcslen(wp);
if (archive_wstring_ensure(&ws,
path_length + 2) == NULL) {
archive_set_error(&a->archive, ENOMEM,
"Can't allocate ustar data");
archive_wstring_free(&ws);
return(ARCHIVE_FATAL);
}
/* Should we keep '\' ? */
if (wp[path_length -1] == L'\\')
path_length--;
archive_wstrncpy(&ws, wp, path_length);
archive_wstrappend_wchar(&ws, L'/');
archive_entry_copy_pathname_w(entry, ws.s);
archive_wstring_free(&ws);
p = NULL;
} else
#endif
p = archive_entry_pathname(entry);
/*
* On Windows, this is a backup operation just in
* case getting WCS failed. On POSIX, this is a
* normal operation.
*/
if (p != NULL && p[0] != '\0' && p[strlen(p) - 1] != '/') {
struct archive_string as;
archive_string_init(&as);
path_length = strlen(p);
if (archive_string_ensure(&as,
path_length + 2) == NULL) {
archive_set_error(&a->archive, ENOMEM,
"Can't allocate ustar data");
archive_string_free(&as);
return(ARCHIVE_FATAL);
}
#if defined(_WIN32) && !defined(__CYGWIN__)
/* NOTE: This might break the pathname
* if the current code page is CP932 and
* the pathname includes a character '\'
* as a part of its multibyte pathname. */
if (p[strlen(p) -1] == '\\')
path_length--;
else
#endif
archive_strncpy(&as, p, path_length);
archive_strappend_char(&as, '/');
archive_entry_copy_pathname(entry, as.s);
archive_string_free(&as);
}
}
#if defined(_WIN32) && !defined(__CYGWIN__)
/* Make sure the path separators in pathname, hardlink and symlink
* are all slash '/', not the Windows path separator '\'. */
entry_main = __la_win_entry_in_posix_pathseparator(entry);
if (entry_main == NULL) {
archive_set_error(&a->archive, ENOMEM,
"Can't allocate ustar data");
return(ARCHIVE_FATAL);
}
if (entry != entry_main)
entry = entry_main;
else
entry_main = NULL;
#else
entry_main = NULL;
#endif
r = archive_entry_pathname_l(entry, &(gnutar->pathname),
&(gnutar->pathname_length), sconv);
if (r != 0) {
if (errno == ENOMEM) {
archive_set_error(&a->archive, ENOMEM,
"Can't allocate memory for Pathame");
ret = ARCHIVE_FATAL;
goto exit_write_header;
}
archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
"Can't translate pathname '%s' to %s",
archive_entry_pathname(entry),
archive_string_conversion_charset_name(sconv));
ret2 = ARCHIVE_WARN;
}
r = archive_entry_uname_l(entry, &(gnutar->uname),
&(gnutar->uname_length), sconv);
if (r != 0) {
if (errno == ENOMEM) {
archive_set_error(&a->archive, ENOMEM,
"Can't allocate memory for Uname");
ret = ARCHIVE_FATAL;
goto exit_write_header;
}
archive_set_error(&a->archive,
ARCHIVE_ERRNO_FILE_FORMAT,
"Can't translate uname '%s' to %s",
archive_entry_uname(entry),
archive_string_conversion_charset_name(sconv));
ret2 = ARCHIVE_WARN;
}
r = archive_entry_gname_l(entry, &(gnutar->gname),
&(gnutar->gname_length), sconv);
if (r != 0) {
if (errno == ENOMEM) {
archive_set_error(&a->archive, ENOMEM,
"Can't allocate memory for Gname");
ret = ARCHIVE_FATAL;
goto exit_write_header;
}
archive_set_error(&a->archive,
ARCHIVE_ERRNO_FILE_FORMAT,
"Can't translate gname '%s' to %s",
archive_entry_gname(entry),
archive_string_conversion_charset_name(sconv));
ret2 = ARCHIVE_WARN;
}
/* If linkname is longer than 100 chars we need to add a 'K' header. */
r = archive_entry_hardlink_l(entry, &(gnutar->linkname),
&(gnutar->linkname_length), sconv);
if (r != 0) {
if (errno == ENOMEM) {
archive_set_error(&a->archive, ENOMEM,
"Can't allocate memory for Linkname");
ret = ARCHIVE_FATAL;
goto exit_write_header;
}
archive_set_error(&a->archive,
ARCHIVE_ERRNO_FILE_FORMAT,
"Can't translate linkname '%s' to %s",
archive_entry_hardlink(entry),
archive_string_conversion_charset_name(sconv));
ret2 = ARCHIVE_WARN;
}
if (gnutar->linkname_length == 0) {
r = archive_entry_symlink_l(entry, &(gnutar->linkname),
&(gnutar->linkname_length), sconv);
if (r != 0) {
if (errno == ENOMEM) {
archive_set_error(&a->archive, ENOMEM,
"Can't allocate memory for Linkname");
ret = ARCHIVE_FATAL;
goto exit_write_header;
}
archive_set_error(&a->archive,
ARCHIVE_ERRNO_FILE_FORMAT,
"Can't translate linkname '%s' to %s",
archive_entry_hardlink(entry),
archive_string_conversion_charset_name(sconv));
ret2 = ARCHIVE_WARN;
}
}
if (gnutar->linkname_length > GNUTAR_linkname_size) {
size_t length = gnutar->linkname_length + 1;
struct archive_entry *temp = archive_entry_new2(&a->archive);
/* Uname/gname here don't really matter since no one reads them;
* these are the values that GNU tar happens to use on FreeBSD. */
archive_entry_set_uname(temp, "root");
archive_entry_set_gname(temp, "wheel");
archive_entry_set_pathname(temp, "././@LongLink");
archive_entry_set_size(temp, length);
ret = archive_format_gnutar_header(a, buff, temp, 'K');
archive_entry_free(temp);
if (ret < ARCHIVE_WARN)
goto exit_write_header;
ret = __archive_write_output(a, buff, 512);
if (ret < ARCHIVE_WARN)
goto exit_write_header;
/* Write name and trailing null byte. */
ret = __archive_write_output(a, gnutar->linkname, length);
if (ret < ARCHIVE_WARN)
goto exit_write_header;
/* Pad to 512 bytes */
ret = __archive_write_nulls(a, 0x1ff & (-(ssize_t)length));
if (ret < ARCHIVE_WARN)
goto exit_write_header;
}
/* If pathname is longer than 100 chars we need to add an 'L' header. */
if (gnutar->pathname_length > GNUTAR_name_size) {
const char *pathname = gnutar->pathname;
size_t length = gnutar->pathname_length + 1;
struct archive_entry *temp = archive_entry_new2(&a->archive);
/* Uname/gname here don't really matter since no one reads them;
* these are the values that GNU tar happens to use on FreeBSD. */
archive_entry_set_uname(temp, "root");
archive_entry_set_gname(temp, "wheel");
archive_entry_set_pathname(temp, "././@LongLink");
archive_entry_set_size(temp, length);
ret = archive_format_gnutar_header(a, buff, temp, 'L');
archive_entry_free(temp);
if (ret < ARCHIVE_WARN)
goto exit_write_header;
ret = __archive_write_output(a, buff, 512);
if(ret < ARCHIVE_WARN)
goto exit_write_header;
/* Write pathname + trailing null byte. */
ret = __archive_write_output(a, pathname, length);
if(ret < ARCHIVE_WARN)
goto exit_write_header;
/* Pad to multiple of 512 bytes. */
ret = __archive_write_nulls(a, 0x1ff & (-(ssize_t)length));
if (ret < ARCHIVE_WARN)
goto exit_write_header;
}
if (archive_entry_hardlink(entry) != NULL) {
tartype = '1';
} else
switch (archive_entry_filetype(entry)) {
case AE_IFREG: tartype = '0' ; break;
case AE_IFLNK: tartype = '2' ; break;
case AE_IFCHR: tartype = '3' ; break;
case AE_IFBLK: tartype = '4' ; break;
case AE_IFDIR: tartype = '5' ; break;
case AE_IFIFO: tartype = '6' ; break;
default: /* AE_IFSOCK and unknown */
__archive_write_entry_filetype_unsupported(
&a->archive, entry, "gnutar");
ret = ARCHIVE_FAILED;
goto exit_write_header;
}
ret = archive_format_gnutar_header(a, buff, entry, tartype);
if (ret < ARCHIVE_WARN)
goto exit_write_header;
if (ret2 < ret)
ret = ret2;
ret2 = __archive_write_output(a, buff, 512);
if (ret2 < ARCHIVE_WARN) {
ret = ret2;
goto exit_write_header;
}
if (ret2 < ret)
ret = ret2;
gnutar->entry_bytes_remaining = archive_entry_size(entry);
gnutar->entry_padding = 0x1ff & (-(int64_t)gnutar->entry_bytes_remaining);
exit_write_header:
archive_entry_free(entry_main);
return (ret);
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x300, %rsp # imm = 0x300
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x22c(%rbp)
movq -0x10(%rbp), %rax
movq 0xf8(%rax), %rax
movq %rax, -0x238(%rbp)
movq -0x238(%rbp), %rax
cmpq $0x0, 0x50(%rax)
jne 0x94cef3
movq -0x238(%rbp), %rax
cmpl $0x0, 0x60(%rax)
jne 0x94cedf
movq -0x10(%rbp), %rdi
callq 0x938ee0
movq %rax, %rcx
movq -0x238(%rbp), %rax
movq %rcx, 0x58(%rax)
movq -0x238(%rbp), %rax
movl $0x1, 0x60(%rax)
movq -0x238(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x240(%rbp)
jmp 0x94cf05
movq -0x238(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x240(%rbp)
movq -0x18(%rbp), %rdi
callq 0x8ea180
cmpq $0x0, %rax
jne 0x94cf33
movq -0x18(%rbp), %rdi
callq 0x8ea840
cmpq $0x0, %rax
jne 0x94cf33
movq -0x18(%rbp), %rdi
callq 0x8e9c10
cmpl $0x8000, %eax # imm = 0x8000
je 0x94cf40
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x8ec160
movq -0x18(%rbp), %rdi
callq 0x8e9c10
movl %eax, %ecx
movl $0x4000, %eax # imm = 0x4000
cmpl %ecx, %eax
jne 0x94d094
movq -0x18(%rbp), %rdi
callq 0x8ea480
movq %rax, -0x250(%rbp)
cmpq $0x0, -0x250(%rbp)
je 0x94d092
movq -0x250(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x94d092
movq -0x250(%rbp), %rax
movq %rax, -0x2a0(%rbp)
movq -0x250(%rbp), %rdi
callq 0x3b8f0
movq %rax, %rcx
movq -0x2a0(%rbp), %rax
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2f, %eax
je 0x94d092
jmp 0x94cfc0
movq $0x0, -0x270(%rbp)
movq $0x0, -0x268(%rbp)
movq $0x0, -0x260(%rbp)
movq -0x250(%rbp), %rdi
callq 0x3b8f0
movq %rax, -0x258(%rbp)
movq -0x258(%rbp), %rsi
addq $0x2, %rsi
leaq -0x270(%rbp), %rdi
callq 0x938530
cmpq $0x0, %rax
jne 0x94d040
movq -0x10(%rbp), %rdi
movl $0xc, %esi
leaq 0x279bdb(%rip), %rdx # 0xbc6bfc
movb $0x0, %al
callq 0x9401f0
leaq -0x270(%rbp), %rdi
callq 0x938460
movl $0xffffffe2, -0x4(%rbp) # imm = 0xFFFFFFE2
jmp 0x94d8da
movq $0x0, -0x268(%rbp)
movq -0x250(%rbp), %rsi
movq -0x258(%rbp), %rdx
leaq -0x270(%rbp), %rdi
callq 0x938660
leaq -0x270(%rbp), %rdi
movl $0x2f, %esi
callq 0x938810
movq -0x18(%rbp), %rdi
movq -0x270(%rbp), %rsi
callq 0x8ebf40
leaq -0x270(%rbp), %rdi
callq 0x938460
jmp 0x94d094
movq $0x0, -0x248(%rbp)
movq -0x18(%rbp), %rdi
movq -0x238(%rbp), %rsi
addq $0x20, %rsi
movq -0x238(%rbp), %rdx
addq $0x28, %rdx
movq -0x240(%rbp), %rcx
callq 0x8ea5d0
movl %eax, -0x224(%rbp)
cmpl $0x0, -0x224(%rbp)
je 0x94d15d
callq 0x3e130
cmpl $0xc, (%rax)
jne 0x94d108
movq -0x10(%rbp), %rdi
movl $0xc, %esi
leaq 0x279b24(%rip), %rdx # 0xbc6c16
movb $0x0, %al
callq 0x9401f0
movl $0xffffffe2, -0x228(%rbp) # imm = 0xFFFFFFE2
jmp 0x94d8c5
movq -0x10(%rbp), %rax
movq %rax, -0x2b0(%rbp)
movq -0x18(%rbp), %rdi
callq 0x8ea480
movq %rax, -0x2a8(%rbp)
movq -0x240(%rbp), %rdi
callq 0x938fb0
movq -0x2b0(%rbp), %rdi
movq -0x2a8(%rbp), %rcx
movq %rax, %r8
movl $0x54, %esi
leaq 0x279808(%rip), %rdx # 0xbc6954
movb $0x0, %al
callq 0x9401f0
movl $0xffffffec, -0x22c(%rbp) # imm = 0xFFFFFFEC
movq -0x18(%rbp), %rdi
movq -0x238(%rbp), %rsi
addq $0x30, %rsi
movq -0x238(%rbp), %rdx
addq $0x38, %rdx
movq -0x240(%rbp), %rcx
callq 0x8eabd0
movl %eax, -0x224(%rbp)
cmpl $0x0, -0x224(%rbp)
je 0x94d21b
callq 0x3e130
cmpl $0xc, (%rax)
jne 0x94d1c6
movq -0x10(%rbp), %rdi
movl $0xc, %esi
leaq 0x279a88(%rip), %rdx # 0xbc6c38
movb $0x0, %al
callq 0x9401f0
movl $0xffffffe2, -0x228(%rbp) # imm = 0xFFFFFFE2
jmp 0x94d8c5
movq -0x10(%rbp), %rax
movq %rax, -0x2c0(%rbp)
movq -0x18(%rbp), %rdi
callq 0x8eaa80
movq %rax, -0x2b8(%rbp)
movq -0x240(%rbp), %rdi
callq 0x938fb0
movq -0x2c0(%rbp), %rdi
movq -0x2b8(%rbp), %rcx
movq %rax, %r8
movl $0x54, %esi
leaq 0x279a4e(%rip), %rdx # 0xbc6c58
movb $0x0, %al
callq 0x9401f0
movl $0xffffffec, -0x22c(%rbp) # imm = 0xFFFFFFEC
movq -0x18(%rbp), %rdi
movq -0x238(%rbp), %rsi
addq $0x40, %rsi
movq -0x238(%rbp), %rdx
addq $0x48, %rdx
movq -0x240(%rbp), %rcx
callq 0x8ea130
movl %eax, -0x224(%rbp)
cmpl $0x0, -0x224(%rbp)
je 0x94d2d9
callq 0x3e130
cmpl $0xc, (%rax)
jne 0x94d284
movq -0x10(%rbp), %rdi
movl $0xc, %esi
leaq 0x279a0b(%rip), %rdx # 0xbc6c79
movb $0x0, %al
callq 0x9401f0
movl $0xffffffe2, -0x228(%rbp) # imm = 0xFFFFFFE2
jmp 0x94d8c5
movq -0x10(%rbp), %rax
movq %rax, -0x2d0(%rbp)
movq -0x18(%rbp), %rdi
callq 0x8e9fe0
movq %rax, -0x2c8(%rbp)
movq -0x240(%rbp), %rdi
callq 0x938fb0
movq -0x2d0(%rbp), %rdi
movq -0x2c8(%rbp), %rcx
movq %rax, %r8
movl $0x54, %esi
leaq 0x2799d1(%rip), %rdx # 0xbc6c99
movb $0x0, %al
callq 0x9401f0
movl $0xffffffec, -0x22c(%rbp) # imm = 0xFFFFFFEC
movq -0x18(%rbp), %rdi
movq -0x238(%rbp), %rsi
addq $0x10, %rsi
movq -0x238(%rbp), %rdx
addq $0x18, %rdx
movq -0x240(%rbp), %rcx
callq 0x8ea300
movl %eax, -0x224(%rbp)
cmpl $0x0, -0x224(%rbp)
je 0x94d397
callq 0x3e130
cmpl $0xc, (%rax)
jne 0x94d342
movq -0x10(%rbp), %rdi
movl $0xc, %esi
leaq 0x26e295(%rip), %rdx # 0xbbb5c1
movb $0x0, %al
callq 0x9401f0
movl $0xffffffe2, -0x228(%rbp) # imm = 0xFFFFFFE2
jmp 0x94d8c5
movq -0x10(%rbp), %rax
movq %rax, -0x2e0(%rbp)
movq -0x18(%rbp), %rdi
callq 0x8ea180
movq %rax, -0x2d8(%rbp)
movq -0x240(%rbp), %rdi
callq 0x938fb0
movq -0x2e0(%rbp), %rdi
movq -0x2d8(%rbp), %rcx
movq %rax, %r8
movl $0x54, %esi
leaq 0x2796b9(%rip), %rdx # 0xbc6a3f
movb $0x0, %al
callq 0x9401f0
movl $0xffffffec, -0x22c(%rbp) # imm = 0xFFFFFFEC
movq -0x238(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x94d469
movq -0x18(%rbp), %rdi
movq -0x238(%rbp), %rsi
addq $0x10, %rsi
movq -0x238(%rbp), %rdx
addq $0x18, %rdx
movq -0x240(%rbp), %rcx
callq 0x8ea9e0
movl %eax, -0x224(%rbp)
cmpl $0x0, -0x224(%rbp)
je 0x94d467
callq 0x3e130
cmpl $0xc, (%rax)
jne 0x94d412
movq -0x10(%rbp), %rdi
movl $0xc, %esi
leaq 0x26e1c5(%rip), %rdx # 0xbbb5c1
movb $0x0, %al
callq 0x9401f0
movl $0xffffffe2, -0x228(%rbp) # imm = 0xFFFFFFE2
jmp 0x94d8c5
movq -0x10(%rbp), %rax
movq %rax, -0x2f0(%rbp)
movq -0x18(%rbp), %rdi
callq 0x8ea180
movq %rax, -0x2e8(%rbp)
movq -0x240(%rbp), %rdi
callq 0x938fb0
movq -0x2f0(%rbp), %rdi
movq -0x2e8(%rbp), %rcx
movq %rax, %r8
movl $0x54, %esi
leaq 0x2795e9(%rip), %rdx # 0xbc6a3f
movb $0x0, %al
callq 0x9401f0
movl $0xffffffec, -0x22c(%rbp) # imm = 0xFFFFFFEC
jmp 0x94d469
movq -0x238(%rbp), %rax
cmpq $0x64, 0x18(%rax)
jbe 0x94d5b2
movq -0x238(%rbp), %rax
movq 0x18(%rax), %rax
addq $0x1, %rax
movq %rax, -0x278(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8e9900
movq %rax, -0x280(%rbp)
movq -0x280(%rbp), %rdi
leaq 0x23c0e9(%rip), %rsi # 0xb89598
callq 0x8ec530
movq -0x280(%rbp), %rdi
leaq 0x2797f8(%rip), %rsi # 0xbc6cba
callq 0x8eb2e0
movq -0x280(%rbp), %rdi
leaq 0x2797eb(%rip), %rsi # 0xbc6cc0
callq 0x8ebee0
movq -0x280(%rbp), %rdi
movq -0x278(%rbp), %rsi
callq 0x8ec160
movq -0x10(%rbp), %rdi
leaq -0x220(%rbp), %rsi
movq -0x280(%rbp), %rdx
movl $0x4b, %ecx
callq 0x94da40
movl %eax, -0x228(%rbp)
movq -0x280(%rbp), %rdi
callq 0x8e9990
cmpl $-0x14, -0x228(%rbp)
jge 0x94d529
jmp 0x94d8c5
movq -0x10(%rbp), %rdi
leaq -0x220(%rbp), %rsi
movl $0x200, %edx # imm = 0x200
callq 0x941080
movl %eax, -0x228(%rbp)
cmpl $-0x14, -0x228(%rbp)
jge 0x94d552
jmp 0x94d8c5
movq -0x10(%rbp), %rdi
movq -0x238(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x278(%rbp), %rdx
callq 0x941080
movl %eax, -0x228(%rbp)
cmpl $-0x14, -0x228(%rbp)
jge 0x94d581
jmp 0x94d8c5
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
subq -0x278(%rbp), %rsi
andq $0x1ff, %rsi # imm = 0x1FF
callq 0x9410c0
movl %eax, -0x228(%rbp)
cmpl $-0x14, -0x228(%rbp)
jge 0x94d5b0
jmp 0x94d8c5
jmp 0x94d5b2
movq -0x238(%rbp), %rax
cmpq $0x64, 0x28(%rax)
jbe 0x94d709
movq -0x238(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x288(%rbp)
movq -0x238(%rbp), %rax
movq 0x28(%rax), %rax
addq $0x1, %rax
movq %rax, -0x290(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8e9900
movq %rax, -0x298(%rbp)
movq -0x298(%rbp), %rdi
leaq 0x23bf8e(%rip), %rsi # 0xb89598
callq 0x8ec530
movq -0x298(%rbp), %rdi
leaq 0x27969d(%rip), %rsi # 0xbc6cba
callq 0x8eb2e0
movq -0x298(%rbp), %rdi
leaq 0x279690(%rip), %rsi # 0xbc6cc0
callq 0x8ebee0
movq -0x298(%rbp), %rdi
movq -0x290(%rbp), %rsi
callq 0x8ec160
movq -0x10(%rbp), %rdi
leaq -0x220(%rbp), %rsi
movq -0x298(%rbp), %rdx
movl $0x4c, %ecx
callq 0x94da40
movl %eax, -0x228(%rbp)
movq -0x298(%rbp), %rdi
callq 0x8e9990
cmpl $-0x14, -0x228(%rbp)
jge 0x94d684
jmp 0x94d8c5
movq -0x10(%rbp), %rdi
leaq -0x220(%rbp), %rsi
movl $0x200, %edx # imm = 0x200
callq 0x941080
movl %eax, -0x228(%rbp)
cmpl $-0x14, -0x228(%rbp)
jge 0x94d6ad
jmp 0x94d8c5
movq -0x10(%rbp), %rdi
movq -0x288(%rbp), %rsi
movq -0x290(%rbp), %rdx
callq 0x941080
movl %eax, -0x228(%rbp)
cmpl $-0x14, -0x228(%rbp)
jge 0x94d6d8
jmp 0x94d8c5
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
subq -0x290(%rbp), %rsi
andq $0x1ff, %rsi # imm = 0x1FF
callq 0x9410c0
movl %eax, -0x228(%rbp)
cmpl $-0x14, -0x228(%rbp)
jge 0x94d707
jmp 0x94d8c5
jmp 0x94d709
movq -0x18(%rbp), %rdi
callq 0x8ea180
cmpq $0x0, %rax
je 0x94d727
movl $0x31, -0x230(%rbp)
jmp 0x94d7fd
movq -0x18(%rbp), %rdi
callq 0x8e9c10
movl %eax, %ecx
movl %ecx, -0x2f4(%rbp)
subl $0x1000, %eax # imm = 0x1000
je 0x94d7cc
jmp 0x94d745
movl -0x2f4(%rbp), %eax
subl $0x2000, %eax # imm = 0x2000
je 0x94d7a8
jmp 0x94d754
movl -0x2f4(%rbp), %eax
subl $0x4000, %eax # imm = 0x4000
je 0x94d7c0
jmp 0x94d763
movl -0x2f4(%rbp), %eax
subl $0x6000, %eax # imm = 0x6000
je 0x94d7b4
jmp 0x94d772
movl -0x2f4(%rbp), %eax
subl $0x8000, %eax # imm = 0x8000
je 0x94d790
jmp 0x94d781
movl -0x2f4(%rbp), %eax
subl $0xa000, %eax # imm = 0xA000
je 0x94d79c
jmp 0x94d7d8
movl $0x30, -0x230(%rbp)
jmp 0x94d7fb
movl $0x32, -0x230(%rbp)
jmp 0x94d7fb
movl $0x33, -0x230(%rbp)
jmp 0x94d7fb
movl $0x34, -0x230(%rbp)
jmp 0x94d7fb
movl $0x35, -0x230(%rbp)
jmp 0x94d7fb
movl $0x36, -0x230(%rbp)
jmp 0x94d7fb
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq 0x270665(%rip), %rdx # 0xbbde4c
callq 0x98bca0
movl $0xffffffe7, -0x228(%rbp) # imm = 0xFFFFFFE7
jmp 0x94d8c5
jmp 0x94d7fd
movq -0x10(%rbp), %rdi
leaq -0x220(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x230(%rbp), %ecx
callq 0x94da40
movl %eax, -0x228(%rbp)
cmpl $-0x14, -0x228(%rbp)
jge 0x94d82b
jmp 0x94d8c5
movl -0x22c(%rbp), %eax
cmpl -0x228(%rbp), %eax
jge 0x94d845
movl -0x22c(%rbp), %eax
movl %eax, -0x228(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x220(%rbp), %rsi
movl $0x200, %edx # imm = 0x200
callq 0x941080
movl %eax, -0x22c(%rbp)
cmpl $-0x14, -0x22c(%rbp)
jge 0x94d877
movl -0x22c(%rbp), %eax
movl %eax, -0x228(%rbp)
jmp 0x94d8c5
movl -0x22c(%rbp), %eax
cmpl -0x228(%rbp), %eax
jge 0x94d891
movl -0x22c(%rbp), %eax
movl %eax, -0x228(%rbp)
movq -0x18(%rbp), %rdi
callq 0x8ea740
movq %rax, %rcx
movq -0x238(%rbp), %rax
movq %rcx, (%rax)
movq -0x238(%rbp), %rax
xorl %ecx, %ecx
subq (%rax), %rcx
andq $0x1ff, %rcx # imm = 0x1FF
movq -0x238(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x248(%rbp), %rdi
callq 0x8e9990
movl -0x228(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x300, %rsp # imm = 0x300
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_gnutar.c
|
archive_write_gnutar_finish_entry
|
static int
archive_write_gnutar_finish_entry(struct archive_write *a)
{
struct gnutar *gnutar;
int ret;
gnutar = (struct gnutar *)a->format_data;
ret = __archive_write_nulls(a, (size_t)
(gnutar->entry_bytes_remaining + gnutar->entry_padding));
gnutar->entry_bytes_remaining = gnutar->entry_padding = 0;
return (ret);
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0xf8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rax
addq 0x8(%rax), %rsi
callq 0x9410c0
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_gnutar.c
|
archive_write_set_format_iso9660
|
int
archive_write_set_format_iso9660(struct archive *_a)
{
struct archive_write *a = (struct archive_write *)_a;
struct iso9660 *iso9660;
archive_check_magic(_a, ARCHIVE_WRITE_MAGIC,
ARCHIVE_STATE_NEW, "archive_write_set_format_iso9660");
/* If another format was already registered, unregister it. */
if (a->format_free != NULL)
(a->format_free)(a);
iso9660 = calloc(1, sizeof(*iso9660));
if (iso9660 == NULL) {
archive_set_error(&a->archive, ENOMEM,
"Can't allocate iso9660 data");
return (ARCHIVE_FATAL);
}
iso9660->birth_time = 0;
iso9660->temp_fd = -1;
iso9660->cur_file = NULL;
iso9660->primary.max_depth = 0;
iso9660->primary.vdd_type = VDD_PRIMARY;
iso9660->primary.pathtbl = NULL;
iso9660->joliet.rootent = NULL;
iso9660->joliet.max_depth = 0;
iso9660->joliet.vdd_type = VDD_JOLIET;
iso9660->joliet.pathtbl = NULL;
isofile_init_entry_list(iso9660);
isofile_init_entry_data_file_list(iso9660);
isofile_init_hardlinks(iso9660);
iso9660->directories_too_deep = NULL;
iso9660->dircnt_max = 1;
iso9660->wbuff_remaining = wb_buffmax();
iso9660->wbuff_type = WB_TO_TEMP;
iso9660->wbuff_offset = 0;
iso9660->wbuff_written = 0;
iso9660->wbuff_tail = 0;
archive_string_init(&(iso9660->utf16be));
archive_string_init(&(iso9660->mbs));
/*
* Init Identifiers used for PVD and SVD.
*/
archive_string_init(&(iso9660->volume_identifier));
archive_strcpy(&(iso9660->volume_identifier), "CDROM");
archive_string_init(&(iso9660->publisher_identifier));
archive_string_init(&(iso9660->data_preparer_identifier));
archive_string_init(&(iso9660->application_identifier));
archive_strcpy(&(iso9660->application_identifier),
archive_version_string());
archive_string_init(&(iso9660->copyright_file_identifier));
archive_string_init(&(iso9660->abstract_file_identifier));
archive_string_init(&(iso9660->bibliographic_file_identifier));
/*
* Init El Torito bootable CD variables.
*/
archive_string_init(&(iso9660->el_torito.catalog_filename));
iso9660->el_torito.catalog = NULL;
/* Set default file name of boot catalog */
archive_strcpy(&(iso9660->el_torito.catalog_filename),
"boot.catalog");
archive_string_init(&(iso9660->el_torito.boot_filename));
iso9660->el_torito.boot = NULL;
iso9660->el_torito.platform_id = BOOT_PLATFORM_X86;
archive_string_init(&(iso9660->el_torito.id));
iso9660->el_torito.boot_load_seg = 0;
iso9660->el_torito.boot_load_size = BOOT_LOAD_SIZE;
/*
* Init zisofs variables.
*/
#ifdef HAVE_ZLIB_H
iso9660->zisofs.block_pointers = NULL;
iso9660->zisofs.block_pointers_allocated = 0;
iso9660->zisofs.stream_valid = 0;
iso9660->zisofs.compression_level = 9;
memset(&(iso9660->zisofs.stream), 0,
sizeof(iso9660->zisofs.stream));
#endif
/*
* Set default value of iso9660 options.
*/
iso9660->opt.abstract_file = OPT_ABSTRACT_FILE_DEFAULT;
iso9660->opt.application_id = OPT_APPLICATION_ID_DEFAULT;
iso9660->opt.allow_vernum = OPT_ALLOW_VERNUM_DEFAULT;
iso9660->opt.biblio_file = OPT_BIBLIO_FILE_DEFAULT;
iso9660->opt.boot = OPT_BOOT_DEFAULT;
iso9660->opt.boot_catalog = OPT_BOOT_CATALOG_DEFAULT;
iso9660->opt.boot_info_table = OPT_BOOT_INFO_TABLE_DEFAULT;
iso9660->opt.boot_load_seg = OPT_BOOT_LOAD_SEG_DEFAULT;
iso9660->opt.boot_load_size = OPT_BOOT_LOAD_SIZE_DEFAULT;
iso9660->opt.boot_type = OPT_BOOT_TYPE_DEFAULT;
iso9660->opt.compression_level = OPT_COMPRESSION_LEVEL_DEFAULT;
iso9660->opt.copyright_file = OPT_COPYRIGHT_FILE_DEFAULT;
iso9660->opt.iso_level = OPT_ISO_LEVEL_DEFAULT;
iso9660->opt.joliet = OPT_JOLIET_DEFAULT;
iso9660->opt.limit_depth = OPT_LIMIT_DEPTH_DEFAULT;
iso9660->opt.limit_dirs = OPT_LIMIT_DIRS_DEFAULT;
iso9660->opt.pad = OPT_PAD_DEFAULT;
iso9660->opt.publisher = OPT_PUBLISHER_DEFAULT;
iso9660->opt.rr = OPT_RR_DEFAULT;
iso9660->opt.volume_id = OPT_VOLUME_ID_DEFAULT;
iso9660->opt.zisofs = OPT_ZISOFS_DEFAULT;
/* Create the root directory. */
iso9660->primary.rootent =
isoent_create_virtual_dir(a, iso9660, "");
if (iso9660->primary.rootent == NULL) {
free(iso9660);
archive_set_error(&a->archive, ENOMEM,
"Can't allocate memory");
return (ARCHIVE_FATAL);
}
iso9660->primary.rootent->parent = iso9660->primary.rootent;
iso9660->cur_dirent = iso9660->primary.rootent;
archive_string_init(&(iso9660->cur_dirstr));
archive_string_ensure(&(iso9660->cur_dirstr), 1);
iso9660->cur_dirstr.s[0] = 0;
iso9660->sconv_to_utf16be = NULL;
iso9660->sconv_from_utf16be = NULL;
a->format_data = iso9660;
a->format_name = "iso9660";
a->format_options = iso9660_options;
a->format_write_header = iso9660_write_header;
a->format_write_data = iso9660_write_data;
a->format_finish_entry = iso9660_finish_entry;
a->format_close = iso9660_close;
a->format_free = iso9660_free;
a->archive.archive_format = ARCHIVE_FORMAT_ISO9660;
a->archive.archive_format_name = "ISO9660";
return (ARCHIVE_OK);
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0xb0c5c0de, %esi # imm = 0xB0C5C0DE
movl $0x1, %edx
leaq 0x27936f(%rip), %rcx # 0xbc73a8
callq 0x9770c0
movl %eax, -0x24(%rbp)
cmpl $-0x1e, -0x24(%rbp)
jne 0x94e053
movl $0xffffffe2, -0x4(%rbp) # imm = 0xFFFFFFE2
jmp 0x94e8b8
jmp 0x94e055
movq -0x18(%rbp), %rax
cmpq $0x0, 0x138(%rax)
je 0x94e074
movq -0x18(%rbp), %rax
movq 0x138(%rax), %rax
movq -0x18(%rbp), %rdi
callq *%rax
movl $0x1, %edi
movl $0x10378, %esi # imm = 0x10378
callq 0x3e570
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x94e0b1
movq -0x18(%rbp), %rdi
movl $0xc, %esi
leaq 0x26d6fe(%rip), %rdx # 0xbbb79c
movb $0x0, %al
callq 0x9401f0
movl $0xffffffe2, -0x4(%rbp) # imm = 0xFFFFFFE2
jmp 0x94e8b8
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movq -0x20(%rbp), %rax
movl $0xffffffff, 0x8(%rax) # imm = 0xFFFFFFFF
movq -0x20(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0xd0(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0xc0(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0xc8(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0xe8(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x100(%rax)
movq -0x20(%rbp), %rax
movl $0x1, 0xf0(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0xf8(%rax)
movq -0x20(%rbp), %rdi
callq 0x94e8d0
movq -0x20(%rbp), %rdi
callq 0x94e900
movq -0x20(%rbp), %rdi
callq 0x94e930
movq -0x20(%rbp), %rax
movq $0x0, 0x2d0(%rax)
movq -0x20(%rbp), %rax
movl $0x1, 0x2d8(%rax)
movq -0x20(%rbp), %rax
movq $0x10000, 0x102e0(%rax) # imm = 0x10000
movq -0x20(%rbp), %rax
movl $0x1, 0x102e8(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x102f0(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x102f8(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x10300(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x48(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x50(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x58(%rax)
jmp 0x94e1e0
movq -0x20(%rbp), %rax
movq $0x0, 0x60(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x68(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x70(%rax)
jmp 0x94e206
movq -0x20(%rbp), %rax
movq $0x0, 0x128(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x130(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x138(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x130(%rax)
movq -0x20(%rbp), %rdi
addq $0x128, %rdi # imm = 0x128
leaq 0x279175(%rip), %rsi # 0xbc73c9
movl $0x5, %edx
callq 0x938660
movq -0x20(%rbp), %rax
movq $0x0, 0x140(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x148(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x150(%rax)
jmp 0x94e28d
movq -0x20(%rbp), %rax
movq $0x0, 0x158(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x160(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x168(%rax)
jmp 0x94e2bc
movq -0x20(%rbp), %rax
movq $0x0, 0x170(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x178(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x180(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x178(%rax)
movq -0x20(%rbp), %rax
addq $0x170, %rax # imm = 0x170
movq %rax, -0x38(%rbp)
callq 0x940070
movq %rax, -0x30(%rbp)
callq 0x940070
cmpq $0x0, %rax
jne 0x94e322
xorl %eax, %eax
movq %rax, -0x40(%rbp)
jmp 0x94e333
callq 0x940070
movq %rax, %rdi
callq 0x3b8f0
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rdx
callq 0x938660
movq -0x20(%rbp), %rax
movq $0x0, 0x188(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x190(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x198(%rax)
jmp 0x94e373
movq -0x20(%rbp), %rax
movq $0x0, 0x1a0(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x1a8(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x1b0(%rax)
jmp 0x94e3a2
movq -0x20(%rbp), %rax
movq $0x0, 0x1b8(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x1c0(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x1c8(%rax)
jmp 0x94e3d1
movq -0x20(%rbp), %rax
movq $0x0, 0x10308(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x10310(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x10318(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x10320(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x10310(%rax)
movq -0x20(%rbp), %rdi
addq $0x10308, %rdi # imm = 0x10308
leaq 0x278fa1(%rip), %rsi # 0xbc73cf
movl $0xc, %edx
callq 0x938660
movq -0x20(%rbp), %rax
movq $0x0, 0x10328(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x10330(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x10338(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x10340(%rax)
movq -0x20(%rbp), %rax
movb $0x0, 0x10348(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x10350(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x10358(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x10360(%rax)
movq -0x20(%rbp), %rax
movw $0x0, 0x1036a(%rax)
movq -0x20(%rbp), %rax
movw $0x4, 0x1036c(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x220(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x228(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x2b8(%rax)
movq -0x20(%rbp), %rax
movl $0x9, 0x2c8(%rax)
movq -0x20(%rbp), %rdi
addq $0x1d8, %rdi # imm = 0x1D8
addq $0x70, %rdi
xorl %esi, %esi
movl $0x70, %edx
callq 0x3b780
movq -0x20(%rbp), %rax
movl 0x10370(%rax), %ecx
andl $-0x2, %ecx
orl $0x0, %ecx
movl %ecx, 0x10370(%rax)
movq -0x20(%rbp), %rax
movl 0x10370(%rax), %ecx
andl $-0x3, %ecx
orl $0x0, %ecx
movl %ecx, 0x10370(%rax)
movq -0x20(%rbp), %rax
movl 0x10370(%rax), %ecx
andl $-0x5, %ecx
orl $0x4, %ecx
movl %ecx, 0x10370(%rax)
movq -0x20(%rbp), %rax
movl 0x10370(%rax), %ecx
andl $-0x9, %ecx
orl $0x0, %ecx
movl %ecx, 0x10370(%rax)
movq -0x20(%rbp), %rax
movl 0x10370(%rax), %ecx
andl $-0x11, %ecx
orl $0x0, %ecx
movl %ecx, 0x10370(%rax)
movq -0x20(%rbp), %rax
movl 0x10370(%rax), %ecx
andl $-0x21, %ecx
orl $0x0, %ecx
movl %ecx, 0x10370(%rax)
movq -0x20(%rbp), %rax
movl 0x10370(%rax), %ecx
andl $-0x41, %ecx
orl $0x0, %ecx
movl %ecx, 0x10370(%rax)
movq -0x20(%rbp), %rax
movl 0x10370(%rax), %ecx
andl $0xffffff7f, %ecx # imm = 0xFFFFFF7F
orl $0x0, %ecx
movl %ecx, 0x10370(%rax)
movq -0x20(%rbp), %rax
movl 0x10370(%rax), %ecx
andl $0xfffffeff, %ecx # imm = 0xFFFFFEFF
orl $0x0, %ecx
movl %ecx, 0x10370(%rax)
movq -0x20(%rbp), %rax
movl 0x10370(%rax), %ecx
andl $0xfffff9ff, %ecx # imm = 0xFFFFF9FF
orl $0x0, %ecx
movl %ecx, 0x10370(%rax)
movq -0x20(%rbp), %rax
movl 0x10370(%rax), %ecx
andl $0xfffff7ff, %ecx # imm = 0xFFFFF7FF
orl $0x0, %ecx
movl %ecx, 0x10370(%rax)
movq -0x20(%rbp), %rax
movl 0x10370(%rax), %ecx
andl $0xffffefff, %ecx # imm = 0xFFFFEFFF
orl $0x0, %ecx
movl %ecx, 0x10370(%rax)
movq -0x20(%rbp), %rax
movl 0x10370(%rax), %ecx
andl $0xfffe3fff, %ecx # imm = 0xFFFE3FFF
orl $0x4000, %ecx # imm = 0x4000
movl %ecx, 0x10370(%rax)
movq -0x20(%rbp), %rax
movl 0x10370(%rax), %ecx
andl $0xfff9ffff, %ecx # imm = 0xFFF9FFFF
orl $0x20000, %ecx # imm = 0x20000
movl %ecx, 0x10370(%rax)
movq -0x20(%rbp), %rax
movl 0x10370(%rax), %ecx
andl $0xfff7ffff, %ecx # imm = 0xFFF7FFFF
orl $0x80000, %ecx # imm = 0x80000
movl %ecx, 0x10370(%rax)
movq -0x20(%rbp), %rax
movl 0x10370(%rax), %ecx
andl $0xffefffff, %ecx # imm = 0xFFEFFFFF
orl $0x100000, %ecx # imm = 0x100000
movl %ecx, 0x10370(%rax)
movq -0x20(%rbp), %rax
movl 0x10370(%rax), %ecx
andl $0xffdfffff, %ecx # imm = 0xFFDFFFFF
orl $0x200000, %ecx # imm = 0x200000
movl %ecx, 0x10370(%rax)
movq -0x20(%rbp), %rax
movl 0x10370(%rax), %ecx
andl $0xffbfffff, %ecx # imm = 0xFFBFFFFF
orl $0x0, %ecx
movl %ecx, 0x10370(%rax)
movq -0x20(%rbp), %rax
movl 0x10370(%rax), %ecx
andl $0xfe7fffff, %ecx # imm = 0xFE7FFFFF
orl $0x1000000, %ecx # imm = 0x1000000
movl %ecx, 0x10370(%rax)
movq -0x20(%rbp), %rax
movl 0x10370(%rax), %ecx
andl $0xfdffffff, %ecx # imm = 0xFDFFFFFF
orl $0x0, %ecx
movl %ecx, 0x10370(%rax)
movq -0x20(%rbp), %rax
movl 0x10370(%rax), %ecx
andl $0xfbffffff, %ecx # imm = 0xFBFFFFFF
orl $0x0, %ecx
movl %ecx, 0x10370(%rax)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
leaq 0x270a83(%rip), %rdx # 0xbbf1b7
callq 0x94e960
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0xb8(%rax)
movq -0x20(%rbp), %rax
cmpq $0x0, 0xb8(%rax)
jne 0x94e781
movq -0x20(%rbp), %rdi
callq 0x3e548
movq -0x18(%rbp), %rdi
movl $0xc, %esi
leaq 0x26b44f(%rip), %rdx # 0xbb9bbd
movb $0x0, %al
callq 0x9401f0
movl $0xffffffe2, -0x4(%rbp) # imm = 0xFFFFFFE2
jmp 0x94e8b8
movq -0x20(%rbp), %rax
movq 0xb8(%rax), %rcx
movq -0x20(%rbp), %rax
movq 0xb8(%rax), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rax
movq 0xb8(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x20(%rbp), %rdi
addq $0x20, %rdi
movl $0x1, %esi
callq 0x938530
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movb $0x0, (%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x78(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x80(%rax)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0xf8(%rax)
movq -0x18(%rbp), %rax
leaq 0x278b9d(%rip), %rcx # 0xbc73c1
movq %rcx, 0x100(%rax)
movq -0x18(%rbp), %rax
leaq 0x28a(%rip), %rcx # 0x94eac0
movq %rcx, 0x110(%rax)
movq -0x18(%rbp), %rax
leaq 0xe68(%rip), %rcx # 0x94f6b0
movq %rcx, 0x120(%rax)
movq -0x18(%rbp), %rax
leaq 0x1216(%rip), %rcx # 0x94fa70
movq %rcx, 0x128(%rax)
movq -0x18(%rbp), %rax
leaq 0x12d4(%rip), %rcx # 0x94fb40
movq %rcx, 0x118(%rax)
movq -0x18(%rbp), %rax
leaq 0x1472(%rip), %rcx # 0x94fcf0
movq %rcx, 0x130(%rax)
movq -0x18(%rbp), %rax
leaq 0x1c50(%rip), %rcx # 0x9504e0
movq %rcx, 0x138(%rax)
movq -0x18(%rbp), %rax
movl $0x40000, 0x10(%rax) # imm = 0x40000
movq -0x18(%rbp), %rax
leaq 0x26cf34(%rip), %rcx # 0xbbb7e1
movq %rcx, 0x18(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c
|
iso9660_options
|
static int
iso9660_options(struct archive_write *a, const char *key, const char *value)
{
struct iso9660 *iso9660 = a->format_data;
const char *p;
int r;
switch (key[0]) {
case 'a':
if (strcmp(key, "abstract-file") == 0) {
r = get_str_opt(a,
&(iso9660->abstract_file_identifier),
ABSTRACT_FILE_SIZE, key, value);
iso9660->opt.abstract_file = r == ARCHIVE_OK;
return (r);
}
if (strcmp(key, "application-id") == 0) {
r = get_str_opt(a,
&(iso9660->application_identifier),
APPLICATION_IDENTIFIER_SIZE, key, value);
iso9660->opt.application_id = r == ARCHIVE_OK;
return (r);
}
if (strcmp(key, "allow-vernum") == 0) {
iso9660->opt.allow_vernum = value != NULL;
return (ARCHIVE_OK);
}
break;
case 'b':
if (strcmp(key, "biblio-file") == 0) {
r = get_str_opt(a,
&(iso9660->bibliographic_file_identifier),
BIBLIO_FILE_SIZE, key, value);
iso9660->opt.biblio_file = r == ARCHIVE_OK;
return (r);
}
if (strcmp(key, "boot") == 0) {
if (value == NULL)
iso9660->opt.boot = 0;
else {
iso9660->opt.boot = 1;
archive_strcpy(
&(iso9660->el_torito.boot_filename),
value);
}
return (ARCHIVE_OK);
}
if (strcmp(key, "boot-catalog") == 0) {
r = get_str_opt(a,
&(iso9660->el_torito.catalog_filename),
1024, key, value);
iso9660->opt.boot_catalog = r == ARCHIVE_OK;
return (r);
}
if (strcmp(key, "boot-info-table") == 0) {
iso9660->opt.boot_info_table = value != NULL;
return (ARCHIVE_OK);
}
if (strcmp(key, "boot-load-seg") == 0) {
uint32_t seg;
iso9660->opt.boot_load_seg = 0;
if (value == NULL)
goto invalid_value;
seg = 0;
p = value;
if (p[0] == '0' && (p[1] == 'x' || p[1] == 'X'))
p += 2;
while (*p) {
if (seg)
seg <<= 4;
if (*p >= 'A' && *p <= 'F')
seg += *p - 'A' + 0x0a;
else if (*p >= 'a' && *p <= 'f')
seg += *p - 'a' + 0x0a;
else if (*p >= '0' && *p <= '9')
seg += *p - '0';
else
goto invalid_value;
if (seg > 0xffff) {
archive_set_error(&a->archive,
ARCHIVE_ERRNO_MISC,
"Invalid value(over 0xffff) for "
"option ``%s''", key);
return (ARCHIVE_FATAL);
}
p++;
}
iso9660->el_torito.boot_load_seg = (uint16_t)seg;
iso9660->opt.boot_load_seg = 1;
return (ARCHIVE_OK);
}
if (strcmp(key, "boot-load-size") == 0) {
int num = 0;
r = get_num_opt(a, &num, 0xffff, 1, key, value);
iso9660->opt.boot_load_size = r == ARCHIVE_OK;
if (r != ARCHIVE_OK)
return (ARCHIVE_FATAL);
iso9660->el_torito.boot_load_size = (uint16_t)num;
return (ARCHIVE_OK);
}
if (strcmp(key, "boot-type") == 0) {
if (value == NULL)
goto invalid_value;
if (strcmp(value, "no-emulation") == 0)
iso9660->opt.boot_type = OPT_BOOT_TYPE_NO_EMU;
else if (strcmp(value, "fd") == 0)
iso9660->opt.boot_type = OPT_BOOT_TYPE_FD;
else if (strcmp(value, "hard-disk") == 0)
iso9660->opt.boot_type = OPT_BOOT_TYPE_HARD_DISK;
else
goto invalid_value;
return (ARCHIVE_OK);
}
break;
case 'c':
if (strcmp(key, "compression-level") == 0) {
#ifdef HAVE_ZLIB_H
if (value == NULL ||
!(value[0] >= '0' && value[0] <= '9') ||
value[1] != '\0')
goto invalid_value;
iso9660->zisofs.compression_level = value[0] - '0';
iso9660->opt.compression_level = 1;
return (ARCHIVE_OK);
#else
archive_set_error(&a->archive,
ARCHIVE_ERRNO_MISC,
"Option ``%s'' "
"is not supported on this platform.", key);
return (ARCHIVE_FATAL);
#endif
}
if (strcmp(key, "copyright-file") == 0) {
r = get_str_opt(a,
&(iso9660->copyright_file_identifier),
COPYRIGHT_FILE_SIZE, key, value);
iso9660->opt.copyright_file = r == ARCHIVE_OK;
return (r);
}
#ifdef DEBUG
/* Specifies Volume creation date and time;
* year(4),month(2),day(2),hour(2),minute(2),second(2).
* e.g. "20090929033757"
*/
if (strcmp(key, "creation") == 0) {
struct tm tm;
char buf[5];
p = value;
if (p == NULL || strlen(p) < 14)
goto invalid_value;
memset(&tm, 0, sizeof(tm));
memcpy(buf, p, 4); buf[4] = '\0'; p += 4;
tm.tm_year = strtol(buf, NULL, 10) - 1900;
memcpy(buf, p, 2); buf[2] = '\0'; p += 2;
tm.tm_mon = strtol(buf, NULL, 10) - 1;
memcpy(buf, p, 2); buf[2] = '\0'; p += 2;
tm.tm_mday = strtol(buf, NULL, 10);
memcpy(buf, p, 2); buf[2] = '\0'; p += 2;
tm.tm_hour = strtol(buf, NULL, 10);
memcpy(buf, p, 2); buf[2] = '\0'; p += 2;
tm.tm_min = strtol(buf, NULL, 10);
memcpy(buf, p, 2); buf[2] = '\0';
tm.tm_sec = strtol(buf, NULL, 10);
iso9660->birth_time = mktime(&tm);
return (ARCHIVE_OK);
}
#endif
break;
case 'i':
if (strcmp(key, "iso-level") == 0) {
if (value != NULL && value[1] == '\0' &&
(value[0] >= '1' && value[0] <= '4')) {
iso9660->opt.iso_level = value[0]-'0';
return (ARCHIVE_OK);
}
goto invalid_value;
}
break;
case 'j':
if (strcmp(key, "joliet") == 0) {
if (value == NULL)
iso9660->opt.joliet = OPT_JOLIET_DISABLE;
else if (strcmp(value, "1") == 0)
iso9660->opt.joliet = OPT_JOLIET_ENABLE;
else if (strcmp(value, "long") == 0)
iso9660->opt.joliet = OPT_JOLIET_LONGNAME;
else
goto invalid_value;
return (ARCHIVE_OK);
}
break;
case 'l':
if (strcmp(key, "limit-depth") == 0) {
iso9660->opt.limit_depth = value != NULL;
return (ARCHIVE_OK);
}
if (strcmp(key, "limit-dirs") == 0) {
iso9660->opt.limit_dirs = value != NULL;
return (ARCHIVE_OK);
}
break;
case 'p':
if (strcmp(key, "pad") == 0) {
iso9660->opt.pad = value != NULL;
return (ARCHIVE_OK);
}
if (strcmp(key, "publisher") == 0) {
r = get_str_opt(a,
&(iso9660->publisher_identifier),
PUBLISHER_IDENTIFIER_SIZE, key, value);
iso9660->opt.publisher = r == ARCHIVE_OK;
return (r);
}
break;
case 'r':
if (strcmp(key, "rockridge") == 0 ||
strcmp(key, "Rockridge") == 0) {
if (value == NULL)
iso9660->opt.rr = OPT_RR_DISABLED;
else if (strcmp(value, "1") == 0)
iso9660->opt.rr = OPT_RR_USEFUL;
else if (strcmp(value, "strict") == 0)
iso9660->opt.rr = OPT_RR_STRICT;
else if (strcmp(value, "useful") == 0)
iso9660->opt.rr = OPT_RR_USEFUL;
else
goto invalid_value;
return (ARCHIVE_OK);
}
break;
case 'v':
if (strcmp(key, "volume-id") == 0) {
r = get_str_opt(a, &(iso9660->volume_identifier),
VOLUME_IDENTIFIER_SIZE, key, value);
iso9660->opt.volume_id = r == ARCHIVE_OK;
return (r);
}
break;
case 'z':
if (strcmp(key, "zisofs") == 0) {
if (value == NULL)
iso9660->opt.zisofs = OPT_ZISOFS_DISABLED;
else {
#ifdef HAVE_ZLIB_H
iso9660->opt.zisofs = OPT_ZISOFS_DIRECT;
#else
archive_set_error(&a->archive,
ARCHIVE_ERRNO_MISC,
"``zisofs'' "
"is not supported on this platform.");
return (ARCHIVE_FATAL);
#endif
}
return (ARCHIVE_OK);
}
break;
}
/* Note: The "warn" return is just to inform the options
* supervisor that we didn't handle it. It will generate
* a suitable error if no one used this option. */
return (ARCHIVE_WARN);
invalid_value:
archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
"Invalid value for option ``%s''", key);
return (ARCHIVE_FAILED);
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0xf8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
addl $-0x61, %eax
movl %eax, %ecx
movq %rcx, -0x48(%rbp)
subl $0x19, %eax
ja 0x94f677
movq -0x48(%rbp), %rax
leaq 0x278459(%rip), %rcx # 0xbc6f60
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x18(%rbp), %rdi
leaq 0x2788c1(%rip), %rsi # 0xbc73dc
callq 0x3dbb0
cmpl $0x0, %eax
jne 0x94eb78
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
addq $0x1a0, %rsi # imm = 0x1A0
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
movl $0x25, %edx
callq 0x950700
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %edx
movq -0x28(%rbp), %rax
movl 0x10370(%rax), %ecx
andl $0x1, %edx
andl $-0x2, %ecx
orl %edx, %ecx
movl %ecx, 0x10370(%rax)
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x94f6a2
movq -0x18(%rbp), %rdi
leaq 0x278867(%rip), %rsi # 0xbc73ea
callq 0x3dbb0
cmpl $0x0, %eax
jne 0x94ebe2
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
addq $0x170, %rsi # imm = 0x170
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
movl $0x80, %edx
callq 0x950700
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %edx
movq -0x28(%rbp), %rax
movl 0x10370(%rax), %ecx
andl $0x1, %edx
shll %edx
andl $-0x3, %ecx
orl %edx, %ecx
movl %ecx, 0x10370(%rax)
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x94f6a2
movq -0x18(%rbp), %rdi
leaq 0x27880c(%rip), %rsi # 0xbc73f9
callq 0x3dbb0
cmpl $0x0, %eax
jne 0x94ec2b
cmpq $0x0, -0x20(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %edx
movq -0x28(%rbp), %rax
movl 0x10370(%rax), %ecx
andl $0x1, %edx
shll $0x2, %edx
andl $-0x5, %ecx
orl %edx, %ecx
movl %ecx, 0x10370(%rax)
movl $0x0, -0x4(%rbp)
jmp 0x94f6a2
jmp 0x94f677
movq -0x18(%rbp), %rdi
leaq 0x2787cb(%rip), %rsi # 0xbc7406
callq 0x3dbb0
cmpl $0x0, %eax
jne 0x94ec9b
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
addq $0x1b8, %rsi # imm = 0x1B8
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
movl $0x25, %edx
callq 0x950700
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %edx
movq -0x28(%rbp), %rax
movl 0x10370(%rax), %ecx
andl $0x1, %edx
shll $0x3, %edx
andl $-0x9, %ecx
orl %edx, %ecx
movl %ecx, 0x10370(%rax)
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x94f6a2
movq -0x18(%rbp), %rdi
leaq 0x27876c(%rip), %rsi # 0xbc7412
callq 0x3dbb0
cmpl $0x0, %eax
jne 0x94ed4b
cmpq $0x0, -0x20(%rbp)
jne 0x94ecd3
movq -0x28(%rbp), %rax
movl 0x10370(%rax), %ecx
andl $-0x11, %ecx
orl $0x0, %ecx
movl %ecx, 0x10370(%rax)
jmp 0x94ed3f
movq -0x28(%rbp), %rax
movl 0x10370(%rax), %ecx
andl $-0x11, %ecx
orl $0x10, %ecx
movl %ecx, 0x10370(%rax)
movq -0x28(%rbp), %rax
movq $0x0, 0x10330(%rax)
movq -0x28(%rbp), %rax
addq $0x10308, %rax # imm = 0x10308
addq $0x20, %rax
movq %rax, -0x58(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x94ed21
xorl %eax, %eax
movq %rax, -0x60(%rbp)
jmp 0x94ed2e
movq -0x20(%rbp), %rdi
callq 0x3b8f0
movq %rax, -0x60(%rbp)
movq -0x50(%rbp), %rsi
movq -0x58(%rbp), %rdi
movq -0x60(%rbp), %rdx
callq 0x938660
movl $0x0, -0x4(%rbp)
jmp 0x94f6a2
movq -0x18(%rbp), %rdi
leaq 0x2786c1(%rip), %rsi # 0xbc7417
callq 0x3dbb0
cmpl $0x0, %eax
jne 0x94edb6
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
addq $0x10308, %rsi # imm = 0x10308
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
movl $0x400, %edx # imm = 0x400
callq 0x950700
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %edx
movq -0x28(%rbp), %rax
movl 0x10370(%rax), %ecx
andl $0x1, %edx
shll $0x5, %edx
andl $-0x21, %ecx
orl %edx, %ecx
movl %ecx, 0x10370(%rax)
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x94f6a2
movq -0x18(%rbp), %rdi
leaq 0x278663(%rip), %rsi # 0xbc7424
callq 0x3dbb0
cmpl $0x0, %eax
jne 0x94edff
cmpq $0x0, -0x20(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %edx
movq -0x28(%rbp), %rax
movl 0x10370(%rax), %ecx
andl $0x1, %edx
shll $0x6, %edx
andl $-0x41, %ecx
orl %edx, %ecx
movl %ecx, 0x10370(%rax)
movl $0x0, -0x4(%rbp)
jmp 0x94f6a2
movq -0x18(%rbp), %rdi
leaq 0x27862a(%rip), %rsi # 0xbc7434
callq 0x3dbb0
cmpl $0x0, %eax
jne 0x94efa3
movq -0x28(%rbp), %rax
movl 0x10370(%rax), %ecx
andl $0xffffff7f, %ecx # imm = 0xFFFFFF7F
orl $0x0, %ecx
movl %ecx, 0x10370(%rax)
cmpq $0x0, -0x20(%rbp)
jne 0x94ee3d
jmp 0x94f680
movl $0x0, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x30, %eax
jne 0x94ee7e
movq -0x30(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x78, %eax
je 0x94ee72
movq -0x30(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x58, %eax
jne 0x94ee7e
movq -0x30(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x30(%rbp)
jmp 0x94ee80
movq -0x30(%rbp), %rax
cmpb $0x0, (%rax)
je 0x94ef6a
cmpl $0x0, -0x38(%rbp)
je 0x94ee9c
movl -0x38(%rbp), %eax
shll $0x4, %eax
movl %eax, -0x38(%rbp)
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x41, %eax
jl 0x94eec9
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x46, %eax
jg 0x94eec9
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
subl $0x41, %eax
addl $0xa, %eax
addl -0x38(%rbp), %eax
movl %eax, -0x38(%rbp)
jmp 0x94ef29
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x61, %eax
jl 0x94eef6
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x66, %eax
jg 0x94eef6
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
subl $0x61, %eax
addl $0xa, %eax
addl -0x38(%rbp), %eax
movl %eax, -0x38(%rbp)
jmp 0x94ef27
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x30, %eax
jl 0x94ef20
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x39, %eax
jg 0x94ef20
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
subl $0x30, %eax
addl -0x38(%rbp), %eax
movl %eax, -0x38(%rbp)
jmp 0x94ef25
jmp 0x94f680
jmp 0x94ef27
jmp 0x94ef29
cmpl $0xffff, -0x38(%rbp) # imm = 0xFFFF
jbe 0x94ef59
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rcx
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
leaq 0x2784fc(%rip), %rdx # 0xbc7442
movb $0x0, %al
callq 0x9401f0
movl $0xffffffe2, -0x4(%rbp) # imm = 0xFFFFFFE2
jmp 0x94f6a2
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x94ee80
movl -0x38(%rbp), %eax
movw %ax, %cx
movq -0x28(%rbp), %rax
movw %cx, 0x1036a(%rax)
movq -0x28(%rbp), %rax
movl 0x10370(%rax), %ecx
andl $0xffffff7f, %ecx # imm = 0xFFFFFF7F
orl $0x80, %ecx
movl %ecx, 0x10370(%rax)
movl $0x0, -0x4(%rbp)
jmp 0x94f6a2
movq -0x18(%rbp), %rdi
leaq 0x2784c1(%rip), %rsi # 0xbc746f
callq 0x3dbb0
cmpl $0x0, %eax
jne 0x94f03e
movl $0x0, -0x3c(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %r8
movq -0x20(%rbp), %r9
leaq -0x3c(%rbp), %rsi
movl $0xffff, %edx # imm = 0xFFFF
movl $0x1, %ecx
callq 0x9507b0
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %edx
movq -0x28(%rbp), %rax
movl 0x10370(%rax), %ecx
andl $0x1, %edx
shll $0x8, %edx
andl $0xfffffeff, %ecx # imm = 0xFFFFFEFF
orl %edx, %ecx
movl %ecx, 0x10370(%rax)
cmpl $0x0, -0x34(%rbp)
je 0x94f021
movl $0xffffffe2, -0x4(%rbp) # imm = 0xFFFFFFE2
jmp 0x94f6a2
movl -0x3c(%rbp), %eax
movw %ax, %cx
movq -0x28(%rbp), %rax
movw %cx, 0x1036c(%rax)
movl $0x0, -0x4(%rbp)
jmp 0x94f6a2
movq -0x18(%rbp), %rdi
leaq 0x278435(%rip), %rsi # 0xbc747e
callq 0x3dbb0
cmpl $0x0, %eax
jne 0x94f111
cmpq $0x0, -0x20(%rbp)
jne 0x94f063
jmp 0x94f680
movq -0x20(%rbp), %rdi
leaq 0x27841a(%rip), %rsi # 0xbc7488
callq 0x3dbb0
cmpl $0x0, %eax
jne 0x94f096
movq -0x28(%rbp), %rax
movl 0x10370(%rax), %ecx
andl $0xfffff9ff, %ecx # imm = 0xFFFFF9FF
orl $0x200, %ecx # imm = 0x200
movl %ecx, 0x10370(%rax)
jmp 0x94f105
movq -0x20(%rbp), %rdi
leaq 0x2783f4(%rip), %rsi # 0xbc7495
callq 0x3dbb0
cmpl $0x0, %eax
jne 0x94f0c9
movq -0x28(%rbp), %rax
movl 0x10370(%rax), %ecx
andl $0xfffff9ff, %ecx # imm = 0xFFFFF9FF
orl $0x400, %ecx # imm = 0x400
movl %ecx, 0x10370(%rax)
jmp 0x94f103
movq -0x20(%rbp), %rdi
leaq 0x2783c4(%rip), %rsi # 0xbc7498
callq 0x3dbb0
cmpl $0x0, %eax
jne 0x94f0fc
movq -0x28(%rbp), %rax
movl 0x10370(%rax), %ecx
andl $0xfffff9ff, %ecx # imm = 0xFFFFF9FF
orl $0x600, %ecx # imm = 0x600
movl %ecx, 0x10370(%rax)
jmp 0x94f101
jmp 0x94f680
jmp 0x94f103
jmp 0x94f105
movl $0x0, -0x4(%rbp)
jmp 0x94f6a2
jmp 0x94f677
movq -0x18(%rbp), %rdi
leaq 0x1f6472(%rip), %rsi # 0xb45593
callq 0x3dbb0
cmpl $0x0, %eax
jne 0x94f198
cmpq $0x0, -0x20(%rbp)
je 0x94f157
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x30, %eax
jl 0x94f157
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x39, %eax
jg 0x94f157
movq -0x20(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x0, %eax
je 0x94f15c
jmp 0x94f680
movq -0x20(%rbp), %rax
movsbl (%rax), %ecx
subl $0x30, %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x2c8(%rax)
movq -0x28(%rbp), %rax
movl 0x10370(%rax), %ecx
andl $0xfffff7ff, %ecx # imm = 0xFFFFF7FF
orl $0x800, %ecx # imm = 0x800
movl %ecx, 0x10370(%rax)
movl $0x0, -0x4(%rbp)
jmp 0x94f6a2
movq -0x18(%rbp), %rdi
leaq 0x2782ff(%rip), %rsi # 0xbc74a2
callq 0x3dbb0
cmpl $0x0, %eax
jne 0x94f206
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
addq $0x188, %rsi # imm = 0x188
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
movl $0x25, %edx
callq 0x950700
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %edx
movq -0x28(%rbp), %rax
movl 0x10370(%rax), %ecx
andl $0x1, %edx
shll $0xc, %edx
andl $0xffffefff, %ecx # imm = 0xFFFFEFFF
orl %edx, %ecx
movl %ecx, 0x10370(%rax)
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x94f6a2
jmp 0x94f677
movq -0x18(%rbp), %rdi
leaq 0x27829b(%rip), %rsi # 0xbc74b1
callq 0x3dbb0
cmpl $0x0, %eax
jne 0x94f285
cmpq $0x0, -0x20(%rbp)
je 0x94f280
movq -0x20(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x0, %eax
jne 0x94f280
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x31, %eax
jl 0x94f280
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x34, %eax
jg 0x94f280
movq -0x20(%rbp), %rax
movsbl (%rax), %edx
subl $0x30, %edx
movq -0x28(%rbp), %rax
movl 0x10370(%rax), %ecx
andl $0x7, %edx
shll $0xe, %edx
andl $0xfffe3fff, %ecx # imm = 0xFFFE3FFF
orl %edx, %ecx
movl %ecx, 0x10370(%rax)
movl $0x0, -0x4(%rbp)
jmp 0x94f6a2
jmp 0x94f680
jmp 0x94f677
movq -0x18(%rbp), %rdi
leaq 0x26c529(%rip), %rsi # 0xbbb7be
callq 0x3dbb0
cmpl $0x0, %eax
jne 0x94f340
cmpq $0x0, -0x20(%rbp)
jne 0x94f2c5
movq -0x28(%rbp), %rax
movl 0x10370(%rax), %ecx
andl $0xfff9ffff, %ecx # imm = 0xFFF9FFFF
orl $0x0, %ecx
movl %ecx, 0x10370(%rax)
jmp 0x94f334
movq -0x20(%rbp), %rdi
leaq 0x282998(%rip), %rsi # 0xbd1c68
callq 0x3dbb0
cmpl $0x0, %eax
jne 0x94f2f8
movq -0x28(%rbp), %rax
movl 0x10370(%rax), %ecx
andl $0xfff9ffff, %ecx # imm = 0xFFF9FFFF
orl $0x20000, %ecx # imm = 0x20000
movl %ecx, 0x10370(%rax)
jmp 0x94f332
movq -0x20(%rbp), %rdi
leaq 0x28c1d9(%rip), %rsi # 0xbdb4dc
callq 0x3dbb0
cmpl $0x0, %eax
jne 0x94f32b
movq -0x28(%rbp), %rax
movl 0x10370(%rax), %ecx
andl $0xfff9ffff, %ecx # imm = 0xFFF9FFFF
orl $0x40000, %ecx # imm = 0x40000
movl %ecx, 0x10370(%rax)
jmp 0x94f330
jmp 0x94f680
jmp 0x94f332
jmp 0x94f334
movl $0x0, -0x4(%rbp)
jmp 0x94f6a2
jmp 0x94f677
movq -0x18(%rbp), %rdi
leaq 0x27816b(%rip), %rsi # 0xbc74bb
callq 0x3dbb0
cmpl $0x0, %eax
jne 0x94f391
cmpq $0x0, -0x20(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %edx
movq -0x28(%rbp), %rax
movl 0x10370(%rax), %ecx
andl $0x1, %edx
shll $0x13, %edx
andl $0xfff7ffff, %ecx # imm = 0xFFF7FFFF
orl %edx, %ecx
movl %ecx, 0x10370(%rax)
movl $0x0, -0x4(%rbp)
jmp 0x94f6a2
movq -0x18(%rbp), %rdi
leaq 0x27812b(%rip), %rsi # 0xbc74c7
callq 0x3dbb0
cmpl $0x0, %eax
jne 0x94f3dd
cmpq $0x0, -0x20(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %edx
movq -0x28(%rbp), %rax
movl 0x10370(%rax), %ecx
andl $0x1, %edx
shll $0x14, %edx
andl $0xffefffff, %ecx # imm = 0xFFEFFFFF
orl %edx, %ecx
movl %ecx, 0x10370(%rax)
movl $0x0, -0x4(%rbp)
jmp 0x94f6a2
jmp 0x94f677
movq -0x18(%rbp), %rdi
leaq 0x2780e5(%rip), %rsi # 0xbc74d2
callq 0x3dbb0
cmpl $0x0, %eax
jne 0x94f42e
cmpq $0x0, -0x20(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %edx
movq -0x28(%rbp), %rax
movl 0x10370(%rax), %ecx
andl $0x1, %edx
shll $0x15, %edx
andl $0xffdfffff, %ecx # imm = 0xFFDFFFFF
orl %edx, %ecx
movl %ecx, 0x10370(%rax)
movl $0x0, -0x4(%rbp)
jmp 0x94f6a2
movq -0x18(%rbp), %rdi
leaq 0x27809d(%rip), %rsi # 0xbc74d6
callq 0x3dbb0
cmpl $0x0, %eax
jne 0x94f49c
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
addq $0x140, %rsi # imm = 0x140
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
movl $0x80, %edx
callq 0x950700
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %edx
movq -0x28(%rbp), %rax
movl 0x10370(%rax), %ecx
andl $0x1, %edx
shll $0x16, %edx
andl $0xffbfffff, %ecx # imm = 0xFFBFFFFF
orl %edx, %ecx
movl %ecx, 0x10370(%rax)
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x94f6a2
jmp 0x94f677
movq -0x18(%rbp), %rdi
leaq 0x26c321(%rip), %rsi # 0xbbb7cd
callq 0x3dbb0
cmpl $0x0, %eax
je 0x94f4cf
movq -0x18(%rbp), %rdi
leaq 0x26c316(%rip), %rsi # 0xbbb7d7
callq 0x3dbb0
cmpl $0x0, %eax
jne 0x94f5a4
cmpq $0x0, -0x20(%rbp)
jne 0x94f4f4
movq -0x28(%rbp), %rax
movl 0x10370(%rax), %ecx
andl $0xfe7fffff, %ecx # imm = 0xFE7FFFFF
orl $0x0, %ecx
movl %ecx, 0x10370(%rax)
jmp 0x94f598
movq -0x20(%rbp), %rdi
leaq 0x282769(%rip), %rsi # 0xbd1c68
callq 0x3dbb0
cmpl $0x0, %eax
jne 0x94f527
movq -0x28(%rbp), %rax
movl 0x10370(%rax), %ecx
andl $0xfe7fffff, %ecx # imm = 0xFE7FFFFF
orl $0x1000000, %ecx # imm = 0x1000000
movl %ecx, 0x10370(%rax)
jmp 0x94f596
movq -0x20(%rbp), %rdi
leaq 0x20d166(%rip), %rsi # 0xb5c698
callq 0x3dbb0
cmpl $0x0, %eax
jne 0x94f55a
movq -0x28(%rbp), %rax
movl 0x10370(%rax), %ecx
andl $0xfe7fffff, %ecx # imm = 0xFE7FFFFF
orl $0x800000, %ecx # imm = 0x800000
movl %ecx, 0x10370(%rax)
jmp 0x94f594
movq -0x20(%rbp), %rdi
leaq 0x277f7b(%rip), %rsi # 0xbc74e0
callq 0x3dbb0
cmpl $0x0, %eax
jne 0x94f58d
movq -0x28(%rbp), %rax
movl 0x10370(%rax), %ecx
andl $0xfe7fffff, %ecx # imm = 0xFE7FFFFF
orl $0x1000000, %ecx # imm = 0x1000000
movl %ecx, 0x10370(%rax)
jmp 0x94f592
jmp 0x94f680
jmp 0x94f594
jmp 0x94f596
jmp 0x94f598
movl $0x0, -0x4(%rbp)
jmp 0x94f6a2
jmp 0x94f677
movq -0x18(%rbp), %rdi
leaq 0x277f33(%rip), %rsi # 0xbc74e7
callq 0x3dbb0
cmpl $0x0, %eax
jne 0x94f617
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
addq $0x128, %rsi # imm = 0x128
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
movl $0x20, %edx
callq 0x950700
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %edx
movq -0x28(%rbp), %rax
movl 0x10370(%rax), %ecx
andl $0x1, %edx
shll $0x19, %edx
andl $0xfdffffff, %ecx # imm = 0xFDFFFFFF
orl %edx, %ecx
movl %ecx, 0x10370(%rax)
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x94f6a2
jmp 0x94f677
movq -0x18(%rbp), %rdi
leaq 0x277ecd(%rip), %rsi # 0xbc74f1
callq 0x3dbb0
cmpl $0x0, %eax
jne 0x94f675
cmpq $0x0, -0x20(%rbp)
jne 0x94f650
movq -0x28(%rbp), %rax
movl 0x10370(%rax), %ecx
andl $0xfbffffff, %ecx # imm = 0xFBFFFFFF
orl $0x0, %ecx
movl %ecx, 0x10370(%rax)
jmp 0x94f66c
movq -0x28(%rbp), %rax
movl 0x10370(%rax), %ecx
andl $0xfbffffff, %ecx # imm = 0xFBFFFFFF
orl $0x4000000, %ecx # imm = 0x4000000
movl %ecx, 0x10370(%rax)
movl $0x0, -0x4(%rbp)
jmp 0x94f6a2
jmp 0x94f677
movl $0xffffffec, -0x4(%rbp) # imm = 0xFFFFFFEC
jmp 0x94f6a2
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rcx
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
leaq 0x277e64(%rip), %rdx # 0xbc74f8
movb $0x0, %al
callq 0x9401f0
movl $0xffffffe7, -0x4(%rbp) # imm = 0xFFFFFFE7
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c
|
isoent_new
|
static struct isoent *
isoent_new(struct isofile *file)
{
struct isoent *isoent;
static const struct archive_rb_tree_ops rb_ops = {
isoent_cmp_node, isoent_cmp_key,
};
isoent = calloc(1, sizeof(*isoent));
if (isoent == NULL)
return (NULL);
isoent->file = file;
isoent->children.first = NULL;
isoent->children.last = &(isoent->children.first);
__archive_rb_tree_init(&(isoent->rbtree), &rb_ops);
isoent->subdirs.first = NULL;
isoent->subdirs.last = &(isoent->subdirs.first);
isoent->extr_rec_list.first = NULL;
isoent->extr_rec_list.last = &(isoent->extr_rec_list.first);
isoent->extr_rec_list.current = NULL;
if (archive_entry_filetype(file->entry) == AE_IFDIR)
isoent->dir = 1;
return (isoent);
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x1, %edi
movl $0xf0, %esi
callq 0x3e570
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x951493
movq $0x0, -0x8(%rbp)
jmp 0x951551
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x18(%rbp), %rcx
addq $0x28, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x18(%rbp), %rdi
addq $0x40, %rdi
leaq 0x5a6ad6(%rip), %rsi # 0xef7fa0
callq 0x8f17b0
movq -0x18(%rbp), %rax
movq $0x0, 0x50(%rax)
movq -0x18(%rbp), %rcx
addq $0x50, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x58(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0xd0(%rax)
movq -0x18(%rbp), %rcx
addq $0xd0, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0xd8(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0xe0(%rax)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x8e9c10
cmpl $0x4000, %eax # imm = 0x4000
jne 0x951549
movq -0x18(%rbp), %rax
movb 0xe8(%rax), %cl
andb $-0x3, %cl
orb $0x2, %cl
movb %cl, 0xe8(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c
|
isoent_add_child_tail
|
static int
isoent_add_child_tail(struct isoent *parent, struct isoent *child)
{
if (!__archive_rb_tree_insert_node(
&(parent->rbtree), (struct archive_rb_node *)child))
return (0);
child->chnext = NULL;
*parent->children.last = child;
parent->children.last = &(child->chnext);
parent->children.cnt++;
child->parent = parent;
/* Add a child to a sub-directory chain */
child->drnext = NULL;
if (child->dir) {
*parent->subdirs.last = child;
parent->subdirs.last = &(child->drnext);
parent->subdirs.cnt++;
child->parent = parent;
}
return (1);
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
addq $0x40, %rdi
movq -0x18(%rbp), %rsi
callq 0x8f19d0
cmpl $0x0, %eax
jne 0x9521f2
movl $0x0, -0x4(%rbp)
jmp 0x952299
movq -0x18(%rbp), %rax
movq $0x0, 0x70(%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
addq $0x70, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rax
movl 0x38(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x38(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x78(%rax)
movq -0x18(%rbp), %rax
movb 0xe8(%rax), %al
shlb $0x6, %al
sarb $0x7, %al
movsbl %al, %eax
cmpl $0x0, %eax
je 0x952292
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
addq $0x78, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x58(%rax)
movq -0x10(%rbp), %rax
movl 0x60(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x60(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c
|
isoent_free
|
static void
_isoent_free(struct isoent *isoent)
{
struct extr_rec *er, *er_next;
free(isoent->children_sorted);
free(isoent->identifier);
er = isoent->extr_rec_list.first;
while (er != NULL) {
er_next = er->next;
free(er);
er = er_next;
}
free(isoent);
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rdi
callq 0x3e548
movq -0x8(%rbp), %rax
movq 0xa8(%rax), %rdi
callq 0x3e548
movq -0x8(%rbp), %rax
movq 0xd0(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x9523c1
movq -0x10(%rbp), %rax
movq 0x808(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3e548
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x952398
movq -0x8(%rbp), %rdi
callq 0x3e548
addq $0x20, %rsp
popq %rbp
retq
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c
|
zisofs_init_zstream
|
static int
zisofs_init_zstream(struct archive_write *a)
{
struct iso9660 *iso9660 = a->format_data;
int r;
iso9660->zisofs.stream.next_in = NULL;
iso9660->zisofs.stream.avail_in = 0;
iso9660->zisofs.stream.total_in = 0;
iso9660->zisofs.stream.total_out = 0;
if (iso9660->zisofs.stream_valid)
r = deflateReset(&(iso9660->zisofs.stream));
else {
r = deflateInit(&(iso9660->zisofs.stream),
iso9660->zisofs.compression_level);
iso9660->zisofs.stream_valid = 1;
}
switch (r) {
case Z_OK:
break;
default:
case Z_STREAM_ERROR:
archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
"Internal error initializing "
"compression library: invalid setup parameter");
return (ARCHIVE_FATAL);
case Z_MEM_ERROR:
archive_set_error(&a->archive, ENOMEM,
"Internal error initializing "
"compression library");
return (ARCHIVE_FATAL);
case Z_VERSION_ERROR:
archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
"Internal error initializing "
"compression library: invalid library version");
return (ARCHIVE_FATAL);
}
return (ARCHIVE_OK);
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0xf8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq $0x0, 0x248(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x250(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x258(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x270(%rax)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x2b8(%rax)
je 0x95247c
movq -0x18(%rbp), %rdi
addq $0x1d8, %rdi # imm = 0x1D8
addq $0x70, %rdi
callq 0xb2d050
movl %eax, -0x1c(%rbp)
jmp 0x9524b7
movq -0x18(%rbp), %rdi
addq $0x1d8, %rdi # imm = 0x1D8
addq $0x70, %rdi
movq -0x18(%rbp), %rax
movl 0x2c8(%rax), %esi
leaq 0x2520a1(%rip), %rdx # 0xba453d
movl $0x70, %ecx
callq 0xb2ca90
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl $0x1, 0x2b8(%rax)
movl -0x1c(%rbp), %eax
addl $0x6, %eax
movl %eax, %ecx
movq %rcx, -0x28(%rbp)
subl $0x6, %eax
ja 0x9524de
movq -0x28(%rbp), %rax
leaq 0x274af5(%rip), %rcx # 0xbc6fc8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x952540
jmp 0x9524e0
movq -0x10(%rbp), %rdi
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
leaq 0x267bee(%rip), %rdx # 0xbba0de
movb $0x0, %al
callq 0x9401f0
movl $0xffffffe2, -0x4(%rbp) # imm = 0xFFFFFFE2
jmp 0x952547
movq -0x10(%rbp), %rdi
movl $0xc, %esi
leaq 0x273e74(%rip), %rdx # 0xbc6384
movb $0x0, %al
callq 0x9401f0
movl $0xffffffe2, -0x4(%rbp) # imm = 0xFFFFFFE2
jmp 0x952547
movq -0x10(%rbp), %rdi
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
leaq 0x267c36(%rip), %rdx # 0xbba166
movb $0x0, %al
callq 0x9401f0
movl $0xffffffe2, -0x4(%rbp) # imm = 0xFFFFFFE2
jmp 0x952547
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c
|
write_to_temp
|
static int
write_to_temp(struct archive_write *a, const void *buff, size_t s)
{
struct iso9660 *iso9660 = a->format_data;
ssize_t written;
const unsigned char *b;
b = (const unsigned char *)buff;
while (s) {
written = write(iso9660->temp_fd, b, s);
if (written < 0) {
archive_set_error(&a->archive, errno,
"Can't write to temporary file");
return (ARCHIVE_FATAL);
}
s -= written;
b += written;
}
return (ARCHIVE_OK);
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0xf8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x9529e8
movq -0x28(%rbp), %rax
movl 0x8(%rax), %edi
movq -0x38(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x3e020
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jge 0x9529cb
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
callq 0x3e130
movq -0x40(%rbp), %rdi
movl (%rax), %esi
leaq 0x274dc0(%rip), %rdx # 0xbc777b
movb $0x0, %al
callq 0x9401f0
movl $0xffffffe2, -0x4(%rbp) # imm = 0xFFFFFFE2
jmp 0x9529ef
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x30(%rbp), %rax
addq -0x38(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x95297b
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c
|
write_iso9660_data
|
static ssize_t
write_iso9660_data(struct archive_write *a, const void *buff, size_t s)
{
struct iso9660 *iso9660 = a->format_data;
size_t ws;
if (iso9660->temp_fd < 0) {
archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
"Couldn't create temporary file");
return (ARCHIVE_FATAL);
}
ws = s;
if (iso9660->need_multi_extent &&
(iso9660->cur_file->cur_content->size + ws) >=
(MULTI_EXTENT_SIZE - LOGICAL_BLOCK_SIZE)) {
struct content *con;
size_t ts;
ts = (size_t)(MULTI_EXTENT_SIZE - LOGICAL_BLOCK_SIZE -
iso9660->cur_file->cur_content->size);
if (iso9660->zisofs.detect_magic)
zisofs_detect_magic(a, buff, ts);
if (iso9660->zisofs.making) {
if (zisofs_write_to_temp(a, buff, ts) != ARCHIVE_OK)
return (ARCHIVE_FATAL);
} else {
if (wb_write_to_temp(a, buff, ts) != ARCHIVE_OK)
return (ARCHIVE_FATAL);
iso9660->cur_file->cur_content->size += ts;
}
/* Write padding. */
if (wb_write_padding_to_temp(a,
iso9660->cur_file->cur_content->size) != ARCHIVE_OK)
return (ARCHIVE_FATAL);
/* Compute the logical block number. */
iso9660->cur_file->cur_content->blocks = (int)
((iso9660->cur_file->cur_content->size
+ LOGICAL_BLOCK_SIZE -1) >> LOGICAL_BLOCK_BITS);
/*
* Make next extent.
*/
ws -= ts;
buff = (const void *)(((const unsigned char *)buff) + ts);
/* Make a content for next extent. */
con = calloc(1, sizeof(*con));
if (con == NULL) {
archive_set_error(&a->archive, ENOMEM,
"Can't allocate content data");
return (ARCHIVE_FATAL);
}
con->offset_of_temp = wb_offset(a);
iso9660->cur_file->cur_content->next = con;
iso9660->cur_file->cur_content = con;
#ifdef HAVE_ZLIB_H
iso9660->zisofs.block_offset = 0;
#endif
}
if (iso9660->zisofs.detect_magic)
zisofs_detect_magic(a, buff, ws);
if (iso9660->zisofs.making) {
if (zisofs_write_to_temp(a, buff, ws) != ARCHIVE_OK)
return (ARCHIVE_FATAL);
} else {
if (wb_write_to_temp(a, buff, ws) != ARCHIVE_OK)
return (ARCHIVE_FATAL);
iso9660->cur_file->cur_content->size += ws;
}
return (s);
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0xf8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jge 0x952a51
movq -0x10(%rbp), %rdi
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
leaq 0x274bd2(%rip), %rdx # 0xbc760f
movb $0x0, %al
callq 0x9401f0
movq $-0x1e, -0x8(%rbp)
jmp 0x952d19
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, 0x40(%rax)
je 0x952c73
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq 0xb0(%rax), %rax
movq 0x8(%rax), %rax
addq -0x30(%rbp), %rax
movl $0xfffff800, %ecx # imm = 0xFFFFF800
cmpq %rcx, %rax
jb 0x952c73
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq 0xb0(%rax), %rcx
movl $0xfffff800, %eax # imm = 0xFFFFF800
subq 0x8(%rcx), %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rax
movb 0x1d8(%rax), %al
shlb $0x7, %al
sarb $0x7, %al
movsbl %al, %eax
cmpl $0x0, %eax
je 0x952ad1
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0x952d30
movq -0x28(%rbp), %rax
movb 0x1d8(%rax), %al
shlb $0x6, %al
sarb $0x7, %al
movsbl %al, %eax
cmpl $0x0, %eax
je 0x952b0e
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0x953030
cmpl $0x0, %eax
je 0x952b0c
movq $-0x1e, -0x8(%rbp)
jmp 0x952d19
jmp 0x952b4c
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0x953440
cmpl $0x0, %eax
je 0x952b31
movq $-0x1e, -0x8(%rbp)
jmp 0x952d19
movq -0x40(%rbp), %rcx
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq 0xb0(%rax), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq 0xb0(%rax), %rax
movq 0x8(%rax), %rsi
callq 0x9535c0
cmpl $0x0, %eax
je 0x952b7a
movq $-0x1e, -0x8(%rbp)
jmp 0x952d19
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq 0xb0(%rax), %rax
movq 0x8(%rax), %rax
addq $0x800, %rax # imm = 0x800
subq $0x1, %rax
sarq $0xb, %rax
movl %eax, %ecx
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq 0xb0(%rax), %rax
movl %ecx, 0x10(%rax)
movq -0x40(%rbp), %rcx
movq -0x30(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
addq -0x40(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x1, %edi
movl $0x20, %esi
callq 0x3e570
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x952c08
movq -0x10(%rbp), %rdi
movl $0xc, %esi
leaq 0x274ba5(%rip), %rdx # 0xbc7799
movb $0x0, %al
callq 0x9401f0
movq $-0x1e, -0x8(%rbp)
jmp 0x952d19
movq -0x10(%rbp), %rax
movq 0xf8(%rax), %rax
movq 0x102f0(%rax), %rcx
addq $0x10000, %rcx # imm = 0x10000
movq -0x10(%rbp), %rax
movq 0xf8(%rax), %rax
subq 0x102e0(%rax), %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rcx
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq 0xb0(%rax), %rax
movq %rcx, 0x18(%rax)
movq -0x38(%rbp), %rcx
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rcx, 0xb0(%rax)
movq -0x28(%rbp), %rax
movq $0x0, 0x240(%rax)
movq -0x28(%rbp), %rax
movb 0x1d8(%rax), %al
shlb $0x7, %al
sarb $0x7, %al
movsbl %al, %eax
cmpl $0x0, %eax
je 0x952c9c
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x952d30
movq -0x28(%rbp), %rax
movb 0x1d8(%rax), %al
shlb $0x6, %al
sarb $0x7, %al
movsbl %al, %eax
cmpl $0x0, %eax
je 0x952cd6
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x953030
cmpl $0x0, %eax
je 0x952cd4
movq $-0x1e, -0x8(%rbp)
jmp 0x952d19
jmp 0x952d11
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x953440
cmpl $0x0, %eax
je 0x952cf6
movq $-0x1e, -0x8(%rbp)
jmp 0x952d19
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq 0xb0(%rax), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c
|
zisofs_detect_magic
|
static void
zisofs_detect_magic(struct archive_write *a, const void *buff, size_t s)
{
struct iso9660 *iso9660 = a->format_data;
struct isofile *file = iso9660->cur_file;
const unsigned char *p, *endp;
const unsigned char *magic_buff;
uint32_t uncompressed_size;
unsigned char header_size;
unsigned char log2_bs;
size_t _ceil, doff;
uint32_t bst, bed;
int magic_max;
int64_t entry_size;
entry_size = archive_entry_size(file->entry);
if ((int64_t)sizeof(iso9660->zisofs.magic_buffer) > entry_size)
magic_max = (int)entry_size;
else
magic_max = sizeof(iso9660->zisofs.magic_buffer);
if (iso9660->zisofs.magic_cnt == 0 && s >= (size_t)magic_max)
/* It's unnecessary we copy buffer. */
magic_buff = buff;
else {
if (iso9660->zisofs.magic_cnt < magic_max) {
size_t l;
l = sizeof(iso9660->zisofs.magic_buffer)
- iso9660->zisofs.magic_cnt;
if (l > s)
l = s;
memcpy(iso9660->zisofs.magic_buffer
+ iso9660->zisofs.magic_cnt, buff, l);
iso9660->zisofs.magic_cnt += (int)l;
if (iso9660->zisofs.magic_cnt < magic_max)
return;
}
magic_buff = iso9660->zisofs.magic_buffer;
}
iso9660->zisofs.detect_magic = 0;
p = magic_buff;
/* Check the magic code of zisofs. */
if (memcmp(p, zisofs_magic, sizeof(zisofs_magic)) != 0)
/* This is not zisofs file which made by mkzftree. */
return;
p += sizeof(zisofs_magic);
/* Read a zisofs header. */
uncompressed_size = archive_le32dec(p);
header_size = p[4];
log2_bs = p[5];
if (uncompressed_size < 24 || header_size != 4 ||
log2_bs > 30 || log2_bs < 7)
return;/* Invalid or not supported header. */
/* Calculate a size of Block Pointers of zisofs. */
_ceil = (uncompressed_size +
(ARCHIVE_LITERAL_LL(1) << log2_bs) -1) >> log2_bs;
doff = (_ceil + 1) * 4 + 16;
if (entry_size < (int64_t)doff)
return;/* Invalid data. */
/* Check every Block Pointer has valid value. */
p = magic_buff + 16;
endp = magic_buff + magic_max;
while (_ceil && p + 8 <= endp) {
bst = archive_le32dec(p);
if (bst != doff)
return;/* Invalid data. */
p += 4;
bed = archive_le32dec(p);
if (bed < bst || bed > entry_size)
return;/* Invalid data. */
doff += bed - bst;
_ceil--;
}
file->zisofs.uncompressed_size = uncompressed_size;
file->zisofs.header_size = header_size;
file->zisofs.log2_bs = log2_bs;
/* Disable making a zisofs image. */
iso9660->zisofs.making = 0;
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0xf8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x8ea740
movq %rax, -0x70(%rbp)
movl $0x40, %eax
cmpq -0x70(%rbp), %rax
jle 0x952d87
movq -0x70(%rbp), %rax
movl %eax, -0x64(%rbp)
jmp 0x952d8e
movl $0x40, -0x64(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, 0x21c(%rax)
jne 0x952db5
movq -0x18(%rbp), %rax
movslq -0x64(%rbp), %rcx
cmpq %rcx, %rax
jb 0x952db5
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0x952e55
movq -0x20(%rbp), %rax
movl 0x21c(%rax), %eax
cmpl -0x64(%rbp), %eax
jge 0x952e43
movq -0x20(%rbp), %rax
movslq 0x21c(%rax), %rcx
movl $0x40, %eax
subq %rcx, %rax
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rax
cmpq -0x18(%rbp), %rax
jbe 0x952ded
movq -0x18(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x20(%rbp), %rdi
addq $0x1d8, %rdi # imm = 0x1D8
addq $0x1, %rdi
movq -0x20(%rbp), %rax
movslq 0x21c(%rax), %rax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
movq -0x78(%rbp), %rdx
callq 0x3cb70
movq -0x78(%rbp), %rax
movl %eax, %ecx
movq -0x20(%rbp), %rax
addl 0x21c(%rax), %ecx
movl %ecx, 0x21c(%rax)
movq -0x20(%rbp), %rax
movl 0x21c(%rax), %eax
cmpl -0x64(%rbp), %eax
jge 0x952e41
jmp 0x953019
jmp 0x952e43
movq -0x20(%rbp), %rax
addq $0x1d8, %rax # imm = 0x1D8
addq $0x1, %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
movb 0x1d8(%rax), %cl
andb $-0x2, %cl
orb $0x0, %cl
movb %cl, 0x1d8(%rax)
movq -0x40(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq (%rax), %rax
movabsq $0x7d6dbc99653e437, %rcx # imm = 0x7D6DBC99653E437
subq %rcx, %rax
setne %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x952e97
jmp 0x953019
movq -0x30(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x953610
movl %eax, -0x44(%rbp)
movq -0x30(%rbp), %rax
movb 0x4(%rax), %al
movb %al, -0x45(%rbp)
movq -0x30(%rbp), %rax
movb 0x5(%rax), %al
movb %al, -0x46(%rbp)
cmpl $0x18, -0x44(%rbp)
jb 0x952ee4
movzbl -0x45(%rbp), %eax
cmpl $0x4, %eax
jne 0x952ee4
movzbl -0x46(%rbp), %eax
cmpl $0x1e, %eax
jg 0x952ee4
movzbl -0x46(%rbp), %eax
cmpl $0x7, %eax
jge 0x952ee9
jmp 0x953019
movl -0x44(%rbp), %eax
movzbl -0x46(%rbp), %ecx
movl %ecx, %ecx
movl $0x1, %edx
shlq %cl, %rdx
movq %rdx, %rcx
addq %rcx, %rax
subq $0x1, %rax
movzbl -0x46(%rbp), %ecx
movl %ecx, %ecx
sarq %cl, %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
addq $0x1, %rax
shlq $0x2, %rax
addq $0x10, %rax
movq %rax, -0x58(%rbp)
movq -0x70(%rbp), %rax
cmpq -0x58(%rbp), %rax
jge 0x952f34
jmp 0x953019
movq -0x40(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x30(%rbp)
movq -0x40(%rbp), %rax
movslq -0x64(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x50(%rbp)
movb %al, -0x79(%rbp)
je 0x952f6d
movq -0x30(%rbp), %rax
addq $0x8, %rax
cmpq -0x38(%rbp), %rax
setbe %al
movb %al, -0x79(%rbp)
movb -0x79(%rbp), %al
testb $0x1, %al
jne 0x952f76
jmp 0x952fdc
movq -0x30(%rbp), %rdi
callq 0x953610
movl %eax, -0x5c(%rbp)
movl -0x5c(%rbp), %eax
cmpq -0x58(%rbp), %rax
je 0x952f90
jmp 0x953019
movq -0x30(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x953610
movl %eax, -0x60(%rbp)
movl -0x60(%rbp), %eax
cmpl -0x5c(%rbp), %eax
jb 0x952fb9
movl -0x60(%rbp), %eax
cmpq -0x70(%rbp), %rax
jle 0x952fbb
jmp 0x953019
movl -0x60(%rbp), %eax
subl -0x5c(%rbp), %eax
movl %eax, %eax
addq -0x58(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x50(%rbp)
jmp 0x952f4f
movl -0x44(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0xc4(%rax)
movb -0x45(%rbp), %cl
movq -0x28(%rbp), %rax
movb %cl, 0xc0(%rax)
movb -0x46(%rbp), %cl
movq -0x28(%rbp), %rax
movb %cl, 0xc1(%rax)
movq -0x20(%rbp), %rax
movb 0x1d8(%rax), %cl
andb $-0x3, %cl
orb $0x0, %cl
movb %cl, 0x1d8(%rax)
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c
|
wb_write_to_temp
|
static int
wb_write_to_temp(struct archive_write *a, const void *buff, size_t s)
{
const char *xp = buff;
size_t xs = s;
/*
* If a written data size is big enough to use system-call
* and there is no waiting data, this calls write_to_temp() in
* order to reduce a extra memory copy.
*/
if (wb_remaining(a) == wb_buffmax() && s > (1024 * 16)) {
struct iso9660 *iso9660 = (struct iso9660 *)a->format_data;
xs = s % LOGICAL_BLOCK_SIZE;
iso9660->wbuff_offset += s - xs;
if (write_to_temp(a, buff, s - xs) != ARCHIVE_OK)
return (ARCHIVE_FATAL);
if (xs == 0)
return (ARCHIVE_OK);
xp += s - xs;
}
while (xs) {
size_t size = xs;
if (size > wb_remaining(a))
size = wb_remaining(a);
memcpy(wb_buffptr(a), xp, size);
if (wb_consume(a, size) != ARCHIVE_OK)
return (ARCHIVE_FATAL);
xs -= size;
xp += size;
}
return (ARCHIVE_OK);
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0xf8(%rax), %rax
cmpq $0x10000, 0x102e0(%rax) # imm = 0x10000
jne 0x95350e
cmpq $0x4000, -0x20(%rbp) # imm = 0x4000
jbe 0x95350e
movq -0x10(%rbp), %rax
movq 0xf8(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
andq $0x7ff, %rax # imm = 0x7FF
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rcx
subq -0x30(%rbp), %rcx
movq -0x38(%rbp), %rax
addq 0x102f0(%rax), %rcx
movq %rcx, 0x102f0(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
subq -0x30(%rbp), %rdx
callq 0x952950
cmpl $0x0, %eax
je 0x9534eb
movl $0xffffffe2, -0x4(%rbp) # imm = 0xFFFFFFE2
jmp 0x9535ac
cmpq $0x0, -0x30(%rbp)
jne 0x9534fe
movl $0x0, -0x4(%rbp)
jmp 0x9535ac
movq -0x20(%rbp), %rax
subq -0x30(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x953510
cmpq $0x0, -0x30(%rbp)
je 0x9535a5
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0xf8(%rcx), %rcx
cmpq 0x102e0(%rcx), %rax
jbe 0x953551
movq -0x10(%rbp), %rax
movq 0xf8(%rax), %rax
movq 0x102e0(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x952710
movq %rax, %rdi
movq -0x28(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0x3cb70
movq -0x10(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x952750
cmpl $0x0, %eax
je 0x953585
movl $0xffffffe2, -0x4(%rbp) # imm = 0xFFFFFFE2
jmp 0x9535ac
movq -0x40(%rbp), %rcx
movq -0x30(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x40(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x953510
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c
|
wb_write_padding_to_temp
|
static int
wb_write_padding_to_temp(struct archive_write *a, int64_t csize)
{
size_t ns;
int ret;
ns = (size_t)(csize % LOGICAL_BLOCK_SIZE);
if (ns != 0)
ret = write_null(a, LOGICAL_BLOCK_SIZE - ns);
else
ret = ARCHIVE_OK;
return (ret);
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x800, %ecx # imm = 0x800
cqto
idivq %rcx
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x953600
movq -0x8(%rbp), %rdi
movl $0x800, %esi # imm = 0x800
subq -0x18(%rbp), %rsi
callq 0x952550
movl %eax, -0x1c(%rbp)
jmp 0x953607
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c
|
archive_le32dec
|
static inline uint32_t
archive_le32dec(const void *pp)
{
unsigned char const *p = (unsigned char const *)pp;
/* Store into unsigned temporaries before left shifting, to avoid
promotion to signed int and then left shifting into the sign bit,
which is undefined behaviour. */
unsigned int p3 = p[3];
unsigned int p2 = p[2];
unsigned int p1 = p[1];
unsigned int p0 = p[0];
return ((p3 << 24) | (p2 << 16) | (p1 << 8) | p0);
}
|
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x3(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x2(%rax), %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x20(%rbp)
movl -0x14(%rbp), %eax
shll $0x18, %eax
movl -0x18(%rbp), %ecx
shll $0x10, %ecx
orl %ecx, %eax
movl -0x1c(%rbp), %ecx
shll $0x8, %ecx
orl %ecx, %eax
orl -0x20(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_endian.h
|
wb_set_offset
|
static int
wb_set_offset(struct archive_write *a, int64_t off)
{
struct iso9660 *iso9660 = (struct iso9660 *)a->format_data;
int64_t used, ext_bytes;
if (iso9660->wbuff_type != WB_TO_TEMP) {
archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
"Internal Programming error: iso9660:wb_set_offset()");
return (ARCHIVE_FATAL);
}
used = sizeof(iso9660->wbuff) - iso9660->wbuff_remaining;
if (iso9660->wbuff_offset + used > iso9660->wbuff_tail)
iso9660->wbuff_tail = iso9660->wbuff_offset + used;
if (iso9660->wbuff_offset < iso9660->wbuff_written) {
if (used > 0 &&
write_to_temp(a, iso9660->wbuff, (size_t)used) != ARCHIVE_OK)
return (ARCHIVE_FATAL);
iso9660->wbuff_offset = iso9660->wbuff_written;
lseek(iso9660->temp_fd, iso9660->wbuff_offset, SEEK_SET);
iso9660->wbuff_remaining = sizeof(iso9660->wbuff);
used = 0;
}
if (off < iso9660->wbuff_offset) {
/*
* Write out waiting data.
*/
if (used > 0) {
if (wb_write_out(a) != ARCHIVE_OK)
return (ARCHIVE_FATAL);
}
lseek(iso9660->temp_fd, off, SEEK_SET);
iso9660->wbuff_offset = off;
iso9660->wbuff_remaining = sizeof(iso9660->wbuff);
} else if (off <= iso9660->wbuff_tail) {
iso9660->wbuff_remaining = (size_t)
(sizeof(iso9660->wbuff) - (off - iso9660->wbuff_offset));
} else {
ext_bytes = off - iso9660->wbuff_tail;
iso9660->wbuff_remaining = (size_t)(sizeof(iso9660->wbuff)
- (iso9660->wbuff_tail - iso9660->wbuff_offset));
while (ext_bytes >= (int64_t)iso9660->wbuff_remaining) {
if (write_null(a, (size_t)iso9660->wbuff_remaining)
!= ARCHIVE_OK)
return (ARCHIVE_FATAL);
ext_bytes -= iso9660->wbuff_remaining;
}
if (ext_bytes > 0) {
if (write_null(a, (size_t)ext_bytes) != ARCHIVE_OK)
return (ARCHIVE_FATAL);
}
}
return (ARCHIVE_OK);
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0xf8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x1, 0x102e8(%rax)
je 0x9536bf
movq -0x10(%rbp), %rdi
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
leaq 0x27413f(%rip), %rdx # 0xbc77eb
movb $0x0, %al
callq 0x9401f0
movl $0xffffffe2, -0x4(%rbp) # imm = 0xFFFFFFE2
jmp 0x9538ee
movq -0x20(%rbp), %rcx
movl $0x10000, %eax # imm = 0x10000
subq 0x102e0(%rcx), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq 0x102f0(%rax), %rax
addq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpq 0x10300(%rcx), %rax
jle 0x953709
movq -0x20(%rbp), %rax
movq 0x102f0(%rax), %rcx
addq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10300(%rax)
movq -0x20(%rbp), %rax
movq 0x102f0(%rax), %rax
movq -0x20(%rbp), %rcx
cmpq 0x102f8(%rcx), %rax
jge 0x953797
cmpq $0x0, -0x28(%rbp)
jle 0x953751
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x2dc, %rsi # imm = 0x2DC
movq -0x28(%rbp), %rdx
callq 0x952950
cmpl $0x0, %eax
je 0x953751
movl $0xffffffe2, -0x4(%rbp) # imm = 0xFFFFFFE2
jmp 0x9538ee
movq -0x20(%rbp), %rax
movq 0x102f8(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x102f0(%rax)
movq -0x20(%rbp), %rax
movl 0x8(%rax), %edi
movq -0x20(%rbp), %rax
movq 0x102f0(%rax), %rsi
xorl %edx, %edx
callq 0x3b6b0
movq -0x20(%rbp), %rax
movq $0x10000, 0x102e0(%rax) # imm = 0x10000
movq $0x0, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpq 0x102f0(%rcx), %rax
jge 0x953800
cmpq $0x0, -0x28(%rbp)
jle 0x9537cb
movq -0x10(%rbp), %rdi
callq 0x952810
cmpl $0x0, %eax
je 0x9537c9
movl $0xffffffe2, -0x4(%rbp) # imm = 0xFFFFFFE2
jmp 0x9538ee
jmp 0x9537cb
movq -0x20(%rbp), %rax
movl 0x8(%rax), %edi
movq -0x18(%rbp), %rsi
xorl %edx, %edx
callq 0x3b6b0
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x102f0(%rax)
movq -0x20(%rbp), %rax
movq $0x10000, 0x102e0(%rax) # imm = 0x10000
jmp 0x9538e7
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpq 0x10300(%rcx), %rax
jg 0x953838
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
subq 0x102f0(%rcx), %rax
movl $0x10000, %ecx # imm = 0x10000
subq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x102e0(%rax)
jmp 0x9538e5
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
subq 0x10300(%rcx), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq 0x10300(%rax), %rax
movq -0x20(%rbp), %rcx
subq 0x102f0(%rcx), %rax
movl $0x10000, %ecx # imm = 0x10000
subq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x102e0(%rax)
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpq 0x102e0(%rcx), %rax
jl 0x9538bf
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x102e0(%rax), %rsi
callq 0x952550
cmpl $0x0, %eax
je 0x9538a7
movl $0xffffffe2, -0x4(%rbp) # imm = 0xFFFFFFE2
jmp 0x9538ee
movq -0x20(%rbp), %rax
movq 0x102e0(%rax), %rcx
movq -0x30(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x30(%rbp)
jmp 0x953874
cmpq $0x0, -0x30(%rbp)
jle 0x9538e3
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x952550
cmpl $0x0, %eax
je 0x9538e1
movl $0xffffffe2, -0x4(%rbp) # imm = 0xFFFFFFE2
jmp 0x9538ee
jmp 0x9538e3
jmp 0x9538e5
jmp 0x9538e7
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c
|
isoent_find_out_boot_file
|
static int
isoent_find_out_boot_file(struct archive_write *a, struct isoent *rootent)
{
struct iso9660 *iso9660 = a->format_data;
/* Find a isoent of the boot file. */
iso9660->el_torito.boot = isoent_find_entry(rootent,
iso9660->el_torito.boot_filename.s);
if (iso9660->el_torito.boot == NULL) {
archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
"Can't find the boot image file ``%s''",
iso9660->el_torito.boot_filename.s);
return (ARCHIVE_FATAL);
}
iso9660->el_torito.boot->file->boot = BOOT_IMAGE;
return (ARCHIVE_OK);
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0xf8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x10328(%rax), %rsi
callq 0x956360
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10340(%rax)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x10340(%rax)
jne 0x953b2a
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x10328(%rax), %rcx
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
leaq 0x273d1f(%rip), %rdx # 0xbc7839
movb $0x0, %al
callq 0x9401f0
movl $0xffffffe2, -0x4(%rbp) # imm = 0xFFFFFFE2
jmp 0x953b4a
movq -0x20(%rbp), %rax
movq 0x10340(%rax), %rax
movq 0x18(%rax), %rax
movl $0x2, 0xbc(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c
|
zisofs_rewind_boot_file
|
static int
zisofs_rewind_boot_file(struct archive_write *a)
{
struct iso9660 *iso9660 = a->format_data;
struct isofile *file;
unsigned char *rbuff;
ssize_t r;
size_t remaining, rbuff_size;
struct zisofs_extract zext;
int64_t read_offset, write_offset, new_offset;
int fd, ret = ARCHIVE_OK;
file = iso9660->el_torito.boot->file;
/*
* There is nothing to do if this boot file does not have
* zisofs header.
*/
if (file->zisofs.header_size == 0)
return (ARCHIVE_OK);
/*
* Uncompress the zisofs'ed file contents.
*/
memset(&zext, 0, sizeof(zext));
zext.pz_uncompressed_size = file->zisofs.uncompressed_size;
zext.pz_log2_bs = file->zisofs.log2_bs;
fd = iso9660->temp_fd;
new_offset = wb_offset(a);
read_offset = file->content.offset_of_temp;
remaining = (size_t)file->content.size;
if (remaining > 1024 * 32)
rbuff_size = 1024 * 32;
else
rbuff_size = remaining;
rbuff = malloc(rbuff_size);
if (rbuff == NULL) {
archive_set_error(&a->archive, ENOMEM, "Can't allocate memory");
return (ARCHIVE_FATAL);
}
while (remaining) {
size_t rsize;
ssize_t rs;
/* Get the current file pointer. */
write_offset = lseek(fd, 0, SEEK_CUR);
/* Change the file pointer to read. */
lseek(fd, read_offset, SEEK_SET);
rsize = rbuff_size;
if (rsize > remaining)
rsize = remaining;
rs = read(iso9660->temp_fd, rbuff, rsize);
if (rs <= 0) {
archive_set_error(&a->archive, errno,
"Can't read temporary file(%jd)", (intmax_t)rs);
ret = ARCHIVE_FATAL;
break;
}
remaining -= rs;
read_offset += rs;
/* Put the file pointer back to write. */
lseek(fd, write_offset, SEEK_SET);
r = zisofs_extract(a, &zext, rbuff, rs);
if (r < 0) {
ret = (int)r;
break;
}
}
if (ret == ARCHIVE_OK) {
/*
* Change the boot file content from zisofs'ed data
* to plain data.
*/
file->content.offset_of_temp = new_offset;
file->content.size = file->zisofs.uncompressed_size;
archive_entry_set_size(file->entry, file->content.size);
/* Set to be no zisofs. */
file->zisofs.header_size = 0;
file->zisofs.log2_bs = 0;
file->zisofs.uncompressed_size = 0;
r = wb_write_padding_to_temp(a, file->content.size);
if (r < 0)
ret = ARCHIVE_FATAL;
}
/*
* Free the resource we used in this function only.
*/
free(rbuff);
free(zext.block_pointers);
if (zext.stream_valid && inflateEnd(&(zext.stream)) != Z_OK) {
archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
"Failed to clean up compressor");
ret = ARCHIVE_FATAL;
}
return (ret);
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp # imm = 0x140
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0xf8(%rax), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x120(%rbp)
movq -0x18(%rbp), %rax
movq 0x10340(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movzbl 0xc0(%rax), %eax
cmpl $0x0, %eax
jne 0x953bb7
movl $0x0, -0x4(%rbp)
jmp 0x953eca
leaq -0x100(%rbp), %rdi
xorl %esi, %esi
movl $0xc0, %edx
callq 0x3b780
movq -0x20(%rbp), %rax
movl 0xc4(%rax), %eax
movq %rax, -0xf8(%rbp)
movq -0x20(%rbp), %rax
movzbl 0xc1(%rax), %eax
movl %eax, -0x100(%rbp)
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x11c(%rbp)
movq -0x10(%rbp), %rax
movq 0xf8(%rax), %rax
movq 0x102f0(%rax), %rax
addq $0x10000, %rax # imm = 0x10000
movq -0x10(%rbp), %rcx
movq 0xf8(%rcx), %rcx
subq 0x102e0(%rcx), %rax
movq %rax, -0x118(%rbp)
movq -0x20(%rbp), %rax
movq 0x90(%rax), %rax
movq %rax, -0x108(%rbp)
movq -0x20(%rbp), %rax
movq 0x98(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x8000, -0x38(%rbp) # imm = 0x8000
jbe 0x953c5f
movq $0x8000, -0x40(%rbp) # imm = 0x8000
jmp 0x953c67
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0x3e578
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x953c9e
movq -0x10(%rbp), %rdi
movl $0xc, %esi
leaq 0x265f32(%rip), %rdx # 0xbb9bbd
movb $0x0, %al
callq 0x9401f0
movl $0xffffffe2, -0x4(%rbp) # imm = 0xFFFFFFE2
jmp 0x953eca
jmp 0x953ca0
cmpq $0x0, -0x38(%rbp)
je 0x953dd1
movl -0x11c(%rbp), %edi
xorl %eax, %eax
movl %eax, %esi
movl $0x1, %edx
callq 0x3b6b0
movq %rax, -0x110(%rbp)
movl -0x11c(%rbp), %edi
movq -0x108(%rbp), %rsi
xorl %edx, %edx
callq 0x3b6b0
movq -0x40(%rbp), %rax
movq %rax, -0x128(%rbp)
movq -0x128(%rbp), %rax
cmpq -0x38(%rbp), %rax
jbe 0x953cfd
movq -0x38(%rbp), %rax
movq %rax, -0x128(%rbp)
movq -0x18(%rbp), %rax
movl 0x8(%rax), %edi
movq -0x28(%rbp), %rsi
movq -0x128(%rbp), %rdx
callq 0x3da70
movq %rax, -0x130(%rbp)
cmpq $0x0, -0x130(%rbp)
jg 0x953d5f
movq -0x10(%rbp), %rax
movq %rax, -0x138(%rbp)
callq 0x3e130
movq -0x138(%rbp), %rdi
movl (%rax), %esi
movq -0x130(%rbp), %rcx
leaq 0x273b13(%rip), %rdx # 0xbc785f
movb $0x0, %al
callq 0x9401f0
movl $0xffffffe2, -0x120(%rbp) # imm = 0xFFFFFFE2
jmp 0x953dd1
movq -0x130(%rbp), %rcx
movq -0x38(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x130(%rbp), %rax
addq -0x108(%rbp), %rax
movq %rax, -0x108(%rbp)
movl -0x11c(%rbp), %edi
movq -0x110(%rbp), %rsi
xorl %edx, %edx
callq 0x3b6b0
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rdx
movq -0x130(%rbp), %rcx
leaq -0x100(%rbp), %rsi
callq 0x956460
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jge 0x953dcc
movq -0x30(%rbp), %rax
movl %eax, -0x120(%rbp)
jmp 0x953dd1
jmp 0x953ca0
cmpl $0x0, -0x120(%rbp)
jne 0x953e70
movq -0x118(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x90(%rax)
movq -0x20(%rbp), %rax
movl 0xc4(%rax), %eax
movl %eax, %ecx
movq -0x20(%rbp), %rax
movq %rcx, 0x98(%rax)
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x20(%rbp), %rax
movq 0x98(%rax), %rsi
callq 0x8ec160
movq -0x20(%rbp), %rax
movb $0x0, 0xc0(%rax)
movq -0x20(%rbp), %rax
movb $0x0, 0xc1(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0xc4(%rax)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x98(%rax), %rsi
callq 0x9535c0
cltq
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jge 0x953e6e
movl $0xffffffe2, -0x120(%rbp) # imm = 0xFFFFFFE2
jmp 0x953e70
movq -0x28(%rbp), %rdi
callq 0x3e548
movq -0xe0(%rbp), %rdi
callq 0x3e548
cmpl $0x0, -0x48(%rbp)
je 0x953ec1
leaq -0x100(%rbp), %rdi
addq $0x48, %rdi
callq 0xb38730
cmpl $0x0, %eax
je 0x953ec1
movq -0x10(%rbp), %rdi
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
leaq 0x272581(%rip), %rdx # 0xbc6431
movb $0x0, %al
callq 0x9401f0
movl $0xffffffe2, -0x120(%rbp) # imm = 0xFFFFFFE2
movl -0x120(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x140, %rsp # imm = 0x140
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c
|
isoent_clone_tree
|
static int
isoent_clone_tree(struct archive_write *a, struct isoent **nroot,
struct isoent *root)
{
struct isoent *np, *xroot, *newent;
np = root;
xroot = NULL;
do {
newent = isoent_clone(np);
if (newent == NULL) {
archive_set_error(&a->archive, ENOMEM,
"Can't allocate memory");
return (ARCHIVE_FATAL);
}
if (xroot == NULL) {
*nroot = xroot = newent;
newent->parent = xroot;
} else
isoent_add_child_tail(xroot, newent);
if (np->dir && np->children.first != NULL) {
/* Enter to sub directories. */
np = np->children.first;
xroot = newent;
continue;
}
while (np != np->parent) {
if (np->chnext == NULL) {
/* Return to the parent directory. */
np = np->parent;
xroot = xroot->parent;
} else {
np = np->chnext;
break;
}
}
} while (np != np->parent);
return (ARCHIVE_OK);
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x956b80
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x95430b
movq -0x10(%rbp), %rdi
movl $0xc, %esi
leaq 0x2658c5(%rip), %rdx # 0xbb9bbd
movb $0x0, %al
callq 0x9401f0
movl $0xffffffe2, -0x4(%rbp) # imm = 0xFFFFFFE2
jmp 0x9543d5
cmpq $0x0, -0x30(%rbp)
jne 0x95432f
movq -0x38(%rbp), %rcx
movq %rcx, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x20(%rax)
jmp 0x95433c
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x9521c0
movq -0x28(%rbp), %rax
movb 0xe8(%rax), %al
shlb $0x6, %al
sarb $0x7, %al
movsbl %al, %eax
cmpl $0x0, %eax
je 0x954375
movq -0x28(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x954375
movq -0x28(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x9543bc
jmp 0x954377
movq -0x28(%rbp), %rax
movq -0x28(%rbp), %rcx
cmpq 0x20(%rcx), %rax
je 0x9543ba
movq -0x28(%rbp), %rax
cmpq $0x0, 0x70(%rax)
jne 0x9543aa
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x9543b8
movq -0x28(%rbp), %rax
movq 0x70(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x9543ba
jmp 0x954377
jmp 0x9543bc
movq -0x28(%rbp), %rax
movq -0x28(%rbp), %rcx
cmpq 0x20(%rcx), %rax
jne 0x9542d4
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c
|
isoent_setup_file_location
|
static void
isoent_setup_file_location(struct iso9660 *iso9660, int location)
{
struct isoent *isoent;
struct isoent *np;
struct isofile *file;
size_t size;
int block;
int depth;
int joliet;
int symlocation;
int total_block;
iso9660->total_file_block = 0;
if ((isoent = iso9660->el_torito.catalog) != NULL) {
isoent->file->content.location = location;
block = (int)((archive_entry_size(isoent->file->entry) +
LOGICAL_BLOCK_SIZE -1) >> LOGICAL_BLOCK_BITS);
location += block;
iso9660->total_file_block += block;
}
if ((isoent = iso9660->el_torito.boot) != NULL) {
isoent->file->content.location = location;
size = fd_boot_image_size(iso9660->el_torito.media_type);
if (size == 0)
size = (size_t)archive_entry_size(isoent->file->entry);
block = ((int)size + LOGICAL_BLOCK_SIZE -1)
>> LOGICAL_BLOCK_BITS;
location += block;
iso9660->total_file_block += block;
isoent->file->content.blocks = block;
}
depth = 0;
symlocation = -16;
if (!iso9660->opt.rr && iso9660->opt.joliet) {
joliet = 1;
np = iso9660->joliet.rootent;
} else {
joliet = 0;
np = iso9660->primary.rootent;
}
do {
_isoent_file_location(iso9660, np, &symlocation);
if (np->subdirs.first != NULL &&
(joliet ||
((iso9660->opt.rr == OPT_RR_DISABLED &&
depth + 2 < iso9660->primary.max_depth) ||
(iso9660->opt.rr &&
depth + 1 < iso9660->primary.max_depth)))) {
/* Enter to sub directories. */
np = np->subdirs.first;
depth++;
continue;
}
while (np != np->parent) {
if (np->drnext == NULL) {
/* Return to the parent directory. */
np = np->parent;
depth--;
} else {
np = np->drnext;
break;
}
}
} while (np != np->parent);
total_block = 0;
for (file = iso9660->data_file_list.first;
file != NULL; file = file->datanext) {
if (!file->write_content)
continue;
file->cur_content = &(file->content);
do {
file->cur_content->location = location;
location += file->cur_content->blocks;
total_block += file->cur_content->blocks;
/* Next fragment */
file->cur_content = file->cur_content->next;
} while (file->cur_content != NULL);
}
iso9660->total_file_block += total_block;
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0x120(%rax)
movq -0x8(%rbp), %rax
movq 0x10320(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x9548d1
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movl %ecx, 0xa4(%rax)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x20(%rax), %rdi
callq 0x8ea740
addq $0x800, %rax # imm = 0x800
subq $0x1, %rax
sarq $0xb, %rax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x34(%rbp), %ecx
movq -0x8(%rbp), %rax
addl 0x120(%rax), %ecx
movl %ecx, 0x120(%rax)
movq -0x8(%rbp), %rax
movq 0x10340(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x95496a
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movl %ecx, 0xa4(%rax)
movq -0x8(%rbp), %rax
movzbl 0x10368(%rax), %edi
callq 0x95bb20
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x95492b
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x20(%rax), %rdi
callq 0x8ea740
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
addl $0x800, %eax # imm = 0x800
subl $0x1, %eax
sarl $0xb, %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x34(%rbp), %ecx
movq -0x8(%rbp), %rax
addl 0x120(%rax), %ecx
movl %ecx, 0x120(%rax)
movl -0x34(%rbp), %ecx
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movl %ecx, 0xa0(%rax)
movl $0x0, -0x38(%rbp)
movl $0xfffffff0, -0x40(%rbp) # imm = 0xFFFFFFF0
movq -0x8(%rbp), %rax
movl 0x10370(%rax), %eax
shrl $0x17, %eax
andl $0x3, %eax
cmpl $0x0, %eax
jne 0x9549ba
movq -0x8(%rbp), %rax
movl 0x10370(%rax), %eax
shrl $0x11, %eax
andl $0x3, %eax
cmpl $0x0, %eax
je 0x9549ba
movl $0x1, -0x3c(%rbp)
movq -0x8(%rbp), %rax
movq 0xe8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x9549d0
movl $0x0, -0x3c(%rbp)
movq -0x8(%rbp), %rax
movq 0xb8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x9549d2
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
leaq -0x40(%rbp), %rdx
callq 0x95bb80
movq -0x20(%rbp), %rax
cmpq $0x0, 0x50(%rax)
je 0x954a59
cmpl $0x0, -0x3c(%rbp)
jne 0x954a42
movq -0x8(%rbp), %rax
movl 0x10370(%rax), %eax
shrl $0x17, %eax
andl $0x3, %eax
cmpl $0x0, %eax
jne 0x954a1b
movl -0x38(%rbp), %eax
addl $0x2, %eax
movq -0x8(%rbp), %rcx
cmpl 0xd0(%rcx), %eax
jl 0x954a42
movq -0x8(%rbp), %rax
movl 0x10370(%rax), %eax
shrl $0x17, %eax
andl $0x3, %eax
cmpl $0x0, %eax
je 0x954a59
movl -0x38(%rbp), %eax
addl $0x1, %eax
movq -0x8(%rbp), %rcx
cmpl 0xd0(%rcx), %eax
jge 0x954a59
movq -0x20(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x20(%rbp)
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x954a9d
jmp 0x954a5b
movq -0x20(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpq 0x20(%rcx), %rax
je 0x954a9b
movq -0x20(%rbp), %rax
cmpq $0x0, 0x78(%rax)
jne 0x954a8b
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
movl -0x38(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x954a99
movq -0x20(%rbp), %rax
movq 0x78(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x954a9b
jmp 0x954a5b
jmp 0x954a9d
movq -0x20(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpq 0x20(%rcx), %rax
jne 0x9549d2
movl $0x0, -0x44(%rbp)
movq -0x8(%rbp), %rax
movq 0x98(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x954b69
movq -0x28(%rbp), %rax
cmpl $0x0, 0xb8(%rax)
jne 0x954adf
jmp 0x954b58
movq -0x28(%rbp), %rcx
addq $0x90, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0xb0(%rax)
movl -0xc(%rbp), %ecx
movq -0x28(%rbp), %rax
movq 0xb0(%rax), %rax
movl %ecx, 0x14(%rax)
movq -0x28(%rbp), %rax
movq 0xb0(%rax), %rax
movl 0x10(%rax), %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movq -0x28(%rbp), %rax
movq 0xb0(%rax), %rax
movl 0x10(%rax), %eax
addl -0x44(%rbp), %eax
movl %eax, -0x44(%rbp)
movq -0x28(%rbp), %rax
movq 0xb0(%rax), %rax
movq 0x18(%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0xb0(%rax)
movq -0x28(%rbp), %rax
cmpq $0x0, 0xb0(%rax)
jne 0x954af5
jmp 0x954b58
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x954ac5
movl -0x44(%rbp), %ecx
movq -0x8(%rbp), %rax
addl 0x120(%rax), %ecx
movl %ecx, 0x120(%rax)
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c
|
setup_boot_information
|
static int
setup_boot_information(struct archive_write *a)
{
struct iso9660 *iso9660 = a->format_data;
struct isoent *np;
int64_t size;
uint32_t sum;
unsigned char buff[4096];
np = iso9660->el_torito.boot;
lseek(iso9660->temp_fd,
np->file->content.offset_of_temp + 64, SEEK_SET);
size = archive_entry_size(np->file->entry) - 64;
if (size <= 0) {
archive_set_error(&a->archive, errno,
"Boot file(%jd) is too small", (intmax_t)size + 64);
return (ARCHIVE_FATAL);
}
sum = 0;
while (size > 0) {
size_t rsize;
ssize_t i, rs;
if (size > (int64_t)sizeof(buff))
rsize = sizeof(buff);
else
rsize = (size_t)size;
rs = read(iso9660->temp_fd, buff, rsize);
if (rs <= 0) {
archive_set_error(&a->archive, errno,
"Can't read temporary file(%jd)",
(intmax_t)rs);
return (ARCHIVE_FATAL);
}
for (i = 0; i < rs; i += 4)
sum += archive_le32dec(buff + i);
size -= rs;
}
/* Set the location of Primary Volume Descriptor. */
set_num_731(buff, SYSTEM_AREA_BLOCK);
/* Set the location of the boot file. */
set_num_731(buff+4, np->file->content.location);
/* Set the size of the boot file. */
size = fd_boot_image_size(iso9660->el_torito.media_type);
if (size == 0)
size = archive_entry_size(np->file->entry);
set_num_731(buff+8, (uint32_t)size);
/* Set the sum of the boot file. */
set_num_731(buff+12, sum);
/* Clear reserved bytes. */
memset(buff+16, 0, 40);
/* Overwrite the boot file. */
lseek(iso9660->temp_fd,
np->file->content.offset_of_temp + 8, SEEK_SET);
return (write_to_temp(a, buff, 56));
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x1060, %rsp # imm = 0x1060
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0xf8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x10340(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl 0x8(%rax), %edi
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x90(%rax), %rsi
addq $0x40, %rsi
xorl %edx, %edx
callq 0x3b6b0
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x20(%rax), %rdi
callq 0x8ea740
subq $0x40, %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jg 0x954c39
movq -0x10(%rbp), %rax
movq %rax, -0x1050(%rbp)
callq 0x3e130
movq -0x1050(%rbp), %rdi
movl (%rax), %esi
movq -0x28(%rbp), %rcx
addq $0x40, %rcx
leaq 0x272d22(%rip), %rdx # 0xbc7948
movb $0x0, %al
callq 0x9401f0
movl $0xffffffe2, -0x4(%rbp) # imm = 0xFFFFFFE2
jmp 0x954e09
movl $0x0, -0x2c(%rbp)
cmpq $0x0, -0x28(%rbp)
jle 0x954d31
cmpq $0x1000, -0x28(%rbp) # imm = 0x1000
jle 0x954c62
movq $0x1000, -0x1038(%rbp) # imm = 0x1000
jmp 0x954c6d
movq -0x28(%rbp), %rax
movq %rax, -0x1038(%rbp)
movq -0x18(%rbp), %rax
movl 0x8(%rax), %edi
leaq -0x1030(%rbp), %rsi
movq -0x1038(%rbp), %rdx
callq 0x3da70
movq %rax, -0x1048(%rbp)
cmpq $0x0, -0x1048(%rbp)
jg 0x954cd2
movq -0x10(%rbp), %rax
movq %rax, -0x1058(%rbp)
callq 0x3e130
movq -0x1058(%rbp), %rdi
movl (%rax), %esi
movq -0x1048(%rbp), %rcx
leaq 0x272ba0(%rip), %rdx # 0xbc785f
movb $0x0, %al
callq 0x9401f0
movl $0xffffffe2, -0x4(%rbp) # imm = 0xFFFFFFE2
jmp 0x954e09
movq $0x0, -0x1040(%rbp)
movq -0x1040(%rbp), %rax
cmpq -0x1048(%rbp), %rax
jge 0x954d1a
leaq -0x1030(%rbp), %rdi
addq -0x1040(%rbp), %rdi
callq 0x953610
addl -0x2c(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x1040(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x1040(%rbp)
jmp 0x954cdd
movq -0x1048(%rbp), %rcx
movq -0x28(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x28(%rbp)
jmp 0x954c40
leaq -0x1030(%rbp), %rdi
movl $0x10, %esi
callq 0x953a80
leaq -0x1030(%rbp), %rdi
addq $0x4, %rdi
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movl 0xa4(%rax), %esi
callq 0x953a80
movq -0x18(%rbp), %rax
movzbl 0x10368(%rax), %edi
callq 0x95bb20
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x954d90
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x20(%rax), %rdi
callq 0x8ea740
movq %rax, -0x28(%rbp)
leaq -0x1030(%rbp), %rdi
addq $0x8, %rdi
movq -0x28(%rbp), %rax
movl %eax, %esi
callq 0x953a80
leaq -0x1030(%rbp), %rdi
addq $0xc, %rdi
movl -0x2c(%rbp), %esi
callq 0x953a80
leaq -0x1030(%rbp), %rdi
addq $0x10, %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x3b780
movq -0x18(%rbp), %rax
movl 0x8(%rax), %edi
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x90(%rax), %rsi
addq $0x8, %rsi
xorl %edx, %edx
callq 0x3b6b0
movq -0x10(%rbp), %rdi
leaq -0x1030(%rbp), %rsi
movl $0x38, %edx
callq 0x952950
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x1060, %rsp # imm = 0x1060
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c
|
write_VD
|
static int
write_VD(struct archive_write *a, struct vdd *vdd)
{
struct iso9660 *iso9660;
unsigned char *bp;
uint16_t volume_set_size = 1;
char identifier[256];
enum VD_type vdt;
enum vdc vdc;
unsigned char vd_ver, fst_ver;
int r;
iso9660 = a->format_data;
switch (vdd->vdd_type) {
case VDD_JOLIET:
vdt = VDT_SUPPLEMENTARY;
vd_ver = fst_ver = 1;
vdc = VDC_UCS2;
break;
case VDD_ENHANCED:
vdt = VDT_SUPPLEMENTARY;
vd_ver = fst_ver = 2;
vdc = VDC_LOWERCASE;
break;
case VDD_PRIMARY:
default:
vdt = VDT_PRIMARY;
vd_ver = fst_ver = 1;
#ifdef COMPAT_MKISOFS
vdc = VDC_LOWERCASE;
#else
vdc = VDC_STD;
#endif
break;
}
bp = wb_buffptr(a) -1;
/* Volume Descriptor Type */
set_VD_bp(bp, vdt, vd_ver);
/* Unused Field */
set_unused_field_bp(bp, 8, 8);
/* System Identifier */
get_system_identitier(identifier, sizeof(identifier));
r = set_str_a_characters_bp(a, bp, 9, 40, identifier, vdc);
if (r != ARCHIVE_OK)
return (r);
/* Volume Identifier */
r = set_str_d_characters_bp(a, bp, 41, 72,
iso9660->volume_identifier.s, vdc);
if (r != ARCHIVE_OK)
return (r);
/* Unused Field */
set_unused_field_bp(bp, 73, 80);
/* Volume Space Size */
set_num_733(bp+81, iso9660->volume_space_size);
if (vdd->vdd_type == VDD_JOLIET) {
/* Escape Sequences */
bp[89] = 0x25;/* UCS-2 Level 3 */
bp[90] = 0x2F;
bp[91] = 0x45;
memset(bp + 92, 0, 120 - 92 + 1);
} else {
/* Unused Field */
set_unused_field_bp(bp, 89, 120);
}
/* Volume Set Size */
set_num_723(bp+121, volume_set_size);
/* Volume Sequence Number */
set_num_723(bp+125, iso9660->volume_sequence_number);
/* Logical Block Size */
set_num_723(bp+129, LOGICAL_BLOCK_SIZE);
/* Path Table Size */
set_num_733(bp+133, vdd->path_table_size);
/* Location of Occurrence of Type L Path Table */
set_num_731(bp+141, vdd->location_type_L_path_table);
/* Location of Optional Occurrence of Type L Path Table */
set_num_731(bp+145, 0);
/* Location of Occurrence of Type M Path Table */
set_num_732(bp+149, vdd->location_type_M_path_table);
/* Location of Optional Occurrence of Type M Path Table */
set_num_732(bp+153, 0);
/* Directory Record for Root Directory(BP 157 to 190) */
set_directory_record(bp+157, 190-157+1, vdd->rootent,
iso9660, DIR_REC_VD, vdd->vdd_type);
/* Volume Set Identifier */
r = set_str_d_characters_bp(a, bp, 191, 318, "", vdc);
if (r != ARCHIVE_OK)
return (r);
/* Publisher Identifier */
r = set_file_identifier(bp, 319, 446, vdc, a, vdd,
&(iso9660->publisher_identifier),
"Publisher File", 1, A_CHAR);
if (r != ARCHIVE_OK)
return (r);
/* Data Preparer Identifier */
r = set_file_identifier(bp, 447, 574, vdc, a, vdd,
&(iso9660->data_preparer_identifier),
"Data Preparer File", 1, A_CHAR);
if (r != ARCHIVE_OK)
return (r);
/* Application Identifier */
r = set_file_identifier(bp, 575, 702, vdc, a, vdd,
&(iso9660->application_identifier),
"Application File", 1, A_CHAR);
if (r != ARCHIVE_OK)
return (r);
/* Copyright File Identifier */
r = set_file_identifier(bp, 703, 739, vdc, a, vdd,
&(iso9660->copyright_file_identifier),
"Copyright File", 0, D_CHAR);
if (r != ARCHIVE_OK)
return (r);
/* Abstract File Identifier */
r = set_file_identifier(bp, 740, 776, vdc, a, vdd,
&(iso9660->abstract_file_identifier),
"Abstract File", 0, D_CHAR);
if (r != ARCHIVE_OK)
return (r);
/* Bibliographic File Identifier */
r = set_file_identifier(bp, 777, 813, vdc, a, vdd,
&(iso9660->bibliographic_file_identifier),
"Bibliongraphic File", 0, D_CHAR);
if (r != ARCHIVE_OK)
return (r);
/* Volume Creation Date and Time */
set_date_time(bp+814, iso9660->birth_time);
/* Volume Modification Date and Time */
set_date_time(bp+831, iso9660->birth_time);
/* Volume Expiration Date and Time(obsolete) */
set_date_time_null(bp+848);
/* Volume Effective Date and Time */
set_date_time(bp+865, iso9660->birth_time);
/* File Structure Version */
bp[882] = fst_ver;
/* Reserved */
bp[883] = 0;
/* Application Use */
memset(bp + 884, 0x20, 1395 - 884 + 1);
/* Reserved */
set_unused_field_bp(bp, 1396, LOGICAL_BLOCK_SIZE);
return (wb_consume(a, LOGICAL_BLOCK_SIZE));
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x170, %rsp # imm = 0x170
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movw $0x1, -0x2a(%rbp)
movq -0x10(%rbp), %rax
movq 0xf8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x144(%rbp)
testl %eax, %eax
je 0x954ebd
jmp 0x954e5b
movl -0x144(%rbp), %eax
subl $0x1, %eax
je 0x954e75
jmp 0x954e68
movl -0x144(%rbp), %eax
subl $0x2, %eax
je 0x954e99
jmp 0x954ebf
movl $0x2, -0x134(%rbp)
movb $0x1, -0x13a(%rbp)
movb $0x1, -0x139(%rbp)
movl $0x2, -0x138(%rbp)
jmp 0x954ee1
movl $0x2, -0x134(%rbp)
movb $0x2, -0x13a(%rbp)
movb $0x2, -0x139(%rbp)
movl $0x1, -0x138(%rbp)
jmp 0x954ee1
jmp 0x954ebf
movl $0x1, -0x134(%rbp)
movb $0x1, -0x13a(%rbp)
movb $0x1, -0x139(%rbp)
movl $0x0, -0x138(%rbp)
movq -0x10(%rbp), %rdi
callq 0x952710
addq $-0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movl -0x134(%rbp), %esi
movzbl -0x139(%rbp), %edx
callq 0x95bc90
movq -0x28(%rbp), %rdi
movl $0x8, %edx
movl %edx, %esi
callq 0x95bcd0
leaq -0x130(%rbp), %rdi
movl $0x100, %esi # imm = 0x100
callq 0x95bd10
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
leaq -0x130(%rbp), %r8
movl -0x138(%rbp), %r9d
movl $0x9, %edx
movl $0x28, %ecx
callq 0x95bd60
movl %eax, -0x140(%rbp)
cmpl $0x0, -0x140(%rbp)
je 0x954f6b
movl -0x140(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x955472
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rax
movq 0x128(%rax), %r8
movl -0x138(%rbp), %r9d
movl $0x29, %edx
movl $0x48, %ecx
callq 0x95be60
movl %eax, -0x140(%rbp)
cmpl $0x0, -0x140(%rbp)
je 0x954fb1
movl -0x140(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x955472
movq -0x28(%rbp), %rdi
movl $0x49, %esi
movl $0x50, %edx
callq 0x95bcd0
movq -0x28(%rbp), %rdi
addq $0x51, %rdi
movq -0x20(%rbp), %rax
movl 0x118(%rax), %esi
callq 0x95a140
movq -0x18(%rbp), %rax
cmpl $0x1, 0x8(%rax)
jne 0x955013
movq -0x28(%rbp), %rax
movb $0x25, 0x59(%rax)
movq -0x28(%rbp), %rax
movb $0x2f, 0x5a(%rax)
movq -0x28(%rbp), %rax
movb $0x45, 0x5b(%rax)
movq -0x28(%rbp), %rdi
addq $0x5c, %rdi
xorl %esi, %esi
movl $0x1d, %edx
callq 0x3b780
jmp 0x955026
movq -0x28(%rbp), %rdi
movl $0x59, %esi
movl $0x78, %edx
callq 0x95bcd0
movq -0x28(%rbp), %rdi
addq $0x79, %rdi
movzwl -0x2a(%rbp), %esi
callq 0x95a240
movq -0x28(%rbp), %rdi
addq $0x7d, %rdi
movq -0x20(%rbp), %rax
movl 0x11c(%rax), %eax
movzwl %ax, %esi
callq 0x95a240
movq -0x28(%rbp), %rdi
addq $0x81, %rdi
movl $0x800, %esi # imm = 0x800
callq 0x95a240
movq -0x28(%rbp), %rdi
addq $0x85, %rdi
movq -0x18(%rbp), %rax
movl 0x20(%rax), %esi
callq 0x95a140
movq -0x28(%rbp), %rdi
addq $0x8d, %rdi
movq -0x18(%rbp), %rax
movl 0x24(%rax), %esi
callq 0x953a80
movq -0x28(%rbp), %rdi
addq $0x91, %rdi
xorl %esi, %esi
callq 0x953a80
movq -0x28(%rbp), %rdi
addq $0x95, %rdi
movq -0x18(%rbp), %rax
movl 0x28(%rax), %esi
callq 0x95bf60
movq -0x28(%rbp), %rdi
addq $0x99, %rdi
xorl %esi, %esi
callq 0x95bf60
movq -0x28(%rbp), %rdi
addq $0x9d, %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rdx
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movl 0x8(%rax), %r9d
movl $0x22, %esi
xorl %r8d, %r8d
callq 0x959cc0
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl -0x138(%rbp), %r9d
movl $0xbf, %edx
movl $0x13e, %ecx # imm = 0x13E
leaq 0x26a09d(%rip), %r8 # 0xbbf1b7
callq 0x95be60
movl %eax, -0x140(%rbp)
cmpl $0x0, -0x140(%rbp)
je 0x95513c
movl -0x140(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x955472
movq -0x28(%rbp), %rdi
movl -0x138(%rbp), %ecx
movq -0x10(%rbp), %r8
movq -0x18(%rbp), %r9
movq -0x20(%rbp), %r10
addq $0x140, %r10 # imm = 0x140
movl $0x13f, %esi # imm = 0x13F
movl $0x1be, %edx # imm = 0x1BE
leaq 0x2727fa(%rip), %rax # 0xbc7964
xorl %r11d, %r11d
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
movl $0x1, 0x10(%rsp)
movl $0x0, 0x18(%rsp)
callq 0x95bf90
movl %eax, -0x140(%rbp)
cmpl $0x0, -0x140(%rbp)
je 0x9551a8
movl -0x140(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x955472
movq -0x28(%rbp), %rdi
movl -0x138(%rbp), %ecx
movq -0x10(%rbp), %r8
movq -0x18(%rbp), %r9
movq -0x20(%rbp), %r10
addq $0x158, %r10 # imm = 0x158
movl $0x1bf, %esi # imm = 0x1BF
movl $0x23e, %edx # imm = 0x23E
leaq 0x27279d(%rip), %rax # 0xbc7973
xorl %r11d, %r11d
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
movl $0x1, 0x10(%rsp)
movl $0x0, 0x18(%rsp)
callq 0x95bf90
movl %eax, -0x140(%rbp)
cmpl $0x0, -0x140(%rbp)
je 0x955214
movl -0x140(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x955472
movq -0x28(%rbp), %rdi
movl -0x138(%rbp), %ecx
movq -0x10(%rbp), %r8
movq -0x18(%rbp), %r9
movq -0x20(%rbp), %r10
addq $0x170, %r10 # imm = 0x170
movl $0x23f, %esi # imm = 0x23F
movl $0x2be, %edx # imm = 0x2BE
leaq 0x272744(%rip), %rax # 0xbc7986
xorl %r11d, %r11d
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
movl $0x1, 0x10(%rsp)
movl $0x0, 0x18(%rsp)
callq 0x95bf90
movl %eax, -0x140(%rbp)
cmpl $0x0, -0x140(%rbp)
je 0x955280
movl -0x140(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x955472
movq -0x28(%rbp), %rdi
movl -0x138(%rbp), %ecx
movq -0x10(%rbp), %r8
movq -0x18(%rbp), %r9
movq -0x20(%rbp), %r10
addq $0x188, %r10 # imm = 0x188
movl $0x2bf, %esi # imm = 0x2BF
movl $0x2e3, %edx # imm = 0x2E3
leaq 0x2726e9(%rip), %rax # 0xbc7997
xorl %r11d, %r11d
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
movl $0x1, 0x18(%rsp)
callq 0x95bf90
movl %eax, -0x140(%rbp)
cmpl $0x0, -0x140(%rbp)
je 0x9552ec
movl -0x140(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x955472
movq -0x28(%rbp), %rdi
movl -0x138(%rbp), %ecx
movq -0x10(%rbp), %r8
movq -0x18(%rbp), %r9
movq -0x20(%rbp), %r10
addq $0x1a0, %r10 # imm = 0x1A0
movl $0x2e4, %esi # imm = 0x2E4
movl $0x308, %edx # imm = 0x308
leaq 0x27268c(%rip), %rax # 0xbc79a6
xorl %r11d, %r11d
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
movl $0x1, 0x18(%rsp)
callq 0x95bf90
movl %eax, -0x140(%rbp)
cmpl $0x0, -0x140(%rbp)
je 0x955358
movl -0x140(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x955472
movq -0x28(%rbp), %rdi
movl -0x138(%rbp), %ecx
movq -0x10(%rbp), %r8
movq -0x18(%rbp), %r9
movq -0x20(%rbp), %r10
addq $0x1b8, %r10 # imm = 0x1B8
movl $0x309, %esi # imm = 0x309
movl $0x32d, %edx # imm = 0x32D
leaq 0x27262e(%rip), %rax # 0xbc79b4
xorl %r11d, %r11d
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
movl $0x1, 0x18(%rsp)
callq 0x95bf90
movl %eax, -0x140(%rbp)
cmpl $0x0, -0x140(%rbp)
je 0x9553c4
movl -0x140(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x955472
movq -0x28(%rbp), %rdi
addq $0x32e, %rdi # imm = 0x32E
movq -0x20(%rbp), %rax
movq (%rax), %rsi
callq 0x95c230
movq -0x28(%rbp), %rdi
addq $0x33f, %rdi # imm = 0x33F
movq -0x20(%rbp), %rax
movq (%rax), %rsi
callq 0x95c230
movq -0x28(%rbp), %rdi
addq $0x350, %rdi # imm = 0x350
callq 0x95c310
movq -0x28(%rbp), %rdi
addq $0x361, %rdi # imm = 0x361
movq -0x20(%rbp), %rax
movq (%rax), %rsi
callq 0x95c230
movb -0x13a(%rbp), %cl
movq -0x28(%rbp), %rax
movb %cl, 0x372(%rax)
movq -0x28(%rbp), %rax
movb $0x0, 0x373(%rax)
movq -0x28(%rbp), %rdi
addq $0x374, %rdi # imm = 0x374
movl $0x20, %esi
movl $0x200, %edx # imm = 0x200
callq 0x3b780
movq -0x28(%rbp), %rdi
movl $0x574, %esi # imm = 0x574
movl $0x800, %edx # imm = 0x800
callq 0x95bcd0
movq -0x10(%rbp), %rdi
movl $0x800, %esi # imm = 0x800
callq 0x952750
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x170, %rsp # imm = 0x170
popq %rbp
retq
nop
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c
|
write_VD_boot_record
|
static int
write_VD_boot_record(struct archive_write *a)
{
struct iso9660 *iso9660;
unsigned char *bp;
iso9660 = a->format_data;
bp = wb_buffptr(a) -1;
/* Volume Descriptor Type */
set_VD_bp(bp, VDT_BOOT_RECORD, 1);
/* Boot System Identifier */
memcpy(bp+8, "EL TORITO SPECIFICATION", 23);
set_unused_field_bp(bp, 8+23, 39);
/* Unused */
set_unused_field_bp(bp, 40, 71);
/* Absolute pointer to first sector of Boot Catalog */
set_num_731(bp+72,
iso9660->el_torito.catalog->file->content.location);
/* Unused */
set_unused_field_bp(bp, 76, LOGICAL_BLOCK_SIZE);
return (wb_consume(a, LOGICAL_BLOCK_SIZE));
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0xf8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x952710
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0x95bc90
movq -0x18(%rbp), %rax
movq 0x272514(%rip), %rcx # 0xbc79db
movq %rcx, 0x8(%rax)
movq 0x272511(%rip), %rcx # 0xbc79e3
movq %rcx, 0x10(%rax)
movl 0x27250f(%rip), %ecx # 0xbc79eb
movl %ecx, 0x18(%rax)
movw 0x272509(%rip), %cx # 0xbc79ef
movw %cx, 0x1c(%rax)
movb 0x272501(%rip), %cl # 0xbc79f1
movb %cl, 0x1e(%rax)
movq -0x18(%rbp), %rdi
movl $0x1f, %esi
movl $0x27, %edx
callq 0x95bcd0
movq -0x18(%rbp), %rdi
movl $0x28, %esi
movl $0x47, %edx
callq 0x95bcd0
movq -0x18(%rbp), %rdi
addq $0x48, %rdi
movq -0x10(%rbp), %rax
movq 0x10320(%rax), %rax
movq 0x18(%rax), %rax
movl 0xa4(%rax), %esi
callq 0x953a80
movq -0x18(%rbp), %rdi
movl $0x4c, %esi
movl $0x800, %edx # imm = 0x800
callq 0x95bcd0
movq -0x8(%rbp), %rdi
movl $0x800, %esi # imm = 0x800
callq 0x952750
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c
|
write_information_block
|
static int
write_information_block(struct archive_write *a)
{
struct iso9660 *iso9660;
char buf[128];
const char *v;
int opt, r;
struct archive_string info;
size_t info_size = LOGICAL_BLOCK_SIZE *
NON_ISO_FILE_SYSTEM_INFORMATION_BLOCK;
iso9660 = (struct iso9660 *)a->format_data;
if (info_size > wb_remaining(a)) {
r = wb_write_out(a);
if (r != ARCHIVE_OK)
return (r);
}
archive_string_init(&info);
if (archive_string_ensure(&info, info_size) == NULL) {
archive_set_error(&a->archive, ENOMEM,
"Can't allocate memory");
return (ARCHIVE_FATAL);
}
memset(info.s, 0, info_size);
opt = 0;
#if defined(HAVE__CTIME64_S)
{
__time64_t iso9660_birth_time_tmp = (__time64_t) iso9660->birth_time; //time_t may be shorter than 64 bits
_ctime64_s(buf, sizeof(buf), &(iso9660_birth_time_tmp));
}
#elif defined(HAVE_CTIME_R)
ctime_r(&(iso9660->birth_time), buf);
#else
strncpy(buf, ctime(&(iso9660->birth_time)), sizeof(buf)-1);
buf[sizeof(buf)-1] = '\0';
#endif
archive_string_sprintf(&info,
"INFO %s%s", buf, archive_version_string());
if (iso9660->opt.abstract_file != OPT_ABSTRACT_FILE_DEFAULT)
set_option_info(&info, &opt, "abstract-file",
KEY_STR, iso9660->abstract_file_identifier.s);
if (iso9660->opt.application_id != OPT_APPLICATION_ID_DEFAULT)
set_option_info(&info, &opt, "application-id",
KEY_STR, iso9660->application_identifier.s);
if (iso9660->opt.allow_vernum != OPT_ALLOW_VERNUM_DEFAULT)
set_option_info(&info, &opt, "allow-vernum",
KEY_FLG, iso9660->opt.allow_vernum);
if (iso9660->opt.biblio_file != OPT_BIBLIO_FILE_DEFAULT)
set_option_info(&info, &opt, "biblio-file",
KEY_STR, iso9660->bibliographic_file_identifier.s);
if (iso9660->opt.boot != OPT_BOOT_DEFAULT)
set_option_info(&info, &opt, "boot",
KEY_STR, iso9660->el_torito.boot_filename.s);
if (iso9660->opt.boot_catalog != OPT_BOOT_CATALOG_DEFAULT)
set_option_info(&info, &opt, "boot-catalog",
KEY_STR, iso9660->el_torito.catalog_filename.s);
if (iso9660->opt.boot_info_table != OPT_BOOT_INFO_TABLE_DEFAULT)
set_option_info(&info, &opt, "boot-info-table",
KEY_FLG, iso9660->opt.boot_info_table);
if (iso9660->opt.boot_load_seg != OPT_BOOT_LOAD_SEG_DEFAULT)
set_option_info(&info, &opt, "boot-load-seg",
KEY_HEX, iso9660->el_torito.boot_load_seg);
if (iso9660->opt.boot_load_size != OPT_BOOT_LOAD_SIZE_DEFAULT)
set_option_info(&info, &opt, "boot-load-size",
KEY_INT, iso9660->el_torito.boot_load_size);
if (iso9660->opt.boot_type != OPT_BOOT_TYPE_DEFAULT) {
v = "no-emulation";
if (iso9660->opt.boot_type == OPT_BOOT_TYPE_FD)
v = "fd";
if (iso9660->opt.boot_type == OPT_BOOT_TYPE_HARD_DISK)
v = "hard-disk";
set_option_info(&info, &opt, "boot-type",
KEY_STR, v);
}
#ifdef HAVE_ZLIB_H
if (iso9660->opt.compression_level != OPT_COMPRESSION_LEVEL_DEFAULT)
set_option_info(&info, &opt, "compression-level",
KEY_INT, iso9660->zisofs.compression_level);
#endif
if (iso9660->opt.copyright_file != OPT_COPYRIGHT_FILE_DEFAULT)
set_option_info(&info, &opt, "copyright-file",
KEY_STR, iso9660->copyright_file_identifier.s);
if (iso9660->opt.iso_level != OPT_ISO_LEVEL_DEFAULT)
set_option_info(&info, &opt, "iso-level",
KEY_INT, iso9660->opt.iso_level);
if (iso9660->opt.joliet != OPT_JOLIET_DEFAULT) {
if (iso9660->opt.joliet == OPT_JOLIET_LONGNAME)
set_option_info(&info, &opt, "joliet",
KEY_STR, "long");
else
set_option_info(&info, &opt, "joliet",
KEY_FLG, iso9660->opt.joliet);
}
if (iso9660->opt.limit_depth != OPT_LIMIT_DEPTH_DEFAULT)
set_option_info(&info, &opt, "limit-depth",
KEY_FLG, iso9660->opt.limit_depth);
if (iso9660->opt.limit_dirs != OPT_LIMIT_DIRS_DEFAULT)
set_option_info(&info, &opt, "limit-dirs",
KEY_FLG, iso9660->opt.limit_dirs);
if (iso9660->opt.pad != OPT_PAD_DEFAULT)
set_option_info(&info, &opt, "pad",
KEY_FLG, iso9660->opt.pad);
if (iso9660->opt.publisher != OPT_PUBLISHER_DEFAULT)
set_option_info(&info, &opt, "publisher",
KEY_STR, iso9660->publisher_identifier.s);
if (iso9660->opt.rr != OPT_RR_DEFAULT) {
if (iso9660->opt.rr == OPT_RR_DISABLED)
set_option_info(&info, &opt, "rockridge",
KEY_FLG, iso9660->opt.rr);
else if (iso9660->opt.rr == OPT_RR_STRICT)
set_option_info(&info, &opt, "rockridge",
KEY_STR, "strict");
else if (iso9660->opt.rr == OPT_RR_USEFUL)
set_option_info(&info, &opt, "rockridge",
KEY_STR, "useful");
}
if (iso9660->opt.volume_id != OPT_VOLUME_ID_DEFAULT)
set_option_info(&info, &opt, "volume-id",
KEY_STR, iso9660->volume_identifier.s);
if (iso9660->opt.zisofs != OPT_ZISOFS_DEFAULT)
set_option_info(&info, &opt, "zisofs",
KEY_FLG, iso9660->opt.zisofs);
memcpy(wb_buffptr(a), info.s, info_size);
archive_string_free(&info);
return (wb_consume(a, info_size));
}
|
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x10(%rbp)
movq $0x800, -0xd0(%rbp) # imm = 0x800
movq -0x10(%rbp), %rax
movq 0xf8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0xd0(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0xf8(%rcx), %rcx
cmpq 0x102e0(%rcx), %rax
jbe 0x95563c
movq -0x10(%rbp), %rdi
callq 0x952810
movl %eax, -0xb0(%rbp)
cmpl $0x0, -0xb0(%rbp)
je 0x95563a
movl -0xb0(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x955dee
jmp 0x95563c
jmp 0x95563e
movq $0x0, -0xc8(%rbp)
movq $0x0, -0xc0(%rbp)
movq $0x0, -0xb8(%rbp)
movq -0xd0(%rbp), %rsi
leaq -0xc8(%rbp), %rdi
callq 0x938530
cmpq $0x0, %rax
jne 0x95569b
movq -0x10(%rbp), %rdi
movl $0xc, %esi
leaq 0x264535(%rip), %rdx # 0xbb9bbd
movb $0x0, %al
callq 0x9401f0
movl $0xffffffe2, -0x4(%rbp) # imm = 0xFFFFFFE2
jmp 0x955dee
movq -0xc8(%rbp), %rdi
movq -0xd0(%rbp), %rdx
xorl %esi, %esi
callq 0x3b780
movl $0x0, -0xac(%rbp)
movq -0x18(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x3d410
leaq -0xa0(%rbp), %rax
movq %rax, -0xd8(%rbp)
callq 0x940070
movq -0xd8(%rbp), %rdx
movq %rax, %rcx
leaq -0xc8(%rbp), %rdi
leaq 0x2722fe(%rip), %rsi # 0xbc79f3
movb $0x0, %al
callq 0x93f6c0
movq -0x18(%rbp), %rax
movl 0x10370(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x95573a
movq -0x18(%rbp), %rax
movq 0x1a0(%rax), %r8
leaq -0xc8(%rbp), %rdi
leaq -0xac(%rbp), %rsi
leaq 0x271cae(%rip), %rdx # 0xbc73dc
movl $0x1, %ecx
movb $0x0, %al
callq 0x95c6a0
movq -0x18(%rbp), %rax
movl 0x10370(%rax), %eax
shrl %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x95577a
movq -0x18(%rbp), %rax
movq 0x170(%rax), %r8
leaq -0xc8(%rbp), %rdi
leaq -0xac(%rbp), %rsi
leaq 0x271c7c(%rip), %rdx # 0xbc73ea
movl $0x1, %ecx
movb $0x0, %al
callq 0x95c6a0
movq -0x18(%rbp), %rax
movl 0x10370(%rax), %eax
shrl $0x2, %eax
andl $0x1, %eax
cmpl $0x1, %eax
je 0x9557c0
movq -0x18(%rbp), %rax
movl 0x10370(%rax), %r8d
shrl $0x2, %r8d
andl $0x1, %r8d
leaq -0xc8(%rbp), %rdi
leaq -0xac(%rbp), %rsi
leaq 0x271c42(%rip), %rdx # 0xbc73f9
xorl %ecx, %ecx
movb $0x0, %al
callq 0x95c6a0
movq -0x18(%rbp), %rax
movl 0x10370(%rax), %eax
shrl $0x3, %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x955801
movq -0x18(%rbp), %rax
movq 0x1b8(%rax), %r8
leaq -0xc8(%rbp), %rdi
leaq -0xac(%rbp), %rsi
leaq 0x271c11(%rip), %rdx # 0xbc7406
movl $0x1, %ecx
movb $0x0, %al
callq 0x95c6a0
movq -0x18(%rbp), %rax
movl 0x10370(%rax), %eax
shrl $0x4, %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x955842
movq -0x18(%rbp), %rax
movq 0x10328(%rax), %r8
leaq -0xc8(%rbp), %rdi
leaq -0xac(%rbp), %rsi
leaq 0x271bdc(%rip), %rdx # 0xbc7412
movl $0x1, %ecx
movb $0x0, %al
callq 0x95c6a0
movq -0x18(%rbp), %rax
movl 0x10370(%rax), %eax
shrl $0x5, %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x955883
movq -0x18(%rbp), %rax
movq 0x10308(%rax), %r8
leaq -0xc8(%rbp), %rdi
leaq -0xac(%rbp), %rsi
leaq 0x271ba0(%rip), %rdx # 0xbc7417
movl $0x1, %ecx
movb $0x0, %al
callq 0x95c6a0
movq -0x18(%rbp), %rax
movl 0x10370(%rax), %eax
shrl $0x6, %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x9558c9
movq -0x18(%rbp), %rax
movl 0x10370(%rax), %r8d
shrl $0x6, %r8d
andl $0x1, %r8d
leaq -0xc8(%rbp), %rdi
leaq -0xac(%rbp), %rsi
leaq 0x271b64(%rip), %rdx # 0xbc7424
xorl %ecx, %ecx
movb $0x0, %al
callq 0x95c6a0
movq -0x18(%rbp), %rax
movl 0x10370(%rax), %eax
shrl $0x7, %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x95590b
movq -0x18(%rbp), %rax
movzwl 0x1036a(%rax), %r8d
leaq -0xc8(%rbp), %rdi
leaq -0xac(%rbp), %rsi
leaq 0x271b35(%rip), %rdx # 0xbc7434
movl $0x3, %ecx
movb $0x0, %al
callq 0x95c6a0
movq -0x18(%rbp), %rax
movl 0x10370(%rax), %eax
shrl $0x8, %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x95594d
movq -0x18(%rbp), %rax
movzwl 0x1036c(%rax), %r8d
leaq -0xc8(%rbp), %rdi
leaq -0xac(%rbp), %rsi
leaq 0x271b2e(%rip), %rdx # 0xbc746f
movl $0x2, %ecx
movb $0x0, %al
callq 0x95c6a0
movq -0x18(%rbp), %rax
movl 0x10370(%rax), %eax
shrl $0x9, %eax
andl $0x3, %eax
cmpl $0x0, %eax
je 0x9559de
leaq 0x271b1f(%rip), %rax # 0xbc7488
movq %rax, -0xa8(%rbp)
movq -0x18(%rbp), %rax
movl 0x10370(%rax), %eax
shrl $0x9, %eax
andl $0x3, %eax
cmpl $0x2, %eax
jne 0x955993
leaq 0x271b09(%rip), %rax # 0xbc7495
movq %rax, -0xa8(%rbp)
movq -0x18(%rbp), %rax
movl 0x10370(%rax), %eax
shrl $0x9, %eax
andl $0x3, %eax
cmpl $0x3, %eax
jne 0x9559b6
leaq 0x271ae9(%rip), %rax # 0xbc7498
movq %rax, -0xa8(%rbp)
movq -0xa8(%rbp), %r8
leaq -0xc8(%rbp), %rdi
leaq -0xac(%rbp), %rsi
leaq 0x271aac(%rip), %rdx # 0xbc747e
movl $0x1, %ecx
movb $0x0, %al
callq 0x95c6a0
movq -0x18(%rbp), %rax
movl 0x10370(%rax), %eax
shrl $0xb, %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x955a1f
movq -0x18(%rbp), %rax
movl 0x2c8(%rax), %r8d
leaq -0xc8(%rbp), %rdi
leaq -0xac(%rbp), %rsi
leaq 0x1efb80(%rip), %rdx # 0xb45593
movl $0x2, %ecx
movb $0x0, %al
callq 0x95c6a0
movq -0x18(%rbp), %rax
movl 0x10370(%rax), %eax
shrl $0xc, %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x955a60
movq -0x18(%rbp), %rax
movq 0x188(%rax), %r8
leaq -0xc8(%rbp), %rdi
leaq -0xac(%rbp), %rsi
leaq 0x271a4e(%rip), %rdx # 0xbc74a2
movl $0x1, %ecx
movb $0x0, %al
callq 0x95c6a0
movq -0x18(%rbp), %rax
movl 0x10370(%rax), %eax
shrl $0xe, %eax
andl $0x7, %eax
cmpl $0x1, %eax
je 0x955aa9
movq -0x18(%rbp), %rax
movl 0x10370(%rax), %r8d
shrl $0xe, %r8d
andl $0x7, %r8d
leaq -0xc8(%rbp), %rdi
leaq -0xac(%rbp), %rsi
leaq 0x271a14(%rip), %rdx # 0xbc74b1
movl $0x2, %ecx
movb $0x0, %al
callq 0x95c6a0
movq -0x18(%rbp), %rax
movl 0x10370(%rax), %eax
shrl $0x11, %eax
andl $0x3, %eax
cmpl $0x1, %eax
je 0x955b30
movq -0x18(%rbp), %rax
movl 0x10370(%rax), %eax
shrl $0x11, %eax
andl $0x3, %eax
cmpl $0x2, %eax
jne 0x955afd
leaq -0xc8(%rbp), %rdi
leaq -0xac(%rbp), %rsi
leaq 0x265cd6(%rip), %rdx # 0xbbb7be
movl $0x1, %ecx
leaq 0x2859e8(%rip), %r8 # 0xbdb4dc
movb $0x0, %al
callq 0x95c6a0
jmp 0x955b2e
movq -0x18(%rbp), %rax
movl 0x10370(%rax), %r8d
shrl $0x11, %r8d
andl $0x3, %r8d
leaq -0xc8(%rbp), %rdi
leaq -0xac(%rbp), %rsi
leaq 0x265c99(%rip), %rdx # 0xbbb7be
xorl %ecx, %ecx
movb $0x0, %al
callq 0x95c6a0
jmp 0x955b30
movq -0x18(%rbp), %rax
movl 0x10370(%rax), %eax
shrl $0x13, %eax
andl $0x1, %eax
cmpl $0x1, %eax
je 0x955b76
movq -0x18(%rbp), %rax
movl 0x10370(%rax), %r8d
shrl $0x13, %r8d
andl $0x1, %r8d
leaq -0xc8(%rbp), %rdi
leaq -0xac(%rbp), %rsi
leaq 0x27194e(%rip), %rdx # 0xbc74bb
xorl %ecx, %ecx
movb $0x0, %al
callq 0x95c6a0
movq -0x18(%rbp), %rax
movl 0x10370(%rax), %eax
shrl $0x14, %eax
andl $0x1, %eax
cmpl $0x1, %eax
je 0x955bbc
movq -0x18(%rbp), %rax
movl 0x10370(%rax), %r8d
shrl $0x14, %r8d
andl $0x1, %r8d
leaq -0xc8(%rbp), %rdi
leaq -0xac(%rbp), %rsi
leaq 0x271914(%rip), %rdx # 0xbc74c7
xorl %ecx, %ecx
movb $0x0, %al
callq 0x95c6a0
movq -0x18(%rbp), %rax
movl 0x10370(%rax), %eax
shrl $0x15, %eax
andl $0x1, %eax
cmpl $0x1, %eax
je 0x955c02
movq -0x18(%rbp), %rax
movl 0x10370(%rax), %r8d
shrl $0x15, %r8d
andl $0x1, %r8d
leaq -0xc8(%rbp), %rdi
leaq -0xac(%rbp), %rsi
leaq 0x2718d9(%rip), %rdx # 0xbc74d2
xorl %ecx, %ecx
movb $0x0, %al
callq 0x95c6a0
movq -0x18(%rbp), %rax
movl 0x10370(%rax), %eax
shrl $0x16, %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x955c43
movq -0x18(%rbp), %rax
movq 0x140(%rax), %r8
leaq -0xc8(%rbp), %rdi
leaq -0xac(%rbp), %rsi
leaq 0x27189f(%rip), %rdx # 0xbc74d6
movl $0x1, %ecx
movb $0x0, %al
callq 0x95c6a0
movq -0x18(%rbp), %rax
movl 0x10370(%rax), %eax
shrl $0x17, %eax
andl $0x3, %eax
cmpl $0x2, %eax
je 0x955d29
movq -0x18(%rbp), %rax
movl 0x10370(%rax), %eax
shrl $0x17, %eax
andl $0x3, %eax
cmpl $0x0, %eax
jne 0x955ca7
movq -0x18(%rbp), %rax
movl 0x10370(%rax), %r8d
shrl $0x17, %r8d
andl $0x3, %r8d
leaq -0xc8(%rbp), %rdi
leaq -0xac(%rbp), %rsi
leaq 0x265b34(%rip), %rdx # 0xbbb7cd
xorl %ecx, %ecx
movb $0x0, %al
callq 0x95c6a0
jmp 0x955d27
movq -0x18(%rbp), %rax
movl 0x10370(%rax), %eax
shrl $0x17, %eax
andl $0x3, %eax
cmpl $0x1, %eax
jne 0x955ce6
leaq -0xc8(%rbp), %rdi
leaq -0xac(%rbp), %rsi
leaq 0x265afc(%rip), %rdx # 0xbbb7cd
movl $0x1, %ecx
leaq 0x2069bb(%rip), %r8 # 0xb5c698
movb $0x0, %al
callq 0x95c6a0
jmp 0x955d25
movq -0x18(%rbp), %rax
movl 0x10370(%rax), %eax
shrl $0x17, %eax
andl $0x3, %eax
cmpl $0x2, %eax
jne 0x955d23
leaq -0xc8(%rbp), %rdi
leaq -0xac(%rbp), %rsi
leaq 0x265abd(%rip), %rdx # 0xbbb7cd
movl $0x1, %ecx
leaq 0x2717c4(%rip), %r8 # 0xbc74e0
movb $0x0, %al
callq 0x95c6a0
jmp 0x955d25
jmp 0x955d27
jmp 0x955d29
movq -0x18(%rbp), %rax
movl 0x10370(%rax), %eax
shrl $0x19, %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x955d6a
movq -0x18(%rbp), %rax
movq 0x128(%rax), %r8
leaq -0xc8(%rbp), %rdi
leaq -0xac(%rbp), %rsi
leaq 0x271789(%rip), %rdx # 0xbc74e7
movl $0x1, %ecx
movb $0x0, %al
callq 0x95c6a0
movq -0x18(%rbp), %rax
movl 0x10370(%rax), %eax
shrl $0x1a, %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x955db0
movq -0x18(%rbp), %rax
movl 0x10370(%rax), %r8d
shrl $0x1a, %r8d
andl $0x1, %r8d
leaq -0xc8(%rbp), %rdi
leaq -0xac(%rbp), %rsi
leaq 0x27174a(%rip), %rdx # 0xbc74f1
xorl %ecx, %ecx
movb $0x0, %al
callq 0x95c6a0
movq -0x10(%rbp), %rdi
callq 0x952710
movq %rax, %rdi
movq -0xc8(%rbp), %rsi
movq -0xd0(%rbp), %rdx
callq 0x3cb70
leaq -0xc8(%rbp), %rdi
callq 0x938460
movq -0x10(%rbp), %rdi
movq -0xd0(%rbp), %rsi
callq 0x952750
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xe0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c
|
write_path_table
|
static int
write_path_table(struct archive_write *a, int type_m, struct vdd *vdd)
{
int depth, r;
size_t path_table_size;
r = ARCHIVE_OK;
path_table_size = 0;
for (depth = 0; depth < vdd->max_depth; depth++) {
r = _write_path_table(a, type_m, depth, vdd);
if (r < 0)
return (r);
path_table_size += r;
}
/* Write padding data. */
path_table_size = path_table_size % PATH_TABLE_BLOCK_SIZE;
if (path_table_size > 0)
r = write_null(a, PATH_TABLE_BLOCK_SIZE - path_table_size);
return (r);
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jge 0x955e70
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x24(%rbp), %edx
movq -0x20(%rbp), %rcx
callq 0x95c9b0
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
jge 0x955e59
movl -0x28(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x955ea0
movslq -0x28(%rbp), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x955e29
movq -0x30(%rbp), %rax
andq $0xfff, %rax # imm = 0xFFF
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jbe 0x955e9a
movq -0x10(%rbp), %rdi
movl $0x1000, %esi # imm = 0x1000
subq -0x30(%rbp), %rsi
callq 0x952550
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c
|
write_directory_descriptors
|
static int
write_directory_descriptors(struct archive_write *a, struct vdd *vdd)
{
struct isoent *np;
int depth, r;
depth = 0;
np = vdd->rootent;
do {
struct extr_rec *extr;
r = _write_directory_descriptors(a, vdd, np, depth);
if (r < 0)
return (r);
if (vdd->vdd_type != VDD_JOLIET) {
/*
* This extract record is used by SUSP,RRIP.
* Not for joliet.
*/
for (extr = np->extr_rec_list.first;
extr != NULL;
extr = extr->next) {
unsigned char *wb;
wb = wb_buffptr(a);
memcpy(wb, extr->buf, extr->offset);
memset(wb + extr->offset, 0,
LOGICAL_BLOCK_SIZE - extr->offset);
r = wb_consume(a, LOGICAL_BLOCK_SIZE);
if (r < 0)
return (r);
}
}
if (np->subdirs.first != NULL && depth + 1 < vdd->max_depth) {
/* Enter to sub directories. */
np = np->subdirs.first;
depth++;
continue;
}
while (np != np->parent) {
if (np->drnext == NULL) {
/* Return to the parent directory. */
np = np->parent;
depth--;
} else {
np = np->drnext;
break;
}
}
} while (np != np->parent);
return (ARCHIVE_OK);
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0x24(%rbp), %ecx
callq 0x95ccf0
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
jge 0x955efa
movl -0x28(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x956035
movq -0x18(%rbp), %rax
cmpl $0x1, 0x8(%rax)
je 0x955fa7
movq -0x20(%rbp), %rax
movq 0xd0(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x955fa5
movq -0x10(%rbp), %rdi
callq 0x952710
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
addq $0x8, %rsi
movq -0x30(%rbp), %rax
movslq 0x4(%rax), %rdx
callq 0x3cb70
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rax
movslq 0x4(%rax), %rax
addq %rax, %rdi
movq -0x30(%rbp), %rcx
movl $0x800, %eax # imm = 0x800
subl 0x4(%rcx), %eax
movslq %eax, %rdx
xorl %esi, %esi
callq 0x3b780
movq -0x10(%rbp), %rdi
movl $0x800, %esi # imm = 0x800
callq 0x952750
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
jge 0x955f8f
movl -0x28(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x956035
jmp 0x955f91
movq -0x30(%rbp), %rax
movq 0x808(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x955f17
jmp 0x955fa7
movq -0x20(%rbp), %rax
cmpq $0x0, 0x50(%rax)
je 0x955fd8
movl -0x24(%rbp), %eax
addl $0x1, %eax
movq -0x18(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jge 0x955fd8
movq -0x20(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x20(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x95601c
jmp 0x955fda
movq -0x20(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpq 0x20(%rcx), %rax
je 0x95601a
movq -0x20(%rbp), %rax
cmpq $0x0, 0x78(%rax)
jne 0x95600a
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
movl -0x24(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x956018
movq -0x20(%rbp), %rax
movq 0x78(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x95601a
jmp 0x955fda
jmp 0x95601c
movq -0x20(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpq 0x20(%rcx), %rax
jne 0x955ed2
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c
|
write_rr_ER
|
static int
write_rr_ER(struct archive_write *a)
{
unsigned char *p;
p = wb_buffptr(a);
memset(p, 0, LOGICAL_BLOCK_SIZE);
p[0] = 'E';
p[1] = 'R';
p[3] = 0x01;
p[2] = RRIP_ER_SIZE;
p[4] = RRIP_ER_ID_SIZE;
p[5] = RRIP_ER_DSC_SIZE;
p[6] = RRIP_ER_SRC_SIZE;
p[7] = 0x01;
memcpy(&p[8], rrip_identifier, p[4]);
memcpy(&p[8+p[4]], rrip_descriptor, p[5]);
memcpy(&p[8+p[4]+p[5]], rrip_source, p[6]);
return (wb_consume(a, LOGICAL_BLOCK_SIZE));
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x952710
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x800, %edx # imm = 0x800
callq 0x3b780
movq -0x10(%rbp), %rax
movb $0x45, (%rax)
movq -0x10(%rbp), %rax
movb $0x52, 0x1(%rax)
movq -0x10(%rbp), %rax
movb $0x1, 0x3(%rax)
movq -0x10(%rbp), %rax
movb $-0x13, 0x2(%rax)
movq -0x10(%rbp), %rax
movb $0xa, 0x4(%rax)
movq -0x10(%rbp), %rax
movb $0x54, 0x5(%rax)
movq -0x10(%rbp), %rax
movb $-0x79, 0x6(%rax)
movq -0x10(%rbp), %rax
movb $0x1, 0x7(%rax)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rax
movzbl 0x4(%rax), %eax
movl %eax, %edx
leaq 0x2711ef(%rip), %rsi # 0xbc72b0
callq 0x3cb70
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movzbl 0x4(%rax), %eax
addl $0x8, %eax
cltq
addq %rax, %rdi
movq -0x10(%rbp), %rax
movzbl 0x5(%rax), %eax
movl %eax, %edx
leaq 0x2711d5(%rip), %rsi # 0xbc72c0
callq 0x3cb70
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movzbl 0x4(%rax), %eax
addl $0x8, %eax
movq -0x10(%rbp), %rcx
movzbl 0x5(%rcx), %ecx
addl %ecx, %eax
cltq
addq %rax, %rdi
movq -0x10(%rbp), %rax
movzbl 0x6(%rax), %eax
movl %eax, %edx
leaq 0x271201(%rip), %rsi # 0xbc7320
callq 0x3cb70
movq -0x8(%rbp), %rdi
movl $0x800, %esi # imm = 0x800
callq 0x952750
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c
|
isoent_find_entry
|
static struct isoent *
isoent_find_entry(struct isoent *rootent, const char *fn)
{
#if defined(_WIN32) && !defined(__CYGWIN__)
char name[_MAX_FNAME];/* Included null terminator size. */
#elif defined(NAME_MAX) && NAME_MAX >= 255
char name[NAME_MAX+1];
#else
char name[256];
#endif
struct isoent *isoent, *np;
int l;
isoent = rootent;
np = NULL;
for (;;) {
l = get_path_component(name, sizeof(name), fn);
if (l == 0)
break;
fn += l;
if (fn[0] == '/')
fn++;
np = isoent_find_child(isoent, name);
if (np == NULL)
break;
if (fn[0] == '\0')
break;/* We found out the entry */
/* Try sub directory. */
isoent = np;
np = NULL;
if (!isoent->dir)
break;/* Not directory */
}
return (np);
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp # imm = 0x130
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x118(%rbp)
movq $0x0, -0x120(%rbp)
leaq -0x110(%rbp), %rdi
movq -0x10(%rbp), %rdx
movl $0x100, %esi # imm = 0x100
callq 0x9522b0
movl %eax, -0x124(%rbp)
cmpl $0x0, -0x124(%rbp)
jne 0x9563b2
jmp 0x95644d
movl -0x124(%rbp), %ecx
movq -0x10(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0x9563de
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x118(%rbp), %rdi
leaq -0x110(%rbp), %rsi
callq 0x9523d0
movq %rax, -0x120(%rbp)
cmpq $0x0, -0x120(%rbp)
jne 0x956404
jmp 0x95644d
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x956412
jmp 0x95644d
movq -0x120(%rbp), %rax
movq %rax, -0x118(%rbp)
movq $0x0, -0x120(%rbp)
movq -0x118(%rbp), %rax
movb 0xe8(%rax), %al
shlb $0x6, %al
sarb $0x7, %al
movsbl %al, %eax
cmpl $0x0, %eax
jne 0x956448
jmp 0x95644d
jmp 0x956389
movq -0x120(%rbp), %rax
addq $0x130, %rsp # imm = 0x130
popq %rbp
retq
nopl (%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c
|
zisofs_extract
|
static ssize_t
zisofs_extract(struct archive_write *a, struct zisofs_extract *zisofs,
const unsigned char *p, size_t bytes)
{
size_t avail;
int r;
if (!zisofs->initialized) {
ssize_t rs = zisofs_extract_init(a, zisofs, p, bytes);
if (rs < 0)
return (rs);
if (!zisofs->initialized) {
/* We need more data. */
zisofs->pz_offset += (uint32_t)bytes;
return (bytes);
}
avail = rs;
p += bytes - avail;
} else
avail = bytes;
/*
* Get block offsets from block pointers.
*/
if (zisofs->block_avail == 0) {
uint32_t bst, bed;
if (zisofs->block_off + 4 >= zisofs->block_pointers_size) {
/* There isn't a pair of offsets. */
archive_set_error(&a->archive,
ARCHIVE_ERRNO_FILE_FORMAT,
"Illegal zisofs block pointers");
return (ARCHIVE_FATAL);
}
bst = archive_le32dec(
zisofs->block_pointers + zisofs->block_off);
if (bst != zisofs->pz_offset + (bytes - avail)) {
archive_set_error(&a->archive,
ARCHIVE_ERRNO_FILE_FORMAT,
"Illegal zisofs block pointers(cannot seek)");
return (ARCHIVE_FATAL);
}
bed = archive_le32dec(
zisofs->block_pointers + zisofs->block_off + 4);
if (bed < bst) {
archive_set_error(&a->archive,
ARCHIVE_ERRNO_FILE_FORMAT,
"Illegal zisofs block pointers");
return (ARCHIVE_FATAL);
}
zisofs->block_avail = bed - bst;
zisofs->block_off += 4;
/* Initialize compression library for new block. */
if (zisofs->stream_valid)
r = inflateReset(&zisofs->stream);
else
r = inflateInit(&zisofs->stream);
if (r != Z_OK) {
archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
"Can't initialize zisofs decompression.");
return (ARCHIVE_FATAL);
}
zisofs->stream_valid = 1;
zisofs->stream.total_in = 0;
zisofs->stream.total_out = 0;
}
/*
* Make uncompressed data.
*/
if (zisofs->block_avail == 0) {
/*
* It's basically 32K bytes NUL data.
*/
unsigned char *wb;
size_t size, wsize;
size = zisofs->uncompressed_buffer_size;
while (size) {
wb = wb_buffptr(a);
if (size > wb_remaining(a))
wsize = wb_remaining(a);
else
wsize = size;
memset(wb, 0, wsize);
r = wb_consume(a, wsize);
if (r < 0)
return (r);
size -= wsize;
}
} else {
zisofs->stream.next_in = (Bytef *)(uintptr_t)(const void *)p;
if (avail > zisofs->block_avail)
zisofs->stream.avail_in = zisofs->block_avail;
else
zisofs->stream.avail_in = (uInt)avail;
zisofs->stream.next_out = wb_buffptr(a);
zisofs->stream.avail_out = (uInt)wb_remaining(a);
r = inflate(&zisofs->stream, 0);
switch (r) {
case Z_OK: /* Decompressor made some progress.*/
case Z_STREAM_END: /* Found end of stream. */
break;
default:
archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
"zisofs decompression failed (%d)", r);
return (ARCHIVE_FATAL);
}
avail -= zisofs->stream.next_in - p;
zisofs->block_avail -= (uint32_t)(zisofs->stream.next_in - p);
r = wb_consume(a, wb_remaining(a) - zisofs->stream.avail_out);
if (r < 0)
return (r);
}
zisofs->pz_offset += (uint32_t)bytes;
return (bytes - avail);
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rax
movb 0x18(%rax), %al
shlb $0x7, %al
sarb $0x7, %al
movsbl %al, %eax
cmpl $0x0, %eax
jne 0x956506
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x9568a0
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jge 0x9564ba
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x956888
movq -0x18(%rbp), %rax
movb 0x18(%rax), %al
shlb $0x7, %al
sarb $0x7, %al
movsbl %al, %eax
cmpl $0x0, %eax
jne 0x9564ec
movq -0x28(%rbp), %rax
movl %eax, %ecx
movq -0x18(%rbp), %rax
addl 0x1c(%rax), %ecx
movl %ecx, 0x1c(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x956888
movq -0x40(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
subq -0x30(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x95650e
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x40(%rax)
jne 0x95669c
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
addq $0x4, %rax
movq -0x18(%rbp), %rcx
cmpq 0x28(%rcx), %rax
jb 0x956556
movq -0x10(%rbp), %rdi
movl $0x54, %esi
leaq 0x2656c3(%rip), %rdx # 0xbbbc05
movb $0x0, %al
callq 0x9401f0
movq $-0x1e, -0x8(%rbp)
jmp 0x956888
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x18(%rbp), %rax
addq 0x38(%rax), %rdi
callq 0x953610
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %eax
movq -0x18(%rbp), %rcx
movl 0x1c(%rcx), %ecx
movq -0x28(%rbp), %rdx
subq -0x30(%rbp), %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
je 0x9565ac
movq -0x10(%rbp), %rdi
movl $0x54, %esi
leaq 0x26568b(%rip), %rdx # 0xbbbc23
movb $0x0, %al
callq 0x9401f0
movq $-0x1e, -0x8(%rbp)
jmp 0x956888
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x18(%rbp), %rax
addq 0x38(%rax), %rdi
addq $0x4, %rdi
callq 0x953610
movl %eax, -0x48(%rbp)
movl -0x48(%rbp), %eax
cmpl -0x44(%rbp), %eax
jae 0x9565f4
movq -0x10(%rbp), %rdi
movl $0x54, %esi
leaq 0x265625(%rip), %rdx # 0xbbbc05
movb $0x0, %al
callq 0x9401f0
movq $-0x1e, -0x8(%rbp)
jmp 0x956888
movl -0x48(%rbp), %ecx
subl -0x44(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x40(%rax)
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rcx
addq $0x4, %rcx
movq %rcx, 0x38(%rax)
movq -0x18(%rbp), %rax
cmpl $0x0, 0xb8(%rax)
je 0x956630
movq -0x18(%rbp), %rdi
addq $0x48, %rdi
callq 0xb35a40
movl %eax, -0x34(%rbp)
jmp 0x95664c
movq -0x18(%rbp), %rdi
addq $0x48, %rdi
leaq 0x24defe(%rip), %rsi # 0xba453d
movl $0x70, %edx
callq 0xb35cf0
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
je 0x956676
movq -0x10(%rbp), %rdi
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
leaq 0x2655ec(%rip), %rdx # 0xbbbc4e
movb $0x0, %al
callq 0x9401f0
movq $-0x1e, -0x8(%rbp)
jmp 0x956888
movq -0x18(%rbp), %rax
movl $0x1, 0xb8(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x58(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x70(%rax)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x40(%rax)
jne 0x956751
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x58(%rbp)
cmpq $0x0, -0x58(%rbp)
je 0x95674c
movq -0x10(%rbp), %rdi
callq 0x952710
movq %rax, -0x50(%rbp)
movq -0x58(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0xf8(%rcx), %rcx
cmpq 0x102e0(%rcx), %rax
jbe 0x9566fe
movq -0x10(%rbp), %rax
movq 0xf8(%rax), %rax
movq 0x102e0(%rax), %rax
movq %rax, -0x60(%rbp)
jmp 0x956706
movq -0x58(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x50(%rbp), %rdi
movq -0x60(%rbp), %rdx
xorl %esi, %esi
callq 0x3b780
movq -0x10(%rbp), %rdi
movq -0x60(%rbp), %rsi
callq 0x952750
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jge 0x956738
movslq -0x34(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x956888
movq -0x60(%rbp), %rcx
movq -0x58(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x58(%rbp)
jmp 0x9566b6
jmp 0x95686c
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
movl 0x40(%rcx), %ecx
cmpq %rcx, %rax
jbe 0x95677d
movq -0x18(%rbp), %rax
movl 0x40(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x50(%rax)
jmp 0x95678a
movq -0x30(%rbp), %rax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x50(%rax)
movq -0x10(%rbp), %rdi
callq 0x952710
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x60(%rax)
movq -0x10(%rbp), %rax
movq 0xf8(%rax), %rax
movl 0x102e0(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x68(%rax)
movq -0x18(%rbp), %rdi
addq $0x48, %rdi
xorl %esi, %esi
callq 0xb35e00
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
subl $0x1, %eax
ja 0x9567d4
jmp 0x9567d2
jmp 0x9567fb
movq -0x10(%rbp), %rdi
movl -0x34(%rbp), %ecx
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
leaq 0x26548e(%rip), %rdx # 0xbbbc75
movb $0x0, %al
callq 0x9401f0
movq $-0x1e, -0x8(%rbp)
jmp 0x956888
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rcx
movq -0x20(%rbp), %rax
subq %rax, %rcx
movq -0x30(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x20(%rbp), %rcx
subq %rcx, %rax
movl %eax, %edx
movq -0x18(%rbp), %rax
movl 0x40(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x40(%rax)
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0xf8(%rax), %rax
movq 0x102e0(%rax), %rsi
movq -0x18(%rbp), %rax
movl 0x68(%rax), %eax
subq %rax, %rsi
callq 0x952750
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jge 0x95686a
movslq -0x34(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x956888
jmp 0x95686c
movq -0x28(%rbp), %rax
movl %eax, %ecx
movq -0x18(%rbp), %rax
addl 0x1c(%rax), %ecx
movl %ecx, 0x1c(%rax)
movq -0x28(%rbp), %rax
subq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c
|
zisofs_extract_init
|
static ssize_t
zisofs_extract_init(struct archive_write *a, struct zisofs_extract *zisofs,
const unsigned char *p, size_t bytes)
{
size_t avail = bytes;
size_t _ceil, xsize;
/* Allocate block pointers buffer. */
_ceil = (size_t)((zisofs->pz_uncompressed_size +
(((int64_t)1) << zisofs->pz_log2_bs) - 1)
>> zisofs->pz_log2_bs);
xsize = (_ceil + 1) * 4;
if (zisofs->block_pointers == NULL) {
size_t alloc = ((xsize >> 10) + 1) << 10;
zisofs->block_pointers = malloc(alloc);
if (zisofs->block_pointers == NULL) {
archive_set_error(&a->archive, ENOMEM,
"No memory for zisofs decompression");
return (ARCHIVE_FATAL);
}
}
zisofs->block_pointers_size = xsize;
/* Allocate uncompressed data buffer. */
zisofs->uncompressed_buffer_size = (size_t)1UL << zisofs->pz_log2_bs;
/*
* Read the file header, and check the magic code of zisofs.
*/
if (!zisofs->header_passed) {
int err = 0;
if (avail < 16) {
archive_set_error(&a->archive,
ARCHIVE_ERRNO_FILE_FORMAT,
"Illegal zisofs file body");
return (ARCHIVE_FATAL);
}
if (memcmp(p, zisofs_magic, sizeof(zisofs_magic)) != 0)
err = 1;
else if (archive_le32dec(p + 8) != zisofs->pz_uncompressed_size)
err = 1;
else if (p[12] != 4 || p[13] != zisofs->pz_log2_bs)
err = 1;
if (err) {
archive_set_error(&a->archive,
ARCHIVE_ERRNO_FILE_FORMAT,
"Illegal zisofs file body");
return (ARCHIVE_FATAL);
}
avail -= 16;
p += 16;
zisofs->header_passed = 1;
}
/*
* Read block pointers.
*/
if (zisofs->header_passed &&
zisofs->block_pointers_avail < zisofs->block_pointers_size) {
xsize = zisofs->block_pointers_size
- zisofs->block_pointers_avail;
if (avail < xsize)
xsize = avail;
memcpy(zisofs->block_pointers
+ zisofs->block_pointers_avail, p, xsize);
zisofs->block_pointers_avail += xsize;
avail -= xsize;
if (zisofs->block_pointers_avail
== zisofs->block_pointers_size) {
/* We've got all block pointers and initialize
* related variables. */
zisofs->block_off = 0;
zisofs->block_avail = 0;
/* Complete a initialization */
zisofs->initialized = 1;
}
}
return ((ssize_t)avail);
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
movl (%rcx), %ecx
movl $0x1, %edx
shlq %cl, %rdx
movq %rdx, %rcx
addq %rcx, %rax
subq $0x1, %rax
movq -0x18(%rbp), %rcx
movl (%rcx), %ecx
shrq %cl, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
addq $0x1, %rax
shlq $0x2, %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x956961
movq -0x40(%rbp), %rax
shrq $0xa, %rax
addq $0x1, %rax
shlq $0xa, %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
callq 0x3e578
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x95695f
movq -0x10(%rbp), %rdi
movl $0xc, %esi
leaq 0x26527e(%rip), %rdx # 0xbbbbc9
movb $0x0, %al
callq 0x9401f0
movq $-0x1e, -0x8(%rbp)
jmp 0x956b6b
jmp 0x956961
movq -0x40(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movb 0x18(%rax), %al
shlb $0x6, %al
sarb $0x7, %al
movsbl %al, %eax
cmpl $0x0, %eax
jne 0x956a97
movl $0x0, -0x4c(%rbp)
cmpq $0x10, -0x30(%rbp)
jae 0x9569d3
movq -0x10(%rbp), %rdi
movl $0x54, %esi
leaq 0x26522d(%rip), %rdx # 0xbbbbec
movb $0x0, %al
callq 0x9401f0
movq $-0x1e, -0x8(%rbp)
jmp 0x956b6b
movq -0x20(%rbp), %rax
movq (%rax), %rax
movabsq $0x7d6dbc99653e437, %rcx # imm = 0x7D6DBC99653E437
subq %rcx, %rax
setne %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x9569fb
movl $0x1, -0x4c(%rbp)
jmp 0x956a45
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
callq 0x953610
movl %eax, %eax
movq -0x18(%rbp), %rcx
cmpq 0x8(%rcx), %rax
je 0x956a1d
movl $0x1, -0x4c(%rbp)
jmp 0x956a43
movq -0x20(%rbp), %rax
movzbl 0xc(%rax), %eax
cmpl $0x4, %eax
jne 0x956a3a
movq -0x20(%rbp), %rax
movzbl 0xd(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
je 0x956a41
movl $0x1, -0x4c(%rbp)
jmp 0x956a43
jmp 0x956a45
cmpl $0x0, -0x4c(%rbp)
je 0x956a6f
movq -0x10(%rbp), %rdi
movl $0x54, %esi
leaq 0x265191(%rip), %rdx # 0xbbbbec
movb $0x0, %al
callq 0x9401f0
movq $-0x1e, -0x8(%rbp)
jmp 0x956b6b
movq -0x30(%rbp), %rax
subq $0x10, %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movb 0x18(%rax), %cl
andb $-0x3, %cl
orb $0x2, %cl
movb %cl, 0x18(%rax)
movq -0x18(%rbp), %rax
movb 0x18(%rax), %al
shlb $0x6, %al
sarb $0x7, %al
movsbl %al, %eax
cmpl $0x0, %eax
je 0x956b63
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x28(%rcx), %rax
jae 0x956b63
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x18(%rbp), %rcx
subq 0x30(%rcx), %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x40(%rbp), %rax
jae 0x956aec
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x18(%rbp), %rax
addq 0x30(%rax), %rdi
movq -0x20(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0x3cb70
movq -0x40(%rbp), %rcx
movq -0x18(%rbp), %rax
addq 0x30(%rax), %rcx
movq %rcx, 0x30(%rax)
movq -0x40(%rbp), %rcx
movq -0x30(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x28(%rcx), %rax
jne 0x956b61
movq -0x18(%rbp), %rax
movq $0x0, 0x38(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x40(%rax)
movq -0x18(%rbp), %rax
movb 0x18(%rax), %cl
andb $-0x2, %cl
orb $0x1, %cl
movb %cl, 0x18(%rax)
jmp 0x956b63
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c
|
isoent_collect_dirs
|
static int
isoent_collect_dirs(struct vdd *vdd, struct isoent *rootent, int depth)
{
struct isoent *np;
if (rootent == NULL)
rootent = vdd->rootent;
np = rootent;
do {
/* Register current directory to pathtable. */
path_table_add_entry(&(vdd->pathtbl[depth]), np);
if (np->subdirs.first != NULL && depth + 1 < vdd->max_depth) {
/* Enter to sub directories. */
np = np->subdirs.first;
depth++;
continue;
}
while (np != rootent) {
if (np->drnext == NULL) {
/* Return to the parent directory. */
np = np->parent;
depth--;
} else {
np = np->drnext;
break;
}
}
} while (np != rootent);
return (ARCHIVE_OK);
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x956ce5
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movslq -0x14(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rdi
movq -0x20(%rbp), %rsi
callq 0x9574f0
movq -0x20(%rbp), %rax
cmpq $0x0, 0x50(%rax)
je 0x956d3a
movl -0x14(%rbp), %eax
addl $0x1, %eax
movq -0x8(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jge 0x956d3a
movq -0x20(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x956d7a
jmp 0x956d3c
movq -0x20(%rbp), %rax
cmpq -0x10(%rbp), %rax
je 0x956d78
movq -0x20(%rbp), %rax
cmpq $0x0, 0x78(%rax)
jne 0x956d68
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x956d76
movq -0x20(%rbp), %rax
movq 0x78(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x956d78
jmp 0x956d3c
jmp 0x956d7a
movq -0x20(%rbp), %rax
cmpq -0x10(%rbp), %rax
jne 0x956ced
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c
|
isofile_connect_hardlink_files
|
static void
isofile_connect_hardlink_files(struct iso9660 *iso9660)
{
struct archive_rb_node *n;
struct hardlink *hl;
struct isofile *target, *nf;
ARCHIVE_RB_TREE_FOREACH(n, &(iso9660->hardlink_rbtree)) {
hl = (struct hardlink *)n;
/* The first entry must be a hardlink target. */
target = hl->file_list.first;
archive_entry_set_nlink(target->entry, hl->nlink);
/* Set a hardlink target to reference entries. */
for (nf = target->hlnext;
nf != NULL; nf = nf->hlnext) {
nf->hardlink_target = target;
archive_entry_set_nlink(nf->entry, hl->nlink);
}
}
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0xa8, %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x8f1ec0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x956fce
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x18(%rbp), %rax
movl 0x18(%rax), %esi
callq 0x8ebeb0
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x956faa
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x18(%rbp), %rax
movl 0x18(%rax), %esi
callq 0x8ebeb0
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x956f75
jmp 0x956fac
movq -0x8(%rbp), %rdi
addq $0xa8, %rdi
movq -0x10(%rbp), %rsi
movl $0x1, %edx
callq 0x8f1ec0
movq %rax, -0x10(%rbp)
jmp 0x956f36
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c
|
calculate_path_table_size
|
static void
calculate_path_table_size(struct vdd *vdd)
{
int depth, size;
struct path_table *pt;
pt = vdd->pathtbl;
size = 0;
for (depth = 0; depth < vdd->max_depth; depth++) {
struct isoent **ptbl;
int i, cnt;
if ((cnt = pt[depth].cnt) == 0)
break;
ptbl = pt[depth].sorted;
for (i = 0; i < cnt; i++) {
int len;
if (ptbl[i]->identifier == NULL)
len = 1; /* root directory */
else
len = ptbl[i]->id_len;
if (len & 0x01)
len++; /* Padding Field */
size += 8 + len;
}
}
vdd->path_table_size = size;
vdd->path_table_block =
((size + PATH_TABLE_BLOCK_SIZE -1) /
PATH_TABLE_BLOCK_SIZE) *
(PATH_TABLE_BLOCK_SIZE / LOGICAL_BLOCK_SIZE);
}
|
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x10(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jge 0x9574c6
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movl 0x18(%rax), %eax
movl %eax, -0x28(%rbp)
cmpl $0x0, %eax
jne 0x957431
jmp 0x9574c6
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x28(%rbp), %eax
jge 0x9574b6
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpq $0x0, 0xa8(%rax)
jne 0x957476
movl $0x1, -0x2c(%rbp)
jmp 0x95748b
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl 0xb8(%rax), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x95749f
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
addl $0x8, %eax
addl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x95744f
jmp 0x9574b8
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x957402
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x20(%rax)
movl -0x10(%rbp), %eax
addl $0x1000, %eax # imm = 0x1000
subl $0x1, %eax
movl $0x1000, %ecx # imm = 0x1000
cltd
idivl %ecx
movl %eax, %ecx
shll %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x1c(%rax)
popq %rbp
retq
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c
|
isoent_remove_child
|
static void
isoent_remove_child(struct isoent *parent, struct isoent *child)
{
struct isoent *ent;
/* Remove a child entry from children chain. */
ent = parent->children.first;
while (ent->chnext != child)
ent = ent->chnext;
if ((ent->chnext = ent->chnext->chnext) == NULL)
parent->children.last = &(ent->chnext);
parent->children.cnt--;
if (child->dir) {
/* Remove a child entry from sub-directory chain. */
ent = parent->subdirs.first;
while (ent->drnext != child)
ent = ent->drnext;
if ((ent->drnext = ent->drnext->drnext) == NULL)
parent->subdirs.last = &(ent->drnext);
parent->subdirs.cnt--;
}
__archive_rb_tree_remove_node(&(parent->rbtree),
(struct archive_rb_node *)child);
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x70(%rax), %rax
cmpq -0x10(%rbp), %rax
je 0x957578
movq -0x18(%rbp), %rax
movq 0x70(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x95755c
movq -0x18(%rbp), %rax
movq 0x70(%rax), %rax
movq 0x70(%rax), %rax
movq -0x18(%rbp), %rcx
movq %rax, 0x70(%rcx)
cmpq $0x0, %rax
jne 0x9575a2
movq -0x18(%rbp), %rcx
addq $0x70, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x8(%rbp), %rax
movl 0x38(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x38(%rax)
movq -0x10(%rbp), %rax
movb 0xe8(%rax), %al
shlb $0x6, %al
sarb $0x7, %al
movsbl %al, %eax
cmpl $0x0, %eax
je 0x957626
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x78(%rax), %rax
cmpq -0x10(%rbp), %rax
je 0x9575ef
movq -0x18(%rbp), %rax
movq 0x78(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x9575d3
movq -0x18(%rbp), %rax
movq 0x78(%rax), %rax
movq 0x78(%rax), %rax
movq -0x18(%rbp), %rcx
movq %rax, 0x78(%rcx)
cmpq $0x0, %rax
jne 0x957619
movq -0x18(%rbp), %rcx
addq $0x78, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x58(%rax)
movq -0x8(%rbp), %rax
movl 0x60(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x60(%rax)
movq -0x8(%rbp), %rdi
addq $0x40, %rdi
movq -0x10(%rbp), %rsi
callq 0x8f1cb0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c
|
idr_init
|
static void
idr_init(struct iso9660 *iso9660, struct vdd *vdd, struct idr *idr)
{
idr->idrent_pool = NULL;
idr->pool_size = 0;
if (vdd->vdd_type != VDD_JOLIET) {
if (iso9660->opt.iso_level <= 3) {
memcpy(idr->char_map, d_characters_map,
sizeof(idr->char_map));
} else {
memcpy(idr->char_map, d1_characters_map,
sizeof(idr->char_map));
idr_relaxed_filenames(idr->char_map);
}
}
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x28(%rax)
movq -0x10(%rbp), %rax
cmpl $0x1, 0x8(%rax)
je 0x957abc
movq -0x8(%rbp), %rax
movl 0x10370(%rax), %eax
shrl $0xe, %eax
andl $0x7, %eax
cmpl $0x3, %eax
jg 0x957a94
movq -0x18(%rbp), %rdi
addq $0x38, %rdi
leaq 0x26f628(%rip), %rsi # 0xbc70b0
movl $0x80, %edx
callq 0x3cb70
jmp 0x957aba
movq -0x18(%rbp), %rdi
addq $0x38, %rdi
leaq 0x26f58d(%rip), %rsi # 0xbc7030
movl $0x80, %edx
callq 0x3cb70
movq -0x18(%rbp), %rdi
addq $0x38, %rdi
callq 0x9587f0
jmp 0x957abc
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c
|
isoent_gen_joliet_identifier
|
static int
isoent_gen_joliet_identifier(struct archive_write *a, struct isoent *isoent,
struct idr *idr)
{
struct iso9660 *iso9660;
struct isoent *np;
unsigned char *p;
size_t l;
int r;
size_t ffmax, parent_len;
static const struct archive_rb_tree_ops rb_ops = {
isoent_cmp_node_joliet, isoent_cmp_key_joliet
};
if (isoent->children.cnt == 0)
return (0);
iso9660 = a->format_data;
if (iso9660->opt.joliet == OPT_JOLIET_LONGNAME)
ffmax = 206;
else
ffmax = 128;
r = idr_start(a, idr, isoent->children.cnt, (int)ffmax, 6, 2, &rb_ops);
if (r < 0)
return (r);
parent_len = 1;
for (np = isoent; np->parent != np; np = np->parent)
parent_len += np->mb_len + 1;
for (np = isoent->children.first; np != NULL; np = np->chnext) {
unsigned char *dot;
int ext_off, noff, weight;
size_t lt;
if ((l = np->file->basename_utf16.length) > ffmax)
l = ffmax;
p = malloc((l+1)*2);
if (p == NULL) {
archive_set_error(&a->archive, ENOMEM,
"Can't allocate memory");
return (ARCHIVE_FATAL);
}
memcpy(p, np->file->basename_utf16.s, l);
p[l] = 0;
p[l+1] = 0;
np->identifier = (char *)p;
lt = l;
dot = p + l;
weight = 0;
while (lt > 0) {
if (!joliet_allowed_char(p[0], p[1]))
archive_be16enc(p, 0x005F); /* '_' */
else if (p[0] == 0 && p[1] == 0x2E) /* '.' */
dot = p;
p += 2;
lt -= 2;
}
ext_off = (int)(dot - (unsigned char *)np->identifier);
np->ext_off = ext_off;
np->ext_len = (int)l - ext_off;
np->id_len = (int)l;
/*
* Get a length of MBS of a full-pathname.
*/
if (np->file->basename_utf16.length > ffmax) {
if (archive_strncpy_l(&iso9660->mbs,
(const char *)np->identifier, l,
iso9660->sconv_from_utf16be) != 0 &&
errno == ENOMEM) {
archive_set_error(&a->archive, errno,
"No memory");
return (ARCHIVE_FATAL);
}
np->mb_len = (int)iso9660->mbs.length;
if (np->mb_len != (int)np->file->basename.length)
weight = np->mb_len;
} else
np->mb_len = (int)np->file->basename.length;
/* If a length of full-pathname is longer than 240 bytes,
* it violates Joliet extensions regulation. */
if (parent_len > 240
|| np->mb_len > 240
|| parent_len + np->mb_len > 240) {
archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
"The regulation of Joliet extensions;"
" A length of a full-pathname of `%s' is "
"longer than 240 bytes, (p=%d, b=%d)",
archive_entry_pathname(np->file->entry),
(int)parent_len, (int)np->mb_len);
return (ARCHIVE_FATAL);
}
/* Make an offset of the number which is used to be set
* hexadecimal number to avoid duplicate identifier. */
if (l == ffmax)
noff = ext_off - 6;
else if (l == ffmax-2)
noff = ext_off - 4;
else if (l == ffmax-4)
noff = ext_off - 2;
else
noff = ext_off;
/* Register entry to the identifier resolver. */
idr_register(idr, np, weight, noff);
}
/* Resolve duplicate identifier with Joliet Volume. */
idr_resolve(idr, idr_set_num_beutf16);
return (ARCHIVE_OK);
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x38(%rax)
jne 0x957afd
movl $0x0, -0x4(%rbp)
jmp 0x957f29
movq -0x10(%rbp), %rax
movq 0xf8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl 0x10370(%rax), %eax
shrl $0x11, %eax
andl $0x3, %eax
cmpl $0x2, %eax
jne 0x957b2b
movq $0xce, -0x50(%rbp)
jmp 0x957b33
movq $0x80, -0x50(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rax
movl 0x38(%rax), %edx
movq -0x50(%rbp), %rax
movl %eax, %ecx
movl $0x6, %r8d
movl $0x2, %r9d
leaq 0x5a0455(%rip), %rax # 0xef7fb0
movq %rax, (%rsp)
callq 0x958920
movl %eax, -0x44(%rbp)
cmpl $0x0, -0x44(%rbp)
jge 0x957b78
movl -0x44(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x957f29
movq $0x1, -0x58(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rax
cmpq -0x30(%rbp), %rax
je 0x957bbb
movq -0x30(%rbp), %rax
movl 0xbc(%rax), %eax
addl $0x1, %eax
cltq
addq -0x58(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x957b88
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x957f12
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x60(%rax), %rax
movq %rax, -0x40(%rbp)
cmpq -0x50(%rbp), %rax
jbe 0x957bf0
movq -0x50(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
addq $0x1, %rdi
shlq %rdi
callq 0x3e578
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x957c2e
movq -0x10(%rbp), %rdi
movl $0xc, %esi
leaq 0x261fa2(%rip), %rdx # 0xbb9bbd
movb $0x0, %al
callq 0x9401f0
movl $0xffffffe2, -0x4(%rbp) # imm = 0xFFFFFFE2
jmp 0x957f29
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x58(%rax), %rsi
movq -0x40(%rbp), %rdx
callq 0x3cb70
movq -0x38(%rbp), %rax
movq -0x40(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x38(%rbp), %rax
movq -0x40(%rbp), %rcx
movb $0x0, 0x1(%rax,%rcx)
movq -0x38(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0xa8(%rax)
movq -0x40(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x38(%rbp), %rax
addq -0x40(%rbp), %rax
movq %rax, -0x60(%rbp)
movl $0x0, -0x6c(%rbp)
cmpq $0x0, -0x78(%rbp)
jbe 0x957cf9
movq -0x38(%rbp), %rax
movb (%rax), %cl
movq -0x38(%rbp), %rax
movzbl %cl, %edi
movzbl 0x1(%rax), %esi
callq 0x9589c0
cmpl $0x0, %eax
jne 0x957cbc
movq -0x38(%rbp), %rdi
movl $0x5f, %esi
callq 0x958a40
jmp 0x957cdf
movq -0x38(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x0, %eax
jne 0x957cdd
movq -0x38(%rbp), %rax
movzbl 0x1(%rax), %eax
cmpl $0x2e, %eax
jne 0x957cdd
movq -0x38(%rbp), %rax
movq %rax, -0x60(%rbp)
jmp 0x957cdf
movq -0x38(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x38(%rbp)
movq -0x78(%rbp), %rax
subq $0x2, %rax
movq %rax, -0x78(%rbp)
jmp 0x957c8a
movq -0x60(%rbp), %rax
movq -0x30(%rbp), %rcx
movq 0xa8(%rcx), %rcx
subq %rcx, %rax
movl %eax, -0x64(%rbp)
movl -0x64(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0xb0(%rax)
movq -0x40(%rbp), %rax
movl %eax, %ecx
subl -0x64(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0xb4(%rax)
movq -0x40(%rbp), %rax
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0xb8(%rax)
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x60(%rax), %rax
cmpq -0x50(%rbp), %rax
jbe 0x957df4
movq -0x28(%rbp), %rdi
addq $0x60, %rdi
movq -0x30(%rbp), %rax
movq 0xa8(%rax), %rsi
movq -0x40(%rbp), %rdx
movq -0x28(%rbp), %rax
movq 0x80(%rax), %rcx
callq 0x939320
cmpl $0x0, %eax
je 0x957db7
callq 0x3e130
cmpl $0xc, (%rax)
jne 0x957db7
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
callq 0x3e130
movq -0x80(%rbp), %rdi
movl (%rax), %esi
leaq 0x260d54(%rip), %rdx # 0xbb8af8
movb $0x0, %al
callq 0x9401f0
movl $0xffffffe2, -0x4(%rbp) # imm = 0xFFFFFFE2
jmp 0x957f29
movq -0x28(%rbp), %rax
movq 0x68(%rax), %rax
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0xbc(%rax)
movq -0x30(%rbp), %rax
movl 0xbc(%rax), %eax
movq -0x30(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq 0x48(%rcx), %rcx
cmpl %ecx, %eax
je 0x957df2
movq -0x30(%rbp), %rax
movl 0xbc(%rax), %eax
movl %eax, -0x6c(%rbp)
jmp 0x957e0c
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x48(%rax), %rax
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0xbc(%rax)
cmpq $0xf0, -0x58(%rbp)
ja 0x957e40
movq -0x30(%rbp), %rax
cmpl $0xf0, 0xbc(%rax)
jg 0x957e40
movq -0x58(%rbp), %rax
movq -0x30(%rbp), %rcx
movslq 0xbc(%rcx), %rcx
addq %rcx, %rax
cmpq $0xf0, %rax
jbe 0x957e97
movq -0x10(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x20(%rax), %rdi
callq 0x8ea480
movq -0x88(%rbp), %rdi
movq %rax, %rcx
movq -0x58(%rbp), %rax
movl %eax, %r8d
movq -0x30(%rbp), %rax
movl 0xbc(%rax), %r9d
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
leaq 0x26fa54(%rip), %rdx # 0xbc78d8
movb $0x0, %al
callq 0x9401f0
movl $0xffffffe2, -0x4(%rbp) # imm = 0xFFFFFFE2
jmp 0x957f29
movq -0x40(%rbp), %rax
cmpq -0x50(%rbp), %rax
jne 0x957eac
movl -0x64(%rbp), %eax
subl $0x6, %eax
movl %eax, -0x68(%rbp)
jmp 0x957eee
movq -0x40(%rbp), %rax
movq -0x50(%rbp), %rcx
subq $0x2, %rcx
cmpq %rcx, %rax
jne 0x957ec8
movl -0x64(%rbp), %eax
subl $0x4, %eax
movl %eax, -0x68(%rbp)
jmp 0x957eec
movq -0x40(%rbp), %rax
movq -0x50(%rbp), %rcx
subq $0x4, %rcx
cmpq %rcx, %rax
jne 0x957ee4
movl -0x64(%rbp), %eax
subl $0x2, %eax
movl %eax, -0x68(%rbp)
jmp 0x957eea
movl -0x64(%rbp), %eax
movl %eax, -0x68(%rbp)
jmp 0x957eec
jmp 0x957eee
movq -0x20(%rbp), %rdi
movq -0x30(%rbp), %rsi
movl -0x6c(%rbp), %edx
movl -0x68(%rbp), %ecx
callq 0x958a80
movq -0x30(%rbp), %rax
movq 0x70(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x957bc7
movq -0x20(%rbp), %rdi
leaq 0xd03(%rip), %rsi # 0x958c20
callq 0x958b70
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c
|
archive_write_set_format_shar
|
int
archive_write_set_format_shar(struct archive *_a)
{
struct archive_write *a = (struct archive_write *)_a;
struct shar *shar;
archive_check_magic(_a, ARCHIVE_WRITE_MAGIC,
ARCHIVE_STATE_NEW, "archive_write_set_format_shar");
/* If someone else was already registered, unregister them. */
if (a->format_free != NULL)
(a->format_free)(a);
shar = (struct shar *)calloc(1, sizeof(*shar));
if (shar == NULL) {
archive_set_error(&a->archive, ENOMEM, "Can't allocate shar data");
return (ARCHIVE_FATAL);
}
archive_string_init(&shar->work);
archive_string_init(&shar->quoted_name);
a->format_data = shar;
a->format_name = "shar";
a->format_write_header = archive_write_shar_header;
a->format_close = archive_write_shar_close;
a->format_free = archive_write_shar_free;
a->format_write_data = archive_write_shar_data_sed;
a->format_finish_entry = archive_write_shar_finish_entry;
a->archive.archive_format = ARCHIVE_FORMAT_SHAR_BASE;
a->archive.archive_format_name = "shar";
return (ARCHIVE_OK);
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0xb0c5c0de, %esi # imm = 0xB0C5C0DE
movl $0x1, %edx
leaq 0x2626ea(%rip), %rcx # 0xbc8533
callq 0x9770c0
movl %eax, -0x24(%rbp)
cmpl $-0x1e, -0x24(%rbp)
jne 0x965e63
movl $0xffffffe2, -0x4(%rbp) # imm = 0xFFFFFFE2
jmp 0x965faf
jmp 0x965e65
movq -0x18(%rbp), %rax
cmpq $0x0, 0x138(%rax)
je 0x965e84
movq -0x18(%rbp), %rax
movq 0x138(%rax), %rax
movq -0x18(%rbp), %rdi
callq *%rax
movl $0x1, %edi
movl $0x90, %esi
callq 0x3e570
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x965ec1
movq -0x18(%rbp), %rdi
movl $0xc, %esi
leaq 0x2626a3(%rip), %rdx # 0xbc8551
movb $0x0, %al
callq 0x9401f0
movl $0xffffffe2, -0x4(%rbp) # imm = 0xFFFFFFE2
jmp 0x965faf
jmp 0x965ec3
movq -0x20(%rbp), %rax
movq $0x0, 0x60(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x68(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x70(%rax)
jmp 0x965ee9
movq -0x20(%rbp), %rax
movq $0x0, 0x78(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x80(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x88(%rax)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0xf8(%rax)
movq -0x18(%rbp), %rax
leaq 0x26261f(%rip), %rcx # 0xbc854c
movq %rcx, 0x100(%rax)
movq -0x18(%rbp), %rax
leaq 0x81(%rip), %rcx # 0x965fc0
movq %rcx, 0x120(%rax)
movq -0x18(%rbp), %rax
leaq 0x75f(%rip), %rcx # 0x9666b0
movq %rcx, 0x130(%rax)
movq -0x18(%rbp), %rax
leaq 0x7dd(%rip), %rcx # 0x966740
movq %rcx, 0x138(%rax)
movq -0x18(%rbp), %rax
leaq 0x85b(%rip), %rcx # 0x9667d0
movq %rcx, 0x128(%rax)
movq -0x18(%rbp), %rax
leaq 0xa79(%rip), %rcx # 0x966a00
movq %rcx, 0x118(%rax)
movq -0x18(%rbp), %rax
movl $0x20001, 0x10(%rax) # imm = 0x20001
movq -0x18(%rbp), %rax
leaq 0x2625a8(%rip), %rcx # 0xbc854c
movq %rcx, 0x18(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_shar.c
|
archive_write_shar_close
|
static int
archive_write_shar_close(struct archive_write *a)
{
struct shar *shar;
int ret;
/*
* TODO: Accumulate list of directory names/modes and
* fix them all up at end-of-archive.
*/
shar = (struct shar *)a->format_data;
/*
* Only write the end-of-archive markers if the archive was
* actually started. This avoids problems if someone sets
* shar format, then sets another format (which would invoke
* shar_finish to free the format-specific data).
*/
if (shar->wrote_header == 0)
return (ARCHIVE_OK);
archive_strcat(&shar->work, "exit\n");
ret = __archive_write_output(a, shar->work.s, shar->work.length);
if (ret != ARCHIVE_OK)
return (ARCHIVE_FATAL);
/* Shar output is never padded. */
archive_write_set_bytes_in_last_block(&a->archive, 1);
/*
* TODO: shar should also suppress padding of
* uncompressed data within gzip/bzip2 streams.
*/
return (ARCHIVE_OK);
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0xf8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x58(%rax)
jne 0x9666de
movl $0x0, -0x4(%rbp)
jmp 0x966732
movq -0x18(%rbp), %rdi
addq $0x60, %rdi
leaq 0x261fc8(%rip), %rsi # 0xbc86b5
callq 0x9387b0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x60(%rax), %rsi
movq -0x18(%rbp), %rax
movq 0x68(%rax), %rdx
callq 0x941080
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x96671d
movl $0xffffffe2, -0x4(%rbp) # imm = 0xFFFFFFE2
jmp 0x966732
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x940e00
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_shar.c
|
archive_write_shar_finish_entry
|
static int
archive_write_shar_finish_entry(struct archive_write *a)
{
const char *g, *p, *u;
struct shar *shar;
int ret;
shar = (struct shar *)a->format_data;
if (shar->entry == NULL)
return (0);
if (shar->dump) {
/* Finish uuencoded data. */
if (shar->has_data) {
if (shar->outpos > 0)
uuencode_line(a, shar, shar->outbuff,
shar->outpos);
archive_strcat(&shar->work, "`\nend\n");
archive_strcat(&shar->work, "SHAR_END\n");
}
/* Restore file mode, owner, flags. */
/*
* TODO: Don't immediately restore mode for
* directories; defer that to end of script.
*/
archive_string_sprintf(&shar->work, "chmod %o ",
(unsigned int)(archive_entry_mode(shar->entry) & 07777));
shar_quote(&shar->work, archive_entry_pathname(shar->entry), 1);
archive_strcat(&shar->work, "\n");
u = archive_entry_uname(shar->entry);
g = archive_entry_gname(shar->entry);
if (u != NULL || g != NULL) {
archive_strcat(&shar->work, "chown ");
if (u != NULL)
shar_quote(&shar->work, u, 1);
if (g != NULL) {
archive_strcat(&shar->work, ":");
shar_quote(&shar->work, g, 1);
}
archive_strcat(&shar->work, " ");
shar_quote(&shar->work,
archive_entry_pathname(shar->entry), 1);
archive_strcat(&shar->work, "\n");
}
if ((p = archive_entry_fflags_text(shar->entry)) != NULL) {
archive_string_sprintf(&shar->work, "chflags %s ", p);
shar_quote(&shar->work,
archive_entry_pathname(shar->entry), 1);
archive_strcat(&shar->work, "\n");
}
/* TODO: restore ACLs */
} else {
if (shar->has_data) {
/* Finish sed-encoded data: ensure last line ends. */
if (!shar->end_of_line)
archive_strappend_char(&shar->work, '\n');
archive_strcat(&shar->work, "SHAR_END\n");
}
}
archive_entry_free(shar->entry);
shar->entry = NULL;
if (shar->work.length < 65536)
return (ARCHIVE_OK);
ret = __archive_write_output(a, shar->work.s, shar->work.length);
if (ret != ARCHIVE_OK)
return (ARCHIVE_FATAL);
archive_string_empty(&shar->work);
return (ARCHIVE_OK);
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0xf8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x966a32
movl $0x0, -0x4(%rbp)
jmp 0x966d28
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0x966c7e
movq -0x30(%rbp), %rax
cmpl $0x0, 0x10(%rax)
je 0x966ab4
movq -0x30(%rbp), %rax
cmpq $0x0, 0x50(%rax)
jbe 0x966a8c
jmp 0x966a56
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x30(%rbp), %rdx
addq $0x20, %rdx
movq -0x30(%rbp), %rax
movq 0x50(%rax), %rcx
callq 0x967090
movl %eax, -0x38(%rbp)
cmpl $0x0, -0x38(%rbp)
je 0x966a88
movl $0xffffffe2, -0x4(%rbp) # imm = 0xFFFFFFE2
jmp 0x966d28
jmp 0x966a8a
jmp 0x966a8c
movq -0x30(%rbp), %rdi
addq $0x60, %rdi
leaq 0x261bec(%rip), %rsi # 0xbc8687
callq 0x9387b0
movq -0x30(%rbp), %rdi
addq $0x60, %rdi
leaq 0x261bdf(%rip), %rsi # 0xbc868e
callq 0x9387b0
movq -0x30(%rbp), %rax
addq $0x60, %rax
movq %rax, -0x48(%rbp)
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x8ea3e0
movq -0x48(%rbp), %rdi
movl %eax, %edx
andl $0xfff, %edx # imm = 0xFFF
leaq 0x261bb8(%rip), %rsi # 0xbc8698
movb $0x0, %al
callq 0x93f6c0
movq -0x30(%rbp), %rax
addq $0x60, %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x8ea480
movq -0x40(%rbp), %rdi
movq %rax, %rsi
movl $0x1, %edx
callq 0x966fb0
movq -0x30(%rbp), %rdi
addq $0x60, %rdi
leaq 0x21f895(%rip), %rsi # 0xb863b5
callq 0x9387b0
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x8eaa80
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x8e9fe0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x966b59
cmpq $0x0, -0x18(%rbp)
je 0x966c0d
movq -0x30(%rbp), %rdi
addq $0x60, %rdi
leaq 0x261b3a(%rip), %rsi # 0xbc86a2
callq 0x9387b0
cmpq $0x0, -0x28(%rbp)
je 0x966b8a
movq -0x30(%rbp), %rdi
addq $0x60, %rdi
movq -0x28(%rbp), %rsi
movl $0x1, %edx
callq 0x966fb0
cmpq $0x0, -0x18(%rbp)
je 0x966bbb
movq -0x30(%rbp), %rdi
addq $0x60, %rdi
leaq 0x219e3b(%rip), %rsi # 0xb809db
callq 0x9387b0
movq -0x30(%rbp), %rdi
addq $0x60, %rdi
movq -0x18(%rbp), %rsi
movl $0x1, %edx
callq 0x966fb0
movq -0x30(%rbp), %rdi
addq $0x60, %rdi
leaq 0x215ea5(%rip), %rsi # 0xb7ca6f
callq 0x9387b0
movq -0x30(%rbp), %rax
addq $0x60, %rax
movq %rax, -0x50(%rbp)
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x8ea480
movq -0x50(%rbp), %rdi
movq %rax, %rsi
movl $0x1, %edx
callq 0x966fb0
movq -0x30(%rbp), %rdi
addq $0x60, %rdi
leaq 0x21f7ad(%rip), %rsi # 0xb863b5
callq 0x9387b0
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x8e9c70
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x966c7c
movq -0x30(%rbp), %rdi
addq $0x60, %rdi
movq -0x20(%rbp), %rdx
leaq 0x261a72(%rip), %rsi # 0xbc86a9
movb $0x0, %al
callq 0x93f6c0
movq -0x30(%rbp), %rax
addq $0x60, %rax
movq %rax, -0x58(%rbp)
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x8ea480
movq -0x58(%rbp), %rdi
movq %rax, %rsi
movl $0x1, %edx
callq 0x966fb0
movq -0x30(%rbp), %rdi
addq $0x60, %rdi
leaq 0x21f73e(%rip), %rsi # 0xb863b5
callq 0x9387b0
jmp 0x966cba
movq -0x30(%rbp), %rax
cmpl $0x0, 0x10(%rax)
je 0x966cb8
movq -0x30(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jne 0x966ca4
movq -0x30(%rbp), %rdi
addq $0x60, %rdi
movl $0xa, %esi
callq 0x938810
movq -0x30(%rbp), %rdi
addq $0x60, %rdi
leaq 0x2619db(%rip), %rsi # 0xbc868e
callq 0x9387b0
jmp 0x966cba
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x8e9990
movq -0x30(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x30(%rbp), %rax
cmpq $0x10000, 0x68(%rax) # imm = 0x10000
jae 0x966cea
movl $0x0, -0x4(%rbp)
jmp 0x966d28
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rax
movq 0x60(%rax), %rsi
movq -0x30(%rbp), %rax
movq 0x68(%rax), %rdx
callq 0x941080
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
je 0x966d15
movl $0xffffffe2, -0x4(%rbp) # imm = 0xFFFFFFE2
jmp 0x966d28
movq -0x30(%rbp), %rax
movq $0x0, 0x68(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_shar.c
|
uuencode_line
|
static int
_uuencode_line(struct archive_write *a, struct shar *shar, const char *inbuf, size_t len)
{
char *buf;
size_t alloc_len;
/* len <= 45 -> expanded to 60 + len byte + new line */
alloc_len = shar->work.length + 62;
if (archive_string_ensure(&shar->work, alloc_len) == NULL) {
archive_set_error(&a->archive, ENOMEM, "Out of memory");
return (ARCHIVE_FATAL);
}
buf = shar->work.s + shar->work.length;
*buf++ = UUENC(len);
while (len >= 3) {
uuencode_group(inbuf, buf);
len -= 3;
inbuf += 3;
buf += 4;
}
if (len != 0) {
char tmp_buf[3];
tmp_buf[0] = inbuf[0];
if (len == 1)
tmp_buf[1] = '\0';
else
tmp_buf[1] = inbuf[1];
tmp_buf[2] = '\0';
uuencode_group(tmp_buf, buf);
buf += 4;
}
*buf++ = '\n';
if ((buf - shar->work.s) > (ptrdiff_t)(shar->work.length + 62)) {
archive_set_error(&a->archive,
ARCHIVE_ERRNO_MISC, "Buffer overflow");
return (ARCHIVE_FATAL);
}
shar->work.length = buf - shar->work.s;
return (ARCHIVE_OK);
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq 0x68(%rax), %rax
addq $0x3e, %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
addq $0x60, %rdi
movq -0x38(%rbp), %rsi
callq 0x938530
cmpq $0x0, %rax
jne 0x9670f2
movq -0x10(%rbp), %rdi
movl $0xc, %esi
leaq 0x1f9346(%rip), %rdx # 0xb60425
movb $0x0, %al
callq 0x9401f0
movl $0xffffffe2, -0x4(%rbp) # imm = 0xFFFFFFE2
jmp 0x96722f
movq -0x18(%rbp), %rax
movq 0x60(%rax), %rax
movq -0x18(%rbp), %rcx
addq 0x68(%rcx), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x96711f
movq -0x28(%rbp), %rax
andq $0x3f, %rax
addq $0x20, %rax
movq %rax, -0x48(%rbp)
jmp 0x96712a
movl $0x60, %eax
movq %rax, -0x48(%rbp)
jmp 0x96712a
movq -0x48(%rbp), %rax
movb %al, %cl
movq -0x30(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x30(%rbp)
movb %cl, (%rax)
cmpq $0x3, -0x28(%rbp)
jb 0x96717b
movq -0x20(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x967240
movq -0x28(%rbp), %rax
subq $0x3, %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x20(%rbp)
movq -0x30(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x30(%rbp)
jmp 0x967141
cmpq $0x0, -0x28(%rbp)
je 0x9671bf
movq -0x20(%rbp), %rax
movb (%rax), %al
movb %al, -0x3b(%rbp)
cmpq $0x1, -0x28(%rbp)
jne 0x967198
movb $0x0, -0x3a(%rbp)
jmp 0x9671a2
movq -0x20(%rbp), %rax
movb 0x1(%rax), %al
movb %al, -0x3a(%rbp)
movb $0x0, -0x39(%rbp)
leaq -0x3b(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x967240
movq -0x30(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x30(%rbp)
movb $0xa, (%rax)
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x60(%rcx), %rcx
subq %rcx, %rax
movq -0x18(%rbp), %rcx
movq 0x68(%rcx), %rcx
addq $0x3e, %rcx
cmpq %rcx, %rax
jle 0x967211
movq -0x10(%rbp), %rdi
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
leaq 0x261476(%rip), %rdx # 0xbc8677
movb $0x0, %al
callq 0x9401f0
movl $0xffffffe2, -0x4(%rbp) # imm = 0xFFFFFFE2
jmp 0x96722f
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
movq 0x60(%rax), %rax
subq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x68(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_shar.c
|
arc4_stir
|
static void
arc4_stir(void)
{
int done, fd, i;
struct {
struct timeval tv;
pid_t pid;
uint8_t rnd[KEYSIZE];
} rdat;
if (!rs_initialized) {
arc4_init();
rs_initialized = 1;
}
done = 0;
fd = open(RANDOMDEV, O_RDONLY | O_CLOEXEC, 0);
if (fd >= 0) {
if (read(fd, &rdat, KEYSIZE) == KEYSIZE)
done = 1;
(void)close(fd);
}
if (!done) {
(void)gettimeofday(&rdat.tv, NULL);
rdat.pid = getpid();
/* We'll just take whatever was on the stack too... */
}
arc4_addrandom((uint8_t *)&rdat, KEYSIZE);
/*
* Discard early keystream, as per recommendations in:
* "(Not So) Random Shuffles of RC4" by Ilya Mironov.
* As per the Network Operations Division, cryptographic requirements
* published on wikileaks on March 2017.
*/
for (i = 0; i < 3072; i++)
(void)arc4_getbyte();
arc4_count = 1600000;
}
|
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
cmpl $0x0, 0x585cd2(%rip) # 0xf08f04
jne 0x983243
callq 0x9833b0
movl $0x1, 0x585cc1(%rip) # 0xf08f04
movl $0x0, -0x4(%rbp)
leaq 0x1dcedc(%rip), %rdi # 0xb6012d
movl $0x80000, %esi # imm = 0x80000
xorl %edx, %edx
movb $0x0, %al
callq 0x3d280
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jl 0x983293
movl -0x8(%rbp), %edi
leaq -0xa8(%rbp), %rsi
movl $0x80, %edx
callq 0x3da70
cmpq $0x80, %rax
jne 0x98328b
movl $0x1, -0x4(%rbp)
movl -0x8(%rbp), %edi
callq 0x3ce50
cmpl $0x0, -0x4(%rbp)
jne 0x9832b4
leaq -0xa8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3d400
callq 0x3e360
movl %eax, -0x98(%rbp)
leaq -0xa8(%rbp), %rdi
movl $0x80, %esi
callq 0x983400
movl $0x0, -0xc(%rbp)
cmpl $0xc00, -0xc(%rbp) # imm = 0xC00
jge 0x9832e5
callq 0x983300
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x9832cc
movl $0x186a00, 0x585c11(%rip) # imm = 0x186A00
addq $0xb0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_random.c
|
read_SubStreamsInfo
|
static int
read_SubStreamsInfo(struct archive_read *a, struct _7z_substream_info *ss,
struct _7z_folder *f, size_t numFolders)
{
const unsigned char *p;
uint64_t *usizes;
size_t unpack_streams;
int type;
unsigned i;
uint32_t numDigests;
memset(ss, 0, sizeof(*ss));
for (i = 0; i < numFolders; i++)
f[i].numUnpackStreams = 1;
if ((p = header_bytes(a, 1)) == NULL)
return (-1);
type = *p;
if (type == kNumUnPackStream) {
unpack_streams = 0;
for (i = 0; i < numFolders; i++) {
if (parse_7zip_uint64(a, &(f[i].numUnpackStreams)) < 0)
return (-1);
if (UMAX_ENTRY < f[i].numUnpackStreams)
return (-1);
if (unpack_streams > SIZE_MAX - UMAX_ENTRY) {
return (-1);
}
unpack_streams += (size_t)f[i].numUnpackStreams;
}
if ((p = header_bytes(a, 1)) == NULL)
return (-1);
type = *p;
} else
unpack_streams = numFolders;
ss->unpack_streams = unpack_streams;
if (unpack_streams) {
ss->unpackSizes = calloc(unpack_streams,
sizeof(*ss->unpackSizes));
ss->digestsDefined = calloc(unpack_streams,
sizeof(*ss->digestsDefined));
ss->digests = calloc(unpack_streams,
sizeof(*ss->digests));
if (ss->unpackSizes == NULL || ss->digestsDefined == NULL ||
ss->digests == NULL)
return (-1);
}
usizes = ss->unpackSizes;
for (i = 0; i < numFolders; i++) {
unsigned pack;
uint64_t sum;
if (f[i].numUnpackStreams == 0)
continue;
sum = 0;
if (type == kSize) {
for (pack = 1; pack < f[i].numUnpackStreams; pack++) {
if (parse_7zip_uint64(a, usizes) < 0)
return (-1);
sum += *usizes++;
}
}
*usizes++ = folder_uncompressed_size(&f[i]) - sum;
}
if (type == kSize) {
if ((p = header_bytes(a, 1)) == NULL)
return (-1);
type = *p;
}
for (i = 0; i < unpack_streams; i++) {
ss->digestsDefined[i] = 0;
ss->digests[i] = 0;
}
numDigests = 0;
for (i = 0; i < numFolders; i++) {
if (f[i].numUnpackStreams != 1 || !f[i].digest_defined)
numDigests += (uint32_t)f[i].numUnpackStreams;
}
if (type == kCRC) {
struct _7z_digests tmpDigests;
unsigned char *digestsDefined = ss->digestsDefined;
uint32_t * digests = ss->digests;
int di = 0;
memset(&tmpDigests, 0, sizeof(tmpDigests));
if (read_Digests(a, &(tmpDigests), numDigests) < 0) {
free_Digest(&tmpDigests);
return (-1);
}
for (i = 0; i < numFolders; i++) {
if (f[i].numUnpackStreams == 1 && f[i].digest_defined) {
*digestsDefined++ = 1;
*digests++ = f[i].digest;
} else {
unsigned j;
for (j = 0; j < f[i].numUnpackStreams;
j++, di++) {
*digestsDefined++ =
tmpDigests.defineds[di];
*digests++ =
tmpDigests.digests[di];
}
}
}
free_Digest(&tmpDigests);
if ((p = header_bytes(a, 1)) == NULL)
return (-1);
type = *p;
}
/*
* Must be kEnd.
*/
if (type != kEnd)
return (-1);
return (0);
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x3b780
movl $0x0, -0x48(%rbp)
movl -0x48(%rbp), %eax
cmpq -0x28(%rbp), %rax
jae 0x98979c
movq -0x20(%rbp), %rax
movl -0x48(%rbp), %ecx
imulq $0x68, %rcx, %rcx
addq %rcx, %rax
movq $0x1, 0x50(%rax)
movl -0x48(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
jmp 0x989772
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x985000
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0x9897c0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x989c9e
movq -0x30(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x44(%rbp)
cmpl $0xd, -0x44(%rbp)
jne 0x9898af
movq $0x0, -0x40(%rbp)
movl $0x0, -0x48(%rbp)
movl -0x48(%rbp), %eax
cmpq -0x28(%rbp), %rax
jae 0x98987f
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x48(%rbp), %eax
imulq $0x68, %rax, %rax
addq %rax, %rsi
addq $0x50, %rsi
callq 0x989cb0
cmpl $0x0, %eax
jge 0x98981c
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x989c9e
movq -0x20(%rbp), %rcx
movl -0x48(%rbp), %eax
imulq $0x68, %rax, %rax
addq %rax, %rcx
movl $0x5f5e100, %eax # imm = 0x5F5E100
cmpq 0x50(%rcx), %rax
jae 0x989841
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x989c9e
cmpq $-0x5f5e101, -0x40(%rbp) # imm = 0xFA0A1EFF
jbe 0x989857
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x989c9e
movq -0x20(%rbp), %rax
movl -0x48(%rbp), %ecx
imulq $0x68, %rcx, %rcx
addq %rcx, %rax
movq 0x50(%rax), %rax
addq -0x40(%rbp), %rax
movq %rax, -0x40(%rbp)
movl -0x48(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
jmp 0x9897e3
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x985000
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0x9898a3
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x989c9e
movq -0x30(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x44(%rbp)
jmp 0x9898b7
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
cmpq $0x0, -0x40(%rbp)
je 0x989943
movq -0x40(%rbp), %rdi
movl $0x8, %esi
callq 0x3e570
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x40(%rbp), %rdi
movl $0x1, %esi
callq 0x3e570
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x40(%rbp), %rdi
movl $0x4, %esi
callq 0x3e570
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x989935
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x989935
movq -0x18(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x989941
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x989c9e
jmp 0x989943
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x48(%rbp)
movl -0x48(%rbp), %eax
cmpq -0x28(%rbp), %rax
jae 0x989a28
movq -0x20(%rbp), %rax
movl -0x48(%rbp), %ecx
imulq $0x68, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, 0x50(%rax)
jne 0x98997d
jmp 0x989a1a
movq $0x0, -0x58(%rbp)
cmpl $0x9, -0x44(%rbp)
jne 0x9899ee
movl $0x1, -0x50(%rbp)
movl -0x50(%rbp), %eax
movq -0x20(%rbp), %rcx
movl -0x48(%rbp), %edx
imulq $0x68, %rdx, %rdx
addq %rdx, %rcx
cmpq 0x50(%rcx), %rax
jae 0x9899ec
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x989cb0
cmpl $0x0, %eax
jge 0x9899c7
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x989c9e
movq -0x38(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x38(%rbp)
movq (%rax), %rax
addq -0x58(%rbp), %rax
movq %rax, -0x58(%rbp)
movl -0x50(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x50(%rbp)
jmp 0x989992
jmp 0x9899ee
movq -0x20(%rbp), %rdi
movl -0x48(%rbp), %eax
imulq $0x68, %rax, %rax
addq %rax, %rdi
callq 0x98a710
movq %rax, %rcx
subq -0x58(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, -0x38(%rbp)
movq %rcx, (%rax)
movl -0x48(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
jmp 0x989956
cmpl $0x9, -0x44(%rbp)
jne 0x989a5c
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x985000
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0x989a52
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x989c9e
movq -0x30(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x44(%rbp)
movl $0x0, -0x48(%rbp)
movl -0x48(%rbp), %eax
cmpq -0x40(%rbp), %rax
jae 0x989a98
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x48(%rbp), %ecx
movb $0x0, (%rax,%rcx)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movl -0x48(%rbp), %ecx
movl $0x0, (%rax,%rcx,4)
movl -0x48(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
jmp 0x989a63
movl $0x0, -0x4c(%rbp)
movl $0x0, -0x48(%rbp)
movl -0x48(%rbp), %eax
cmpq -0x28(%rbp), %rax
jae 0x989afd
movq -0x20(%rbp), %rax
movl -0x48(%rbp), %ecx
imulq $0x68, %rcx, %rcx
addq %rcx, %rax
cmpq $0x1, 0x50(%rax)
jne 0x989ad8
movq -0x20(%rbp), %rax
movl -0x48(%rbp), %ecx
imulq $0x68, %rcx, %rcx
addq %rcx, %rax
cmpb $0x0, 0x48(%rax)
jne 0x989af0
movq -0x20(%rbp), %rax
movl -0x48(%rbp), %ecx
imulq $0x68, %rcx, %rcx
addq %rcx, %rax
movq 0x50(%rax), %rax
addl -0x4c(%rbp), %eax
movl %eax, -0x4c(%rbp)
jmp 0x989af2
movl -0x48(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
jmp 0x989aa6
cmpl $0xa, -0x44(%rbp)
jne 0x989c88
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x70(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x78(%rbp)
movl $0x0, -0x7c(%rbp)
leaq -0x68(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x3b780
movq -0x10(%rbp), %rdi
movl -0x4c(%rbp), %eax
movl %eax, %edx
leaq -0x68(%rbp), %rsi
callq 0x989db0
cmpl $0x0, %eax
jge 0x989b62
leaq -0x68(%rbp), %rdi
callq 0x98a680
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x989c9e
movl $0x0, -0x48(%rbp)
movl -0x48(%rbp), %eax
cmpq -0x28(%rbp), %rax
jae 0x989c54
movq -0x20(%rbp), %rax
movl -0x48(%rbp), %ecx
imulq $0x68, %rcx, %rcx
addq %rcx, %rax
cmpq $0x1, 0x50(%rax)
jne 0x989bd8
movq -0x20(%rbp), %rax
movl -0x48(%rbp), %ecx
imulq $0x68, %rcx, %rcx
addq %rcx, %rax
movzbl 0x48(%rax), %eax
cmpl $0x0, %eax
je 0x989bd8
movq -0x70(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x70(%rbp)
movb $0x1, (%rax)
movq -0x20(%rbp), %rax
movl -0x48(%rbp), %ecx
imulq $0x68, %rcx, %rcx
addq %rcx, %rax
movl 0x4c(%rax), %ecx
movq -0x78(%rbp), %rax
movq %rax, %rdx
addq $0x4, %rdx
movq %rdx, -0x78(%rbp)
movl %ecx, (%rax)
jmp 0x989c44
movl $0x0, -0x80(%rbp)
movl -0x80(%rbp), %eax
movq -0x20(%rbp), %rcx
movl -0x48(%rbp), %edx
imulq $0x68, %rdx, %rdx
addq %rdx, %rcx
cmpq 0x50(%rcx), %rax
jae 0x989c42
movq -0x68(%rbp), %rax
movslq -0x7c(%rbp), %rcx
movb (%rax,%rcx), %cl
movq -0x70(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x70(%rbp)
movb %cl, (%rax)
movq -0x60(%rbp), %rax
movslq -0x7c(%rbp), %rcx
movl (%rax,%rcx,4), %ecx
movq -0x78(%rbp), %rax
movq %rax, %rdx
addq $0x4, %rdx
movq %rdx, -0x78(%rbp)
movl %ecx, (%rax)
movl -0x80(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x80(%rbp)
movl -0x7c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x7c(%rbp)
jmp 0x989bdf
jmp 0x989c44
jmp 0x989c46
movl -0x48(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
jmp 0x989b69
leaq -0x68(%rbp), %rdi
callq 0x98a680
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x985000
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0x989c7e
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x989c9e
movq -0x30(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x44(%rbp)
cmpl $0x0, -0x44(%rbp)
je 0x989c97
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x989c9e
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
nopw (%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_7zip.c
|
BZ2_bzCompress
|
int BZ_API(BZ2_bzCompress) ( bz_stream *strm, int action )
{
Bool progress;
EState* s;
if (strm == NULL) return BZ_PARAM_ERROR;
s = strm->state;
if (s == NULL) return BZ_PARAM_ERROR;
if (s->strm != strm) return BZ_PARAM_ERROR;
preswitch:
switch (s->mode) {
case BZ_M_IDLE:
return BZ_SEQUENCE_ERROR;
case BZ_M_RUNNING:
if (action == BZ_RUN) {
progress = handle_compress ( strm );
return progress ? BZ_RUN_OK : BZ_PARAM_ERROR;
}
else
if (action == BZ_FLUSH) {
s->avail_in_expect = strm->avail_in;
s->mode = BZ_M_FLUSHING;
goto preswitch;
}
else
if (action == BZ_FINISH) {
s->avail_in_expect = strm->avail_in;
s->mode = BZ_M_FINISHING;
goto preswitch;
}
else
return BZ_PARAM_ERROR;
case BZ_M_FLUSHING:
if (action != BZ_FLUSH) return BZ_SEQUENCE_ERROR;
if (s->avail_in_expect != s->strm->avail_in)
return BZ_SEQUENCE_ERROR;
progress = handle_compress ( strm );
if (s->avail_in_expect > 0 || !isempty_RL(s) ||
s->state_out_pos < s->numZ) return BZ_FLUSH_OK;
s->mode = BZ_M_RUNNING;
return BZ_RUN_OK;
case BZ_M_FINISHING:
if (action != BZ_FINISH) return BZ_SEQUENCE_ERROR;
if (s->avail_in_expect != s->strm->avail_in)
return BZ_SEQUENCE_ERROR;
progress = handle_compress ( strm );
if (!progress) return BZ_SEQUENCE_ERROR;
if (s->avail_in_expect > 0 || !isempty_RL(s) ||
s->state_out_pos < s->numZ) return BZ_FINISH_OK;
s->mode = BZ_M_IDLE;
return BZ_STREAM_END;
}
return BZ_OK; /*--not reached--*/
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x991562
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x991771
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x991581
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x991771
movq -0x20(%rbp), %rax
movq (%rax), %rax
cmpq -0x10(%rbp), %rax
je 0x99159a
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x991771
jmp 0x99159c
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x28(%rbp)
subl $0x3, %eax
ja 0x99176a
movq -0x28(%rbp), %rax
leaq 0x2391f9(%rip), %rcx # 0xbca7b8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x991771
cmpl $0x0, -0x14(%rbp)
jne 0x991602
movq -0x10(%rbp), %rdi
callq 0x991780
movb %al, -0x15(%rbp)
movzbl -0x15(%rbp), %edx
movl $0xfffffffe, %eax # imm = 0xFFFFFFFE
movl $0x1, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x991771
cmpl $0x1, -0x14(%rbp)
jne 0x991626
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x20(%rbp), %rax
movl $0x3, 0x8(%rax)
jmp 0x99159c
cmpl $0x2, -0x14(%rbp)
jne 0x99164a
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x20(%rbp), %rax
movl $0x4, 0x8(%rax)
jmp 0x99159c
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x991771
cmpl $0x1, -0x14(%rbp)
je 0x991668
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x991771
movq -0x20(%rbp), %rax
movl 0x10(%rax), %eax
movq -0x20(%rbp), %rcx
movq (%rcx), %rcx
cmpl 0x8(%rcx), %eax
je 0x991687
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x991771
movq -0x10(%rbp), %rdi
callq 0x991780
movb %al, -0x15(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, 0x10(%rax)
ja 0x9916ba
movq -0x20(%rbp), %rdi
callq 0x991920
cmpb $0x0, %al
je 0x9916ba
movq -0x20(%rbp), %rax
movl 0x78(%rax), %eax
movq -0x20(%rbp), %rcx
cmpl 0x74(%rcx), %eax
jge 0x9916c6
movl $0x2, -0x4(%rbp)
jmp 0x991771
movq -0x20(%rbp), %rax
movl $0x2, 0x8(%rax)
movl $0x1, -0x4(%rbp)
jmp 0x991771
cmpl $0x2, -0x14(%rbp)
je 0x9916ef
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x991771
movq -0x20(%rbp), %rax
movl 0x10(%rax), %eax
movq -0x20(%rbp), %rcx
movq (%rcx), %rcx
cmpl 0x8(%rcx), %eax
je 0x99170b
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x991771
movq -0x10(%rbp), %rdi
callq 0x991780
movb %al, -0x15(%rbp)
cmpb $0x0, -0x15(%rbp)
jne 0x991726
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x991771
movq -0x20(%rbp), %rax
cmpl $0x0, 0x10(%rax)
ja 0x99174d
movq -0x20(%rbp), %rdi
callq 0x991920
cmpb $0x0, %al
je 0x99174d
movq -0x20(%rbp), %rax
movl 0x78(%rax), %eax
movq -0x20(%rbp), %rcx
cmpl 0x74(%rcx), %eax
jge 0x991756
movl $0x3, -0x4(%rbp)
jmp 0x991771
movq -0x20(%rbp), %rax
movl $0x1, 0x8(%rax)
movl $0x4, -0x4(%rbp)
jmp 0x991771
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmbzip2/bzlib.c
|
BZ2_bzReadOpen
|
BZFILE* BZ_API(BZ2_bzReadOpen)
( int* bzerror,
FILE* f,
int verbosity,
int small,
void* unused,
int nUnused )
{
bzFile* bzf = NULL;
int ret;
BZ_SETERR(BZ_OK);
if (f == NULL ||
(small != 0 && small != 1) ||
(verbosity < 0 || verbosity > 4) ||
(unused == NULL && nUnused != 0) ||
(unused != NULL && (nUnused < 0 || nUnused > BZ_MAX_UNUSED)))
{ BZ_SETERR(BZ_PARAM_ERROR); return NULL; };
if (ferror(f))
{ BZ_SETERR(BZ_IO_ERROR); return NULL; };
bzf = malloc ( sizeof(bzFile) );
if (bzf == NULL)
{ BZ_SETERR(BZ_MEM_ERROR); return NULL; };
BZ_SETERR(BZ_OK);
bzf->initialisedOk = False;
bzf->handle = f;
bzf->bufN = 0;
bzf->writing = False;
bzf->strm.bzalloc = NULL;
bzf->strm.bzfree = NULL;
bzf->strm.opaque = NULL;
while (nUnused > 0) {
bzf->buf[bzf->bufN] = *((UChar*)(unused)); bzf->bufN++;
unused = ((void*)( 1 + ((UChar*)(unused)) ));
nUnused--;
}
ret = BZ2_bzDecompressInit ( &(bzf->strm), verbosity, small );
if (ret != BZ_OK)
{ BZ_SETERR(ret); free(bzf); return NULL; };
bzf->strm.avail_in = bzf->bufN;
bzf->strm.next_in = bzf->buf;
bzf->initialisedOk = True;
return bzf;
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movq $0x0, -0x38(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x993fe7
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
cmpq $0x0, -0x38(%rbp)
je 0x993ffc
movq -0x38(%rbp), %rax
movl $0x0, 0x13e8(%rax)
cmpq $0x0, -0x18(%rbp)
je 0x99403e
cmpl $0x0, -0x20(%rbp)
je 0x99400f
cmpl $0x1, -0x20(%rbp)
jne 0x99403e
cmpl $0x0, -0x1c(%rbp)
jl 0x99403e
cmpl $0x4, -0x1c(%rbp)
jg 0x99403e
cmpq $0x0, -0x28(%rbp)
jne 0x994028
cmpl $0x0, -0x2c(%rbp)
jne 0x99403e
cmpq $0x0, -0x28(%rbp)
je 0x994071
cmpl $0x0, -0x2c(%rbp)
jl 0x99403e
cmpl $0x1388, -0x2c(%rbp) # imm = 0x1388
jle 0x994071
cmpq $0x0, -0x10(%rbp)
je 0x99404f
movq -0x10(%rbp), %rax
movl $0xfffffffe, (%rax) # imm = 0xFFFFFFFE
cmpq $0x0, -0x38(%rbp)
je 0x994064
movq -0x38(%rbp), %rax
movl $0xfffffffe, 0x13e8(%rax) # imm = 0xFFFFFFFE
movq $0x0, -0x8(%rbp)
jmp 0x994255
movq -0x18(%rbp), %rdi
callq 0x3daa0
cmpl $0x0, %eax
je 0x9940b2
cmpq $0x0, -0x10(%rbp)
je 0x994090
movq -0x10(%rbp), %rax
movl $0xfffffffa, (%rax) # imm = 0xFFFFFFFA
cmpq $0x0, -0x38(%rbp)
je 0x9940a5
movq -0x38(%rbp), %rax
movl $0xfffffffa, 0x13e8(%rax) # imm = 0xFFFFFFFA
movq $0x0, -0x8(%rbp)
jmp 0x994255
movl $0x13f0, %edi # imm = 0x13F0
callq 0x3e578
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x9940fa
cmpq $0x0, -0x10(%rbp)
je 0x9940d8
movq -0x10(%rbp), %rax
movl $0xfffffffd, (%rax) # imm = 0xFFFFFFFD
cmpq $0x0, -0x38(%rbp)
je 0x9940ed
movq -0x38(%rbp), %rax
movl $0xfffffffd, 0x13e8(%rax) # imm = 0xFFFFFFFD
movq $0x0, -0x8(%rbp)
jmp 0x994255
cmpq $0x0, -0x10(%rbp)
je 0x99410b
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
cmpq $0x0, -0x38(%rbp)
je 0x994120
movq -0x38(%rbp), %rax
movl $0x0, 0x13e8(%rax)
movq -0x38(%rbp), %rax
movb $0x0, 0x13ec(%rax)
movq -0x18(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rax
movl $0x0, 0x1390(%rax)
movq -0x38(%rbp), %rax
movb $0x0, 0x1394(%rax)
movq -0x38(%rbp), %rax
movq $0x0, 0x13d0(%rax)
movq -0x38(%rbp), %rax
movq $0x0, 0x13d8(%rax)
movq -0x38(%rbp), %rax
movq $0x0, 0x13e0(%rax)
cmpl $0x0, -0x2c(%rbp)
jle 0x9941c5
movq -0x28(%rbp), %rax
movb (%rax), %dl
movq -0x38(%rbp), %rax
movq -0x38(%rbp), %rcx
movslq 0x1390(%rcx), %rcx
movb %dl, 0x8(%rax,%rcx)
movq -0x38(%rbp), %rax
movl 0x1390(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x1390(%rax)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movl -0x2c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x99417c
movq -0x38(%rbp), %rdi
addq $0x1398, %rdi # imm = 0x1398
movl -0x1c(%rbp), %esi
movl -0x20(%rbp), %edx
callq 0x991a50
movl %eax, -0x3c(%rbp)
cmpl $0x0, -0x3c(%rbp)
je 0x99421b
cmpq $0x0, -0x10(%rbp)
je 0x9941f4
movl -0x3c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
cmpq $0x0, -0x38(%rbp)
je 0x994208
movl -0x3c(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x13e8(%rax)
movq -0x38(%rbp), %rdi
callq 0x3e548
movq $0x0, -0x8(%rbp)
jmp 0x994255
movq -0x38(%rbp), %rax
movl 0x1390(%rax), %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x13a0(%rax)
movq -0x38(%rbp), %rcx
addq $0x8, %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x1398(%rax)
movq -0x38(%rbp), %rax
movb $0x1, 0x13ec(%rax)
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
|
/JKorbelRA[P]CMake/Utilities/cmbzip2/bzlib.c
|
copy_output_until_stop
|
static
Bool copy_output_until_stop ( EState* s )
{
Bool progress_out = False;
while (True) {
/*-- no output space? --*/
if (s->strm->avail_out == 0) break;
/*-- block done? --*/
if (s->state_out_pos >= s->numZ) break;
progress_out = True;
*(s->strm->next_out) = s->zbits[s->state_out_pos];
s->state_out_pos++;
s->strm->avail_out--;
s->strm->next_out++;
s->strm->total_out_lo32++;
if (s->strm->total_out_lo32 == 0) s->strm->total_out_hi32++;
}
return progress_out;
}
|
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movb $0x0, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpl $0x0, 0x20(%rax)
jne 0x994fde
jmp 0x995079
movq -0x8(%rbp), %rax
movl 0x78(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x74(%rcx), %eax
jl 0x994ff3
jmp 0x995079
movb $0x1, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x78(%rcx), %rcx
movb (%rax,%rcx), %cl
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movb %cl, (%rax)
movq -0x8(%rbp), %rax
movl 0x78(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x78(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x20(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x20(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x24(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x24(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpl $0x0, 0x24(%rax)
jne 0x995074
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x28(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x28(%rax)
jmp 0x994fcc
movb -0x9(%rbp), %al
popq %rbp
retq
nop
|
/JKorbelRA[P]CMake/Utilities/cmbzip2/bzlib.c
|
add_pair_to_block
|
static
void add_pair_to_block ( EState* s )
{
Int32 i;
UChar ch = (UChar)(s->state_in_ch);
for (i = 0; i < s->state_in_len; i++) {
BZ_UPDATE_CRC( s->blockCRC, ch );
}
s->inUse[s->state_in_ch] = True;
switch (s->state_in_len) {
case 1:
s->block[s->nblock] = (UChar)ch; s->nblock++;
break;
case 2:
s->block[s->nblock] = (UChar)ch; s->nblock++;
s->block[s->nblock] = (UChar)ch; s->nblock++;
break;
case 3:
s->block[s->nblock] = (UChar)ch; s->nblock++;
s->block[s->nblock] = (UChar)ch; s->nblock++;
s->block[s->nblock] = (UChar)ch; s->nblock++;
break;
default:
s->inUse[s->state_in_len-4] = True;
s->block[s->nblock] = (UChar)ch; s->nblock++;
s->block[s->nblock] = (UChar)ch; s->nblock++;
s->block[s->nblock] = (UChar)ch; s->nblock++;
s->block[s->nblock] = (UChar)ch; s->nblock++;
s->block[s->nblock] = ((UChar)(s->state_in_len-4));
s->nblock++;
break;
}
}
|
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x5c(%rax), %eax
movb %al, -0xd(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x60(%rcx), %eax
jge 0x995488
movq -0x8(%rbp), %rax
movl 0x288(%rax), %ecx
shll $0x8, %ecx
movq -0x8(%rbp), %rax
movl 0x288(%rax), %eax
shrl $0x18, %eax
movzbl -0xd(%rbp), %edx
xorl %edx, %eax
movl %eax, %eax
movl %eax, %edx
leaq 0x5674a0(%rip), %rax # 0xefc910
xorl (%rax,%rdx,4), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x288(%rax)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x995439
movq -0x8(%rbp), %rax
movl 0x5c(%rax), %ecx
movb $0x1, 0x80(%rax,%rcx)
movq -0x8(%rbp), %rax
movl 0x60(%rax), %eax
movl %eax, -0x14(%rbp)
subl $0x1, %eax
je 0x9954bf
jmp 0x9954a8
movl -0x14(%rbp), %eax
subl $0x2, %eax
je 0x9954e7
jmp 0x9954b2
movl -0x14(%rbp), %eax
subl $0x3, %eax
je 0x995532
jmp 0x9955a0
movb -0xd(%rbp), %dl
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x6c(%rcx), %rcx
movb %dl, (%rax,%rcx)
movq -0x8(%rbp), %rax
movl 0x6c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x6c(%rax)
jmp 0x995671
movb -0xd(%rbp), %dl
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x6c(%rcx), %rcx
movb %dl, (%rax,%rcx)
movq -0x8(%rbp), %rax
movl 0x6c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x6c(%rax)
movb -0xd(%rbp), %dl
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x6c(%rcx), %rcx
movb %dl, (%rax,%rcx)
movq -0x8(%rbp), %rax
movl 0x6c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x6c(%rax)
jmp 0x995671
movb -0xd(%rbp), %dl
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x6c(%rcx), %rcx
movb %dl, (%rax,%rcx)
movq -0x8(%rbp), %rax
movl 0x6c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x6c(%rax)
movb -0xd(%rbp), %dl
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x6c(%rcx), %rcx
movb %dl, (%rax,%rcx)
movq -0x8(%rbp), %rax
movl 0x6c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x6c(%rax)
movb -0xd(%rbp), %dl
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x6c(%rcx), %rcx
movb %dl, (%rax,%rcx)
movq -0x8(%rbp), %rax
movl 0x6c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x6c(%rax)
jmp 0x995671
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
movl 0x60(%rcx), %ecx
subl $0x4, %ecx
movslq %ecx, %rcx
movb $0x1, 0x80(%rax,%rcx)
movb -0xd(%rbp), %dl
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x6c(%rcx), %rcx
movb %dl, (%rax,%rcx)
movq -0x8(%rbp), %rax
movl 0x6c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x6c(%rax)
movb -0xd(%rbp), %dl
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x6c(%rcx), %rcx
movb %dl, (%rax,%rcx)
movq -0x8(%rbp), %rax
movl 0x6c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x6c(%rax)
movb -0xd(%rbp), %dl
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x6c(%rcx), %rcx
movb %dl, (%rax,%rcx)
movq -0x8(%rbp), %rax
movl 0x6c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x6c(%rax)
movb -0xd(%rbp), %dl
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x6c(%rcx), %rcx
movb %dl, (%rax,%rcx)
movq -0x8(%rbp), %rax
movl 0x6c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x6c(%rax)
movq -0x8(%rbp), %rax
movl 0x60(%rax), %eax
subl $0x4, %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x6c(%rcx), %rcx
movb %dl, (%rax,%rcx)
movq -0x8(%rbp), %rax
movl 0x6c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x6c(%rax)
popq %rbp
retq
nop
nopw %cs:(%rax,%rax)
nop
|
/JKorbelRA[P]CMake/Utilities/cmbzip2/bzlib.c
|
sendMTFValues
|
static
void sendMTFValues ( EState* s )
{
Int32 v, t, i, j, gs, ge, totc, bt, bc, iter;
Int32 nSelectors, alphaSize, minLen, maxLen, selCtr;
Int32 nGroups, nBytes;
/*--
UChar len [BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE];
is a global since the decoder also needs it.
Int32 code[BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE];
Int32 rfreq[BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE];
are also globals only used in this proc.
Made global to keep stack frame size small.
--*/
UInt16 cost[BZ_N_GROUPS];
Int32 fave[BZ_N_GROUPS];
UInt16* mtfv = s->mtfv;
if (s->verbosity >= 3)
VPrintf3( " %d in block, %d after MTF & 1-2 coding, "
"%d+2 syms in use\n",
s->nblock, s->nMTF, s->nInUse );
alphaSize = s->nInUse+2;
for (t = 0; t < BZ_N_GROUPS; t++)
for (v = 0; v < alphaSize; v++)
s->len[t][v] = BZ_GREATER_ICOST;
/*--- Decide how many coding tables to use ---*/
AssertH ( s->nMTF > 0, 3001 );
if (s->nMTF < 200) nGroups = 2; else
if (s->nMTF < 600) nGroups = 3; else
if (s->nMTF < 1200) nGroups = 4; else
if (s->nMTF < 2400) nGroups = 5; else
nGroups = 6;
/*--- Generate an initial set of coding tables ---*/
{
Int32 nPart, remF, tFreq, aFreq;
nPart = nGroups;
remF = s->nMTF;
gs = 0;
while (nPart > 0) {
tFreq = remF / nPart;
ge = gs-1;
aFreq = 0;
while (aFreq < tFreq && ge < alphaSize-1) {
ge++;
aFreq += s->mtfFreq[ge];
}
if (ge > gs
&& nPart != nGroups && nPart != 1
&& ((nGroups-nPart) % 2 == 1)) {
aFreq -= s->mtfFreq[ge];
ge--;
}
if (s->verbosity >= 3)
VPrintf5( " initial group %d, [%d .. %d], "
"has %d syms (%4.1f%%)\n",
nPart, gs, ge, aFreq,
(100.0 * (float)aFreq) / (float)(s->nMTF) );
for (v = 0; v < alphaSize; v++)
if (v >= gs && v <= ge)
s->len[nPart-1][v] = BZ_LESSER_ICOST; else
s->len[nPart-1][v] = BZ_GREATER_ICOST;
nPart--;
gs = ge+1;
remF -= aFreq;
}
}
/*---
Iterate up to BZ_N_ITERS times to improve the tables.
---*/
for (iter = 0; iter < BZ_N_ITERS; iter++) {
for (t = 0; t < nGroups; t++) fave[t] = 0;
for (t = 0; t < nGroups; t++)
for (v = 0; v < alphaSize; v++)
s->rfreq[t][v] = 0;
/*---
Set up an auxiliary length table which is used to fast-track
the common case (nGroups == 6).
---*/
if (nGroups == 6) {
for (v = 0; v < alphaSize; v++) {
s->len_pack[v][0] = (s->len[1][v] << 16) | s->len[0][v];
s->len_pack[v][1] = (s->len[3][v] << 16) | s->len[2][v];
s->len_pack[v][2] = (s->len[5][v] << 16) | s->len[4][v];
}
}
nSelectors = 0;
totc = 0;
gs = 0;
while (True) {
/*--- Set group start & end marks. --*/
if (gs >= s->nMTF) break;
ge = gs + BZ_G_SIZE - 1;
if (ge >= s->nMTF) ge = s->nMTF-1;
/*--
Calculate the cost of this group as coded
by each of the coding tables.
--*/
for (t = 0; t < nGroups; t++) cost[t] = 0;
if (nGroups == 6 && 50 == ge-gs+1) {
/*--- fast track the common case ---*/
register UInt32 cost01, cost23, cost45;
register UInt16 icv;
cost01 = cost23 = cost45 = 0;
# define BZ_ITER(nn) \
icv = mtfv[gs+(nn)]; \
cost01 += s->len_pack[icv][0]; \
cost23 += s->len_pack[icv][1]; \
cost45 += s->len_pack[icv][2]; \
BZ_ITER(0); BZ_ITER(1); BZ_ITER(2); BZ_ITER(3); BZ_ITER(4);
BZ_ITER(5); BZ_ITER(6); BZ_ITER(7); BZ_ITER(8); BZ_ITER(9);
BZ_ITER(10); BZ_ITER(11); BZ_ITER(12); BZ_ITER(13); BZ_ITER(14);
BZ_ITER(15); BZ_ITER(16); BZ_ITER(17); BZ_ITER(18); BZ_ITER(19);
BZ_ITER(20); BZ_ITER(21); BZ_ITER(22); BZ_ITER(23); BZ_ITER(24);
BZ_ITER(25); BZ_ITER(26); BZ_ITER(27); BZ_ITER(28); BZ_ITER(29);
BZ_ITER(30); BZ_ITER(31); BZ_ITER(32); BZ_ITER(33); BZ_ITER(34);
BZ_ITER(35); BZ_ITER(36); BZ_ITER(37); BZ_ITER(38); BZ_ITER(39);
BZ_ITER(40); BZ_ITER(41); BZ_ITER(42); BZ_ITER(43); BZ_ITER(44);
BZ_ITER(45); BZ_ITER(46); BZ_ITER(47); BZ_ITER(48); BZ_ITER(49);
# undef BZ_ITER
cost[0] = cost01 & 0xffff; cost[1] = cost01 >> 16;
cost[2] = cost23 & 0xffff; cost[3] = cost23 >> 16;
cost[4] = cost45 & 0xffff; cost[5] = cost45 >> 16;
} else {
/*--- slow version which correctly handles all situations ---*/
for (i = gs; i <= ge; i++) {
UInt16 icv = mtfv[i];
for (t = 0; t < nGroups; t++) cost[t] += s->len[t][icv];
}
}
/*--
Find the coding table which is best for this group,
and record its identity in the selector table.
--*/
bc = 999999999; bt = -1;
for (t = 0; t < nGroups; t++)
if (cost[t] < bc) { bc = cost[t]; bt = t; };
totc += bc;
fave[bt]++;
s->selector[nSelectors] = bt;
nSelectors++;
/*--
Increment the symbol frequencies for the selected table.
--*/
if (nGroups == 6 && 50 == ge-gs+1) {
/*--- fast track the common case ---*/
# define BZ_ITUR(nn) s->rfreq[bt][ mtfv[gs+(nn)] ]++
BZ_ITUR(0); BZ_ITUR(1); BZ_ITUR(2); BZ_ITUR(3); BZ_ITUR(4);
BZ_ITUR(5); BZ_ITUR(6); BZ_ITUR(7); BZ_ITUR(8); BZ_ITUR(9);
BZ_ITUR(10); BZ_ITUR(11); BZ_ITUR(12); BZ_ITUR(13); BZ_ITUR(14);
BZ_ITUR(15); BZ_ITUR(16); BZ_ITUR(17); BZ_ITUR(18); BZ_ITUR(19);
BZ_ITUR(20); BZ_ITUR(21); BZ_ITUR(22); BZ_ITUR(23); BZ_ITUR(24);
BZ_ITUR(25); BZ_ITUR(26); BZ_ITUR(27); BZ_ITUR(28); BZ_ITUR(29);
BZ_ITUR(30); BZ_ITUR(31); BZ_ITUR(32); BZ_ITUR(33); BZ_ITUR(34);
BZ_ITUR(35); BZ_ITUR(36); BZ_ITUR(37); BZ_ITUR(38); BZ_ITUR(39);
BZ_ITUR(40); BZ_ITUR(41); BZ_ITUR(42); BZ_ITUR(43); BZ_ITUR(44);
BZ_ITUR(45); BZ_ITUR(46); BZ_ITUR(47); BZ_ITUR(48); BZ_ITUR(49);
# undef BZ_ITUR
} else {
/*--- slow version which correctly handles all situations ---*/
for (i = gs; i <= ge; i++)
s->rfreq[bt][ mtfv[i] ]++;
}
gs = ge+1;
}
if (s->verbosity >= 3) {
VPrintf2 ( " pass %d: size is %d, grp uses are ",
iter+1, totc/8 );
for (t = 0; t < nGroups; t++)
VPrintf1 ( "%d ", fave[t] );
VPrintf0 ( "\n" );
}
/*--
Recompute the tables based on the accumulated frequencies.
--*/
/* maxLen was changed from 20 to 17 in bzip2-1.0.3. See
comment in huffman.c for details. */
for (t = 0; t < nGroups; t++)
BZ2_hbMakeCodeLengths ( &(s->len[t][0]), &(s->rfreq[t][0]),
alphaSize, 17 /*20*/ );
}
AssertH( nGroups < 8, 3002 );
AssertH( nSelectors < 32768 &&
nSelectors <= BZ_MAX_SELECTORS,
3003 );
/*--- Compute MTF values for the selectors. ---*/
{
UChar pos[BZ_N_GROUPS], ll_i, tmp2, tmp;
for (i = 0; i < nGroups; i++) pos[i] = i;
for (i = 0; i < nSelectors; i++) {
ll_i = s->selector[i];
j = 0;
tmp = pos[j];
while ( ll_i != tmp ) {
j++;
tmp2 = tmp;
tmp = pos[j];
pos[j] = tmp2;
};
pos[0] = tmp;
s->selectorMtf[i] = j;
}
};
/*--- Assign actual codes for the tables. --*/
for (t = 0; t < nGroups; t++) {
minLen = 32;
maxLen = 0;
for (i = 0; i < alphaSize; i++) {
if (s->len[t][i] > maxLen) maxLen = s->len[t][i];
if (s->len[t][i] < minLen) minLen = s->len[t][i];
}
AssertH ( !(maxLen > 17 /*20*/ ), 3004 );
AssertH ( !(minLen < 1), 3005 );
BZ2_hbAssignCodes ( &(s->code[t][0]), &(s->len[t][0]),
minLen, maxLen, alphaSize );
}
/*--- Transmit the mapping table. ---*/
{
Bool inUse16[16];
for (i = 0; i < 16; i++) {
inUse16[i] = False;
for (j = 0; j < 16; j++)
if (s->inUse[i * 16 + j]) inUse16[i] = True;
}
nBytes = s->numZ;
for (i = 0; i < 16; i++)
if (inUse16[i]) bsW(s,1,1); else bsW(s,1,0);
for (i = 0; i < 16; i++)
if (inUse16[i])
for (j = 0; j < 16; j++) {
if (s->inUse[i * 16 + j]) bsW(s,1,1); else bsW(s,1,0);
}
if (s->verbosity >= 3)
VPrintf1( " bytes: mapping %d, ", s->numZ-nBytes );
}
/*--- Now the selectors. ---*/
nBytes = s->numZ;
bsW ( s, 3, nGroups );
bsW ( s, 15, nSelectors );
for (i = 0; i < nSelectors; i++) {
for (j = 0; j < s->selectorMtf[i]; j++) bsW(s,1,1);
bsW(s,1,0);
}
if (s->verbosity >= 3)
VPrintf1( "selectors %d, ", s->numZ-nBytes );
/*--- Now the coding tables. ---*/
nBytes = s->numZ;
for (t = 0; t < nGroups; t++) {
Int32 curr = s->len[t][0];
bsW ( s, 5, curr );
for (i = 0; i < alphaSize; i++) {
while (curr < s->len[t][i]) { bsW(s,2,2); curr++; /* 10 */ };
while (curr > s->len[t][i]) { bsW(s,2,3); curr--; /* 11 */ };
bsW ( s, 1, 0 );
}
}
if (s->verbosity >= 3)
VPrintf1 ( "code lengths %d, ", s->numZ-nBytes );
/*--- And finally, the block data proper ---*/
nBytes = s->numZ;
selCtr = 0;
gs = 0;
while (True) {
if (gs >= s->nMTF) break;
ge = gs + BZ_G_SIZE - 1;
if (ge >= s->nMTF) ge = s->nMTF-1;
AssertH ( s->selector[selCtr] < nGroups, 3006 );
if (nGroups == 6 && 50 == ge-gs+1) {
/*--- fast track the common case ---*/
UInt16 mtfv_i;
UChar* s_len_sel_selCtr
= &(s->len[s->selector[selCtr]][0]);
Int32* s_code_sel_selCtr
= &(s->code[s->selector[selCtr]][0]);
# define BZ_ITAH(nn) \
mtfv_i = mtfv[gs+(nn)]; \
bsW ( s, \
s_len_sel_selCtr[mtfv_i], \
s_code_sel_selCtr[mtfv_i] )
BZ_ITAH(0); BZ_ITAH(1); BZ_ITAH(2); BZ_ITAH(3); BZ_ITAH(4);
BZ_ITAH(5); BZ_ITAH(6); BZ_ITAH(7); BZ_ITAH(8); BZ_ITAH(9);
BZ_ITAH(10); BZ_ITAH(11); BZ_ITAH(12); BZ_ITAH(13); BZ_ITAH(14);
BZ_ITAH(15); BZ_ITAH(16); BZ_ITAH(17); BZ_ITAH(18); BZ_ITAH(19);
BZ_ITAH(20); BZ_ITAH(21); BZ_ITAH(22); BZ_ITAH(23); BZ_ITAH(24);
BZ_ITAH(25); BZ_ITAH(26); BZ_ITAH(27); BZ_ITAH(28); BZ_ITAH(29);
BZ_ITAH(30); BZ_ITAH(31); BZ_ITAH(32); BZ_ITAH(33); BZ_ITAH(34);
BZ_ITAH(35); BZ_ITAH(36); BZ_ITAH(37); BZ_ITAH(38); BZ_ITAH(39);
BZ_ITAH(40); BZ_ITAH(41); BZ_ITAH(42); BZ_ITAH(43); BZ_ITAH(44);
BZ_ITAH(45); BZ_ITAH(46); BZ_ITAH(47); BZ_ITAH(48); BZ_ITAH(49);
# undef BZ_ITAH
} else {
/*--- slow version which correctly handles all situations ---*/
for (i = gs; i <= ge; i++) {
bsW ( s,
s->len [s->selector[selCtr]] [mtfv[i]],
s->code [s->selector[selCtr]] [mtfv[i]] );
}
}
gs = ge+1;
selCtr++;
}
AssertH( selCtr == nSelectors, 3007 );
if (s->verbosity >= 3)
VPrintf1( "codes %d\n", s->numZ-nBytes );
}
|
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x78(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x3, 0x290(%rax)
jl 0x995fc9
movq 0x563f21(%rip), %rax # 0xef9ec0
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x6c(%rax), %edx
movq -0x8(%rbp), %rax
movl 0x29c(%rax), %ecx
movq -0x8(%rbp), %rax
movl 0x7c(%rax), %r8d
leaq 0x234ef5(%rip), %rsi # 0xbcaeb7
movb $0x0, %al
callq 0x3cd70
movq -0x8(%rbp), %rax
movl 0x7c(%rax), %eax
addl $0x2, %eax
movl %eax, -0x38(%rbp)
movl $0x0, -0x10(%rbp)
cmpl $0x6, -0x10(%rbp)
jge 0x99602a
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x38(%rbp), %eax
jge 0x99601d
movq -0x8(%rbp), %rax
addq $0x934c, %rax # imm = 0x934C
movslq -0x10(%rbp), %rcx
imulq $0x102, %rcx, %rcx # imm = 0x102
addq %rcx, %rax
movslq -0xc(%rbp), %rcx
movb $0xf, (%rax,%rcx)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x995fea
jmp 0x99601f
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x995fdd
movq -0x8(%rbp), %rax
cmpl $0x0, 0x29c(%rax)
jg 0x996041
movl $0xbb9, %edi # imm = 0xBB9
callq 0x991060
movq -0x8(%rbp), %rax
cmpl $0xc8, 0x29c(%rax)
jge 0x99605a
movl $0x2, -0x48(%rbp)
jmp 0x9960b2
movq -0x8(%rbp), %rax
cmpl $0x258, 0x29c(%rax) # imm = 0x258
jge 0x996073
movl $0x3, -0x48(%rbp)
jmp 0x9960b0
movq -0x8(%rbp), %rax
cmpl $0x4b0, 0x29c(%rax) # imm = 0x4B0
jge 0x99608c
movl $0x4, -0x48(%rbp)
jmp 0x9960ae
movq -0x8(%rbp), %rax
cmpl $0x960, 0x29c(%rax) # imm = 0x960
jge 0x9960a5
movl $0x5, -0x48(%rbp)
jmp 0x9960ac
movl $0x6, -0x48(%rbp)
jmp 0x9960ae
jmp 0x9960b0
jmp 0x9960b2
movl -0x48(%rbp), %eax
movl %eax, -0x7c(%rbp)
movq -0x8(%rbp), %rax
movl 0x29c(%rax), %eax
movl %eax, -0x80(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x0, -0x7c(%rbp)
jle 0x9962a0
movl -0x80(%rbp), %eax
cltd
idivl -0x7c(%rbp)
movl %eax, -0x84(%rbp)
movl -0x1c(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x20(%rbp)
movl $0x0, -0x88(%rbp)
movl -0x88(%rbp), %ecx
xorl %eax, %eax
cmpl -0x84(%rbp), %ecx
movb %al, -0xd9(%rbp)
jge 0x996120
movl -0x20(%rbp), %eax
movl -0x38(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
setl %al
movb %al, -0xd9(%rbp)
movb -0xd9(%rbp), %al
testb $0x1, %al
jne 0x99612c
jmp 0x996152
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
movl 0x2a0(%rax,%rcx,4), %eax
addl -0x88(%rbp), %eax
movl %eax, -0x88(%rbp)
jmp 0x9960f6
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jle 0x9961a1
movl -0x7c(%rbp), %eax
cmpl -0x48(%rbp), %eax
je 0x9961a1
cmpl $0x1, -0x7c(%rbp)
je 0x9961a1
movl -0x48(%rbp), %eax
subl -0x7c(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
cmpl $0x1, %edx
jne 0x9961a1
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
movl 0x2a0(%rax,%rcx,4), %ecx
movl -0x88(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x88(%rbp)
movl -0x20(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x3, 0x290(%rax)
jl 0x996203
movq 0x563d0b(%rip), %rax # 0xef9ec0
movq (%rax), %rdi
movl -0x7c(%rbp), %edx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x88(%rbp), %r9d
cvtsi2ssl -0x88(%rbp), %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0x1d5f13(%rip), %xmm0 # 0xb6c0f0
mulsd %xmm1, %xmm0
movq -0x8(%rbp), %rax
cvtsi2ssl 0x29c(%rax), %xmm1
cvtss2sd %xmm1, %xmm1
divsd %xmm1, %xmm0
leaq 0x234cfb(%rip), %rsi # 0xbcaef7
movb $0x1, %al
callq 0x3cd70
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x38(%rbp), %eax
jge 0x99627b
movl -0xc(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jl 0x996249
movl -0xc(%rbp), %eax
cmpl -0x20(%rbp), %eax
jg 0x996249
movq -0x8(%rbp), %rax
addq $0x934c, %rax # imm = 0x934C
movl -0x7c(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
imulq $0x102, %rcx, %rcx # imm = 0x102
addq %rcx, %rax
movslq -0xc(%rbp), %rcx
movb $0x0, (%rax,%rcx)
jmp 0x99626e
movq -0x8(%rbp), %rax
addq $0x934c, %rax # imm = 0x934C
movl -0x7c(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
imulq $0x102, %rcx, %rcx # imm = 0x102
addq %rcx, %rax
movslq -0xc(%rbp), %rcx
movb $0xf, (%rax,%rcx)
jmp 0x996270
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x99620a
movl -0x7c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x7c(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl -0x88(%rbp), %ecx
movl -0x80(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x80(%rbp)
jmp 0x9960cc
movl $0x0, -0x30(%rbp)
cmpl $0x4, -0x30(%rbp)
jge 0x998cb3
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0x48(%rbp), %eax
jge 0x9962d7
movslq -0x10(%rbp), %rax
movl $0x0, -0x70(%rbp,%rax,4)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x9962b8
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0x48(%rbp), %eax
jge 0x996330
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x38(%rbp), %eax
jge 0x996323
movq -0x8(%rbp), %rax
addq $0xb188, %rax # imm = 0xB188
movslq -0x10(%rbp), %rcx
imulq $0x408, %rcx, %rcx # imm = 0x408
addq %rcx, %rax
movslq -0xc(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x9962ed
jmp 0x996325
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x9962de
cmpl $0x6, -0x48(%rbp)
jne 0x996413
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x38(%rbp), %eax
jge 0x996411
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movzbl 0x944e(%rax,%rcx), %ecx
shll $0x10, %ecx
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rdx
movzbl 0x934c(%rax,%rdx), %eax
orl %eax, %ecx
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movslq -0xc(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movzbl 0x9652(%rax,%rcx), %ecx
shll $0x10, %ecx
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rdx
movzbl 0x9550(%rax,%rdx), %eax
orl %eax, %ecx
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movslq -0xc(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movl %ecx, 0x4(%rax)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movzbl 0x9856(%rax,%rcx), %ecx
shll $0x10, %ecx
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rdx
movzbl 0x9754(%rax,%rdx), %eax
orl %eax, %ecx
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movslq -0xc(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movl %ecx, 0x8(%rax)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x996341
jmp 0x996413
movl $0x0, -0x34(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x29c(%rcx), %eax
jl 0x99643c
jmp 0x998bb0
movl -0x1c(%rbp), %eax
addl $0x32, %eax
subl $0x1, %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x29c(%rcx), %eax
jl 0x996467
movq -0x8(%rbp), %rax
movl 0x29c(%rax), %eax
subl $0x1, %eax
movl %eax, -0x20(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0x48(%rbp), %eax
jge 0x99648c
movslq -0x10(%rbp), %rax
movw $0x0, -0x58(%rbp,%rax,2)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x99646e
cmpl $0x6, -0x48(%rbp)
jne 0x998078
movl -0x20(%rbp), %ecx
subl -0x1c(%rbp), %ecx
addl $0x1, %ecx
movl $0x32, %eax
cmpl %ecx, %eax
jne 0x998078
movl $0x0, -0x94(%rbp)
movl $0x0, -0x90(%rbp)
movl $0x0, -0x8c(%rbp)
movq -0x78(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x0, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0x96(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
addl -0x8c(%rbp), %eax
movl %eax, -0x8c(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
addl -0x90(%rbp), %eax
movl %eax, -0x90(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
addl -0x94(%rbp), %eax
movl %eax, -0x94(%rbp)
movq -0x78(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0x96(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
addl -0x8c(%rbp), %eax
movl %eax, -0x8c(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
addl -0x90(%rbp), %eax
movl %eax, -0x90(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
addl -0x94(%rbp), %eax
movl %eax, -0x94(%rbp)
movq -0x78(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0x96(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
addl -0x8c(%rbp), %eax
movl %eax, -0x8c(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
addl -0x90(%rbp), %eax
movl %eax, -0x90(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
addl -0x94(%rbp), %eax
movl %eax, -0x94(%rbp)
movq -0x78(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x3, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0x96(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
addl -0x8c(%rbp), %eax
movl %eax, -0x8c(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
addl -0x90(%rbp), %eax
movl %eax, -0x90(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
addl -0x94(%rbp), %eax
movl %eax, -0x94(%rbp)
movq -0x78(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x4, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0x96(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
addl -0x8c(%rbp), %eax
movl %eax, -0x8c(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
addl -0x90(%rbp), %eax
movl %eax, -0x90(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
addl -0x94(%rbp), %eax
movl %eax, -0x94(%rbp)
movq -0x78(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x5, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0x96(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
addl -0x8c(%rbp), %eax
movl %eax, -0x8c(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
addl -0x90(%rbp), %eax
movl %eax, -0x90(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
addl -0x94(%rbp), %eax
movl %eax, -0x94(%rbp)
movq -0x78(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x6, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0x96(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
addl -0x8c(%rbp), %eax
movl %eax, -0x8c(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
addl -0x90(%rbp), %eax
movl %eax, -0x90(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
addl -0x94(%rbp), %eax
movl %eax, -0x94(%rbp)
movq -0x78(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x7, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0x96(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
addl -0x8c(%rbp), %eax
movl %eax, -0x8c(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
addl -0x90(%rbp), %eax
movl %eax, -0x90(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
addl -0x94(%rbp), %eax
movl %eax, -0x94(%rbp)
movq -0x78(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x8, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0x96(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
addl -0x8c(%rbp), %eax
movl %eax, -0x8c(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
addl -0x90(%rbp), %eax
movl %eax, -0x90(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
addl -0x94(%rbp), %eax
movl %eax, -0x94(%rbp)
movq -0x78(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x9, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0x96(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
addl -0x8c(%rbp), %eax
movl %eax, -0x8c(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
addl -0x90(%rbp), %eax
movl %eax, -0x90(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
addl -0x94(%rbp), %eax
movl %eax, -0x94(%rbp)
movq -0x78(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0xa, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0x96(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
addl -0x8c(%rbp), %eax
movl %eax, -0x8c(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
addl -0x90(%rbp), %eax
movl %eax, -0x90(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
addl -0x94(%rbp), %eax
movl %eax, -0x94(%rbp)
movq -0x78(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0xb, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0x96(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
addl -0x8c(%rbp), %eax
movl %eax, -0x8c(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
addl -0x90(%rbp), %eax
movl %eax, -0x90(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
addl -0x94(%rbp), %eax
movl %eax, -0x94(%rbp)
movq -0x78(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0xc, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0x96(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
addl -0x8c(%rbp), %eax
movl %eax, -0x8c(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
addl -0x90(%rbp), %eax
movl %eax, -0x90(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
addl -0x94(%rbp), %eax
movl %eax, -0x94(%rbp)
movq -0x78(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0xd, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0x96(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
addl -0x8c(%rbp), %eax
movl %eax, -0x8c(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
addl -0x90(%rbp), %eax
movl %eax, -0x90(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
addl -0x94(%rbp), %eax
movl %eax, -0x94(%rbp)
movq -0x78(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0xe, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0x96(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
addl -0x8c(%rbp), %eax
movl %eax, -0x8c(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
addl -0x90(%rbp), %eax
movl %eax, -0x90(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
addl -0x94(%rbp), %eax
movl %eax, -0x94(%rbp)
movq -0x78(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0xf, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0x96(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
addl -0x8c(%rbp), %eax
movl %eax, -0x8c(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
addl -0x90(%rbp), %eax
movl %eax, -0x90(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
addl -0x94(%rbp), %eax
movl %eax, -0x94(%rbp)
movq -0x78(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x10, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0x96(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
addl -0x8c(%rbp), %eax
movl %eax, -0x8c(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
addl -0x90(%rbp), %eax
movl %eax, -0x90(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
addl -0x94(%rbp), %eax
movl %eax, -0x94(%rbp)
movq -0x78(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x11, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0x96(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
addl -0x8c(%rbp), %eax
movl %eax, -0x8c(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
addl -0x90(%rbp), %eax
movl %eax, -0x90(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
addl -0x94(%rbp), %eax
movl %eax, -0x94(%rbp)
movq -0x78(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x12, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0x96(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
addl -0x8c(%rbp), %eax
movl %eax, -0x8c(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
addl -0x90(%rbp), %eax
movl %eax, -0x90(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
addl -0x94(%rbp), %eax
movl %eax, -0x94(%rbp)
movq -0x78(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x13, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0x96(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
addl -0x8c(%rbp), %eax
movl %eax, -0x8c(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
addl -0x90(%rbp), %eax
movl %eax, -0x90(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
addl -0x94(%rbp), %eax
movl %eax, -0x94(%rbp)
movq -0x78(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x14, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0x96(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
addl -0x8c(%rbp), %eax
movl %eax, -0x8c(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
addl -0x90(%rbp), %eax
movl %eax, -0x90(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
addl -0x94(%rbp), %eax
movl %eax, -0x94(%rbp)
movq -0x78(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x15, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0x96(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
addl -0x8c(%rbp), %eax
movl %eax, -0x8c(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
addl -0x90(%rbp), %eax
movl %eax, -0x90(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
addl -0x94(%rbp), %eax
movl %eax, -0x94(%rbp)
movq -0x78(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x16, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0x96(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
addl -0x8c(%rbp), %eax
movl %eax, -0x8c(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
addl -0x90(%rbp), %eax
movl %eax, -0x90(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
addl -0x94(%rbp), %eax
movl %eax, -0x94(%rbp)
movq -0x78(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x17, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0x96(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
addl -0x8c(%rbp), %eax
movl %eax, -0x8c(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
addl -0x90(%rbp), %eax
movl %eax, -0x90(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
addl -0x94(%rbp), %eax
movl %eax, -0x94(%rbp)
movq -0x78(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x18, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0x96(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
addl -0x8c(%rbp), %eax
movl %eax, -0x8c(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
addl -0x90(%rbp), %eax
movl %eax, -0x90(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
addl -0x94(%rbp), %eax
movl %eax, -0x94(%rbp)
movq -0x78(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x19, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0x96(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
addl -0x8c(%rbp), %eax
movl %eax, -0x8c(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
addl -0x90(%rbp), %eax
movl %eax, -0x90(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
addl -0x94(%rbp), %eax
movl %eax, -0x94(%rbp)
movq -0x78(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x1a, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0x96(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
addl -0x8c(%rbp), %eax
movl %eax, -0x8c(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
addl -0x90(%rbp), %eax
movl %eax, -0x90(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
addl -0x94(%rbp), %eax
movl %eax, -0x94(%rbp)
movq -0x78(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x1b, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0x96(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
addl -0x8c(%rbp), %eax
movl %eax, -0x8c(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
addl -0x90(%rbp), %eax
movl %eax, -0x90(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
addl -0x94(%rbp), %eax
movl %eax, -0x94(%rbp)
movq -0x78(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x1c, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0x96(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
addl -0x8c(%rbp), %eax
movl %eax, -0x8c(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
addl -0x90(%rbp), %eax
movl %eax, -0x90(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
addl -0x94(%rbp), %eax
movl %eax, -0x94(%rbp)
movq -0x78(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x1d, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0x96(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
addl -0x8c(%rbp), %eax
movl %eax, -0x8c(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
addl -0x90(%rbp), %eax
movl %eax, -0x90(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
addl -0x94(%rbp), %eax
movl %eax, -0x94(%rbp)
movq -0x78(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x1e, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0x96(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
addl -0x8c(%rbp), %eax
movl %eax, -0x8c(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
addl -0x90(%rbp), %eax
movl %eax, -0x90(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
addl -0x94(%rbp), %eax
movl %eax, -0x94(%rbp)
movq -0x78(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x1f, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0x96(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
addl -0x8c(%rbp), %eax
movl %eax, -0x8c(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
addl -0x90(%rbp), %eax
movl %eax, -0x90(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
addl -0x94(%rbp), %eax
movl %eax, -0x94(%rbp)
movq -0x78(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x20, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0x96(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
addl -0x8c(%rbp), %eax
movl %eax, -0x8c(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
addl -0x90(%rbp), %eax
movl %eax, -0x90(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
addl -0x94(%rbp), %eax
movl %eax, -0x94(%rbp)
movq -0x78(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x21, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0x96(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
addl -0x8c(%rbp), %eax
movl %eax, -0x8c(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
addl -0x90(%rbp), %eax
movl %eax, -0x90(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
addl -0x94(%rbp), %eax
movl %eax, -0x94(%rbp)
movq -0x78(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x22, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0x96(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
addl -0x8c(%rbp), %eax
movl %eax, -0x8c(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
addl -0x90(%rbp), %eax
movl %eax, -0x90(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
addl -0x94(%rbp), %eax
movl %eax, -0x94(%rbp)
movq -0x78(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x23, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0x96(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
addl -0x8c(%rbp), %eax
movl %eax, -0x8c(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
addl -0x90(%rbp), %eax
movl %eax, -0x90(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
addl -0x94(%rbp), %eax
movl %eax, -0x94(%rbp)
movq -0x78(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x24, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0x96(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
addl -0x8c(%rbp), %eax
movl %eax, -0x8c(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
addl -0x90(%rbp), %eax
movl %eax, -0x90(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
addl -0x94(%rbp), %eax
movl %eax, -0x94(%rbp)
movq -0x78(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x25, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0x96(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
addl -0x8c(%rbp), %eax
movl %eax, -0x8c(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
addl -0x90(%rbp), %eax
movl %eax, -0x90(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
addl -0x94(%rbp), %eax
movl %eax, -0x94(%rbp)
movq -0x78(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x26, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0x96(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
addl -0x8c(%rbp), %eax
movl %eax, -0x8c(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
addl -0x90(%rbp), %eax
movl %eax, -0x90(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
addl -0x94(%rbp), %eax
movl %eax, -0x94(%rbp)
movq -0x78(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x27, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0x96(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
addl -0x8c(%rbp), %eax
movl %eax, -0x8c(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
addl -0x90(%rbp), %eax
movl %eax, -0x90(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
addl -0x94(%rbp), %eax
movl %eax, -0x94(%rbp)
movq -0x78(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x28, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0x96(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
addl -0x8c(%rbp), %eax
movl %eax, -0x8c(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
addl -0x90(%rbp), %eax
movl %eax, -0x90(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
addl -0x94(%rbp), %eax
movl %eax, -0x94(%rbp)
movq -0x78(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x29, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0x96(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
addl -0x8c(%rbp), %eax
movl %eax, -0x8c(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
addl -0x90(%rbp), %eax
movl %eax, -0x90(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
addl -0x94(%rbp), %eax
movl %eax, -0x94(%rbp)
movq -0x78(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x2a, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0x96(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
addl -0x8c(%rbp), %eax
movl %eax, -0x8c(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
addl -0x90(%rbp), %eax
movl %eax, -0x90(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
addl -0x94(%rbp), %eax
movl %eax, -0x94(%rbp)
movq -0x78(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x2b, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0x96(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
addl -0x8c(%rbp), %eax
movl %eax, -0x8c(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
addl -0x90(%rbp), %eax
movl %eax, -0x90(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
addl -0x94(%rbp), %eax
movl %eax, -0x94(%rbp)
movq -0x78(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x2c, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0x96(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
addl -0x8c(%rbp), %eax
movl %eax, -0x8c(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
addl -0x90(%rbp), %eax
movl %eax, -0x90(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
addl -0x94(%rbp), %eax
movl %eax, -0x94(%rbp)
movq -0x78(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x2d, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0x96(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
addl -0x8c(%rbp), %eax
movl %eax, -0x8c(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
addl -0x90(%rbp), %eax
movl %eax, -0x90(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
addl -0x94(%rbp), %eax
movl %eax, -0x94(%rbp)
movq -0x78(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x2e, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0x96(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
addl -0x8c(%rbp), %eax
movl %eax, -0x8c(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
addl -0x90(%rbp), %eax
movl %eax, -0x90(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
addl -0x94(%rbp), %eax
movl %eax, -0x94(%rbp)
movq -0x78(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x2f, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0x96(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
addl -0x8c(%rbp), %eax
movl %eax, -0x8c(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
addl -0x90(%rbp), %eax
movl %eax, -0x90(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
addl -0x94(%rbp), %eax
movl %eax, -0x94(%rbp)
movq -0x78(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x30, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0x96(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
addl -0x8c(%rbp), %eax
movl %eax, -0x8c(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
addl -0x90(%rbp), %eax
movl %eax, -0x90(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
addl -0x94(%rbp), %eax
movl %eax, -0x94(%rbp)
movq -0x78(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x31, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0x96(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
addl -0x8c(%rbp), %eax
movl %eax, -0x8c(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
addl -0x90(%rbp), %eax
movl %eax, -0x90(%rbp)
movq -0x8(%rbp), %rax
addq $0xc9b8, %rax # imm = 0xC9B8
movzwl -0x96(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
addl -0x94(%rbp), %eax
movl %eax, -0x94(%rbp)
movl -0x8c(%rbp), %eax
andl $0xffff, %eax # imm = 0xFFFF
movw %ax, -0x58(%rbp)
movl -0x8c(%rbp), %eax
shrl $0x10, %eax
movw %ax, -0x56(%rbp)
movl -0x90(%rbp), %eax
andl $0xffff, %eax # imm = 0xFFFF
movw %ax, -0x54(%rbp)
movl -0x90(%rbp), %eax
shrl $0x10, %eax
movw %ax, -0x52(%rbp)
movl -0x94(%rbp), %eax
andl $0xffff, %eax # imm = 0xFFFF
movw %ax, -0x50(%rbp)
movl -0x94(%rbp), %eax
shrl $0x10, %eax
movw %ax, -0x4e(%rbp)
jmp 0x9980f5
movl -0x1c(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x20(%rbp), %eax
jg 0x9980f3
movq -0x78(%rbp), %rax
movslq -0x14(%rbp), %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0x98(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0x48(%rbp), %eax
jge 0x9980e6
movq -0x8(%rbp), %rax
addq $0x934c, %rax # imm = 0x934C
movslq -0x10(%rbp), %rcx
imulq $0x102, %rcx, %rcx # imm = 0x102
addq %rcx, %rax
movzwl -0x98(%rbp), %ecx
movzbl (%rax,%rcx), %edx
movslq -0x10(%rbp), %rax
movzwl -0x58(%rbp,%rax,2), %ecx
addl %edx, %ecx
movw %cx, -0x58(%rbp,%rax,2)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x9980a0
jmp 0x9980e8
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x99807e
jmp 0x9980f5
movl $0x3b9ac9ff, -0x2c(%rbp) # imm = 0x3B9AC9FF
movl $0xffffffff, -0x28(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0x48(%rbp), %eax
jge 0x99813f
movslq -0x10(%rbp), %rax
movzwl -0x58(%rbp,%rax,2), %eax
cmpl -0x2c(%rbp), %eax
jge 0x998132
movslq -0x10(%rbp), %rax
movzwl -0x58(%rbp,%rax,2), %eax
movl %eax, -0x2c(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x28(%rbp)
jmp 0x998134
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x99810a
movl -0x2c(%rbp), %eax
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
movslq -0x28(%rbp), %rax
movl -0x70(%rbp,%rax,4), %ecx
addl $0x1, %ecx
movl %ecx, -0x70(%rbp,%rax,4)
movl -0x28(%rbp), %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movslq -0x34(%rbp), %rcx
movb %dl, 0x6a8(%rax,%rcx)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
cmpl $0x6, -0x48(%rbp)
jne 0x998b5a
movl -0x20(%rbp), %ecx
subl -0x1c(%rbp), %ecx
addl $0x1, %ecx
movl $0x32, %eax
cmpl %ecx, %eax
jne 0x998b5a
movq -0x8(%rbp), %rax
addq $0xb188, %rax # imm = 0xB188
movslq -0x28(%rbp), %rcx
imulq $0x408, %rcx, %rcx # imm = 0x408
addq %rcx, %rax
movq -0x78(%rbp), %rcx
movl -0x1c(%rbp), %edx
addl $0x0, %edx
movslq %edx, %rdx
movzwl (%rcx,%rdx,2), %ecx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
addq $0xb188, %rax # imm = 0xB188
movslq -0x28(%rbp), %rcx
imulq $0x408, %rcx, %rcx # imm = 0x408
addq %rcx, %rax
movq -0x78(%rbp), %rcx
movl -0x1c(%rbp), %edx
addl $0x1, %edx
movslq %edx, %rdx
movzwl (%rcx,%rdx,2), %ecx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
addq $0xb188, %rax # imm = 0xB188
movslq -0x28(%rbp), %rcx
imulq $0x408, %rcx, %rcx # imm = 0x408
addq %rcx, %rax
movq -0x78(%rbp), %rcx
movl -0x1c(%rbp), %edx
addl $0x2, %edx
movslq %edx, %rdx
movzwl (%rcx,%rdx,2), %ecx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
addq $0xb188, %rax # imm = 0xB188
movslq -0x28(%rbp), %rcx
imulq $0x408, %rcx, %rcx # imm = 0x408
addq %rcx, %rax
movq -0x78(%rbp), %rcx
movl -0x1c(%rbp), %edx
addl $0x3, %edx
movslq %edx, %rdx
movzwl (%rcx,%rdx,2), %ecx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
addq $0xb188, %rax # imm = 0xB188
movslq -0x28(%rbp), %rcx
imulq $0x408, %rcx, %rcx # imm = 0x408
addq %rcx, %rax
movq -0x78(%rbp), %rcx
movl -0x1c(%rbp), %edx
addl $0x4, %edx
movslq %edx, %rdx
movzwl (%rcx,%rdx,2), %ecx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
addq $0xb188, %rax # imm = 0xB188
movslq -0x28(%rbp), %rcx
imulq $0x408, %rcx, %rcx # imm = 0x408
addq %rcx, %rax
movq -0x78(%rbp), %rcx
movl -0x1c(%rbp), %edx
addl $0x5, %edx
movslq %edx, %rdx
movzwl (%rcx,%rdx,2), %ecx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
addq $0xb188, %rax # imm = 0xB188
movslq -0x28(%rbp), %rcx
imulq $0x408, %rcx, %rcx # imm = 0x408
addq %rcx, %rax
movq -0x78(%rbp), %rcx
movl -0x1c(%rbp), %edx
addl $0x6, %edx
movslq %edx, %rdx
movzwl (%rcx,%rdx,2), %ecx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
addq $0xb188, %rax # imm = 0xB188
movslq -0x28(%rbp), %rcx
imulq $0x408, %rcx, %rcx # imm = 0x408
addq %rcx, %rax
movq -0x78(%rbp), %rcx
movl -0x1c(%rbp), %edx
addl $0x7, %edx
movslq %edx, %rdx
movzwl (%rcx,%rdx,2), %ecx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
addq $0xb188, %rax # imm = 0xB188
movslq -0x28(%rbp), %rcx
imulq $0x408, %rcx, %rcx # imm = 0x408
addq %rcx, %rax
movq -0x78(%rbp), %rcx
movl -0x1c(%rbp), %edx
addl $0x8, %edx
movslq %edx, %rdx
movzwl (%rcx,%rdx,2), %ecx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
addq $0xb188, %rax # imm = 0xB188
movslq -0x28(%rbp), %rcx
imulq $0x408, %rcx, %rcx # imm = 0x408
addq %rcx, %rax
movq -0x78(%rbp), %rcx
movl -0x1c(%rbp), %edx
addl $0x9, %edx
movslq %edx, %rdx
movzwl (%rcx,%rdx,2), %ecx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
addq $0xb188, %rax # imm = 0xB188
movslq -0x28(%rbp), %rcx
imulq $0x408, %rcx, %rcx # imm = 0x408
addq %rcx, %rax
movq -0x78(%rbp), %rcx
movl -0x1c(%rbp), %edx
addl $0xa, %edx
movslq %edx, %rdx
movzwl (%rcx,%rdx,2), %ecx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
addq $0xb188, %rax # imm = 0xB188
movslq -0x28(%rbp), %rcx
imulq $0x408, %rcx, %rcx # imm = 0x408
addq %rcx, %rax
movq -0x78(%rbp), %rcx
movl -0x1c(%rbp), %edx
addl $0xb, %edx
movslq %edx, %rdx
movzwl (%rcx,%rdx,2), %ecx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
addq $0xb188, %rax # imm = 0xB188
movslq -0x28(%rbp), %rcx
imulq $0x408, %rcx, %rcx # imm = 0x408
addq %rcx, %rax
movq -0x78(%rbp), %rcx
movl -0x1c(%rbp), %edx
addl $0xc, %edx
movslq %edx, %rdx
movzwl (%rcx,%rdx,2), %ecx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
addq $0xb188, %rax # imm = 0xB188
movslq -0x28(%rbp), %rcx
imulq $0x408, %rcx, %rcx # imm = 0x408
addq %rcx, %rax
movq -0x78(%rbp), %rcx
movl -0x1c(%rbp), %edx
addl $0xd, %edx
movslq %edx, %rdx
movzwl (%rcx,%rdx,2), %ecx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
addq $0xb188, %rax # imm = 0xB188
movslq -0x28(%rbp), %rcx
imulq $0x408, %rcx, %rcx # imm = 0x408
addq %rcx, %rax
movq -0x78(%rbp), %rcx
movl -0x1c(%rbp), %edx
addl $0xe, %edx
movslq %edx, %rdx
movzwl (%rcx,%rdx,2), %ecx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
addq $0xb188, %rax # imm = 0xB188
movslq -0x28(%rbp), %rcx
imulq $0x408, %rcx, %rcx # imm = 0x408
addq %rcx, %rax
movq -0x78(%rbp), %rcx
movl -0x1c(%rbp), %edx
addl $0xf, %edx
movslq %edx, %rdx
movzwl (%rcx,%rdx,2), %ecx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
addq $0xb188, %rax # imm = 0xB188
movslq -0x28(%rbp), %rcx
imulq $0x408, %rcx, %rcx # imm = 0x408
addq %rcx, %rax
movq -0x78(%rbp), %rcx
movl -0x1c(%rbp), %edx
addl $0x10, %edx
movslq %edx, %rdx
movzwl (%rcx,%rdx,2), %ecx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
addq $0xb188, %rax # imm = 0xB188
movslq -0x28(%rbp), %rcx
imulq $0x408, %rcx, %rcx # imm = 0x408
addq %rcx, %rax
movq -0x78(%rbp), %rcx
movl -0x1c(%rbp), %edx
addl $0x11, %edx
movslq %edx, %rdx
movzwl (%rcx,%rdx,2), %ecx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
addq $0xb188, %rax # imm = 0xB188
movslq -0x28(%rbp), %rcx
imulq $0x408, %rcx, %rcx # imm = 0x408
addq %rcx, %rax
movq -0x78(%rbp), %rcx
movl -0x1c(%rbp), %edx
addl $0x12, %edx
movslq %edx, %rdx
movzwl (%rcx,%rdx,2), %ecx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
addq $0xb188, %rax # imm = 0xB188
movslq -0x28(%rbp), %rcx
imulq $0x408, %rcx, %rcx # imm = 0x408
addq %rcx, %rax
movq -0x78(%rbp), %rcx
movl -0x1c(%rbp), %edx
addl $0x13, %edx
movslq %edx, %rdx
movzwl (%rcx,%rdx,2), %ecx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
addq $0xb188, %rax # imm = 0xB188
movslq -0x28(%rbp), %rcx
imulq $0x408, %rcx, %rcx # imm = 0x408
addq %rcx, %rax
movq -0x78(%rbp), %rcx
movl -0x1c(%rbp), %edx
addl $0x14, %edx
movslq %edx, %rdx
movzwl (%rcx,%rdx,2), %ecx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
addq $0xb188, %rax # imm = 0xB188
movslq -0x28(%rbp), %rcx
imulq $0x408, %rcx, %rcx # imm = 0x408
addq %rcx, %rax
movq -0x78(%rbp), %rcx
movl -0x1c(%rbp), %edx
addl $0x15, %edx
movslq %edx, %rdx
movzwl (%rcx,%rdx,2), %ecx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
addq $0xb188, %rax # imm = 0xB188
movslq -0x28(%rbp), %rcx
imulq $0x408, %rcx, %rcx # imm = 0x408
addq %rcx, %rax
movq -0x78(%rbp), %rcx
movl -0x1c(%rbp), %edx
addl $0x16, %edx
movslq %edx, %rdx
movzwl (%rcx,%rdx,2), %ecx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
addq $0xb188, %rax # imm = 0xB188
movslq -0x28(%rbp), %rcx
imulq $0x408, %rcx, %rcx # imm = 0x408
addq %rcx, %rax
movq -0x78(%rbp), %rcx
movl -0x1c(%rbp), %edx
addl $0x17, %edx
movslq %edx, %rdx
movzwl (%rcx,%rdx,2), %ecx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
addq $0xb188, %rax # imm = 0xB188
movslq -0x28(%rbp), %rcx
imulq $0x408, %rcx, %rcx # imm = 0x408
addq %rcx, %rax
movq -0x78(%rbp), %rcx
movl -0x1c(%rbp), %edx
addl $0x18, %edx
movslq %edx, %rdx
movzwl (%rcx,%rdx,2), %ecx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
addq $0xb188, %rax # imm = 0xB188
movslq -0x28(%rbp), %rcx
imulq $0x408, %rcx, %rcx # imm = 0x408
addq %rcx, %rax
movq -0x78(%rbp), %rcx
movl -0x1c(%rbp), %edx
addl $0x19, %edx
movslq %edx, %rdx
movzwl (%rcx,%rdx,2), %ecx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
addq $0xb188, %rax # imm = 0xB188
movslq -0x28(%rbp), %rcx
imulq $0x408, %rcx, %rcx # imm = 0x408
addq %rcx, %rax
movq -0x78(%rbp), %rcx
movl -0x1c(%rbp), %edx
addl $0x1a, %edx
movslq %edx, %rdx
movzwl (%rcx,%rdx,2), %ecx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
addq $0xb188, %rax # imm = 0xB188
movslq -0x28(%rbp), %rcx
imulq $0x408, %rcx, %rcx # imm = 0x408
addq %rcx, %rax
movq -0x78(%rbp), %rcx
movl -0x1c(%rbp), %edx
addl $0x1b, %edx
movslq %edx, %rdx
movzwl (%rcx,%rdx,2), %ecx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
addq $0xb188, %rax # imm = 0xB188
movslq -0x28(%rbp), %rcx
imulq $0x408, %rcx, %rcx # imm = 0x408
addq %rcx, %rax
movq -0x78(%rbp), %rcx
movl -0x1c(%rbp), %edx
addl $0x1c, %edx
movslq %edx, %rdx
movzwl (%rcx,%rdx,2), %ecx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
addq $0xb188, %rax # imm = 0xB188
movslq -0x28(%rbp), %rcx
imulq $0x408, %rcx, %rcx # imm = 0x408
addq %rcx, %rax
movq -0x78(%rbp), %rcx
movl -0x1c(%rbp), %edx
addl $0x1d, %edx
movslq %edx, %rdx
movzwl (%rcx,%rdx,2), %ecx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
addq $0xb188, %rax # imm = 0xB188
movslq -0x28(%rbp), %rcx
imulq $0x408, %rcx, %rcx # imm = 0x408
addq %rcx, %rax
movq -0x78(%rbp), %rcx
movl -0x1c(%rbp), %edx
addl $0x1e, %edx
movslq %edx, %rdx
movzwl (%rcx,%rdx,2), %ecx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
addq $0xb188, %rax # imm = 0xB188
movslq -0x28(%rbp), %rcx
imulq $0x408, %rcx, %rcx # imm = 0x408
addq %rcx, %rax
movq -0x78(%rbp), %rcx
movl -0x1c(%rbp), %edx
addl $0x1f, %edx
movslq %edx, %rdx
movzwl (%rcx,%rdx,2), %ecx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
addq $0xb188, %rax # imm = 0xB188
movslq -0x28(%rbp), %rcx
imulq $0x408, %rcx, %rcx # imm = 0x408
addq %rcx, %rax
movq -0x78(%rbp), %rcx
movl -0x1c(%rbp), %edx
addl $0x20, %edx
movslq %edx, %rdx
movzwl (%rcx,%rdx,2), %ecx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
addq $0xb188, %rax # imm = 0xB188
movslq -0x28(%rbp), %rcx
imulq $0x408, %rcx, %rcx # imm = 0x408
addq %rcx, %rax
movq -0x78(%rbp), %rcx
movl -0x1c(%rbp), %edx
addl $0x21, %edx
movslq %edx, %rdx
movzwl (%rcx,%rdx,2), %ecx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
addq $0xb188, %rax # imm = 0xB188
movslq -0x28(%rbp), %rcx
imulq $0x408, %rcx, %rcx # imm = 0x408
addq %rcx, %rax
movq -0x78(%rbp), %rcx
movl -0x1c(%rbp), %edx
addl $0x22, %edx
movslq %edx, %rdx
movzwl (%rcx,%rdx,2), %ecx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
addq $0xb188, %rax # imm = 0xB188
movslq -0x28(%rbp), %rcx
imulq $0x408, %rcx, %rcx # imm = 0x408
addq %rcx, %rax
movq -0x78(%rbp), %rcx
movl -0x1c(%rbp), %edx
addl $0x23, %edx
movslq %edx, %rdx
movzwl (%rcx,%rdx,2), %ecx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
addq $0xb188, %rax # imm = 0xB188
movslq -0x28(%rbp), %rcx
imulq $0x408, %rcx, %rcx # imm = 0x408
addq %rcx, %rax
movq -0x78(%rbp), %rcx
movl -0x1c(%rbp), %edx
addl $0x24, %edx
movslq %edx, %rdx
movzwl (%rcx,%rdx,2), %ecx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
addq $0xb188, %rax # imm = 0xB188
movslq -0x28(%rbp), %rcx
imulq $0x408, %rcx, %rcx # imm = 0x408
addq %rcx, %rax
movq -0x78(%rbp), %rcx
movl -0x1c(%rbp), %edx
addl $0x25, %edx
movslq %edx, %rdx
movzwl (%rcx,%rdx,2), %ecx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
addq $0xb188, %rax # imm = 0xB188
movslq -0x28(%rbp), %rcx
imulq $0x408, %rcx, %rcx # imm = 0x408
addq %rcx, %rax
movq -0x78(%rbp), %rcx
movl -0x1c(%rbp), %edx
addl $0x26, %edx
movslq %edx, %rdx
movzwl (%rcx,%rdx,2), %ecx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
addq $0xb188, %rax # imm = 0xB188
movslq -0x28(%rbp), %rcx
imulq $0x408, %rcx, %rcx # imm = 0x408
addq %rcx, %rax
movq -0x78(%rbp), %rcx
movl -0x1c(%rbp), %edx
addl $0x27, %edx
movslq %edx, %rdx
movzwl (%rcx,%rdx,2), %ecx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
addq $0xb188, %rax # imm = 0xB188
movslq -0x28(%rbp), %rcx
imulq $0x408, %rcx, %rcx # imm = 0x408
addq %rcx, %rax
movq -0x78(%rbp), %rcx
movl -0x1c(%rbp), %edx
addl $0x28, %edx
movslq %edx, %rdx
movzwl (%rcx,%rdx,2), %ecx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
addq $0xb188, %rax # imm = 0xB188
movslq -0x28(%rbp), %rcx
imulq $0x408, %rcx, %rcx # imm = 0x408
addq %rcx, %rax
movq -0x78(%rbp), %rcx
movl -0x1c(%rbp), %edx
addl $0x29, %edx
movslq %edx, %rdx
movzwl (%rcx,%rdx,2), %ecx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
addq $0xb188, %rax # imm = 0xB188
movslq -0x28(%rbp), %rcx
imulq $0x408, %rcx, %rcx # imm = 0x408
addq %rcx, %rax
movq -0x78(%rbp), %rcx
movl -0x1c(%rbp), %edx
addl $0x2a, %edx
movslq %edx, %rdx
movzwl (%rcx,%rdx,2), %ecx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
addq $0xb188, %rax # imm = 0xB188
movslq -0x28(%rbp), %rcx
imulq $0x408, %rcx, %rcx # imm = 0x408
addq %rcx, %rax
movq -0x78(%rbp), %rcx
movl -0x1c(%rbp), %edx
addl $0x2b, %edx
movslq %edx, %rdx
movzwl (%rcx,%rdx,2), %ecx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
addq $0xb188, %rax # imm = 0xB188
movslq -0x28(%rbp), %rcx
imulq $0x408, %rcx, %rcx # imm = 0x408
addq %rcx, %rax
movq -0x78(%rbp), %rcx
movl -0x1c(%rbp), %edx
addl $0x2c, %edx
movslq %edx, %rdx
movzwl (%rcx,%rdx,2), %ecx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
addq $0xb188, %rax # imm = 0xB188
movslq -0x28(%rbp), %rcx
imulq $0x408, %rcx, %rcx # imm = 0x408
addq %rcx, %rax
movq -0x78(%rbp), %rcx
movl -0x1c(%rbp), %edx
addl $0x2d, %edx
movslq %edx, %rdx
movzwl (%rcx,%rdx,2), %ecx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
addq $0xb188, %rax # imm = 0xB188
movslq -0x28(%rbp), %rcx
imulq $0x408, %rcx, %rcx # imm = 0x408
addq %rcx, %rax
movq -0x78(%rbp), %rcx
movl -0x1c(%rbp), %edx
addl $0x2e, %edx
movslq %edx, %rdx
movzwl (%rcx,%rdx,2), %ecx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
addq $0xb188, %rax # imm = 0xB188
movslq -0x28(%rbp), %rcx
imulq $0x408, %rcx, %rcx # imm = 0x408
addq %rcx, %rax
movq -0x78(%rbp), %rcx
movl -0x1c(%rbp), %edx
addl $0x2f, %edx
movslq %edx, %rdx
movzwl (%rcx,%rdx,2), %ecx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
addq $0xb188, %rax # imm = 0xB188
movslq -0x28(%rbp), %rcx
imulq $0x408, %rcx, %rcx # imm = 0x408
addq %rcx, %rax
movq -0x78(%rbp), %rcx
movl -0x1c(%rbp), %edx
addl $0x30, %edx
movslq %edx, %rdx
movzwl (%rcx,%rdx,2), %ecx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
addq $0xb188, %rax # imm = 0xB188
movslq -0x28(%rbp), %rcx
imulq $0x408, %rcx, %rcx # imm = 0x408
addq %rcx, %rax
movq -0x78(%rbp), %rcx
movl -0x1c(%rbp), %edx
addl $0x31, %edx
movslq %edx, %rdx
movzwl (%rcx,%rdx,2), %ecx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
jmp 0x998ba2
movl -0x1c(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x20(%rbp), %eax
jg 0x998ba0
movq -0x8(%rbp), %rax
addq $0xb188, %rax # imm = 0xB188
movslq -0x28(%rbp), %rcx
imulq $0x408, %rcx, %rcx # imm = 0x408
addq %rcx, %rax
movq -0x78(%rbp), %rcx
movslq -0x14(%rbp), %rdx
movzwl (%rcx,%rdx,2), %ecx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x998b60
jmp 0x998ba2
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x996428
movq -0x8(%rbp), %rax
cmpl $0x3, 0x290(%rax)
jl 0x998c4a
movq 0x5612f8(%rip), %rax # 0xef9ec0
movq (%rax), %rdi
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xe0(%rbp)
movl -0x24(%rbp), %eax
movl $0x8, %ecx
cltd
idivl %ecx
movl -0xe0(%rbp), %edx
movl %eax, %ecx
leaq 0x232341(%rip), %rsi # 0xbcaf32
movb $0x0, %al
callq 0x3cd70
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0x48(%rbp), %eax
jge 0x998c32
movq 0x5612b2(%rip), %rax # 0xef9ec0
movq (%rax), %rdi
movslq -0x10(%rbp), %rax
movl -0x70(%rbp,%rax,4), %edx
leaq 0x1c7816(%rip), %rsi # 0xb60436
movb $0x0, %al
callq 0x3cd70
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x998bff
movq 0x561287(%rip), %rax # 0xef9ec0
movq (%rax), %rdi
leaq 0x1ed772(%rip), %rsi # 0xb863b5
movb $0x0, %al
callq 0x3cd70
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0x48(%rbp), %eax
jge 0x998ca3
movq -0x8(%rbp), %rdi
addq $0x934c, %rdi # imm = 0x934C
movslq -0x10(%rbp), %rax
imulq $0x102, %rax, %rax # imm = 0x102
addq %rax, %rdi
movq -0x8(%rbp), %rsi
addq $0xb188, %rsi # imm = 0xB188
movslq -0x10(%rbp), %rax
imulq $0x408, %rax, %rax # imm = 0x408
addq %rax, %rsi
movl -0x38(%rbp), %edx
movl $0x11, %ecx
callq 0x9a1a60
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x998c51
jmp 0x998ca5
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x9962a7
cmpl $0x8, -0x48(%rbp)
jl 0x998cc3
movl $0xbba, %edi # imm = 0xBBA
callq 0x991060
cmpl $0x8000, -0x34(%rbp) # imm = 0x8000
jge 0x998cd5
cmpl $0x4652, -0x34(%rbp) # imm = 0x4652
jle 0x998cdf
movl $0xbbb, %edi # imm = 0xBBB
callq 0x991060
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x48(%rbp), %eax
jge 0x998d09
movl -0x14(%rbp), %eax
movb %al, %cl
movslq -0x14(%rbp), %rax
movb %cl, -0x9e(%rbp,%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x998ce6
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x34(%rbp), %eax
jge 0x998dc2
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb 0x6a8(%rax,%rcx), %al
movb %al, -0x9f(%rbp)
movl $0x0, -0x18(%rbp)
movslq -0x18(%rbp), %rax
movb -0x9e(%rbp,%rax), %al
movb %al, -0xa1(%rbp)
movzbl -0x9f(%rbp), %eax
movzbl -0xa1(%rbp), %ecx
cmpl %ecx, %eax
je 0x998d94
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movb -0xa1(%rbp), %al
movb %al, -0xa0(%rbp)
movslq -0x18(%rbp), %rax
movb -0x9e(%rbp,%rax), %al
movb %al, -0xa1(%rbp)
movb -0xa0(%rbp), %cl
movslq -0x18(%rbp), %rax
movb %cl, -0x9e(%rbp,%rax)
jmp 0x998d49
movb -0xa1(%rbp), %al
movb %al, -0x9e(%rbp)
movl -0x18(%rbp), %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb %dl, 0x4cfa(%rax,%rcx)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x998d10
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0x48(%rbp), %eax
jge 0x998f05
movl $0x20, -0x3c(%rbp)
movl $0x0, -0x40(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x38(%rbp), %eax
jge 0x998e96
movq -0x8(%rbp), %rax
addq $0x934c, %rax # imm = 0x934C
movslq -0x10(%rbp), %rcx
imulq $0x102, %rcx, %rcx # imm = 0x102
addq %rcx, %rax
movslq -0x14(%rbp), %rcx
movzbl (%rax,%rcx), %eax
cmpl -0x40(%rbp), %eax
jle 0x998e3e
movq -0x8(%rbp), %rax
addq $0x934c, %rax # imm = 0x934C
movslq -0x10(%rbp), %rcx
imulq $0x102, %rcx, %rcx # imm = 0x102
addq %rcx, %rax
movslq -0x14(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0x40(%rbp)
movq -0x8(%rbp), %rax
addq $0x934c, %rax # imm = 0x934C
movslq -0x10(%rbp), %rcx
imulq $0x102, %rcx, %rcx # imm = 0x102
addq %rcx, %rax
movslq -0x14(%rbp), %rcx
movzbl (%rax,%rcx), %eax
cmpl -0x3c(%rbp), %eax
jge 0x998e86
movq -0x8(%rbp), %rax
addq $0x934c, %rax # imm = 0x934C
movslq -0x10(%rbp), %rcx
imulq $0x102, %rcx, %rcx # imm = 0x102
addq %rcx, %rax
movslq -0x14(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0x3c(%rbp)
jmp 0x998e88
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x998dea
cmpl $0x11, -0x40(%rbp)
jle 0x998ea6
movl $0xbbc, %edi # imm = 0xBBC
callq 0x991060
cmpl $0x1, -0x3c(%rbp)
jge 0x998eb6
movl $0xbbd, %edi # imm = 0xBBD
callq 0x991060
movq -0x8(%rbp), %rdi
addq $0x9958, %rdi # imm = 0x9958
movslq -0x10(%rbp), %rax
imulq $0x408, %rax, %rax # imm = 0x408
addq %rax, %rdi
movq -0x8(%rbp), %rsi
addq $0x934c, %rsi # imm = 0x934C
movslq -0x10(%rbp), %rax
imulq $0x102, %rax, %rax # imm = 0x102
addq %rax, %rsi
movl -0x3c(%rbp), %edx
movl -0x40(%rbp), %ecx
movl -0x38(%rbp), %r8d
callq 0x9a2080
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x998dc9
movl $0x0, -0x14(%rbp)
cmpl $0x10, -0x14(%rbp)
jge 0x998f6b
movslq -0x14(%rbp), %rax
movb $0x0, -0xc0(%rbp,%rax)
movl $0x0, -0x18(%rbp)
cmpl $0x10, -0x18(%rbp)
jge 0x998f5e
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
shll $0x4, %ecx
addl -0x18(%rbp), %ecx
movslq %ecx, %rcx
cmpb $0x0, 0x80(%rax,%rcx)
je 0x998f51
movslq -0x14(%rbp), %rax
movb $0x1, -0xc0(%rbp,%rax)
jmp 0x998f53
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x998f25
jmp 0x998f60
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x998f0c
movq -0x8(%rbp), %rax
movl 0x74(%rax), %eax
movl %eax, -0x4c(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x10, -0x14(%rbp)
jge 0x998fbf
movslq -0x14(%rbp), %rax
cmpb $0x0, -0xc0(%rbp,%rax)
je 0x998fa2
movq -0x8(%rbp), %rdi
movl $0x1, %edx
movl %edx, %esi
callq 0x995a30
jmp 0x998fb2
movq -0x8(%rbp), %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x995a30
jmp 0x998fb4
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x998f7c
movl $0x0, -0x14(%rbp)
cmpl $0x10, -0x14(%rbp)
jge 0x99903f
movslq -0x14(%rbp), %rax
cmpb $0x0, -0xc0(%rbp,%rax)
je 0x999032
movl $0x0, -0x18(%rbp)
cmpl $0x10, -0x18(%rbp)
jge 0x999030
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
shll $0x4, %ecx
addl -0x18(%rbp), %ecx
movslq %ecx, %rcx
cmpb $0x0, 0x80(%rax,%rcx)
je 0x999013
movq -0x8(%rbp), %rdi
movl $0x1, %edx
movl %edx, %esi
callq 0x995a30
jmp 0x999023
movq -0x8(%rbp), %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x995a30
jmp 0x999025
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x998fe1
jmp 0x999032
jmp 0x999034
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x998fc6
movq -0x8(%rbp), %rax
cmpl $0x3, 0x290(%rax)
jl 0x99906e
movq 0x560e6d(%rip), %rax # 0xef9ec0
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x74(%rax), %edx
subl -0x4c(%rbp), %edx
leaq 0x231ef4(%rip), %rsi # 0xbcaf5b
movb $0x0, %al
callq 0x3cd70
movq -0x8(%rbp), %rax
movl 0x74(%rax), %eax
movl %eax, -0x4c(%rbp)
movq -0x8(%rbp), %rdi
movl -0x48(%rbp), %edx
movl $0x3, %esi
callq 0x995a30
movq -0x8(%rbp), %rdi
movl -0x34(%rbp), %edx
movl $0xf, %esi
callq 0x995a30
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x34(%rbp), %eax
jge 0x9990fd
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq -0x8(%rbp), %rcx
movslq -0x14(%rbp), %rdx
movzbl 0x4cfa(%rcx,%rdx), %ecx
cmpl %ecx, %eax
jge 0x9990e2
movq -0x8(%rbp), %rdi
movl $0x1, %edx
movl %edx, %esi
callq 0x995a30
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x9990b0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x995a30
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x9990a1
movq -0x8(%rbp), %rax
cmpl $0x3, 0x290(%rax)
jl 0x99912c
movq 0x560daf(%rip), %rax # 0xef9ec0
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x74(%rax), %edx
subl -0x4c(%rbp), %edx
leaq 0x231e50(%rip), %rsi # 0xbcaf75
movb $0x0, %al
callq 0x3cd70
movq -0x8(%rbp), %rax
movl 0x74(%rax), %eax
movl %eax, -0x4c(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0x48(%rbp), %eax
jge 0x99925e
movq -0x8(%rbp), %rax
addq $0x934c, %rax # imm = 0x934C
movslq -0x10(%rbp), %rcx
imulq $0x102, %rcx, %rcx # imm = 0x102
addq %rcx, %rax
movzbl (%rax), %eax
movl %eax, -0xc4(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc4(%rbp), %edx
movl $0x5, %esi
callq 0x995a30
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x38(%rbp), %eax
jge 0x99924e
jmp 0x999193
movl -0xc4(%rbp), %eax
movq -0x8(%rbp), %rcx
addq $0x934c, %rcx # imm = 0x934C
movslq -0x10(%rbp), %rdx
imulq $0x102, %rdx, %rdx # imm = 0x102
addq %rdx, %rcx
movslq -0x14(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jge 0x9991df
movq -0x8(%rbp), %rdi
movl $0x2, %edx
movl %edx, %esi
callq 0x995a30
movl -0xc4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc4(%rbp)
jmp 0x999193
jmp 0x9991e1
movl -0xc4(%rbp), %eax
movq -0x8(%rbp), %rcx
addq $0x934c, %rcx # imm = 0x934C
movslq -0x10(%rbp), %rdx
imulq $0x102, %rdx, %rdx # imm = 0x102
addq %rdx, %rcx
movslq -0x14(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jle 0x999230
movq -0x8(%rbp), %rdi
movl $0x2, %esi
movl $0x3, %edx
callq 0x995a30
movl -0xc4(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc4(%rbp)
jmp 0x9991e1
movq -0x8(%rbp), %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x995a30
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x999185
jmp 0x999250
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x99913d
movq -0x8(%rbp), %rax
cmpl $0x3, 0x290(%rax)
jl 0x99928d
movq 0x560c4e(%rip), %rax # 0xef9ec0
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x74(%rax), %edx
subl -0x4c(%rbp), %edx
leaq 0x231cfe(%rip), %rsi # 0xbcaf84
movb $0x0, %al
callq 0x3cd70
movq -0x8(%rbp), %rax
movl 0x74(%rax), %eax
movl %eax, -0x4c(%rbp)
movl $0x0, -0x44(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x29c(%rcx), %eax
jl 0x9992b9
jmp 0x99a16b
movl -0x1c(%rbp), %eax
addl $0x32, %eax
subl $0x1, %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x29c(%rcx), %eax
jl 0x9992e4
movq -0x8(%rbp), %rax
movl 0x29c(%rax), %eax
subl $0x1, %eax
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movslq -0x44(%rbp), %rcx
movzbl 0x6a8(%rax,%rcx), %eax
cmpl -0x48(%rbp), %eax
jl 0x999303
movl $0xbbe, %edi # imm = 0xBBE
callq 0x991060
cmpl $0x6, -0x48(%rbp)
jne 0x99a0c6
movl -0x20(%rbp), %ecx
subl -0x1c(%rbp), %ecx
addl $0x1, %ecx
movl $0x32, %eax
cmpl %ecx, %eax
jne 0x99a0c6
movq -0x8(%rbp), %rax
addq $0x934c, %rax # imm = 0x934C
movq -0x8(%rbp), %rcx
movslq -0x44(%rbp), %rdx
movzbl 0x6a8(%rcx,%rdx), %ecx
imulq $0x102, %rcx, %rcx # imm = 0x102
addq %rcx, %rax
movq %rax, -0xd0(%rbp)
movq -0x8(%rbp), %rax
addq $0x9958, %rax # imm = 0x9958
movq -0x8(%rbp), %rcx
movslq -0x44(%rbp), %rdx
movzbl 0x6a8(%rcx,%rdx), %ecx
imulq $0x408, %rcx, %rcx # imm = 0x408
addq %rcx, %rax
movq %rax, -0xd8(%rbp)
movq -0x78(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x0, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0xc6(%rbp)
movq -0x8(%rbp), %rdi
movq -0xd0(%rbp), %rax
movzwl -0xc6(%rbp), %ecx
movzbl (%rax,%rcx), %esi
movq -0xd8(%rbp), %rax
movzwl -0xc6(%rbp), %ecx
movl (%rax,%rcx,4), %edx
callq 0x995a30
movq -0x78(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0xc6(%rbp)
movq -0x8(%rbp), %rdi
movq -0xd0(%rbp), %rax
movzwl -0xc6(%rbp), %ecx
movzbl (%rax,%rcx), %esi
movq -0xd8(%rbp), %rax
movzwl -0xc6(%rbp), %ecx
movl (%rax,%rcx,4), %edx
callq 0x995a30
movq -0x78(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0xc6(%rbp)
movq -0x8(%rbp), %rdi
movq -0xd0(%rbp), %rax
movzwl -0xc6(%rbp), %ecx
movzbl (%rax,%rcx), %esi
movq -0xd8(%rbp), %rax
movzwl -0xc6(%rbp), %ecx
movl (%rax,%rcx,4), %edx
callq 0x995a30
movq -0x78(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x3, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0xc6(%rbp)
movq -0x8(%rbp), %rdi
movq -0xd0(%rbp), %rax
movzwl -0xc6(%rbp), %ecx
movzbl (%rax,%rcx), %esi
movq -0xd8(%rbp), %rax
movzwl -0xc6(%rbp), %ecx
movl (%rax,%rcx,4), %edx
callq 0x995a30
movq -0x78(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x4, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0xc6(%rbp)
movq -0x8(%rbp), %rdi
movq -0xd0(%rbp), %rax
movzwl -0xc6(%rbp), %ecx
movzbl (%rax,%rcx), %esi
movq -0xd8(%rbp), %rax
movzwl -0xc6(%rbp), %ecx
movl (%rax,%rcx,4), %edx
callq 0x995a30
movq -0x78(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x5, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0xc6(%rbp)
movq -0x8(%rbp), %rdi
movq -0xd0(%rbp), %rax
movzwl -0xc6(%rbp), %ecx
movzbl (%rax,%rcx), %esi
movq -0xd8(%rbp), %rax
movzwl -0xc6(%rbp), %ecx
movl (%rax,%rcx,4), %edx
callq 0x995a30
movq -0x78(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x6, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0xc6(%rbp)
movq -0x8(%rbp), %rdi
movq -0xd0(%rbp), %rax
movzwl -0xc6(%rbp), %ecx
movzbl (%rax,%rcx), %esi
movq -0xd8(%rbp), %rax
movzwl -0xc6(%rbp), %ecx
movl (%rax,%rcx,4), %edx
callq 0x995a30
movq -0x78(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x7, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0xc6(%rbp)
movq -0x8(%rbp), %rdi
movq -0xd0(%rbp), %rax
movzwl -0xc6(%rbp), %ecx
movzbl (%rax,%rcx), %esi
movq -0xd8(%rbp), %rax
movzwl -0xc6(%rbp), %ecx
movl (%rax,%rcx,4), %edx
callq 0x995a30
movq -0x78(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x8, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0xc6(%rbp)
movq -0x8(%rbp), %rdi
movq -0xd0(%rbp), %rax
movzwl -0xc6(%rbp), %ecx
movzbl (%rax,%rcx), %esi
movq -0xd8(%rbp), %rax
movzwl -0xc6(%rbp), %ecx
movl (%rax,%rcx,4), %edx
callq 0x995a30
movq -0x78(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x9, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0xc6(%rbp)
movq -0x8(%rbp), %rdi
movq -0xd0(%rbp), %rax
movzwl -0xc6(%rbp), %ecx
movzbl (%rax,%rcx), %esi
movq -0xd8(%rbp), %rax
movzwl -0xc6(%rbp), %ecx
movl (%rax,%rcx,4), %edx
callq 0x995a30
movq -0x78(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0xa, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0xc6(%rbp)
movq -0x8(%rbp), %rdi
movq -0xd0(%rbp), %rax
movzwl -0xc6(%rbp), %ecx
movzbl (%rax,%rcx), %esi
movq -0xd8(%rbp), %rax
movzwl -0xc6(%rbp), %ecx
movl (%rax,%rcx,4), %edx
callq 0x995a30
movq -0x78(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0xb, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0xc6(%rbp)
movq -0x8(%rbp), %rdi
movq -0xd0(%rbp), %rax
movzwl -0xc6(%rbp), %ecx
movzbl (%rax,%rcx), %esi
movq -0xd8(%rbp), %rax
movzwl -0xc6(%rbp), %ecx
movl (%rax,%rcx,4), %edx
callq 0x995a30
movq -0x78(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0xc, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0xc6(%rbp)
movq -0x8(%rbp), %rdi
movq -0xd0(%rbp), %rax
movzwl -0xc6(%rbp), %ecx
movzbl (%rax,%rcx), %esi
movq -0xd8(%rbp), %rax
movzwl -0xc6(%rbp), %ecx
movl (%rax,%rcx,4), %edx
callq 0x995a30
movq -0x78(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0xd, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0xc6(%rbp)
movq -0x8(%rbp), %rdi
movq -0xd0(%rbp), %rax
movzwl -0xc6(%rbp), %ecx
movzbl (%rax,%rcx), %esi
movq -0xd8(%rbp), %rax
movzwl -0xc6(%rbp), %ecx
movl (%rax,%rcx,4), %edx
callq 0x995a30
movq -0x78(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0xe, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0xc6(%rbp)
movq -0x8(%rbp), %rdi
movq -0xd0(%rbp), %rax
movzwl -0xc6(%rbp), %ecx
movzbl (%rax,%rcx), %esi
movq -0xd8(%rbp), %rax
movzwl -0xc6(%rbp), %ecx
movl (%rax,%rcx,4), %edx
callq 0x995a30
movq -0x78(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0xf, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0xc6(%rbp)
movq -0x8(%rbp), %rdi
movq -0xd0(%rbp), %rax
movzwl -0xc6(%rbp), %ecx
movzbl (%rax,%rcx), %esi
movq -0xd8(%rbp), %rax
movzwl -0xc6(%rbp), %ecx
movl (%rax,%rcx,4), %edx
callq 0x995a30
movq -0x78(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x10, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0xc6(%rbp)
movq -0x8(%rbp), %rdi
movq -0xd0(%rbp), %rax
movzwl -0xc6(%rbp), %ecx
movzbl (%rax,%rcx), %esi
movq -0xd8(%rbp), %rax
movzwl -0xc6(%rbp), %ecx
movl (%rax,%rcx,4), %edx
callq 0x995a30
movq -0x78(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x11, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0xc6(%rbp)
movq -0x8(%rbp), %rdi
movq -0xd0(%rbp), %rax
movzwl -0xc6(%rbp), %ecx
movzbl (%rax,%rcx), %esi
movq -0xd8(%rbp), %rax
movzwl -0xc6(%rbp), %ecx
movl (%rax,%rcx,4), %edx
callq 0x995a30
movq -0x78(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x12, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0xc6(%rbp)
movq -0x8(%rbp), %rdi
movq -0xd0(%rbp), %rax
movzwl -0xc6(%rbp), %ecx
movzbl (%rax,%rcx), %esi
movq -0xd8(%rbp), %rax
movzwl -0xc6(%rbp), %ecx
movl (%rax,%rcx,4), %edx
callq 0x995a30
movq -0x78(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x13, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0xc6(%rbp)
movq -0x8(%rbp), %rdi
movq -0xd0(%rbp), %rax
movzwl -0xc6(%rbp), %ecx
movzbl (%rax,%rcx), %esi
movq -0xd8(%rbp), %rax
movzwl -0xc6(%rbp), %ecx
movl (%rax,%rcx,4), %edx
callq 0x995a30
movq -0x78(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x14, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0xc6(%rbp)
movq -0x8(%rbp), %rdi
movq -0xd0(%rbp), %rax
movzwl -0xc6(%rbp), %ecx
movzbl (%rax,%rcx), %esi
movq -0xd8(%rbp), %rax
movzwl -0xc6(%rbp), %ecx
movl (%rax,%rcx,4), %edx
callq 0x995a30
movq -0x78(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x15, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0xc6(%rbp)
movq -0x8(%rbp), %rdi
movq -0xd0(%rbp), %rax
movzwl -0xc6(%rbp), %ecx
movzbl (%rax,%rcx), %esi
movq -0xd8(%rbp), %rax
movzwl -0xc6(%rbp), %ecx
movl (%rax,%rcx,4), %edx
callq 0x995a30
movq -0x78(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x16, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0xc6(%rbp)
movq -0x8(%rbp), %rdi
movq -0xd0(%rbp), %rax
movzwl -0xc6(%rbp), %ecx
movzbl (%rax,%rcx), %esi
movq -0xd8(%rbp), %rax
movzwl -0xc6(%rbp), %ecx
movl (%rax,%rcx,4), %edx
callq 0x995a30
movq -0x78(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x17, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0xc6(%rbp)
movq -0x8(%rbp), %rdi
movq -0xd0(%rbp), %rax
movzwl -0xc6(%rbp), %ecx
movzbl (%rax,%rcx), %esi
movq -0xd8(%rbp), %rax
movzwl -0xc6(%rbp), %ecx
movl (%rax,%rcx,4), %edx
callq 0x995a30
movq -0x78(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x18, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0xc6(%rbp)
movq -0x8(%rbp), %rdi
movq -0xd0(%rbp), %rax
movzwl -0xc6(%rbp), %ecx
movzbl (%rax,%rcx), %esi
movq -0xd8(%rbp), %rax
movzwl -0xc6(%rbp), %ecx
movl (%rax,%rcx,4), %edx
callq 0x995a30
movq -0x78(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x19, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0xc6(%rbp)
movq -0x8(%rbp), %rdi
movq -0xd0(%rbp), %rax
movzwl -0xc6(%rbp), %ecx
movzbl (%rax,%rcx), %esi
movq -0xd8(%rbp), %rax
movzwl -0xc6(%rbp), %ecx
movl (%rax,%rcx,4), %edx
callq 0x995a30
movq -0x78(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x1a, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0xc6(%rbp)
movq -0x8(%rbp), %rdi
movq -0xd0(%rbp), %rax
movzwl -0xc6(%rbp), %ecx
movzbl (%rax,%rcx), %esi
movq -0xd8(%rbp), %rax
movzwl -0xc6(%rbp), %ecx
movl (%rax,%rcx,4), %edx
callq 0x995a30
movq -0x78(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x1b, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0xc6(%rbp)
movq -0x8(%rbp), %rdi
movq -0xd0(%rbp), %rax
movzwl -0xc6(%rbp), %ecx
movzbl (%rax,%rcx), %esi
movq -0xd8(%rbp), %rax
movzwl -0xc6(%rbp), %ecx
movl (%rax,%rcx,4), %edx
callq 0x995a30
movq -0x78(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x1c, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0xc6(%rbp)
movq -0x8(%rbp), %rdi
movq -0xd0(%rbp), %rax
movzwl -0xc6(%rbp), %ecx
movzbl (%rax,%rcx), %esi
movq -0xd8(%rbp), %rax
movzwl -0xc6(%rbp), %ecx
movl (%rax,%rcx,4), %edx
callq 0x995a30
movq -0x78(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x1d, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0xc6(%rbp)
movq -0x8(%rbp), %rdi
movq -0xd0(%rbp), %rax
movzwl -0xc6(%rbp), %ecx
movzbl (%rax,%rcx), %esi
movq -0xd8(%rbp), %rax
movzwl -0xc6(%rbp), %ecx
movl (%rax,%rcx,4), %edx
callq 0x995a30
movq -0x78(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x1e, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0xc6(%rbp)
movq -0x8(%rbp), %rdi
movq -0xd0(%rbp), %rax
movzwl -0xc6(%rbp), %ecx
movzbl (%rax,%rcx), %esi
movq -0xd8(%rbp), %rax
movzwl -0xc6(%rbp), %ecx
movl (%rax,%rcx,4), %edx
callq 0x995a30
movq -0x78(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x1f, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0xc6(%rbp)
movq -0x8(%rbp), %rdi
movq -0xd0(%rbp), %rax
movzwl -0xc6(%rbp), %ecx
movzbl (%rax,%rcx), %esi
movq -0xd8(%rbp), %rax
movzwl -0xc6(%rbp), %ecx
movl (%rax,%rcx,4), %edx
callq 0x995a30
movq -0x78(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x20, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0xc6(%rbp)
movq -0x8(%rbp), %rdi
movq -0xd0(%rbp), %rax
movzwl -0xc6(%rbp), %ecx
movzbl (%rax,%rcx), %esi
movq -0xd8(%rbp), %rax
movzwl -0xc6(%rbp), %ecx
movl (%rax,%rcx,4), %edx
callq 0x995a30
movq -0x78(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x21, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0xc6(%rbp)
movq -0x8(%rbp), %rdi
movq -0xd0(%rbp), %rax
movzwl -0xc6(%rbp), %ecx
movzbl (%rax,%rcx), %esi
movq -0xd8(%rbp), %rax
movzwl -0xc6(%rbp), %ecx
movl (%rax,%rcx,4), %edx
callq 0x995a30
movq -0x78(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x22, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0xc6(%rbp)
movq -0x8(%rbp), %rdi
movq -0xd0(%rbp), %rax
movzwl -0xc6(%rbp), %ecx
movzbl (%rax,%rcx), %esi
movq -0xd8(%rbp), %rax
movzwl -0xc6(%rbp), %ecx
movl (%rax,%rcx,4), %edx
callq 0x995a30
movq -0x78(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x23, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0xc6(%rbp)
movq -0x8(%rbp), %rdi
movq -0xd0(%rbp), %rax
movzwl -0xc6(%rbp), %ecx
movzbl (%rax,%rcx), %esi
movq -0xd8(%rbp), %rax
movzwl -0xc6(%rbp), %ecx
movl (%rax,%rcx,4), %edx
callq 0x995a30
movq -0x78(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x24, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0xc6(%rbp)
movq -0x8(%rbp), %rdi
movq -0xd0(%rbp), %rax
movzwl -0xc6(%rbp), %ecx
movzbl (%rax,%rcx), %esi
movq -0xd8(%rbp), %rax
movzwl -0xc6(%rbp), %ecx
movl (%rax,%rcx,4), %edx
callq 0x995a30
movq -0x78(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x25, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0xc6(%rbp)
movq -0x8(%rbp), %rdi
movq -0xd0(%rbp), %rax
movzwl -0xc6(%rbp), %ecx
movzbl (%rax,%rcx), %esi
movq -0xd8(%rbp), %rax
movzwl -0xc6(%rbp), %ecx
movl (%rax,%rcx,4), %edx
callq 0x995a30
movq -0x78(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x26, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0xc6(%rbp)
movq -0x8(%rbp), %rdi
movq -0xd0(%rbp), %rax
movzwl -0xc6(%rbp), %ecx
movzbl (%rax,%rcx), %esi
movq -0xd8(%rbp), %rax
movzwl -0xc6(%rbp), %ecx
movl (%rax,%rcx,4), %edx
callq 0x995a30
movq -0x78(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x27, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0xc6(%rbp)
movq -0x8(%rbp), %rdi
movq -0xd0(%rbp), %rax
movzwl -0xc6(%rbp), %ecx
movzbl (%rax,%rcx), %esi
movq -0xd8(%rbp), %rax
movzwl -0xc6(%rbp), %ecx
movl (%rax,%rcx,4), %edx
callq 0x995a30
movq -0x78(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x28, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0xc6(%rbp)
movq -0x8(%rbp), %rdi
movq -0xd0(%rbp), %rax
movzwl -0xc6(%rbp), %ecx
movzbl (%rax,%rcx), %esi
movq -0xd8(%rbp), %rax
movzwl -0xc6(%rbp), %ecx
movl (%rax,%rcx,4), %edx
callq 0x995a30
movq -0x78(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x29, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0xc6(%rbp)
movq -0x8(%rbp), %rdi
movq -0xd0(%rbp), %rax
movzwl -0xc6(%rbp), %ecx
movzbl (%rax,%rcx), %esi
movq -0xd8(%rbp), %rax
movzwl -0xc6(%rbp), %ecx
movl (%rax,%rcx,4), %edx
callq 0x995a30
movq -0x78(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x2a, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0xc6(%rbp)
movq -0x8(%rbp), %rdi
movq -0xd0(%rbp), %rax
movzwl -0xc6(%rbp), %ecx
movzbl (%rax,%rcx), %esi
movq -0xd8(%rbp), %rax
movzwl -0xc6(%rbp), %ecx
movl (%rax,%rcx,4), %edx
callq 0x995a30
movq -0x78(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x2b, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0xc6(%rbp)
movq -0x8(%rbp), %rdi
movq -0xd0(%rbp), %rax
movzwl -0xc6(%rbp), %ecx
movzbl (%rax,%rcx), %esi
movq -0xd8(%rbp), %rax
movzwl -0xc6(%rbp), %ecx
movl (%rax,%rcx,4), %edx
callq 0x995a30
movq -0x78(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x2c, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0xc6(%rbp)
movq -0x8(%rbp), %rdi
movq -0xd0(%rbp), %rax
movzwl -0xc6(%rbp), %ecx
movzbl (%rax,%rcx), %esi
movq -0xd8(%rbp), %rax
movzwl -0xc6(%rbp), %ecx
movl (%rax,%rcx,4), %edx
callq 0x995a30
movq -0x78(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x2d, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0xc6(%rbp)
movq -0x8(%rbp), %rdi
movq -0xd0(%rbp), %rax
movzwl -0xc6(%rbp), %ecx
movzbl (%rax,%rcx), %esi
movq -0xd8(%rbp), %rax
movzwl -0xc6(%rbp), %ecx
movl (%rax,%rcx,4), %edx
callq 0x995a30
movq -0x78(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x2e, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0xc6(%rbp)
movq -0x8(%rbp), %rdi
movq -0xd0(%rbp), %rax
movzwl -0xc6(%rbp), %ecx
movzbl (%rax,%rcx), %esi
movq -0xd8(%rbp), %rax
movzwl -0xc6(%rbp), %ecx
movl (%rax,%rcx,4), %edx
callq 0x995a30
movq -0x78(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x2f, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0xc6(%rbp)
movq -0x8(%rbp), %rdi
movq -0xd0(%rbp), %rax
movzwl -0xc6(%rbp), %ecx
movzbl (%rax,%rcx), %esi
movq -0xd8(%rbp), %rax
movzwl -0xc6(%rbp), %ecx
movl (%rax,%rcx,4), %edx
callq 0x995a30
movq -0x78(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x30, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0xc6(%rbp)
movq -0x8(%rbp), %rdi
movq -0xd0(%rbp), %rax
movzwl -0xc6(%rbp), %ecx
movzbl (%rax,%rcx), %esi
movq -0xd8(%rbp), %rax
movzwl -0xc6(%rbp), %ecx
movl (%rax,%rcx,4), %edx
callq 0x995a30
movq -0x78(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x31, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0xc6(%rbp)
movq -0x8(%rbp), %rdi
movq -0xd0(%rbp), %rax
movzwl -0xc6(%rbp), %ecx
movzbl (%rax,%rcx), %esi
movq -0xd8(%rbp), %rax
movzwl -0xc6(%rbp), %ecx
movl (%rax,%rcx,4), %edx
callq 0x995a30
jmp 0x99a154
movl -0x1c(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x20(%rbp), %eax
jg 0x99a152
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
addq $0x934c, %rax # imm = 0x934C
movq -0x8(%rbp), %rcx
movslq -0x44(%rbp), %rdx
movzbl 0x6a8(%rcx,%rdx), %ecx
imulq $0x102, %rcx, %rcx # imm = 0x102
addq %rcx, %rax
movq -0x78(%rbp), %rcx
movslq -0x14(%rbp), %rdx
movzwl (%rcx,%rdx,2), %ecx
movzbl (%rax,%rcx), %esi
movq -0x8(%rbp), %rax
addq $0x9958, %rax # imm = 0x9958
movq -0x8(%rbp), %rcx
movslq -0x44(%rbp), %rdx
movzbl 0x6a8(%rcx,%rdx), %ecx
imulq $0x408, %rcx, %rcx # imm = 0x408
addq %rcx, %rax
movq -0x78(%rbp), %rcx
movslq -0x14(%rbp), %rdx
movzwl (%rcx,%rdx,2), %ecx
movl (%rax,%rcx,4), %edx
callq 0x995a30
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x99a0cc
jmp 0x99a154
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x9992a5
movl -0x44(%rbp), %eax
cmpl -0x34(%rbp), %eax
je 0x99a17d
movl $0xbbf, %edi # imm = 0xBBF
callq 0x991060
movq -0x8(%rbp), %rax
cmpl $0x3, 0x290(%rax)
jl 0x99a1ac
movq 0x55fd2f(%rip), %rax # 0xef9ec0
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x74(%rax), %edx
subl -0x4c(%rbp), %edx
leaq 0x230df1(%rip), %rsi # 0xbcaf96
movb $0x0, %al
callq 0x3cd70
addq $0xe0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmbzip2/compress.c
|
makeMaps_e
|
static
void makeMaps_e ( EState* s )
{
Int32 i;
s->nInUse = 0;
for (i = 0; i < 256; i++)
if (s->inUse[i]) {
s->unseqToSeq[i] = s->nInUse;
s->nInUse++;
}
}
|
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0x7c(%rax)
movl $0x0, -0xc(%rbp)
cmpl $0x100, -0xc(%rbp) # imm = 0x100
jge 0x99a297
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
cmpb $0x0, 0x80(%rax,%rcx)
je 0x99a28a
movq -0x8(%rbp), %rax
movl 0x7c(%rax), %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movb %dl, 0x180(%rax,%rcx)
movq -0x8(%rbp), %rax
movl 0x7c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x7c(%rax)
jmp 0x99a28c
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x99a24a
popq %rbp
retq
nopl (%rax)
|
/JKorbelRA[P]CMake/Utilities/cmbzip2/compress.c
|
fallbackSort
|
static
void fallbackSort ( UInt32* fmap,
UInt32* eclass,
UInt32* bhtab,
Int32 nblock,
Int32 verb )
{
Int32 ftab[257];
Int32 ftabCopy[256];
Int32 H, i, j, k, l, r, cc, cc1;
Int32 nNotDone;
Int32 nBhtab;
UChar* eclass8 = (UChar*)eclass;
/*--
Initial 1-char radix sort to generate
initial fmap and initial BH bits.
--*/
if (verb >= 4)
VPrintf0 ( " bucket sorting ...\n" );
for (i = 0; i < 257; i++) ftab[i] = 0;
for (i = 0; i < nblock; i++) ftab[eclass8[i]]++;
for (i = 0; i < 256; i++) ftabCopy[i] = ftab[i];
for (i = 1; i < 257; i++) ftab[i] += ftab[i-1];
for (i = 0; i < nblock; i++) {
j = eclass8[i];
k = ftab[j] - 1;
ftab[j] = k;
fmap[k] = i;
}
nBhtab = 2 + (nblock / 32);
for (i = 0; i < nBhtab; i++) bhtab[i] = 0;
for (i = 0; i < 256; i++) SET_BH(ftab[i]);
/*--
Inductively refine the buckets. Kind-of an
"exponential radix sort" (!), inspired by the
Manber-Myers suffix array construction algorithm.
--*/
/*-- set sentinel bits for block-end detection --*/
for (i = 0; i < 32; i++) {
SET_BH(nblock + 2*i);
CLEAR_BH(nblock + 2*i + 1);
}
/*-- the log(N) loop --*/
H = 1;
while (1) {
if (verb >= 4)
VPrintf1 ( " depth %6d has ", H );
j = 0;
for (i = 0; i < nblock; i++) {
if (ISSET_BH(i)) j = i;
k = fmap[i] - H; if (k < 0) k += nblock;
eclass[k] = j;
}
nNotDone = 0;
r = -1;
while (1) {
/*-- find the next non-singleton bucket --*/
k = r + 1;
while (ISSET_BH(k) && UNALIGNED_BH(k)) k++;
if (ISSET_BH(k)) {
while (WORD_BH(k) == 0xffffffff) k += 32;
while (ISSET_BH(k)) k++;
}
l = k - 1;
if (l >= nblock) break;
while (!ISSET_BH(k) && UNALIGNED_BH(k)) k++;
if (!ISSET_BH(k)) {
while (WORD_BH(k) == 0x00000000) k += 32;
while (!ISSET_BH(k)) k++;
}
r = k - 1;
if (r >= nblock) break;
/*-- now [l, r] bracket current bucket --*/
if (r > l) {
nNotDone += (r - l + 1);
fallbackQSort3 ( fmap, eclass, l, r );
/*-- scan bucket and generate header bits-- */
cc = -1;
for (i = l; i <= r; i++) {
cc1 = eclass[fmap[i]];
if (cc != cc1) { SET_BH(i); cc = cc1; };
}
}
}
if (verb >= 4)
VPrintf1 ( "%6d unresolved strings\n", nNotDone );
H *= 2;
if (H > nblock || nNotDone == 0) break;
}
/*--
Reconstruct the original block in
eclass8 [0 .. nblock-1], since the
previous phase destroyed it.
--*/
if (verb >= 4)
VPrintf0 ( " reconstructing block ...\n" );
j = 0;
for (i = 0; i < nblock; i++) {
while (ftabCopy[j] == 0) j++;
ftabCopy[j]--;
eclass8[fmap[i]] = (UChar)j;
}
AssertH ( j < 256, 1005 );
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x870, %rsp # imm = 0x870
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x860(%rbp)
cmpl $0x4, -0x20(%rbp)
jl 0x99ec57
movq 0x55b27a(%rip), %rax # 0xef9ec0
movq (%rax), %rdi
leaq 0x22c46b(%rip), %rsi # 0xbcb0bb
movb $0x0, %al
callq 0x3cd70
movl $0x0, -0x838(%rbp)
cmpl $0x101, -0x838(%rbp) # imm = 0x101
jge 0x99ec90
movslq -0x838(%rbp), %rax
movl $0x0, -0x430(%rbp,%rax,4)
movl -0x838(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x838(%rbp)
jmp 0x99ec61
movl $0x0, -0x838(%rbp)
movl -0x838(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x99ecd9
movq -0x860(%rbp), %rax
movslq -0x838(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl -0x430(%rbp,%rax,4), %ecx
addl $0x1, %ecx
movl %ecx, -0x430(%rbp,%rax,4)
movl -0x838(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x838(%rbp)
jmp 0x99ec9a
movl $0x0, -0x838(%rbp)
cmpl $0x100, -0x838(%rbp) # imm = 0x100
jge 0x99ed1c
movslq -0x838(%rbp), %rax
movl -0x430(%rbp,%rax,4), %ecx
movslq -0x838(%rbp), %rax
movl %ecx, -0x830(%rbp,%rax,4)
movl -0x838(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x838(%rbp)
jmp 0x99ece3
movl $0x1, -0x838(%rbp)
cmpl $0x101, -0x838(%rbp) # imm = 0x101
jge 0x99ed6a
movl -0x838(%rbp), %eax
subl $0x1, %eax
cltq
movl -0x430(%rbp,%rax,4), %ecx
movslq -0x838(%rbp), %rax
addl -0x430(%rbp,%rax,4), %ecx
movl %ecx, -0x430(%rbp,%rax,4)
movl -0x838(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x838(%rbp)
jmp 0x99ed26
movl $0x0, -0x838(%rbp)
movl -0x838(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x99ede7
movq -0x860(%rbp), %rax
movslq -0x838(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0x83c(%rbp)
movslq -0x83c(%rbp), %rax
movl -0x430(%rbp,%rax,4), %eax
subl $0x1, %eax
movl %eax, -0x840(%rbp)
movl -0x840(%rbp), %ecx
movslq -0x83c(%rbp), %rax
movl %ecx, -0x430(%rbp,%rax,4)
movl -0x838(%rbp), %edx
movq -0x8(%rbp), %rax
movslq -0x840(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x838(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x838(%rbp)
jmp 0x99ed74
movl -0x1c(%rbp), %eax
movl $0x20, %ecx
cltd
idivl %ecx
addl $0x2, %eax
movl %eax, -0x858(%rbp)
movl $0x0, -0x838(%rbp)
movl -0x838(%rbp), %eax
cmpl -0x858(%rbp), %eax
jge 0x99ee36
movq -0x18(%rbp), %rax
movslq -0x838(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
movl -0x838(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x838(%rbp)
jmp 0x99ee05
movl $0x0, -0x838(%rbp)
cmpl $0x100, -0x838(%rbp) # imm = 0x100
jge 0x99ee93
movslq -0x838(%rbp), %rax
movl -0x430(%rbp,%rax,4), %ecx
andl $0x1f, %ecx
movl $0x1, %edx
shll %cl, %edx
movq -0x18(%rbp), %rax
movslq -0x838(%rbp), %rcx
movl -0x430(%rbp,%rcx,4), %ecx
sarl $0x5, %ecx
movslq %ecx, %rcx
orl (%rax,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
movl -0x838(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x838(%rbp)
jmp 0x99ee40
movl $0x0, -0x838(%rbp)
cmpl $0x20, -0x838(%rbp)
jge 0x99ef2f
movl -0x1c(%rbp), %ecx
movl -0x838(%rbp), %eax
shll %eax
addl %eax, %ecx
andl $0x1f, %ecx
movl $0x1, %edx
shll %cl, %edx
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl -0x838(%rbp), %esi
shll %esi
addl %esi, %ecx
sarl $0x5, %ecx
movslq %ecx, %rcx
orl (%rax,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
movl -0x1c(%rbp), %ecx
movl -0x838(%rbp), %eax
shll %eax
addl %eax, %ecx
addl $0x1, %ecx
andl $0x1f, %ecx
movl $0x1, %edx
shll %cl, %edx
xorl $-0x1, %edx
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl -0x838(%rbp), %esi
shll %esi
addl %esi, %ecx
addl $0x1, %ecx
sarl $0x5, %ecx
movslq %ecx, %rcx
andl (%rax,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
movl -0x838(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x838(%rbp)
jmp 0x99ee9d
movl $0x1, -0x834(%rbp)
cmpl $0x4, -0x20(%rbp)
jl 0x99ef5d
movq 0x55af7a(%rip), %rax # 0xef9ec0
movq (%rax), %rdi
movl -0x834(%rbp), %edx
leaq 0x22c181(%rip), %rsi # 0xbcb0d7
movb $0x0, %al
callq 0x3cd70
movl $0x0, -0x83c(%rbp)
movl $0x0, -0x838(%rbp)
movl -0x838(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x99f012
movq -0x18(%rbp), %rax
movl -0x838(%rbp), %ecx
sarl $0x5, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movl -0x838(%rbp), %ecx
andl $0x1f, %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0x99efb8
movl -0x838(%rbp), %eax
movl %eax, -0x83c(%rbp)
movq -0x8(%rbp), %rax
movslq -0x838(%rbp), %rcx
movl (%rax,%rcx,4), %eax
subl -0x834(%rbp), %eax
movl %eax, -0x840(%rbp)
cmpl $0x0, -0x840(%rbp)
jge 0x99efea
movl -0x1c(%rbp), %eax
addl -0x840(%rbp), %eax
movl %eax, -0x840(%rbp)
movl -0x83c(%rbp), %edx
movq -0x10(%rbp), %rax
movslq -0x840(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x838(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x838(%rbp)
jmp 0x99ef71
movl $0x0, -0x854(%rbp)
movl $0xffffffff, -0x848(%rbp) # imm = 0xFFFFFFFF
movl -0x848(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x840(%rbp)
movq -0x18(%rbp), %rax
movl -0x840(%rbp), %ecx
sarl $0x5, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x868(%rbp)
movl -0x840(%rbp), %ecx
andl $0x1f, %ecx
movl $0x1, %eax
shll %cl, %eax
movl -0x868(%rbp), %ecx
andl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x861(%rbp)
je 0x99f088
movl -0x840(%rbp), %eax
andl $0x1f, %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x861(%rbp)
movb -0x861(%rbp), %al
testb $0x1, %al
jne 0x99f094
jmp 0x99f0a5
movl -0x840(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x840(%rbp)
jmp 0x99f035
movq -0x18(%rbp), %rax
movl -0x840(%rbp), %ecx
sarl $0x5, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movl -0x840(%rbp), %ecx
andl $0x1f, %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0x99f13b
jmp 0x99f0d3
movq -0x18(%rbp), %rax
movl -0x840(%rbp), %ecx
sarl $0x5, %ecx
movslq %ecx, %rcx
cmpl $-0x1, (%rax,%rcx,4)
jne 0x99f0fa
movl -0x840(%rbp), %eax
addl $0x20, %eax
movl %eax, -0x840(%rbp)
jmp 0x99f0d3
jmp 0x99f0fc
movq -0x18(%rbp), %rax
movl -0x840(%rbp), %ecx
sarl $0x5, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movl -0x840(%rbp), %ecx
andl $0x1f, %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0x99f139
movl -0x840(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x840(%rbp)
jmp 0x99f0fc
jmp 0x99f13b
movl -0x840(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x844(%rbp)
movl -0x844(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jl 0x99f15a
jmp 0x99f369
jmp 0x99f15c
movq -0x18(%rbp), %rax
movl -0x840(%rbp), %ecx
sarl $0x5, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x870(%rbp)
movl -0x840(%rbp), %ecx
andl $0x1f, %ecx
movl $0x1, %eax
shll %cl, %eax
movl -0x870(%rbp), %ecx
andl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x869(%rbp)
jne 0x99f1af
movl -0x840(%rbp), %eax
andl $0x1f, %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x869(%rbp)
movb -0x869(%rbp), %al
testb $0x1, %al
jne 0x99f1bb
jmp 0x99f1cc
movl -0x840(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x840(%rbp)
jmp 0x99f15c
movq -0x18(%rbp), %rax
movl -0x840(%rbp), %ecx
sarl $0x5, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movl -0x840(%rbp), %ecx
andl $0x1f, %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
jne 0x99f26b
jmp 0x99f1fa
movq -0x18(%rbp), %rax
movl -0x840(%rbp), %ecx
sarl $0x5, %ecx
movslq %ecx, %rcx
cmpl $0x0, (%rax,%rcx,4)
jne 0x99f221
movl -0x840(%rbp), %eax
addl $0x20, %eax
movl %eax, -0x840(%rbp)
jmp 0x99f1fa
jmp 0x99f223
movq -0x18(%rbp), %rax
movl -0x840(%rbp), %ecx
sarl $0x5, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movl -0x840(%rbp), %ecx
andl $0x1f, %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x99f258
jmp 0x99f269
movl -0x840(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x840(%rbp)
jmp 0x99f223
jmp 0x99f26b
movl -0x840(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x848(%rbp)
movl -0x848(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jl 0x99f28a
jmp 0x99f369
movl -0x848(%rbp), %eax
cmpl -0x844(%rbp), %eax
jle 0x99f364
movl -0x848(%rbp), %eax
subl -0x844(%rbp), %eax
addl $0x1, %eax
addl -0x854(%rbp), %eax
movl %eax, -0x854(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x844(%rbp), %edx
movl -0x848(%rbp), %ecx
callq 0x99ffe0
movl $0xffffffff, -0x84c(%rbp) # imm = 0xFFFFFFFF
movl -0x844(%rbp), %eax
movl %eax, -0x838(%rbp)
movl -0x838(%rbp), %eax
cmpl -0x848(%rbp), %eax
jg 0x99f362
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq -0x838(%rbp), %rdx
movl (%rcx,%rdx,4), %ecx
movl (%rax,%rcx,4), %eax
movl %eax, -0x850(%rbp)
movl -0x84c(%rbp), %eax
cmpl -0x850(%rbp), %eax
je 0x99f34f
movl -0x838(%rbp), %ecx
andl $0x1f, %ecx
movl $0x1, %edx
shll %cl, %edx
movq -0x18(%rbp), %rax
movl -0x838(%rbp), %ecx
sarl $0x5, %ecx
movslq %ecx, %rcx
orl (%rax,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
movl -0x850(%rbp), %eax
movl %eax, -0x84c(%rbp)
jmp 0x99f351
movl -0x838(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x838(%rbp)
jmp 0x99f2e6
jmp 0x99f364
jmp 0x99f026
cmpl $0x4, -0x20(%rbp)
jl 0x99f38d
movq 0x55ab4a(%rip), %rax # 0xef9ec0
movq (%rax), %rdi
movl -0x854(%rbp), %edx
leaq 0x22bd68(%rip), %rsi # 0xbcb0ee
movb $0x0, %al
callq 0x3cd70
movl -0x834(%rbp), %eax
shll %eax
movl %eax, -0x834(%rbp)
movl -0x834(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jg 0x99f3af
cmpl $0x0, -0x854(%rbp)
jne 0x99f3b1
jmp 0x99f3b6
jmp 0x99ef39
cmpl $0x4, -0x20(%rbp)
jl 0x99f3d4
movq 0x55aafd(%rip), %rax # 0xef9ec0
movq (%rax), %rdi
leaq 0x22bd39(%rip), %rsi # 0xbcb106
movb $0x0, %al
callq 0x3cd70
movl $0x0, -0x83c(%rbp)
movl $0x0, -0x838(%rbp)
movl -0x838(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x99f460
jmp 0x99f3f5
movslq -0x83c(%rbp), %rax
cmpl $0x0, -0x830(%rbp,%rax,4)
jne 0x99f417
movl -0x83c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x83c(%rbp)
jmp 0x99f3f5
movslq -0x83c(%rbp), %rax
movl -0x830(%rbp,%rax,4), %ecx
addl $-0x1, %ecx
movl %ecx, -0x830(%rbp,%rax,4)
movl -0x83c(%rbp), %eax
movb %al, %dl
movq -0x860(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq -0x838(%rbp), %rsi
movl (%rcx,%rsi,4), %ecx
movb %dl, (%rax,%rcx)
movl -0x838(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x838(%rbp)
jmp 0x99f3e8
cmpl $0x100, -0x83c(%rbp) # imm = 0x100
jl 0x99f476
movl $0x3ed, %edi # imm = 0x3ED
callq 0x991060
addq $0x870, %rsp # imm = 0x870
popq %rbp
retq
nop
|
/JKorbelRA[P]CMake/Utilities/cmbzip2/blocksort.c
|
fallbackQSort3
|
static
void fallbackQSort3 ( UInt32* fmap,
UInt32* eclass,
Int32 loSt,
Int32 hiSt )
{
Int32 unLo, unHi, ltLo, gtHi, n, m;
Int32 sp, lo, hi;
UInt32 med, r, r3;
Int32 stackLo[FALLBACK_QSORT_STACK_SIZE];
Int32 stackHi[FALLBACK_QSORT_STACK_SIZE];
r = 0;
sp = 0;
fpush ( loSt, hiSt );
while (sp > 0) {
AssertH ( sp < FALLBACK_QSORT_STACK_SIZE - 1, 1004 );
fpop ( lo, hi );
if (hi - lo < FALLBACK_QSORT_SMALL_THRESH) {
fallbackSimpleSort ( fmap, eclass, lo, hi );
continue;
}
/* Random partitioning. Median of 3 sometimes fails to
avoid bad cases. Median of 9 seems to help but
looks rather expensive. This too seems to work but
is cheaper. Guidance for the magic constants
7621 and 32768 is taken from Sedgewick's algorithms
book, chapter 35.
*/
r = ((r * 7621) + 1) % 32768;
r3 = r % 3;
if (r3 == 0) med = eclass[fmap[lo]]; else
if (r3 == 1) med = eclass[fmap[(lo+hi)>>1]]; else
med = eclass[fmap[hi]];
unLo = ltLo = lo;
unHi = gtHi = hi;
while (1) {
while (1) {
if (unLo > unHi) break;
n = (Int32)eclass[fmap[unLo]] - (Int32)med;
if (n == 0) {
fswap(fmap[unLo], fmap[ltLo]);
ltLo++; unLo++;
continue;
};
if (n > 0) break;
unLo++;
}
while (1) {
if (unLo > unHi) break;
n = (Int32)eclass[fmap[unHi]] - (Int32)med;
if (n == 0) {
fswap(fmap[unHi], fmap[gtHi]);
gtHi--; unHi--;
continue;
};
if (n < 0) break;
unHi--;
}
if (unLo > unHi) break;
fswap(fmap[unLo], fmap[unHi]); unLo++; unHi--;
}
AssertD ( unHi == unLo-1, "fallbackQSort3(2)" );
if (gtHi < ltLo) continue;
n = fmin(ltLo-lo, unLo-ltLo); fvswap(lo, unLo-n, n);
m = fmin(hi-gtHi, gtHi-unHi); fvswap(unLo, hi-m+1, m);
n = lo + unLo - ltLo - 1;
m = hi - (gtHi - unHi) + 1;
if (n - lo > hi - m) {
fpush ( lo, n );
fpush ( m, hi );
} else {
fpush ( m, hi );
fpush ( lo, n );
}
}
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x3b0, %rsp # imm = 0x3B0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl $0x0, -0x44(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x14(%rbp), %ecx
movslq -0x34(%rbp), %rax
movl %ecx, -0x1e0(%rbp,%rax,4)
movl -0x18(%rbp), %ecx
movslq -0x34(%rbp), %rax
movl %ecx, -0x370(%rbp,%rax,4)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jle 0x9a0502
cmpl $0x63, -0x34(%rbp)
jl 0x9a0046
movl $0x3ec, %edi # imm = 0x3EC
callq 0x991060
movl -0x34(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x34(%rbp)
movslq -0x34(%rbp), %rax
movl -0x1e0(%rbp,%rax,4), %eax
movl %eax, -0x38(%rbp)
movslq -0x34(%rbp), %rax
movl -0x370(%rbp,%rax,4), %eax
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
subl -0x38(%rbp), %eax
cmpl $0xa, %eax
jge 0x9a008b
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x38(%rbp), %edx
movl -0x3c(%rbp), %ecx
callq 0x9a0510
jmp 0x9a002c
imull $0x1dc5, -0x44(%rbp), %eax # imm = 0x1DC5
addl $0x1, %eax
andl $0x7fff, %eax # imm = 0x7FFF
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %eax
movl $0x3, %ecx
xorl %edx, %edx
divl %ecx
movl %edx, -0x48(%rbp)
cmpl $0x0, -0x48(%rbp)
jne 0x9a00c9
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq -0x38(%rbp), %rdx
movl (%rcx,%rdx,4), %ecx
movl (%rax,%rcx,4), %eax
movl %eax, -0x40(%rbp)
jmp 0x9a0104
cmpl $0x1, -0x48(%rbp)
jne 0x9a00ed
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movl -0x38(%rbp), %edx
addl -0x3c(%rbp), %edx
sarl %edx
movslq %edx, %rdx
movl (%rcx,%rdx,4), %ecx
movl (%rax,%rcx,4), %eax
movl %eax, -0x40(%rbp)
jmp 0x9a0102
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq -0x3c(%rbp), %rdx
movl (%rcx,%rdx,4), %ecx
movl (%rax,%rcx,4), %eax
movl %eax, -0x40(%rbp)
jmp 0x9a0104
movl -0x38(%rbp), %eax
movl %eax, -0x24(%rbp)
movl %eax, -0x1c(%rbp)
movl -0x3c(%rbp), %eax
movl %eax, -0x28(%rbp)
movl %eax, -0x20(%rbp)
jmp 0x9a0118
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jle 0x9a0125
jmp 0x9a01a5
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
movl (%rcx,%rdx,4), %ecx
movl (%rax,%rcx,4), %eax
subl -0x40(%rbp), %eax
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jne 0x9a018f
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x374(%rbp)
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x374(%rbp), %edx
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x9a0118
cmpl $0x0, -0x2c(%rbp)
jle 0x9a0197
jmp 0x9a01a5
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x9a0118
jmp 0x9a01a7
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jle 0x9a01b4
jmp 0x9a0234
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq -0x20(%rbp), %rdx
movl (%rcx,%rdx,4), %ecx
movl (%rax,%rcx,4), %eax
subl -0x40(%rbp), %eax
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jne 0x9a021e
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x378(%rbp)
movq -0x8(%rbp), %rax
movslq -0x28(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x378(%rbp), %edx
movq -0x8(%rbp), %rax
movslq -0x28(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x28(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x28(%rbp)
movl -0x20(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x9a01a7
cmpl $0x0, -0x2c(%rbp)
jge 0x9a0226
jmp 0x9a0234
movl -0x20(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x9a01a7
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jle 0x9a023e
jmp 0x9a028d
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x37c(%rbp)
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x37c(%rbp), %edx
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl -0x20(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x9a0116
movl -0x28(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x9a029a
jmp 0x9a002c
movl -0x24(%rbp), %eax
subl -0x38(%rbp), %eax
movl -0x1c(%rbp), %ecx
subl -0x24(%rbp), %ecx
cmpl %ecx, %eax
jge 0x9a02b8
movl -0x24(%rbp), %eax
subl -0x38(%rbp), %eax
movl %eax, -0x3a0(%rbp)
jmp 0x9a02c4
movl -0x1c(%rbp), %eax
subl -0x24(%rbp), %eax
movl %eax, -0x3a0(%rbp)
movl -0x3a0(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x38(%rbp), %eax
movl %eax, -0x380(%rbp)
movl -0x1c(%rbp), %eax
subl -0x2c(%rbp), %eax
movl %eax, -0x384(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x388(%rbp)
cmpl $0x0, -0x388(%rbp)
jle 0x9a0367
movq -0x8(%rbp), %rax
movslq -0x380(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x38c(%rbp)
movq -0x8(%rbp), %rax
movslq -0x384(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq -0x8(%rbp), %rax
movslq -0x380(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x38c(%rbp), %edx
movq -0x8(%rbp), %rax
movslq -0x384(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x380(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x380(%rbp)
movl -0x384(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x384(%rbp)
movl -0x388(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x388(%rbp)
jmp 0x9a02eb
movl -0x3c(%rbp), %eax
subl -0x28(%rbp), %eax
movl -0x28(%rbp), %ecx
subl -0x20(%rbp), %ecx
cmpl %ecx, %eax
jge 0x9a0385
movl -0x3c(%rbp), %eax
subl -0x28(%rbp), %eax
movl %eax, -0x3a4(%rbp)
jmp 0x9a0391
movl -0x28(%rbp), %eax
subl -0x20(%rbp), %eax
movl %eax, -0x3a4(%rbp)
movl -0x3a4(%rbp), %eax
movl %eax, -0x30(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x390(%rbp)
movl -0x3c(%rbp), %eax
subl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x394(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x398(%rbp)
cmpl $0x0, -0x398(%rbp)
jle 0x9a0437
movq -0x8(%rbp), %rax
movslq -0x390(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x39c(%rbp)
movq -0x8(%rbp), %rax
movslq -0x394(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq -0x8(%rbp), %rax
movslq -0x390(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x39c(%rbp), %edx
movq -0x8(%rbp), %rax
movslq -0x394(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x390(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x390(%rbp)
movl -0x394(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x394(%rbp)
movl -0x398(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x398(%rbp)
jmp 0x9a03bb
movl -0x38(%rbp), %eax
addl -0x1c(%rbp), %eax
subl -0x24(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x2c(%rbp)
movl -0x3c(%rbp), %eax
movl -0x28(%rbp), %ecx
subl -0x20(%rbp), %ecx
subl %ecx, %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
movl -0x2c(%rbp), %eax
subl -0x38(%rbp), %eax
movl -0x3c(%rbp), %ecx
subl -0x30(%rbp), %ecx
cmpl %ecx, %eax
jle 0x9a04b3
movl -0x38(%rbp), %ecx
movslq -0x34(%rbp), %rax
movl %ecx, -0x1e0(%rbp,%rax,4)
movl -0x2c(%rbp), %ecx
movslq -0x34(%rbp), %rax
movl %ecx, -0x370(%rbp,%rax,4)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
movl -0x30(%rbp), %ecx
movslq -0x34(%rbp), %rax
movl %ecx, -0x1e0(%rbp,%rax,4)
movl -0x3c(%rbp), %ecx
movslq -0x34(%rbp), %rax
movl %ecx, -0x370(%rbp,%rax,4)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x9a04fd
movl -0x30(%rbp), %ecx
movslq -0x34(%rbp), %rax
movl %ecx, -0x1e0(%rbp,%rax,4)
movl -0x3c(%rbp), %ecx
movslq -0x34(%rbp), %rax
movl %ecx, -0x370(%rbp,%rax,4)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
movl -0x38(%rbp), %ecx
movslq -0x34(%rbp), %rax
movl %ecx, -0x1e0(%rbp,%rax,4)
movl -0x2c(%rbp), %ecx
movslq -0x34(%rbp), %rax
movl %ecx, -0x370(%rbp,%rax,4)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x9a002c
addq $0x3b0, %rsp # imm = 0x3B0
popq %rbp
retq
nopl (%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmbzip2/blocksort.c
|
BZ2_hbMakeCodeLengths
|
void BZ2_hbMakeCodeLengths ( UChar *len,
Int32 *freq,
Int32 alphaSize,
Int32 maxLen )
{
/*--
Nodes and heap entries run from 1. Entry 0
for both the heap and nodes is a sentinel.
--*/
Int32 nNodes, nHeap, n1, n2, i, j, k;
Bool tooLong;
Int32 heap [ BZ_MAX_ALPHA_SIZE + 2 ];
Int32 weight [ BZ_MAX_ALPHA_SIZE * 2 ];
Int32 parent [ BZ_MAX_ALPHA_SIZE * 2 ];
for (i = 0; i < alphaSize; i++)
weight[i+1] = (freq[i] == 0 ? 1 : freq[i]) << 8;
while (True) {
nNodes = alphaSize;
nHeap = 0;
heap[0] = 0;
weight[0] = 0;
parent[0] = -2;
for (i = 1; i <= alphaSize; i++) {
parent[i] = -1;
nHeap++;
heap[nHeap] = i;
UPHEAP(nHeap);
}
AssertH( nHeap < (BZ_MAX_ALPHA_SIZE+2), 2001 );
while (nHeap > 1) {
n1 = heap[1]; heap[1] = heap[nHeap]; nHeap--; DOWNHEAP(1);
n2 = heap[1]; heap[1] = heap[nHeap]; nHeap--; DOWNHEAP(1);
nNodes++;
parent[n1] = parent[n2] = nNodes;
weight[nNodes] = ADDWEIGHTS(weight[n1], weight[n2]);
parent[nNodes] = -1;
nHeap++;
heap[nHeap] = nNodes;
UPHEAP(nHeap);
}
AssertH( nNodes < (BZ_MAX_ALPHA_SIZE * 2), 2002 );
tooLong = False;
for (i = 1; i <= alphaSize; i++) {
j = 0;
k = i;
while (parent[k] >= 0) { k = parent[k]; j++; }
len[i-1] = j;
if (j > maxLen) tooLong = True;
}
if (! tooLong) break;
/* 17 Oct 04: keep-going condition for the following loop used
to be 'i < alphaSize', which missed the last element,
theoretically leading to the possibility of the compressor
looping. However, this count-scaling step is only needed if
one of the generated Huffman code words is longer than
maxLen, which up to and including version 1.0.2 was 20 bits,
which is extremely unlikely. In version 1.0.3 maxLen was
changed to 17 bits, which has minimal effect on compression
ratio, but does mean this scaling step is used from time to
time, enough to verify that it works.
This means that bzip2-1.0.3 and later will only produce
Huffman codes with a maximum length of 17 bits. However, in
order to preserve backwards compatibility with bitstreams
produced by versions pre-1.0.3, the decompressor must still
handle lengths of up to 20. */
for (i = 1; i <= alphaSize; i++) {
j = weight[i] >> 8;
j = 1 + (j / 2);
weight[i] = j << 8;
}
}
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x14b0, %rsp # imm = 0x14B0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x9a1ad7
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jne 0x9a1aa3
movl $0x1, %eax
movl %eax, -0x149c(%rbp)
jmp 0x9a1ab4
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x149c(%rbp)
movl -0x149c(%rbp), %ecx
shll $0x8, %ecx
movl -0x2c(%rbp), %eax
addl $0x1, %eax
cltq
movl %ecx, -0xc60(%rbp,%rax,4)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x9a1a80
jmp 0x9a1ad9
movl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl $0x0, -0x450(%rbp)
movl $0x0, -0xc60(%rbp)
movl $0xfffffffe, -0x1470(%rbp) # imm = 0xFFFFFFFE
movl $0x1, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jg 0x9a1bd5
movslq -0x2c(%rbp), %rax
movl $0xffffffff, -0x1470(%rbp,%rax,4) # imm = 0xFFFFFFFF
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movl -0x2c(%rbp), %ecx
movslq -0x20(%rbp), %rax
movl %ecx, -0x450(%rbp,%rax,4)
movl -0x20(%rbp), %eax
movl %eax, -0x1474(%rbp)
movslq -0x1474(%rbp), %rax
movl -0x450(%rbp,%rax,4), %eax
movl %eax, -0x1478(%rbp)
movslq -0x1478(%rbp), %rax
movl -0xc60(%rbp,%rax,4), %eax
movl -0x1474(%rbp), %ecx
sarl %ecx
movslq %ecx, %rcx
movslq -0x450(%rbp,%rcx,4), %rcx
cmpl -0xc60(%rbp,%rcx,4), %eax
jge 0x9a1bb3
movl -0x1474(%rbp), %eax
sarl %eax
cltq
movl -0x450(%rbp,%rax,4), %ecx
movslq -0x1474(%rbp), %rax
movl %ecx, -0x450(%rbp,%rax,4)
movl -0x1474(%rbp), %eax
sarl %eax
movl %eax, -0x1474(%rbp)
jmp 0x9a1b5a
movl -0x1478(%rbp), %ecx
movslq -0x1474(%rbp), %rax
movl %ecx, -0x450(%rbp,%rax,4)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x9a1b0b
cmpl $0x104, -0x20(%rbp) # imm = 0x104
jl 0x9a1be8
movl $0x7d1, %edi # imm = 0x7D1
callq 0x991060
jmp 0x9a1bea
cmpl $0x1, -0x20(%rbp)
jle 0x9a1f8b
movl -0x44c(%rbp), %eax
movl %eax, -0x24(%rbp)
movslq -0x20(%rbp), %rax
movl -0x450(%rbp,%rax,4), %eax
movl %eax, -0x44c(%rbp)
movl -0x20(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x20(%rbp)
movl $0x1, -0x147c(%rbp)
movslq -0x147c(%rbp), %rax
movl -0x450(%rbp,%rax,4), %eax
movl %eax, -0x1484(%rbp)
movl -0x147c(%rbp), %eax
shll %eax
movl %eax, -0x1480(%rbp)
movl -0x1480(%rbp), %eax
cmpl -0x20(%rbp), %eax
jle 0x9a1c53
jmp 0x9a1cf4
movl -0x1480(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x9a1c9f
movl -0x1480(%rbp), %eax
addl $0x1, %eax
cltq
movslq -0x450(%rbp,%rax,4), %rax
movl -0xc60(%rbp,%rax,4), %eax
movslq -0x1480(%rbp), %rcx
movslq -0x450(%rbp,%rcx,4), %rcx
cmpl -0xc60(%rbp,%rcx,4), %eax
jge 0x9a1c9f
movl -0x1480(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1480(%rbp)
movslq -0x1484(%rbp), %rax
movl -0xc60(%rbp,%rax,4), %eax
movslq -0x1480(%rbp), %rcx
movslq -0x450(%rbp,%rcx,4), %rcx
cmpl -0xc60(%rbp,%rcx,4), %eax
jge 0x9a1cc7
jmp 0x9a1cf4
movslq -0x1480(%rbp), %rax
movl -0x450(%rbp,%rax,4), %ecx
movslq -0x147c(%rbp), %rax
movl %ecx, -0x450(%rbp,%rax,4)
movl -0x1480(%rbp), %eax
movl %eax, -0x147c(%rbp)
jmp 0x9a1c35
movl -0x1484(%rbp), %ecx
movslq -0x147c(%rbp), %rax
movl %ecx, -0x450(%rbp,%rax,4)
movl -0x44c(%rbp), %eax
movl %eax, -0x28(%rbp)
movslq -0x20(%rbp), %rax
movl -0x450(%rbp,%rax,4), %eax
movl %eax, -0x44c(%rbp)
movl -0x20(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x20(%rbp)
movl $0x1, -0x1488(%rbp)
movslq -0x1488(%rbp), %rax
movl -0x450(%rbp,%rax,4), %eax
movl %eax, -0x1490(%rbp)
movl -0x1488(%rbp), %eax
shll %eax
movl %eax, -0x148c(%rbp)
movl -0x148c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jle 0x9a1d67
jmp 0x9a1e08
movl -0x148c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x9a1db3
movl -0x148c(%rbp), %eax
addl $0x1, %eax
cltq
movslq -0x450(%rbp,%rax,4), %rax
movl -0xc60(%rbp,%rax,4), %eax
movslq -0x148c(%rbp), %rcx
movslq -0x450(%rbp,%rcx,4), %rcx
cmpl -0xc60(%rbp,%rcx,4), %eax
jge 0x9a1db3
movl -0x148c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x148c(%rbp)
movslq -0x1490(%rbp), %rax
movl -0xc60(%rbp,%rax,4), %eax
movslq -0x148c(%rbp), %rcx
movslq -0x450(%rbp,%rcx,4), %rcx
cmpl -0xc60(%rbp,%rcx,4), %eax
jge 0x9a1ddb
jmp 0x9a1e08
movslq -0x148c(%rbp), %rax
movl -0x450(%rbp,%rax,4), %ecx
movslq -0x1488(%rbp), %rax
movl %ecx, -0x450(%rbp,%rax,4)
movl -0x148c(%rbp), %eax
movl %eax, -0x1488(%rbp)
jmp 0x9a1d49
movl -0x1490(%rbp), %ecx
movslq -0x1488(%rbp), %rax
movl %ecx, -0x450(%rbp,%rax,4)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %ecx
movslq -0x28(%rbp), %rax
movl %ecx, -0x1470(%rbp,%rax,4)
movslq -0x24(%rbp), %rax
movl %ecx, -0x1470(%rbp,%rax,4)
movslq -0x24(%rbp), %rax
movl -0xc60(%rbp,%rax,4), %eax
andl $0xffffff00, %eax # imm = 0xFFFFFF00
movslq -0x28(%rbp), %rcx
movl -0xc60(%rbp,%rcx,4), %ecx
andl $0xffffff00, %ecx # imm = 0xFFFFFF00
addl %ecx, %eax
movl %eax, -0x14a0(%rbp)
movslq -0x24(%rbp), %rax
movl -0xc60(%rbp,%rax,4), %eax
andl $0xff, %eax
movslq -0x28(%rbp), %rcx
movl -0xc60(%rbp,%rcx,4), %ecx
andl $0xff, %ecx
cmpl %ecx, %eax
jle 0x9a1ea4
movslq -0x24(%rbp), %rax
movl -0xc60(%rbp,%rax,4), %eax
andl $0xff, %eax
movl %eax, -0x14a4(%rbp)
jmp 0x9a1eba
movslq -0x28(%rbp), %rax
movl -0xc60(%rbp,%rax,4), %eax
andl $0xff, %eax
movl %eax, -0x14a4(%rbp)
movl -0x14a0(%rbp), %ecx
movl -0x14a4(%rbp), %eax
addl $0x1, %eax
orl %eax, %ecx
movslq -0x1c(%rbp), %rax
movl %ecx, -0xc60(%rbp,%rax,4)
movslq -0x1c(%rbp), %rax
movl $0xffffffff, -0x1470(%rbp,%rax,4) # imm = 0xFFFFFFFF
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %ecx
movslq -0x20(%rbp), %rax
movl %ecx, -0x450(%rbp,%rax,4)
movl -0x20(%rbp), %eax
movl %eax, -0x1494(%rbp)
movslq -0x1494(%rbp), %rax
movl -0x450(%rbp,%rax,4), %eax
movl %eax, -0x1498(%rbp)
movslq -0x1498(%rbp), %rax
movl -0xc60(%rbp,%rax,4), %eax
movl -0x1494(%rbp), %ecx
sarl %ecx
movslq %ecx, %rcx
movslq -0x450(%rbp,%rcx,4), %rcx
cmpl -0xc60(%rbp,%rcx,4), %eax
jge 0x9a1f72
movl -0x1494(%rbp), %eax
sarl %eax
cltq
movl -0x450(%rbp,%rax,4), %ecx
movslq -0x1494(%rbp), %rax
movl %ecx, -0x450(%rbp,%rax,4)
movl -0x1494(%rbp), %eax
sarl %eax
movl %eax, -0x1494(%rbp)
jmp 0x9a1f19
movl -0x1498(%rbp), %ecx
movslq -0x1494(%rbp), %rax
movl %ecx, -0x450(%rbp,%rax,4)
jmp 0x9a1bea
cmpl $0x204, -0x1c(%rbp) # imm = 0x204
jl 0x9a1f9e
movl $0x7d2, %edi # imm = 0x7D2
callq 0x991060
movb $0x0, -0x35(%rbp)
movl $0x1, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jg 0x9a2013
movl $0x0, -0x30(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x34(%rbp)
movslq -0x34(%rbp), %rax
cmpl $0x0, -0x1470(%rbp,%rax,4)
jl 0x9a1fe5
movslq -0x34(%rbp), %rax
movl -0x1470(%rbp,%rax,4), %eax
movl %eax, -0x34(%rbp)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x9a1fbe
movl -0x30(%rbp), %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movl -0x2c(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0x30(%rbp), %eax
cmpl -0x18(%rbp), %eax
jle 0x9a2006
movb $0x1, -0x35(%rbp)
jmp 0x9a2008
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x9a1fa9
cmpb $0x0, -0x35(%rbp)
jne 0x9a201b
jmp 0x9a206d
movl $0x1, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jg 0x9a2068
movslq -0x2c(%rbp), %rax
movl -0xc60(%rbp,%rax,4), %eax
sarl $0x8, %eax
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
addl $0x1, %eax
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %ecx
shll $0x8, %ecx
movslq -0x2c(%rbp), %rax
movl %ecx, -0xc60(%rbp,%rax,4)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x9a2022
jmp 0x9a1ad9
addq $0x14b0, %rsp # imm = 0x14B0
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmbzip2/huffman.c
|
lzma_crc32
|
extern LZMA_API(uint32_t)
lzma_crc32(const uint8_t *buf, size_t size, uint32_t crc)
{
crc = ~crc;
#ifdef WORDS_BIGENDIAN
crc = bswap32(crc);
#endif
if (size > 8) {
// Fix the alignment, if needed. The if statement above
// ensures that this won't read past the end of buf[].
while ((uintptr_t)(buf) & 7) {
crc = lzma_crc32_table[0][*buf++ ^ A(crc)] ^ S8(crc);
--size;
}
// Calculate the position where to stop.
const uint8_t *const limit = buf + (size & ~(size_t)(7));
// Calculate how many bytes must be calculated separately
// before returning the result.
size &= (size_t)(7);
// Calculate the CRC32 using the slice-by-eight algorithm.
while (buf < limit) {
crc ^= aligned_read32ne(buf);
buf += 4;
crc = lzma_crc32_table[7][A(crc)]
^ lzma_crc32_table[6][B(crc)]
^ lzma_crc32_table[5][C(crc)]
^ lzma_crc32_table[4][D(crc)];
const uint32_t tmp = aligned_read32ne(buf);
buf += 4;
// At least with some compilers, it is critical for
// performance, that the crc variable is XORed
// between the two table-lookup pairs.
crc = lzma_crc32_table[3][A(tmp)]
^ lzma_crc32_table[2][B(tmp)]
^ crc
^ lzma_crc32_table[1][C(tmp)]
^ lzma_crc32_table[0][D(tmp)];
}
}
while (size-- != 0)
crc = lzma_crc32_table[0][*buf++ ^ A(crc)] ^ S8(crc);
#ifdef WORDS_BIGENDIAN
crc = bswap32(crc);
#endif
return ~crc;
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl -0x14(%rbp), %eax
xorl $-0x1, %eax
movl %eax, -0x14(%rbp)
cmpq $0x8, -0x10(%rbp)
jbe 0x9a24c3
jmp 0x9a2329
movq -0x8(%rbp), %rax
andq $0x7, %rax
cmpq $0x0, %rax
je 0x9a237b
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movzbl (%rax), %eax
movl -0x14(%rbp), %ecx
andl $0xff, %ecx
xorl %ecx, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x228e51(%rip), %rax # 0xbcb1b0
movl (%rax,%rcx,4), %eax
movl -0x14(%rbp), %ecx
shrl $0x8, %ecx
xorl %ecx, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x9a2329
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
andq $-0x8, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
andq $0x7, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x9a24c1
movq -0x8(%rbp), %rdi
callq 0x9a2520
xorl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x8(%rbp)
movl -0x14(%rbp), %eax
andl $0xff, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x228dda(%rip), %rax # 0xbcb1b0
movl 0x1c00(%rax,%rcx,4), %eax
movl -0x14(%rbp), %ecx
shrl $0x8, %ecx
andl $0xff, %ecx
movl %ecx, %ecx
movl %ecx, %edx
leaq 0x228dbc(%rip), %rcx # 0xbcb1b0
xorl 0x1800(%rcx,%rdx,4), %eax
movl -0x14(%rbp), %ecx
shrl $0x10, %ecx
andl $0xff, %ecx
movl %ecx, %ecx
movl %ecx, %edx
leaq 0x228d9e(%rip), %rcx # 0xbcb1b0
xorl 0x1400(%rcx,%rdx,4), %eax
movl -0x14(%rbp), %ecx
shrl $0x18, %ecx
movl %ecx, %ecx
movl %ecx, %edx
leaq 0x228d86(%rip), %rcx # 0xbcb1b0
xorl 0x1000(%rcx,%rdx,4), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
callq 0x9a2520
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x8(%rbp)
movl -0x24(%rbp), %eax
andl $0xff, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x228d51(%rip), %rax # 0xbcb1b0
movl 0xc00(%rax,%rcx,4), %eax
movl -0x24(%rbp), %ecx
shrl $0x8, %ecx
andl $0xff, %ecx
movl %ecx, %ecx
movl %ecx, %edx
leaq 0x228d33(%rip), %rcx # 0xbcb1b0
xorl 0x800(%rcx,%rdx,4), %eax
xorl -0x14(%rbp), %eax
movl -0x24(%rbp), %ecx
shrl $0x10, %ecx
andl $0xff, %ecx
movl %ecx, %ecx
movl %ecx, %edx
leaq 0x228d12(%rip), %rcx # 0xbcb1b0
xorl 0x400(%rcx,%rdx,4), %eax
movl -0x24(%rbp), %ecx
shrl $0x18, %ecx
movl %ecx, %ecx
movl %ecx, %edx
leaq 0x228cfa(%rip), %rcx # 0xbcb1b0
xorl (%rcx,%rdx,4), %eax
movl %eax, -0x14(%rbp)
jmp 0x9a239a
jmp 0x9a24c3
jmp 0x9a24c5
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x10(%rbp)
cmpq $0x0, %rax
je 0x9a2512
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movzbl (%rax), %eax
movl -0x14(%rbp), %ecx
andl $0xff, %ecx
xorl %ecx, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x228cae(%rip), %rax # 0xbcb1b0
movl (%rax,%rcx,4), %eax
movl -0x14(%rbp), %ecx
shrl $0x8, %ecx
xorl %ecx, %eax
movl %eax, -0x14(%rbp)
jmp 0x9a24c5
movl -0x14(%rbp), %eax
xorl $-0x1, %eax
addq $0x30, %rsp
popq %rbp
retq
nop
|
/JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/check/crc32_fast.c
|
lzma_alone_decoder_init
|
extern lzma_ret
lzma_alone_decoder_init(lzma_next_coder *next, const lzma_allocator *allocator,
uint64_t memlimit, bool picky)
{
lzma_next_coder_init(&lzma_alone_decoder_init, next, allocator);
lzma_alone_coder *coder = next->coder;
if (coder == NULL) {
coder = lzma_alloc(sizeof(lzma_alone_coder), allocator);
if (coder == NULL)
return LZMA_MEM_ERROR;
next->coder = coder;
next->code = &alone_decode;
next->end = &alone_decoder_end;
next->memconfig = &alone_decoder_memconfig;
coder->next = LZMA_NEXT_CODER_INIT;
}
coder->sequence = SEQ_PROPERTIES;
coder->picky = picky;
coder->pos = 0;
coder->options.dict_size = 0;
coder->options.preset_dict = NULL;
coder->options.preset_dict_size = 0;
coder->uncompressed_size = 0;
coder->memlimit = my_max(1, memlimit);
coder->memusage = LZMA_MEMUSAGE_BASE;
return LZMA_OK;
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movb %cl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
movq -0x10(%rbp), %rcx
leaq -0x29(%rip), %rax # 0x9a2540
cmpq 0x10(%rcx), %rax
je 0x9a257c
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x9a32d0
movq -0x10(%rbp), %rax
leaq -0x47(%rip), %rcx # 0x9a2540
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x9a2630
movq -0x18(%rbp), %rsi
movl $0xe0, %edi
callq 0x9a3040
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x9a25c6
movl $0x5, -0x4(%rbp)
jmp 0x9a26cb
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0x104(%rip), %rcx # 0x9a26e0
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
leaq 0x4b5(%rip), %rcx # 0x9a2aa0
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
leaq 0x4e6(%rip), %rcx # 0x9a2ae0
movq %rcx, 0x38(%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq -0x78(%rbp), %rdi
xorl %esi, %esi
movl $0x48, %edx
callq 0x3b780
movq -0x80(%rbp), %rdi
movq $-0x1, -0x70(%rbp)
leaq -0x78(%rbp), %rsi
movl $0x48, %edx
callq 0x3cb70
movq -0x30(%rbp), %rax
movl $0x0, 0x48(%rax)
movb -0x21(%rbp), %cl
movq -0x30(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x4c(%rax)
movq -0x30(%rbp), %rax
movq $0x0, 0x50(%rax)
movq -0x30(%rbp), %rax
movl $0x0, 0x70(%rax)
movq -0x30(%rbp), %rax
movq $0x0, 0x78(%rax)
movq -0x30(%rbp), %rax
movl $0x0, 0x80(%rax)
movq -0x30(%rbp), %rax
movq $0x0, 0x58(%rax)
movl $0x1, %eax
cmpq -0x20(%rbp), %rax
jbe 0x9a269e
movl $0x1, %eax
movq %rax, -0x88(%rbp)
jmp 0x9a26a9
movq -0x20(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x88(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x60(%rax)
movq -0x30(%rbp), %rax
movq $0x8000, 0x68(%rax) # imm = 0x8000
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
nopw (%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/alone_decoder.c
|
alone_decoder_memconfig
|
static lzma_ret
alone_decoder_memconfig(void *coder_ptr, uint64_t *memusage,
uint64_t *old_memlimit, uint64_t new_memlimit)
{
lzma_alone_coder *coder = coder_ptr;
*memusage = coder->memusage;
*old_memlimit = coder->memlimit;
if (new_memlimit != 0) {
if (new_memlimit < coder->memusage)
return LZMA_MEMLIMIT_ERROR;
coder->memlimit = new_memlimit;
}
return LZMA_OK;
}
|
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq 0x68(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
movq 0x60(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
cmpq $0x0, -0x28(%rbp)
je 0x9a2b44
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
cmpq 0x68(%rcx), %rax
jae 0x9a2b38
movl $0x6, -0x4(%rbp)
jmp 0x9a2b4b
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x60(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
|
/JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/alone_decoder.c
|
lzma_alloc_zero
|
extern void * lzma_attribute((__malloc__)) lzma_attr_alloc_size(1)
lzma_alloc_zero(size_t size, const lzma_allocator *allocator)
{
// Some calloc() variants return NULL if called with size == 0.
if (size == 0)
size = 1;
void *ptr;
if (allocator != NULL && allocator->alloc != NULL) {
ptr = allocator->alloc(allocator->opaque, 1, size);
if (ptr != NULL)
memzero(ptr, size);
} else {
ptr = calloc(1, size);
}
return ptr;
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x9a30cf
movq $0x1, -0x8(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x9a3116
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x9a3116
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rdi
movq -0x8(%rbp), %rdx
movl $0x1, %esi
callq *%rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x9a3114
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rdx
xorl %esi, %esi
callq 0x3b780
jmp 0x9a3128
movq -0x8(%rbp), %rsi
movl $0x1, %edi
callq 0x3e570
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/common.c
|
decoder_find
|
static const lzma_filter_decoder *
decoder_find(lzma_vli id)
{
for (size_t i = 0; i < ARRAY_SIZE(decoders); ++i)
if (decoders[i].id == id)
return decoders + i;
return NULL;
}
|
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x9, -0x18(%rbp)
jae 0x9a3c6a
movq -0x18(%rbp), %rcx
leaq 0x55596e(%rip), %rax # 0xef95a0
shlq $0x5, %rcx
addq %rcx, %rax
movq (%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x9a3c5a
movq -0x18(%rbp), %rcx
leaq 0x555953(%rip), %rax # 0xef95a0
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x9a3c72
jmp 0x9a3c5c
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x9a3c20
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/filter_decoder.c
|
encoder_find
|
static const lzma_filter_encoder *
encoder_find(lzma_vli id)
{
for (size_t i = 0; i < ARRAY_SIZE(encoders); ++i)
if (encoders[i].id == id)
return encoders + i;
return NULL;
}
|
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x9, -0x18(%rbp)
jae 0x9a3e94
leaq 0x555862(%rip), %rax # 0xef96c0
imulq $0x38, -0x18(%rbp), %rcx
addq %rcx, %rax
movq (%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x9a3e84
leaq 0x55584a(%rip), %rax # 0xef96c0
imulq $0x38, -0x18(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x9a3e9c
jmp 0x9a3e86
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x9a3e50
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/filter_encoder.c
|
lzma_raw_encoder
|
extern LZMA_API(lzma_ret)
lzma_raw_encoder(lzma_stream *strm, const lzma_filter *options)
{
lzma_next_strm_init(lzma_raw_coder_init, strm, options,
(lzma_filter_find)(&encoder_find), true);
strm->internal->supported_actions[LZMA_RUN] = true;
strm->internal->supported_actions[LZMA_SYNC_FLUSH] = true;
strm->internal->supported_actions[LZMA_FINISH] = true;
return LZMA_OK;
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
jmp 0x9a4052
movq -0x10(%rbp), %rdi
callq 0x9a3400
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x9a406c
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x9a40db
jmp 0x9a406e
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rsi
movq -0x18(%rbp), %rdx
leaq -0x249(%rip), %rcx # 0x9a3e40
movl $0x1, %r8d
callq 0x9bfb70
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
je 0x9a40ae
movq -0x10(%rbp), %rdi
callq 0x9a3940
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x9a40db
jmp 0x9a40b0
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movb $0x1, 0x58(%rax)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movb $0x1, 0x59(%rax)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movb $0x1, 0x5b(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/filter_encoder.c
|
lzma_properties_size
|
extern LZMA_API(lzma_ret)
lzma_properties_size(uint32_t *size, const lzma_filter *filter)
{
const lzma_filter_encoder *const fe = encoder_find(filter->id);
if (fe == NULL) {
// Unknown filter - if the Filter ID is a proper VLI,
// return LZMA_OPTIONS_ERROR instead of LZMA_PROG_ERROR,
// because it's possible that we just don't have support
// compiled in for the requested filter.
return filter->id <= LZMA_VLI_MAX
? LZMA_OPTIONS_ERROR : LZMA_PROG_ERROR;
}
if (fe->props_size_get == NULL) {
// No props_size_get() function, use props_size_fixed.
*size = fe->props_size_fixed;
return LZMA_OK;
}
return fe->props_size_get(size, filter->options);
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x9a3e40
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x9a420d
movq -0x18(%rbp), %rax
movq (%rax), %rdx
movabsq $0x7fffffffffffffff, %rsi # imm = 0x7FFFFFFFFFFFFFFF
movl $0xb, %eax
movl $0x8, %ecx
cmpq %rsi, %rdx
cmovbel %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x9a4247
movq -0x20(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x9a422e
movq -0x20(%rbp), %rax
movl 0x28(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x9a4247
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rsi
callq *%rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
|
/JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/filter_encoder.c
|
wait_for_work
|
static bool
wait_for_work(lzma_stream_coder *coder, mythread_condtime *wait_abs,
bool *has_blocked, bool has_input)
{
if (coder->timeout != 0 && !*has_blocked) {
// Every time when stream_encode_mt() is called via
// lzma_code(), *has_blocked starts as false. We set it
// to true here and calculate the absolute time when
// we must return if there's nothing to do.
//
// The idea of *has_blocked is to avoid unneeded calls
// to mythread_condtime_set(), which may do a syscall
// depending on the operating system.
*has_blocked = true;
mythread_condtime_set(wait_abs, &coder->cond, coder->timeout);
}
bool timed_out = false;
mythread_sync(coder->mutex) {
// There are four things that we wait. If one of them
// becomes possible, we return.
// - If there is input left, we need to get a free
// worker thread and an output buffer for it.
// - Data ready to be read from the output queue.
// - A worker thread indicates an error.
// - Time out occurs.
while ((!has_input || coder->threads_free == NULL
|| !lzma_outq_has_buf(&coder->outq))
&& !lzma_outq_is_readable(&coder->outq)
&& coder->thread_error == LZMA_OK
&& !timed_out) {
if (coder->timeout != 0)
timed_out = mythread_cond_timedwait(
&coder->cond, &coder->mutex,
wait_abs) != 0;
else
mythread_cond_wait(&coder->cond,
&coder->mutex);
}
}
return timed_out;
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x130(%rax)
je 0x9a7126
movq -0x18(%rbp), %rax
testb $0x1, (%rax)
jne 0x9a7126
movq -0x18(%rbp), %rax
movb $0x1, (%rax)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x190, %rsi # imm = 0x190
movq -0x8(%rbp), %rax
movl 0x130(%rax), %edx
callq 0x9a8350
movb $0x0, -0x1a(%rbp)
movl $0x0, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
je 0x9a714e
movq -0x8(%rbp), %rdi
addq $0x168, %rdi # imm = 0x168
callq 0x9a6d60
xorl %eax, %eax
movl %eax, -0x28(%rbp)
jmp 0x9a7166
movq -0x8(%rbp), %rdi
addq $0x168, %rdi # imm = 0x168
callq 0x9a6db0
movl $0x1, %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl $0x0, %eax
je 0x9a7271
movl $0x0, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x9a718b
jmp 0x9a7263
jmp 0x9a718d
testb $0x1, -0x19(%rbp)
je 0x9a71bd
movq -0x8(%rbp), %rax
cmpq $0x0, 0x148(%rax)
je 0x9a71bd
movq -0x8(%rbp), %rdi
addq $0x100, %rdi # imm = 0x100
callq 0x9a7500
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x29(%rbp)
jne 0x9a71f3
movq -0x8(%rbp), %rdi
addq $0x100, %rdi # imm = 0x100
callq 0x9c3750
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x29(%rbp)
jne 0x9a71f3
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpl $0x0, 0x134(%rcx)
movb %al, -0x29(%rbp)
jne 0x9a71f3
movb -0x1a(%rbp), %al
xorb $-0x1, %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x9a71fc
jmp 0x9a7255
movq -0x8(%rbp), %rax
cmpl $0x0, 0x130(%rax)
je 0x9a7235
movq -0x8(%rbp), %rdi
addq $0x190, %rdi # imm = 0x190
movq -0x8(%rbp), %rsi
addq $0x168, %rsi # imm = 0x168
movq -0x10(%rbp), %rdx
callq 0x9a8400
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x1a(%rbp)
jmp 0x9a7250
movq -0x8(%rbp), %rdi
addq $0x190, %rdi # imm = 0x190
movq -0x8(%rbp), %rsi
addq $0x168, %rsi # imm = 0x168
callq 0x9a7b70
jmp 0x9a718d
jmp 0x9a7257
movl $0x1, -0x24(%rbp)
jmp 0x9a7179
jmp 0x9a7265
movl $0x1, -0x20(%rbp)
jmp 0x9a7131
movb -0x1a(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
|
/JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/stream_encoder_mt.c
|
get_thread
|
static lzma_ret
get_thread(lzma_stream_coder *coder, const lzma_allocator *allocator)
{
// If there are no free output subqueues, there is no
// point to try getting a thread.
if (!lzma_outq_has_buf(&coder->outq))
return LZMA_OK;
// If there is a free structure on the stack, use it.
mythread_sync(coder->mutex) {
if (coder->threads_free != NULL) {
coder->thr = coder->threads_free;
coder->threads_free = coder->threads_free->next;
}
}
if (coder->thr == NULL) {
// If there are no uninitialized structures left, return.
if (coder->threads_initialized == coder->threads_max)
return LZMA_OK;
// Initialize a new thread.
return_if_error(initialize_new_thread(coder, allocator));
}
// Reset the parts of the thread state that have to be done
// in the main thread.
mythread_sync(coder->thr->mutex) {
coder->thr->state = THR_RUN;
coder->thr->in_size = 0;
coder->thr->outbuf = lzma_outq_get_buf(&coder->outq);
mythread_cond_signal(&coder->thr->cond);
}
return LZMA_OK;
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
addq $0x100, %rdi # imm = 0x100
callq 0x9a7500
testb $0x1, %al
jne 0x9a72b0
movl $0x0, -0x4(%rbp)
jmp 0x9a74a2
movl $0x0, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x9a72d4
movq -0x10(%rbp), %rdi
addq $0x168, %rdi # imm = 0x168
callq 0x9a6d60
xorl %eax, %eax
movl %eax, -0x30(%rbp)
jmp 0x9a72ec
movq -0x10(%rbp), %rdi
addq $0x168, %rdi # imm = 0x168
callq 0x9a6db0
movl $0x1, %eax
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl $0x0, %eax
je 0x9a7364
movl $0x0, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x9a730a
jmp 0x9a7356
movq -0x10(%rbp), %rax
cmpq $0x0, 0x148(%rax)
je 0x9a734b
movq -0x10(%rbp), %rax
movq 0x148(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x150(%rax)
movq -0x10(%rbp), %rax
movq 0x148(%rax), %rax
movq 0x158(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x148(%rax)
jmp 0x9a734d
movl $0x1, -0x20(%rbp)
jmp 0x9a72fb
jmp 0x9a7358
movl $0x1, -0x1c(%rbp)
jmp 0x9a72b7
movq -0x10(%rbp), %rax
cmpq $0x0, 0x150(%rax)
jne 0x9a73bb
movq -0x10(%rbp), %rax
movl 0x144(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x140(%rcx), %eax
jne 0x9a7394
movl $0x0, -0x4(%rbp)
jmp 0x9a74a2
jmp 0x9a7396
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x9a7520
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x9a73b7
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x9a74a2
jmp 0x9a73b9
jmp 0x9a73bb
movl $0x0, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
je 0x9a73e6
movq -0x10(%rbp), %rax
movq 0x150(%rax), %rdi
addq $0x160, %rdi # imm = 0x160
callq 0x9a6d60
xorl %eax, %eax
movl %eax, -0x34(%rbp)
jmp 0x9a7405
movq -0x10(%rbp), %rax
movq 0x150(%rax), %rdi
addq $0x160, %rdi # imm = 0x160
callq 0x9a6db0
movl $0x1, %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl $0x0, %eax
je 0x9a749b
movl $0x0, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x9a7427
jmp 0x9a748d
movq -0x10(%rbp), %rax
movq 0x150(%rax), %rax
movl $0x1, (%rax)
movq -0x10(%rbp), %rax
movq 0x150(%rax), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rdi
addq $0x100, %rdi # imm = 0x100
callq 0x9c3680
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq 0x150(%rax), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq 0x150(%rax), %rdi
addq $0x188, %rdi # imm = 0x188
callq 0x9a74b0
movl $0x1, -0x2c(%rbp)
jmp 0x9a7418
jmp 0x9a748f
movl $0x1, -0x28(%rbp)
jmp 0x9a73c2
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/stream_encoder_mt.c
|
initialize_new_thread
|
static lzma_ret
initialize_new_thread(lzma_stream_coder *coder,
const lzma_allocator *allocator)
{
worker_thread *thr = &coder->threads[coder->threads_initialized];
thr->in = lzma_alloc(coder->block_size, allocator);
if (thr->in == NULL)
return LZMA_MEM_ERROR;
if (mythread_mutex_init(&thr->mutex))
goto error_mutex;
if (mythread_cond_init(&thr->cond))
goto error_cond;
thr->state = THR_IDLE;
thr->allocator = allocator;
thr->coder = coder;
thr->progress_in = 0;
thr->progress_out = 0;
thr->block_encoder = LZMA_NEXT_CODER_INIT;
if (mythread_create(&thr->thread_id, &worker_start, thr))
goto error_thread;
++coder->threads_initialized;
coder->thr = thr;
return LZMA_OK;
error_thread:
mythread_cond_destroy(&thr->cond);
error_cond:
mythread_mutex_destroy(&thr->mutex);
error_mutex:
lzma_free(thr->in, allocator);
return LZMA_MEM_ERROR;
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x138(%rax), %rax
movq -0x10(%rbp), %rcx
movl 0x144(%rcx), %ecx
imulq $0x1c0, %rcx, %rcx # imm = 0x1C0
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x9a3040
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x9a7586
movl $0x5, -0x4(%rbp)
jmp 0x9a76af
movq -0x20(%rbp), %rdi
addq $0x160, %rdi # imm = 0x160
callq 0x9a6190
cmpl $0x0, %eax
je 0x9a75a0
jmp 0x9a7697
movq -0x20(%rbp), %rdi
addq $0x188, %rdi # imm = 0x188
callq 0x9a61b0
cmpl $0x0, %eax
je 0x9a75ba
jmp 0x9a7687
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x38(%rax)
movq -0x20(%rbp), %rax
addq $0x40, %rax
movq %rax, -0x70(%rbp)
leaq -0x68(%rbp), %rdi
xorl %esi, %esi
movl $0x48, %edx
callq 0x3b780
movq -0x70(%rbp), %rdi
movq $-0x1, -0x60(%rbp)
leaq -0x68(%rbp), %rsi
movl $0x48, %edx
callq 0x3cb70
movq -0x20(%rbp), %rdi
addq $0x1b8, %rdi # imm = 0x1B8
movq -0x20(%rbp), %rdx
leaq 0x100(%rip), %rsi # 0x9a7740
callq 0x9a76c0
cmpl $0x0, %eax
je 0x9a764c
jmp 0x9a7677
movq -0x10(%rbp), %rax
movl 0x144(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x144(%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x150(%rax)
movl $0x0, -0x4(%rbp)
jmp 0x9a76af
movq -0x20(%rbp), %rdi
addq $0x188, %rdi # imm = 0x188
callq 0x9a7ac0
movq -0x20(%rbp), %rdi
addq $0x160, %rdi # imm = 0x160
callq 0x9a61d0
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x9a3140
movl $0x5, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/stream_encoder_mt.c
|
worker_start
|
static MYTHREAD_RET_TYPE
worker_start(void *thr_ptr)
{
worker_thread *thr = thr_ptr;
worker_state state = THR_IDLE; // Init to silence a warning
while (true) {
// Wait for work.
mythread_sync(thr->mutex) {
while (true) {
// The thread is already idle so if we are
// requested to stop, just set the state.
if (thr->state == THR_STOP) {
thr->state = THR_IDLE;
mythread_cond_signal(&thr->cond);
}
state = thr->state;
if (state != THR_IDLE)
break;
mythread_cond_wait(&thr->cond, &thr->mutex);
}
}
assert(state != THR_IDLE);
assert(state != THR_STOP);
if (state <= THR_FINISH)
state = worker_encode(thr, state);
if (state == THR_EXIT)
break;
// Mark the thread as idle unless the main thread has
// told us to exit. Signal is needed for the case
// where the main thread is waiting for the threads to stop.
mythread_sync(thr->mutex) {
if (thr->state != THR_EXIT) {
thr->state = THR_IDLE;
mythread_cond_signal(&thr->cond);
}
}
mythread_sync(thr->coder->mutex) {
// Mark the output buffer as finished if
// no errors occurred.
thr->outbuf->finished = state == THR_FINISH;
// Update the main progress info.
thr->coder->progress_in
+= thr->outbuf->uncompressed_size;
thr->coder->progress_out += thr->outbuf->size;
thr->progress_in = 0;
thr->progress_out = 0;
// Return this thread to the stack of free threads.
thr->next = thr->coder->threads_free;
thr->coder->threads_free = thr;
mythread_cond_signal(&thr->coder->cond);
}
}
// Exiting, free the resources.
mythread_mutex_destroy(&thr->mutex);
mythread_cond_destroy(&thr->cond);
lzma_next_end(&thr->block_encoder, thr->allocator);
lzma_free(thr->in, thr->allocator);
return MYTHREAD_RET_VALUE;
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
je 0x9a777f
movq -0x10(%rbp), %rdi
addq $0x160, %rdi # imm = 0x160
callq 0x9a6d60
xorl %eax, %eax
movl %eax, -0x30(%rbp)
jmp 0x9a7797
movq -0x10(%rbp), %rdi
addq $0x160, %rdi # imm = 0x160
callq 0x9a6db0
movl $0x1, %eax
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl $0x0, %eax
je 0x9a7825
movl $0x0, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x9a77b9
jmp 0x9a7817
jmp 0x9a77bb
movq -0x10(%rbp), %rax
cmpl $0x3, (%rax)
jne 0x9a77de
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
movq -0x10(%rbp), %rdi
addq $0x188, %rdi # imm = 0x188
callq 0x9a74b0
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x9a77ef
jmp 0x9a780c
movq -0x10(%rbp), %rdi
addq $0x188, %rdi # imm = 0x188
movq -0x10(%rbp), %rsi
addq $0x160, %rsi # imm = 0x160
callq 0x9a7b70
jmp 0x9a77bb
jmp 0x9a780e
movl $0x1, -0x1c(%rbp)
jmp 0x9a77aa
jmp 0x9a7819
movl $0x1, -0x18(%rbp)
jmp 0x9a7762
cmpl $0x0, -0x14(%rbp)
je 0x9a782d
jmp 0x9a784c
leaq 0x226252(%rip), %rdi # 0xbcda86
leaq 0x225f6a(%rip), %rsi # 0xbcd7a5
movl $0x172, %edx # imm = 0x172
leaq 0x226251(%rip), %rcx # 0xbcda98
callq 0x3b440
cmpl $0x3, -0x14(%rbp)
je 0x9a7854
jmp 0x9a7873
leaq 0x226258(%rip), %rdi # 0xbcdab3
leaq 0x225f43(%rip), %rsi # 0xbcd7a5
movl $0x173, %edx # imm = 0x173
leaq 0x22622a(%rip), %rcx # 0xbcda98
callq 0x3b440
cmpl $0x2, -0x14(%rbp)
ja 0x9a7888
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x9a7bc0
movl %eax, -0x14(%rbp)
cmpl $0x4, -0x14(%rbp)
jne 0x9a7893
jmp 0x9a7a63
movl $0x0, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
je 0x9a78b7
movq -0x10(%rbp), %rdi
addq $0x160, %rdi # imm = 0x160
callq 0x9a6d60
xorl %eax, %eax
movl %eax, -0x34(%rbp)
jmp 0x9a78cf
movq -0x10(%rbp), %rdi
addq $0x160, %rdi # imm = 0x160
callq 0x9a6db0
movl $0x1, %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl $0x0, %eax
je 0x9a7929
movl $0x0, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x9a78ed
jmp 0x9a791b
movq -0x10(%rbp), %rax
cmpl $0x4, (%rax)
je 0x9a7910
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
movq -0x10(%rbp), %rdi
addq $0x188, %rdi # imm = 0x188
callq 0x9a74b0
jmp 0x9a7912
movl $0x1, -0x24(%rbp)
jmp 0x9a78de
jmp 0x9a791d
movl $0x1, -0x20(%rbp)
jmp 0x9a789a
movl $0x0, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
je 0x9a7951
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
addq $0x168, %rdi # imm = 0x168
callq 0x9a6d60
xorl %eax, %eax
movl %eax, -0x38(%rbp)
jmp 0x9a796d
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
addq $0x168, %rdi # imm = 0x168
callq 0x9a6db0
movl $0x1, %eax
movl %eax, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl $0x0, %eax
je 0x9a7a5e
movl $0x0, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x9a7992
jmp 0x9a7a50
cmpl $0x2, -0x14(%rbp)
sete %cl
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
andb $0x1, %cl
movb %cl, 0x20(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x18(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
addq 0x158(%rax), %rcx
movq %rcx, 0x158(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
addq 0x160(%rax), %rcx
movq %rcx, 0x160(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x38(%rax)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x148(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x158(%rax)
movq -0x10(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rcx, 0x148(%rax)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
addq $0x190, %rdi # imm = 0x190
callq 0x9a74b0
movl $0x1, -0x2c(%rbp)
jmp 0x9a7980
jmp 0x9a7a52
movl $0x1, -0x28(%rbp)
jmp 0x9a7930
jmp 0x9a775b
movq -0x10(%rbp), %rdi
addq $0x160, %rdi # imm = 0x160
callq 0x9a61d0
movq -0x10(%rbp), %rdi
addq $0x188, %rdi # imm = 0x188
callq 0x9a7ac0
movq -0x10(%rbp), %rdi
addq $0x40, %rdi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rsi
callq 0x9a32d0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rsi
callq 0x9a3140
xorl %eax, %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/stream_encoder_mt.c
|
worker_error
|
static void
worker_error(worker_thread *thr, lzma_ret ret)
{
assert(ret != LZMA_OK);
assert(ret != LZMA_STREAM_END);
mythread_sync(thr->coder->mutex) {
if (thr->coder->thread_error == LZMA_OK)
thr->coder->thread_error = ret;
mythread_cond_signal(&thr->coder->cond);
}
return;
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x9a8247
jmp 0x9a8266
leaq 0x22594d(%rip), %rdi # 0xbcdb9b
leaq 0x225550(%rip), %rsi # 0xbcd7a5
movl $0xb8, %edx
leaq 0x225949(%rip), %rcx # 0xbcdbaa
callq 0x3b440
cmpl $0x1, -0xc(%rbp)
je 0x9a826e
jmp 0x9a828d
leaq 0x2256b2(%rip), %rdi # 0xbcd927
leaq 0x225529(%rip), %rsi # 0xbcd7a5
movl $0xb9, %edx
leaq 0x225922(%rip), %rcx # 0xbcdbaa
callq 0x3b440
movl $0x0, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
je 0x9a82b5
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
addq $0x168, %rdi # imm = 0x168
callq 0x9a6d60
xorl %eax, %eax
movl %eax, -0x18(%rbp)
jmp 0x9a82d1
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
addq $0x168, %rdi # imm = 0x168
callq 0x9a6db0
movl $0x1, %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl $0x0, %eax
je 0x9a833c
movl $0x0, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x9a82ef
jmp 0x9a832e
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
cmpl $0x0, 0x134(%rax)
jne 0x9a8311
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movl %ecx, 0x134(%rax)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
addq $0x190, %rdi # imm = 0x190
callq 0x9a74b0
movl $0x1, -0x14(%rbp)
jmp 0x9a82e0
jmp 0x9a8330
movl $0x1, -0x10(%rbp)
jmp 0x9a8294
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/stream_encoder_mt.c
|
lzma_stream_flags_compare
|
extern LZMA_API(lzma_ret)
lzma_stream_flags_compare(
const lzma_stream_flags *a, const lzma_stream_flags *b)
{
// We can compare only version 0 structures.
if (a->version != 0 || b->version != 0)
return LZMA_OPTIONS_ERROR;
// Check type
if ((unsigned int)(a->check) > LZMA_CHECK_ID_MAX
|| (unsigned int)(b->check) > LZMA_CHECK_ID_MAX)
return LZMA_PROG_ERROR;
if (a->check != b->check)
return LZMA_DATA_ERROR;
// Backward Sizes are compared only if they are known in both.
if (a->backward_size != LZMA_VLI_UNKNOWN
&& b->backward_size != LZMA_VLI_UNKNOWN) {
if (!is_backward_size_valid(a) || !is_backward_size_valid(b))
return LZMA_PROG_ERROR;
if (a->backward_size != b->backward_size)
return LZMA_DATA_ERROR;
}
return LZMA_OK;
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x9a84a2
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x9a84ae
movl $0x8, -0x4(%rbp)
jmp 0x9a8543
movq -0x10(%rbp), %rax
cmpl $0xf, 0x10(%rax)
ja 0x9a84c2
movq -0x18(%rbp), %rax
cmpl $0xf, 0x10(%rax)
jbe 0x9a84cb
movl $0xb, -0x4(%rbp)
jmp 0x9a8543
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x10(%rcx), %eax
je 0x9a84e4
movl $0x9, -0x4(%rbp)
jmp 0x9a8543
movq -0x10(%rbp), %rax
cmpq $-0x1, 0x8(%rax)
je 0x9a853c
movq -0x18(%rbp), %rax
cmpq $-0x1, 0x8(%rax)
je 0x9a853c
movq -0x10(%rbp), %rdi
callq 0x9a8550
testb $0x1, %al
jne 0x9a8509
jmp 0x9a8516
movq -0x18(%rbp), %rdi
callq 0x9a8550
testb $0x1, %al
jne 0x9a851f
movl $0xb, -0x4(%rbp)
jmp 0x9a8543
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x8(%rcx), %rax
je 0x9a853a
movl $0x9, -0x4(%rbp)
jmp 0x9a8543
jmp 0x9a853c
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
|
/JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/stream_flags_common.c
|
lzma_stream_header_decode
|
extern LZMA_API(lzma_ret)
lzma_stream_header_decode(lzma_stream_flags *options, const uint8_t *in)
{
// Magic
if (memcmp(in, lzma_header_magic, sizeof(lzma_header_magic)) != 0)
return LZMA_FORMAT_ERROR;
// Verify the CRC32 so we can distinguish between corrupt
// and unsupported files.
const uint32_t crc = lzma_crc32(in + sizeof(lzma_header_magic),
LZMA_STREAM_FLAGS_SIZE, 0);
if (crc != read32le(in + sizeof(lzma_header_magic)
+ LZMA_STREAM_FLAGS_SIZE))
return LZMA_DATA_ERROR;
// Stream Flags
if (stream_flags_decode(options, in + sizeof(lzma_header_magic)))
return LZMA_OPTIONS_ERROR;
// Set Backward Size to indicate unknown value. That way
// lzma_stream_flags_compare() can be used to compare Stream Header
// and Stream Footer while keeping it useful also for comparing
// two Stream Footers.
options->backward_size = LZMA_VLI_UNKNOWN;
return LZMA_OK;
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x2257af(%rip), %rsi # 0xbcdd6a
movl $0x6, %edx
callq 0x3c770
cmpl $0x0, %eax
je 0x9a85d3
movl $0x7, -0x4(%rbp)
jmp 0x9a8646
movq -0x18(%rbp), %rdi
addq $0x6, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x9a2300
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
addq $0x6, %rdi
addq $0x2, %rdi
callq 0x9a8650
movl %eax, %ecx
movl -0x20(%rbp), %eax
cmpl %ecx, %eax
je 0x9a8613
movl $0x9, -0x4(%rbp)
jmp 0x9a8646
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x6, %rsi
callq 0x9a8680
testb $0x1, %al
jne 0x9a862a
jmp 0x9a8633
movl $0x8, -0x4(%rbp)
jmp 0x9a8646
movq -0x10(%rbp), %rax
movq $-0x1, 0x8(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
|
/JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/stream_flags_decoder.c
|
read32le
|
static inline uint32_t
read32le(const uint8_t *buf)
{
#if !defined(WORDS_BIGENDIAN) || defined(TUKLIB_FAST_UNALIGNED_ACCESS)
uint32_t num = read32ne(buf);
return conv32le(num);
#else
uint32_t num = (uint32_t)buf[0];
num |= (uint32_t)buf[1] << 8;
num |= (uint32_t)buf[2] << 16;
num |= (uint32_t)buf[3] << 24;
return num;
#endif
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x9a87c0
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmliblzma/common/tuklib_integer.h
|
read32ne
|
static inline uint32_t
read32ne(const uint8_t *buf)
{
#if defined(TUKLIB_FAST_UNALIGNED_ACCESS) \
&& defined(TUKLIB_USE_UNSAFE_TYPE_PUNNING)
return *(const uint32_t *)buf;
#else
uint32_t num;
memcpy(&num, buf, sizeof(num));
return num;
#endif
}
|
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmliblzma/common/tuklib_integer.h
|
is_backward_size_valid
|
static inline bool
is_backward_size_valid(const lzma_stream_flags *options)
{
return options->backward_size >= LZMA_BACKWARD_SIZE_MIN
&& options->backward_size <= LZMA_BACKWARD_SIZE_MAX
&& (options->backward_size & 3) == 0;
}
|
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpq $0x4, 0x8(%rcx)
movb %al, -0x9(%rbp)
jb 0x9a89e7
movq -0x8(%rbp), %rcx
xorl %eax, %eax
movabsq $0x400000000, %rdx # imm = 0x400000000
cmpq %rdx, 0x8(%rcx)
movb %al, -0x9(%rbp)
ja 0x9a89e7
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
andq $0x3, %rax
cmpq $0x0, %rax
sete %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nop
|
/JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/stream_flags_common.h
|
lzma_delta_coder_memusage
|
extern uint64_t
lzma_delta_coder_memusage(const void *options)
{
const lzma_options_delta *opt = options;
if (opt == NULL || opt->type != LZMA_DELTA_TYPE_BYTE
|| opt->dist < LZMA_DELTA_DIST_MIN
|| opt->dist > LZMA_DELTA_DIST_MAX)
return UINT64_MAX;
return sizeof(lzma_delta_coder);
}
|
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x9a8b87
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x9a8b87
movq -0x18(%rbp), %rax
cmpl $0x1, 0x4(%rax)
jb 0x9a8b87
movq -0x18(%rbp), %rax
cmpl $0x100, 0x4(%rax) # imm = 0x100
jbe 0x9a8b91
movq $-0x1, -0x8(%rbp)
jmp 0x9a8b99
movq $0x158, -0x8(%rbp) # imm = 0x158
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
|
/JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/delta/delta_common.c
|
lzma_delta_props_decode
|
extern lzma_ret
lzma_delta_props_decode(void **options, const lzma_allocator *allocator,
const uint8_t *props, size_t props_size)
{
if (props_size != 1)
return LZMA_OPTIONS_ERROR;
lzma_options_delta *opt
= lzma_alloc(sizeof(lzma_options_delta), allocator);
if (opt == NULL)
return LZMA_MEM_ERROR;
opt->type = LZMA_DELTA_TYPE_BYTE;
opt->dist = props[0] + 1U;
*options = opt;
return LZMA_OK;
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
cmpq $0x1, -0x28(%rbp)
je 0x9a8ce8
movl $0x8, -0x4(%rbp)
jmp 0x9a8d37
movq -0x18(%rbp), %rsi
movl $0x28, %edi
callq 0x9a3040
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x9a8d0a
movl $0x5, -0x4(%rbp)
jmp 0x9a8d37
movq -0x30(%rbp), %rax
movl $0x0, (%rax)
movq -0x20(%rbp), %rax
movzbl (%rax), %ecx
addl $0x1, %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
|
/JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/delta/delta_decoder.c
|
lzma_delta_props_encode
|
extern lzma_ret
lzma_delta_props_encode(const void *options, uint8_t *out)
{
// The caller must have already validated the options, so it's
// LZMA_PROG_ERROR if they are invalid.
if (lzma_delta_coder_memusage(options) == UINT64_MAX)
return LZMA_PROG_ERROR;
const lzma_options_delta *opt = options;
out[0] = opt->dist - LZMA_DELTA_DIST_MIN;
return LZMA_OK;
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x9a8b50
cmpq $-0x1, %rax
jne 0x9a9008
movl $0xb, -0x4(%rbp)
jmp 0x9a9029
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0x4(%rax), %eax
subl $0x1, %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/delta/delta_encoder.c
|
lzma2_decoder_init
|
static lzma_ret
lzma2_decoder_init(lzma_lz_decoder *lz, const lzma_allocator *allocator,
const void *opt, lzma_lz_options *lz_options)
{
lzma_lzma2_coder *coder = lz->coder;
if (coder == NULL) {
coder = lzma_alloc(sizeof(lzma_lzma2_coder), allocator);
if (coder == NULL)
return LZMA_MEM_ERROR;
lz->coder = coder;
lz->code = &lzma2_decode;
lz->end = &lzma2_decoder_end;
coder->lzma = LZMA_LZ_DECODER_INIT;
}
const lzma_options_lzma *options = opt;
coder->sequence = SEQ_CONTROL;
coder->need_properties = true;
coder->need_dictionary_reset = options->preset_dict == NULL
|| options->preset_dict_size == 0;
return lzma_lzma_decoder_create(&coder->lzma,
allocator, options, lz_options);
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x9a9b06
movq -0x18(%rbp), %rsi
movl $0xb8, %edi
callq 0x9a3040
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x9a9aaf
movl $0x5, -0x4(%rbp)
jmp 0x9a9b67
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0x1db(%rip), %rcx # 0x9a9ca0
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x60c(%rip), %rcx # 0x9aa0e0
movq %rcx, 0x20(%rax)
movq -0x30(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x68(%rbp)
leaq -0x58(%rbp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x3b780
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rsi
movl $0x28, %edx
callq 0x3cb70
movq -0x20(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x30(%rbp), %rax
movl $0x0, (%rax)
movq -0x30(%rbp), %rax
movb $0x1, 0x40(%rax)
movq -0x60(%rbp), %rcx
movb $0x1, %al
cmpq $0x0, 0x8(%rcx)
movb %al, -0x69(%rbp)
je 0x9a9b3e
movq -0x60(%rbp), %rax
cmpl $0x0, 0x10(%rax)
sete %al
movb %al, -0x69(%rbp)
movb -0x69(%rbp), %cl
movq -0x30(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x41(%rax)
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
movq -0x18(%rbp), %rsi
movq -0x60(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x9aafc0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
|
/JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/lzma/lzma2_decoder.c
|
lzma_lzma_decoder_create
|
extern lzma_ret
lzma_lzma_decoder_create(lzma_lz_decoder *lz, const lzma_allocator *allocator,
const void *opt, lzma_lz_options *lz_options)
{
if (lz->coder == NULL) {
lz->coder = lzma_alloc(sizeof(lzma_lzma1_decoder), allocator);
if (lz->coder == NULL)
return LZMA_MEM_ERROR;
lz->code = &lzma_decode;
lz->reset = &lzma_decoder_reset;
lz->set_uncompressed = &lzma_decoder_uncompressed;
}
// All dictionary sizes are OK here. LZ decoder will take care of
// the special cases.
const lzma_options_lzma *options = opt;
lz_options->dict_size = options->dict_size;
lz_options->preset_dict = options->preset_dict;
lz_options->preset_dict_size = options->preset_dict_size;
return LZMA_OK;
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x9ab03a
movq -0x18(%rbp), %rsi
movl $0x6ec0, %edi # imm = 0x6EC0
callq 0x9a3040
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x9ab00d
movl $0x5, -0x4(%rbp)
jmp 0x9ab079
movq -0x10(%rbp), %rax
leaq 0x78(%rip), %rcx # 0x9ab090
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x7399(%rip), %rcx # 0x9b23c0
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
leaq 0x780a(%rip), %rcx # 0x9b2840
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x30(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, %ecx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/lzma/lzma_decoder.c
|
lzma_decoder_reset
|
static void
lzma_decoder_reset(void *coder_ptr, const void *opt)
{
lzma_lzma1_decoder *coder = coder_ptr;
const lzma_options_lzma *options = opt;
// NOTE: We assume that lc/lp/pb are valid since they were
// successfully decoded with lzma_lzma_decode_properties().
// Calculate pos_mask. We don't need pos_bits as is for anything.
coder->pos_mask = (1U << options->pb) - 1;
// Initialize the literal decoder.
literal_init(coder->literal, options->lc, options->lp);
coder->literal_context_bits = options->lc;
coder->literal_pos_mask = (1U << options->lp) - 1;
// State
coder->state = STATE_LIT_LIT;
coder->rep0 = 0;
coder->rep1 = 0;
coder->rep2 = 0;
coder->rep3 = 0;
coder->pos_mask = (1U << options->pb) - 1;
// Range decoder
rc_reset(coder->rc);
// Bit and bittree decoders
for (uint32_t i = 0; i < STATES; ++i) {
for (uint32_t j = 0; j <= coder->pos_mask; ++j) {
bit_reset(coder->is_match[i][j]);
bit_reset(coder->is_rep0_long[i][j]);
}
bit_reset(coder->is_rep[i]);
bit_reset(coder->is_rep0[i]);
bit_reset(coder->is_rep1[i]);
bit_reset(coder->is_rep2[i]);
}
for (uint32_t i = 0; i < DIST_STATES; ++i)
bittree_reset(coder->dist_slot[i], DIST_SLOT_BITS);
for (uint32_t i = 0; i < FULL_DISTANCES - DIST_MODEL_END; ++i)
bit_reset(coder->pos_special[i]);
bittree_reset(coder->pos_align, ALIGN_BITS);
// Len decoders (also bit/bittree)
const uint32_t num_pos_states = 1U << options->pb;
bit_reset(coder->match_len_decoder.choice);
bit_reset(coder->match_len_decoder.choice2);
bit_reset(coder->rep_len_decoder.choice);
bit_reset(coder->rep_len_decoder.choice2);
for (uint32_t pos_state = 0; pos_state < num_pos_states; ++pos_state) {
bittree_reset(coder->match_len_decoder.low[pos_state],
LEN_LOW_BITS);
bittree_reset(coder->match_len_decoder.mid[pos_state],
LEN_MID_BITS);
bittree_reset(coder->rep_len_decoder.low[pos_state],
LEN_LOW_BITS);
bittree_reset(coder->rep_len_decoder.mid[pos_state],
LEN_MID_BITS);
}
bittree_reset(coder->match_len_decoder.high, LEN_HIGH_BITS);
bittree_reset(coder->rep_len_decoder.high, LEN_HIGH_BITS);
coder->sequence = SEQ_IS_MATCH;
coder->probs = NULL;
coder->symbol = 0;
coder->limit = 0;
coder->offset = 0;
coder->len = 0;
return;
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0x1c(%rax), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, %ecx
subl $0x1, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x6e8c(%rax)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rax
movl 0x14(%rax), %esi
movq -0x20(%rbp), %rax
movl 0x18(%rax), %edx
callq 0x9b3000
movq -0x20(%rbp), %rax
movl 0x14(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x6e90(%rax)
movq -0x20(%rbp), %rax
movl 0x18(%rax), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, %ecx
subl $0x1, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x6e94(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x6e78(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x6e7c(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x6e80(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x6e84(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x6e88(%rax)
movq -0x20(%rbp), %rax
movl 0x1c(%rax), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, %ecx
subl $0x1, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x6e8c(%rax)
movq -0x18(%rbp), %rax
movl $0xffffffff, 0x6e6c(%rax) # imm = 0xFFFFFFFF
movq -0x18(%rbp), %rax
movl $0x0, 0x6e70(%rax)
movq -0x18(%rbp), %rax
movl $0x5, 0x6e74(%rax)
movl $0x0, -0x24(%rbp)
cmpl $0xc, -0x24(%rbp)
jae 0x9b258d
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x6e8c(%rcx), %eax
ja 0x9b253b
movq -0x18(%rbp), %rax
addq $0x6000, %rax # imm = 0x6000
movl -0x24(%rbp), %ecx
shlq $0x5, %rcx
addq %rcx, %rax
movl -0x28(%rbp), %ecx
movw $0x400, (%rax,%rcx,2) # imm = 0x400
movq -0x18(%rbp), %rax
addq $0x61e0, %rax # imm = 0x61E0
movl -0x24(%rbp), %ecx
shlq $0x5, %rcx
addq %rcx, %rax
movl -0x28(%rbp), %ecx
movw $0x400, (%rax,%rcx,2) # imm = 0x400
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x9b24e7
movq -0x18(%rbp), %rax
movl -0x24(%rbp), %ecx
movw $0x400, 0x6180(%rax,%rcx,2) # imm = 0x400
movq -0x18(%rbp), %rax
movl -0x24(%rbp), %ecx
movw $0x400, 0x6198(%rax,%rcx,2) # imm = 0x400
movq -0x18(%rbp), %rax
movl -0x24(%rbp), %ecx
movw $0x400, 0x61b0(%rax,%rcx,2) # imm = 0x400
movq -0x18(%rbp), %rax
movl -0x24(%rbp), %ecx
movw $0x400, 0x61c8(%rax,%rcx,2) # imm = 0x400
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x9b24d6
movl $0x0, -0x2c(%rbp)
cmpl $0x4, -0x2c(%rbp)
jae 0x9b25dc
movl $0x0, -0x30(%rbp)
cmpl $0x40, -0x30(%rbp)
jae 0x9b25cf
movq -0x18(%rbp), %rax
addq $0x6360, %rax # imm = 0x6360
movl -0x2c(%rbp), %ecx
shlq $0x7, %rcx
addq %rcx, %rax
movl -0x30(%rbp), %ecx
movw $0x400, (%rax,%rcx,2) # imm = 0x400
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x9b25a1
jmp 0x9b25d1
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x9b2594
movl $0x0, -0x34(%rbp)
cmpl $0x72, -0x34(%rbp)
jae 0x9b2605
movq -0x18(%rbp), %rax
movl -0x34(%rbp), %ecx
movw $0x400, 0x6560(%rax,%rcx,2) # imm = 0x400
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x9b25e3
movl $0x0, -0x38(%rbp)
cmpl $0x10, -0x38(%rbp)
jae 0x9b262e
movq -0x18(%rbp), %rax
movl -0x38(%rbp), %ecx
movw $0x400, 0x6644(%rax,%rcx,2) # imm = 0x400
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x9b260c
movq -0x20(%rbp), %rax
movl 0x1c(%rax), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x3c(%rbp)
movq -0x18(%rbp), %rax
movw $0x400, 0x6664(%rax) # imm = 0x400
movq -0x18(%rbp), %rax
movw $0x400, 0x6666(%rax) # imm = 0x400
movq -0x18(%rbp), %rax
movw $0x400, 0x6a68(%rax) # imm = 0x400
movq -0x18(%rbp), %rax
movw $0x400, 0x6a6a(%rax) # imm = 0x400
movl $0x0, -0x40(%rbp)
movl -0x40(%rbp), %eax
cmpl -0x3c(%rbp), %eax
jae 0x9b277e
movl $0x0, -0x44(%rbp)
cmpl $0x8, -0x44(%rbp)
jae 0x9b26bf
movq -0x18(%rbp), %rax
addq $0x6664, %rax # imm = 0x6664
addq $0x4, %rax
movl -0x40(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl -0x44(%rbp), %ecx
movw $0x400, (%rax,%rcx,2) # imm = 0x400
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x9b268d
movl $0x0, -0x48(%rbp)
cmpl $0x8, -0x48(%rbp)
jae 0x9b26fa
movq -0x18(%rbp), %rax
addq $0x6664, %rax # imm = 0x6664
addq $0x104, %rax # imm = 0x104
movl -0x40(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl -0x48(%rbp), %ecx
movw $0x400, (%rax,%rcx,2) # imm = 0x400
movl -0x48(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
jmp 0x9b26c6
movl $0x0, -0x4c(%rbp)
cmpl $0x8, -0x4c(%rbp)
jae 0x9b2733
movq -0x18(%rbp), %rax
addq $0x6a68, %rax # imm = 0x6A68
addq $0x4, %rax
movl -0x40(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl -0x4c(%rbp), %ecx
movw $0x400, (%rax,%rcx,2) # imm = 0x400
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x9b2701
movl $0x0, -0x50(%rbp)
cmpl $0x8, -0x50(%rbp)
jae 0x9b276e
movq -0x18(%rbp), %rax
addq $0x6a68, %rax # imm = 0x6A68
addq $0x104, %rax # imm = 0x104
movl -0x40(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl -0x50(%rbp), %ecx
movw $0x400, (%rax,%rcx,2) # imm = 0x400
movl -0x50(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x50(%rbp)
jmp 0x9b273a
jmp 0x9b2770
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rbp)
jmp 0x9b267a
movl $0x0, -0x54(%rbp)
cmpl $0x100, -0x54(%rbp) # imm = 0x100
jae 0x9b27aa
movq -0x18(%rbp), %rax
movl -0x54(%rbp), %ecx
movw $0x400, 0x6868(%rax,%rcx,2) # imm = 0x400
movl -0x54(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x54(%rbp)
jmp 0x9b2785
movl $0x0, -0x58(%rbp)
cmpl $0x100, -0x58(%rbp) # imm = 0x100
jae 0x9b27d6
movq -0x18(%rbp), %rax
movl -0x58(%rbp), %ecx
movw $0x400, 0x6c6c(%rax,%rcx,2) # imm = 0x400
movl -0x58(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x58(%rbp)
jmp 0x9b27b1
movq -0x18(%rbp), %rax
movl $0x1, 0x6ea0(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x6ea8(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x6eb0(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x6eb4(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x6eb8(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x6ebc(%rax)
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/lzma/lzma_decoder.c
|
read32ne
|
static inline uint32_t
read32ne(const uint8_t *buf)
{
#if defined(TUKLIB_FAST_UNALIGNED_ACCESS) \
&& defined(TUKLIB_USE_UNSAFE_TYPE_PUNNING)
return *(const uint32_t *)buf;
#else
uint32_t num;
memcpy(&num, buf, sizeof(num));
return num;
#endif
}
|
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmliblzma/common/tuklib_integer.h
|
encode_init
|
static bool
encode_init(lzma_lzma1_encoder *coder, lzma_mf *mf)
{
assert(mf_position(mf) == 0);
if (mf->read_pos == mf->read_limit) {
if (mf->action == LZMA_RUN)
return false; // We cannot do anything.
// We are finishing (we cannot get here when flushing).
assert(mf->write_pos == mf->read_pos);
assert(mf->action == LZMA_FINISH);
} else {
// Do the actual initialization. The first LZMA symbol must
// always be a literal.
mf_skip(mf, 1);
mf->read_ahead = 0;
rc_bit(&coder->rc, &coder->is_match[0][0], 0);
rc_bittree(&coder->rc, coder->literal[0], 8, mf->buffer[0]);
}
// Initialization is done (except if empty file).
coder->is_initialized = true;
return true;
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x9b3420
cmpl $0x0, %eax
jne 0x9b3310
jmp 0x9b332f
leaq 0x21b7fd(%rip), %rdi # 0xbceb14
leaq 0x21b69a(%rip), %rsi # 0xbce9b8
movl $0x10e, %edx # imm = 0x10E
leaq 0x21b7ff(%rip), %rcx # 0xbceb29
callq 0x3b440
movq -0x18(%rbp), %rax
movl 0x18(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x20(%rcx), %eax
jne 0x9b33b0
movq -0x18(%rbp), %rax
cmpl $0x0, 0x68(%rax)
jne 0x9b3352
movb $0x0, -0x1(%rbp)
jmp 0x9b3411
movq -0x18(%rbp), %rax
movl 0x24(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jne 0x9b3364
jmp 0x9b3383
leaq 0x21b7f1(%rip), %rdi # 0xbceb5c
leaq 0x21b646(%rip), %rsi # 0xbce9b8
movl $0x115, %edx # imm = 0x115
leaq 0x21b7ab(%rip), %rcx # 0xbceb29
callq 0x3b440
movq -0x18(%rbp), %rax
cmpl $0x3, 0x68(%rax)
jne 0x9b338f
jmp 0x9b33ae
leaq 0x21b7e4(%rip), %rdi # 0xbceb7a
leaq 0x21b61b(%rip), %rsi # 0xbce9b8
movl $0x116, %edx # imm = 0x116
leaq 0x21b780(%rip), %rcx # 0xbceb29
callq 0x3b440
jmp 0x9b3402
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x9b43c0
movq -0x18(%rbp), %rax
movl $0x0, 0x1c(%rax)
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x6b9c, %rsi # imm = 0x6B9C
xorl %edx, %edx
callq 0x9b4400
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0xb9c, %rsi # imm = 0xB9C
movq -0x18(%rbp), %rax
movq (%rax), %rax
movzbl (%rax), %ecx
movl $0x8, %edx
callq 0x9b4450
movq -0x10(%rbp), %rax
movb $0x1, 0xb8d(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
|
/JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/lzma/lzma_encoder.c
|
literal_init
|
static inline void
literal_init(probability (*probs)[LITERAL_CODER_SIZE],
uint32_t lc, uint32_t lp)
{
assert(lc + lp <= LZMA_LCLP_MAX);
const uint32_t coders = 1U << (lc + lp);
for (uint32_t i = 0; i < coders; ++i)
for (uint32_t j = 0; j < LITERAL_CODER_SIZE; ++j)
bit_reset(probs[i][j]);
return;
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0xc(%rbp), %eax
addl -0x10(%rbp), %eax
cmpl $0x4, %eax
ja 0x9b3d7f
jmp 0x9b3d9e
leaq 0x21ab3c(%rip), %rdi # 0xbce8c2
leaq 0x21ab4e(%rip), %rsi # 0xbce8db
movl $0x85, %edx
leaq 0x21abba(%rip), %rcx # 0xbce953
callq 0x3b440
movl -0xc(%rbp), %ecx
addl -0x10(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x9b3dff
movl $0x0, -0x1c(%rbp)
cmpl $0x300, -0x1c(%rbp) # imm = 0x300
jae 0x9b3df2
movq -0x8(%rbp), %rax
movl -0x18(%rbp), %ecx
imulq $0x600, %rcx, %rcx # imm = 0x600
addq %rcx, %rax
movl -0x1c(%rbp), %ecx
movw $0x400, (%rax,%rcx,2) # imm = 0x400
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x9b3dc4
jmp 0x9b3df4
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x9b3db5
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/lzma/lzma_common.h
|
rc_shift_low
|
static inline bool
rc_shift_low(lzma_range_encoder *rc,
uint8_t *out, size_t *out_pos, size_t out_size)
{
if ((uint32_t)(rc->low) < (uint32_t)(0xFF000000)
|| (uint32_t)(rc->low >> 32) != 0) {
do {
if (*out_pos == out_size)
return true;
out[*out_pos] = rc->cache + (uint8_t)(rc->low >> 32);
++*out_pos;
rc->cache = 0xFF;
} while (--rc->cache_size != 0);
rc->cache = (rc->low >> 24) & 0xFF;
}
++rc->cache_size;
rc->low = (rc->low & 0x00FFFFFF) << RC_SHIFT_BITS;
return false;
}
|
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0xff000000, %eax # imm = 0xFF000000
jb 0x9b44f6
movq -0x10(%rbp), %rax
movq (%rax), %rax
shrq $0x20, %rax
cmpl $0x0, %eax
je 0x9b457c
jmp 0x9b44f8
movq -0x20(%rbp), %rax
movq (%rax), %rax
cmpq -0x28(%rbp), %rax
jne 0x9b450e
movb $0x1, -0x1(%rbp)
jmp 0x9b45a9
movq -0x10(%rbp), %rax
movzbl 0x14(%rax), %eax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
shrq $0x20, %rcx
movzbl %cl, %ecx
addl %ecx, %eax
movb %al, %dl
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rcx), %rcx
movb %dl, (%rax,%rcx)
movq -0x20(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movb $-0x1, 0x14(%rax)
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rax
addq $-0x1, %rax
movq %rax, 0x8(%rcx)
cmpq $0x0, %rax
jne 0x9b44f8
movq -0x10(%rbp), %rax
movq (%rax), %rax
shrq $0x18, %rax
andq $0xff, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x14(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
andq $0xffffff, %rcx # imm = 0xFFFFFF
shlq $0x8, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
|
/JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/rangecoder/range_encoder.h
|
length_update_prices
|
static void
length_update_prices(lzma_length_encoder *lc, const uint32_t pos_state)
{
const uint32_t table_size = lc->table_size;
lc->counters[pos_state] = table_size;
const uint32_t a0 = rc_bit_0_price(lc->choice);
const uint32_t a1 = rc_bit_1_price(lc->choice);
const uint32_t b0 = a1 + rc_bit_0_price(lc->choice2);
const uint32_t b1 = a1 + rc_bit_1_price(lc->choice2);
uint32_t *const prices = lc->prices[pos_state];
uint32_t i;
for (i = 0; i < table_size && i < LEN_LOW_SYMBOLS; ++i)
prices[i] = a0 + rc_bittree_price(lc->low[pos_state],
LEN_LOW_BITS, i);
for (; i < table_size && i < LEN_LOW_SYMBOLS + LEN_MID_SYMBOLS; ++i)
prices[i] = b0 + rc_bittree_price(lc->mid[pos_state],
LEN_MID_BITS, i - LEN_LOW_SYMBOLS);
for (; i < table_size; ++i)
prices[i] = b1 + rc_bittree_price(lc->high, LEN_HIGH_BITS,
i - LEN_LOW_SYMBOLS - LEN_MID_SYMBOLS);
return;
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x4804(%rax), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %edx
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %edx, 0x4808(%rax,%rcx,4)
movq -0x8(%rbp), %rax
movzwl (%rax), %edi
callq 0x9b4eb0
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movzwl (%rax), %edi
callq 0x9b4ee0
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x8(%rbp), %rax
movzwl 0x2(%rax), %edi
callq 0x9b4eb0
movl %eax, %ecx
movl -0x34(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x1c(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movzwl 0x2(%rax), %edi
callq 0x9b4ee0
movl %eax, %ecx
movl -0x30(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rax
addq $0x404, %rax # imm = 0x404
movl -0xc(%rbp), %ecx
imulq $0x440, %rcx, %rcx # imm = 0x440
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %ecx
xorl %eax, %eax
cmpl -0x10(%rbp), %ecx
movb %al, -0x35(%rbp)
jae 0x9b4dae
cmpl $0x8, -0x2c(%rbp)
setb %al
movb %al, -0x35(%rbp)
movb -0x35(%rbp), %al
testb $0x1, %al
jne 0x9b4db7
jmp 0x9b4df6
movl -0x14(%rbp), %eax
movl %eax, -0x3c(%rbp)
movq -0x8(%rbp), %rdi
addq $0x4, %rdi
movl -0xc(%rbp), %eax
shlq $0x4, %rax
addq %rax, %rdi
movl -0x2c(%rbp), %edx
movl $0x3, %esi
callq 0x9b4f10
movl -0x3c(%rbp), %edx
addl %eax, %edx
movq -0x28(%rbp), %rax
movl -0x2c(%rbp), %ecx
movl %edx, (%rax,%rcx,4)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x9b4d97
jmp 0x9b4df8
movl -0x2c(%rbp), %ecx
xorl %eax, %eax
cmpl -0x10(%rbp), %ecx
movb %al, -0x3d(%rbp)
jae 0x9b4e0f
cmpl $0x10, -0x2c(%rbp)
setb %al
movb %al, -0x3d(%rbp)
movb -0x3d(%rbp), %al
testb $0x1, %al
jne 0x9b4e18
jmp 0x9b4e5d
movl -0x1c(%rbp), %eax
movl %eax, -0x44(%rbp)
movq -0x8(%rbp), %rdi
addq $0x104, %rdi # imm = 0x104
movl -0xc(%rbp), %eax
shlq $0x4, %rax
addq %rax, %rdi
movl -0x2c(%rbp), %edx
subl $0x8, %edx
movl $0x3, %esi
callq 0x9b4f10
movl -0x44(%rbp), %edx
addl %eax, %edx
movq -0x28(%rbp), %rax
movl -0x2c(%rbp), %ecx
movl %edx, (%rax,%rcx,4)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x9b4df8
jmp 0x9b4e5f
movl -0x2c(%rbp), %eax
cmpl -0x10(%rbp), %eax
jae 0x9b4ea5
movl -0x20(%rbp), %eax
movl %eax, -0x48(%rbp)
movq -0x8(%rbp), %rdi
addq $0x204, %rdi # imm = 0x204
movl -0x2c(%rbp), %edx
subl $0x8, %edx
subl $0x8, %edx
movl $0x8, %esi
callq 0x9b4f10
movl -0x48(%rbp), %edx
addl %eax, %edx
movq -0x28(%rbp), %rax
movl -0x2c(%rbp), %ecx
movl %edx, (%rax,%rcx,4)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x9b4e5f
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/lzma/lzma_encoder.c
|
read64ne
|
static inline uint64_t
read64ne(const uint8_t *buf)
{
#if defined(TUKLIB_FAST_UNALIGNED_ACCESS) \
&& defined(TUKLIB_USE_UNSAFE_TYPE_PUNNING)
return *(const uint64_t *)buf;
#else
uint64_t num;
memcpy(&num, buf, sizeof(num));
return num;
#endif
}
|
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
popq %rbp
retq
nopl (%rax)
|
/JKorbelRA[P]CMake/Utilities/cmliblzma/common/tuklib_integer.h
|
rc_bittree_price
|
static inline uint32_t
rc_bittree_price(const probability *const probs,
const uint32_t bit_levels, uint32_t symbol)
{
uint32_t price = 0;
symbol += UINT32_C(1) << bit_levels;
do {
const uint32_t bit = symbol & 1;
symbol >>= 1;
price += rc_bit_price(probs[symbol], bit);
} while (symbol != 1);
return price;
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0xc(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
addl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
andl $0x1, %eax
movl %eax, -0x18(%rbp)
movl -0x10(%rbp), %eax
shrl %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
movw (%rax,%rcx,2), %ax
movl -0x18(%rbp), %esi
movzwl %ax, %edi
callq 0x9b8990
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
cmpl $0x1, -0x10(%rbp)
jne 0x9b8859
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/rangecoder/price.h
|
read64ne
|
static inline uint64_t
read64ne(const uint8_t *buf)
{
#if defined(TUKLIB_FAST_UNALIGNED_ACCESS) \
&& defined(TUKLIB_USE_UNSAFE_TYPE_PUNNING)
return *(const uint64_t *)buf;
#else
uint64_t num;
memcpy(&num, buf, sizeof(num));
return num;
#endif
}
|
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
popq %rbp
retq
nopl (%rax)
|
/JKorbelRA[P]CMake/Utilities/cmliblzma/common/tuklib_integer.h
|
call_filter
|
static size_t
call_filter(lzma_simple_coder *coder, uint8_t *buffer, size_t size)
{
const size_t filtered = coder->filter(coder->simple,
coder->now_pos, coder->is_encoder,
buffer, size);
coder->now_pos += filtered;
return filtered;
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x58(%rcx), %rdi
movq -0x8(%rbp), %rcx
movl 0x60(%rcx), %esi
movq -0x8(%rbp), %rcx
movb 0x49(%rcx), %dl
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %r8
andb $0x1, %dl
movzbl %dl, %edx
callq *%rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdx
movq -0x8(%rbp), %rax
movl 0x60(%rax), %ecx
addq %rdx, %rcx
movl %ecx, 0x60(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/simple/simple_coder.c
|
x86_coder_init
|
static lzma_ret
x86_coder_init(lzma_next_coder *next, const lzma_allocator *allocator,
const lzma_filter_info *filters, bool is_encoder)
{
const lzma_ret ret = lzma_simple_coder_init(next, allocator, filters,
&x86_code, sizeof(lzma_simple_x86), 5, 1, is_encoder);
if (ret == LZMA_OK) {
lzma_simple_coder *coder = next->coder;
lzma_simple_x86 *simple = coder->simple;
simple->prev_mask = 0;
simple->prev_pos = (uint32_t)(-5);
}
return ret;
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movb -0x19(%rbp), %al
leaq 0x8f(%rip), %rcx # 0x9ba8a0
movl $0x8, %r8d
movl $0x5, %r9d
andb $0x1, %al
movl $0x1, (%rsp)
movzbl %al, %eax
movl %eax, 0x8(%rsp)
callq 0x9b9a70
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jne 0x9ba867
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl $0x0, (%rax)
movq -0x30(%rbp), %rax
movl $0xfffffffb, 0x4(%rax) # imm = 0xFFFFFFFB
movl -0x20(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
|
/JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/simple/x86.c
|
lzma_sha256_finish
|
extern void
lzma_sha256_finish(lzma_check_state *check)
{
// Add padding as described in RFC 3174 (it describes SHA-1 but
// the same padding style is used for SHA-256 too).
size_t pos = check->state.sha256.size & 0x3F;
check->buffer.u8[pos++] = 0x80;
while (pos != 64 - 8) {
if (pos == 64) {
process(check);
pos = 0;
}
check->buffer.u8[pos++] = 0x00;
}
// Convert the message size from bytes to bits.
check->state.sha256.size *= 8;
check->buffer.u64[(64 - 8) / 8] = conv64be(check->state.sha256.size);
process(check);
for (size_t i = 0; i < 8; ++i)
check->buffer.u32[i] = conv32be(check->state.sha256.state[i]);
return;
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rax
andq $0x3f, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
movb $-0x80, (%rax,%rcx)
cmpq $0x38, -0x10(%rbp)
je 0x9bb12b
cmpq $0x40, -0x10(%rbp)
jne 0x9bb112
movq -0x8(%rbp), %rdi
callq 0x9bb090
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
movb $0x0, (%rax,%rcx)
jmp 0x9bb0f3
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rcx
shlq $0x3, %rcx
movq %rcx, 0x60(%rax)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x9bb1a0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x8(%rbp), %rdi
callq 0x9bb090
movq $0x0, -0x18(%rbp)
cmpq $0x8, -0x18(%rbp)
jae 0x9bb197
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movl 0x40(%rax,%rcx,4), %edi
callq 0x9bb250
movl %eax, %edx
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x9bb164
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
|
/JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/check/sha256.c
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.