text stringlengths 1 1.05M |
|---|
namespace Gecode { namespace String { namespace Branch {
LenMax_LLLL::LenMax_LLLL(Home home, ViewArray<String::StringView>& x0):
StringBrancher(home, x0) {};
LenMax_LLLL::LenMax_LLLL(Home home, LenMax_LLLL& b):
StringBrancher(home, b, b.start) {
x.update(home, b.x);
}
Actor*
LenMax_LLLL::copy(Space& home) {
return new (home) LenMax_LLLL(home, *this);
}
void
LenMax_LLLL::post(Home home, ViewArray<String::StringView>& x) {
(void) new (home) LenMax_LLLL(home, x);
}
Choice*
LenMax_LLLL::choice(Space&) {
DashedString* p = x[start].pdomain();
int l = p->max_length() - p->min_length();
int pos = start;
for (int i = start + 1; i < x.size(); ++i) {
DashedString* q = x[i].pdomain();
int m = q->max_length() - q->min_length();
if (!x[i].assigned() && m > l) {
p = q;
l = m;
pos = i;
}
}
return val_llll(pos, p);
}
ExecStatus
LenMax_LLLL::commit(Space& home, const Choice& c, unsigned a) {
const PosLevVal& p = static_cast<const PosLevVal&>(c);
// this->print(home, c, a, std::cerr); std::cerr << '\n';
x[p.pos].commit(home, p.lev, p.val, Block::FIRST, a);
return ES_OK;
}
}}}
|
###############################################################################
# Copyright 2018 Intel Corporation
# All Rights Reserved.
#
# If this software was obtained under the Intel Simplified Software License,
# the following terms apply:
#
# The source code, information and material ("Material") contained herein is
# owned by Intel Corporation or its suppliers or licensors, and title to such
# Material remains with Intel Corporation or its suppliers or licensors. The
# Material contains proprietary information of Intel or its suppliers and
# licensors. The Material is protected by worldwide copyright laws and treaty
# provisions. No part of the Material may be used, copied, reproduced,
# modified, published, uploaded, posted, transmitted, distributed or disclosed
# in any way without Intel's prior express written permission. No license under
# any patent, copyright or other intellectual property rights in the Material
# is granted to or conferred upon you, either expressly, by implication,
# inducement, estoppel or otherwise. Any license under such intellectual
# property rights must be express and approved by Intel in writing.
#
# Unless otherwise agreed by Intel in writing, you may not remove or alter this
# notice or any other notice embedded in Materials by Intel or Intel's
# suppliers or licensors in any way.
#
#
# If this software was obtained under the Apache License, Version 2.0 (the
# "License"), the following terms apply:
#
# You may not use this file except in compliance with the License. You may
# obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
#
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#
# See the License for the specific language governing permissions and
# limitations under the License.
###############################################################################
.section .note.GNU-stack,"",%progbits
.text
.p2align 5, 0x90
LOne:
.long 1,1,1,1,1,1,1,1
LTwo:
.long 2,2,2,2,2,2,2,2
LThree:
.long 3,3,3,3,3,3,3,3
Lpoly:
.quad 0xffffffffffffffff, 0xffffffffffffffff, 0xffffffffffffffff
.quad 0xffffffffffffffff, 0xffffffffffffffff, 0xffffffffffffffff
.quad 0xffffffffffffffff, 0xffffffffffffffff, 0x1ff
.p2align 5, 0x90
.globl e9_p521r1_mul_by_2
.type e9_p521r1_mul_by_2, @function
e9_p521r1_mul_by_2:
push %r12
push %r13
push %r14
push %r15
xor %rcx, %rcx
movq (%rsi), %r8
movq (8)(%rsi), %r9
movq (16)(%rsi), %r10
movq (24)(%rsi), %r11
movq (32)(%rsi), %r12
movq (40)(%rsi), %r13
movq (48)(%rsi), %r14
movq (56)(%rsi), %r15
movq (64)(%rsi), %rax
shld $(1), %rax, %rcx
shld $(1), %r15, %rax
shld $(1), %r14, %r15
shld $(1), %r13, %r14
shld $(1), %r12, %r13
shld $(1), %r11, %r12
shld $(1), %r10, %r11
shld $(1), %r9, %r10
shld $(1), %r8, %r9
shl $(1), %r8
movq %rax, (64)(%rdi)
movq %r15, (56)(%rdi)
movq %r14, (48)(%rdi)
movq %r13, (40)(%rdi)
movq %r12, (32)(%rdi)
movq %r11, (24)(%rdi)
movq %r10, (16)(%rdi)
movq %r9, (8)(%rdi)
movq %r8, (%rdi)
subq Lpoly+0(%rip), %r8
sbbq Lpoly+8(%rip), %r9
sbbq Lpoly+16(%rip), %r10
sbbq Lpoly+24(%rip), %r11
sbbq Lpoly+32(%rip), %r12
sbbq Lpoly+40(%rip), %r13
sbbq Lpoly+48(%rip), %r14
sbbq Lpoly+56(%rip), %r15
sbbq Lpoly+64(%rip), %rax
sbb $(0), %rcx
movq (%rdi), %rdx
cmovne %rdx, %r8
movq (8)(%rdi), %rdx
cmovne %rdx, %r9
movq (16)(%rdi), %rdx
cmovne %rdx, %r10
movq (24)(%rdi), %rdx
cmovne %rdx, %r11
movq (32)(%rdi), %rdx
cmovne %rdx, %r12
movq (40)(%rdi), %rdx
cmovne %rdx, %r13
movq (48)(%rdi), %rdx
cmovne %rdx, %r14
movq (56)(%rdi), %rdx
cmovne %rdx, %r15
movq (64)(%rdi), %rdx
cmovne %rdx, %rax
movq %r8, (%rdi)
movq %r9, (8)(%rdi)
movq %r10, (16)(%rdi)
movq %r11, (24)(%rdi)
movq %r12, (32)(%rdi)
movq %r13, (40)(%rdi)
movq %r14, (48)(%rdi)
movq %r15, (56)(%rdi)
movq %rax, (64)(%rdi)
vzeroupper
pop %r15
pop %r14
pop %r13
pop %r12
ret
.Lfe1:
.size e9_p521r1_mul_by_2, .Lfe1-(e9_p521r1_mul_by_2)
.p2align 5, 0x90
.globl e9_p521r1_div_by_2
.type e9_p521r1_div_by_2, @function
e9_p521r1_div_by_2:
push %r12
push %r13
push %r14
push %r15
movq (%rsi), %r8
movq (8)(%rsi), %r9
movq (16)(%rsi), %r10
movq (24)(%rsi), %r11
movq (32)(%rsi), %r12
movq (40)(%rsi), %r13
movq (48)(%rsi), %r14
movq (56)(%rsi), %r15
movq (64)(%rsi), %rax
xor %rdx, %rdx
xor %rcx, %rcx
addq Lpoly+0(%rip), %r8
adcq Lpoly+8(%rip), %r9
adcq Lpoly+16(%rip), %r10
adcq Lpoly+24(%rip), %r11
adcq Lpoly+32(%rip), %r12
adcq Lpoly+40(%rip), %r13
adcq Lpoly+48(%rip), %r14
adcq Lpoly+56(%rip), %r15
adcq Lpoly+64(%rip), %rax
adc $(0), %rcx
test $(1), %r8
cmovne %rdx, %rcx
movq (%rsi), %rdx
cmovne %rdx, %r8
movq (8)(%rsi), %rdx
cmovne %rdx, %r9
movq (16)(%rsi), %rdx
cmovne %rdx, %r10
movq (24)(%rsi), %rdx
cmovne %rdx, %r11
movq (32)(%rsi), %rdx
cmovne %rdx, %r12
movq (40)(%rsi), %rdx
cmovne %rdx, %r13
movq (48)(%rsi), %rdx
cmovne %rdx, %r14
movq (56)(%rsi), %rdx
cmovne %rdx, %r15
movq (64)(%rsi), %rdx
cmovne %rdx, %rax
shrd $(1), %r9, %r8
shrd $(1), %r10, %r9
shrd $(1), %r11, %r10
shrd $(1), %r12, %r11
shrd $(1), %r13, %r12
shrd $(1), %r14, %r13
shrd $(1), %r15, %r14
shrd $(1), %rax, %r15
shrd $(1), %rcx, %rax
movq %r8, (%rdi)
movq %r9, (8)(%rdi)
movq %r10, (16)(%rdi)
movq %r11, (24)(%rdi)
movq %r12, (32)(%rdi)
movq %r13, (40)(%rdi)
movq %r14, (48)(%rdi)
movq %r15, (56)(%rdi)
movq %rax, (64)(%rdi)
vzeroupper
pop %r15
pop %r14
pop %r13
pop %r12
ret
.Lfe2:
.size e9_p521r1_div_by_2, .Lfe2-(e9_p521r1_div_by_2)
.p2align 5, 0x90
.globl e9_p521r1_mul_by_3
.type e9_p521r1_mul_by_3, @function
e9_p521r1_mul_by_3:
push %r12
push %r13
push %r14
push %r15
sub $(88), %rsp
movq (%rsi), %r8
movq (8)(%rsi), %r9
movq (16)(%rsi), %r10
movq (24)(%rsi), %r11
movq (32)(%rsi), %r12
movq (40)(%rsi), %r13
movq (48)(%rsi), %r14
movq (56)(%rsi), %r15
movq (64)(%rsi), %rax
xor %rcx, %rcx
shld $(1), %rax, %rcx
shld $(1), %r15, %rax
shld $(1), %r14, %r15
shld $(1), %r13, %r14
shld $(1), %r12, %r13
shld $(1), %r11, %r12
shld $(1), %r10, %r11
shld $(1), %r9, %r10
shld $(1), %r8, %r9
shl $(1), %r8
movq %rax, (64)(%rsp)
movq %r15, (56)(%rsp)
movq %r14, (48)(%rsp)
movq %r13, (40)(%rsp)
movq %r12, (32)(%rsp)
movq %r11, (24)(%rsp)
movq %r10, (16)(%rsp)
movq %r9, (8)(%rsp)
movq %r8, (%rsp)
subq Lpoly+0(%rip), %r8
sbbq Lpoly+8(%rip), %r9
sbbq Lpoly+16(%rip), %r10
sbbq Lpoly+24(%rip), %r11
sbbq Lpoly+32(%rip), %r12
sbbq Lpoly+40(%rip), %r13
sbbq Lpoly+48(%rip), %r14
sbbq Lpoly+56(%rip), %r15
sbbq Lpoly+64(%rip), %rax
sbb $(0), %rcx
movq (%rsp), %rdx
cmovb %rdx, %r8
movq (8)(%rsp), %rdx
cmovb %rdx, %r9
movq (16)(%rsp), %rdx
cmovb %rdx, %r10
movq (24)(%rsp), %rdx
cmovb %rdx, %r11
movq (32)(%rsp), %rdx
cmovb %rdx, %r12
movq (40)(%rsp), %rdx
cmovb %rdx, %r13
movq (48)(%rsp), %rdx
cmovb %rdx, %r14
movq (56)(%rsp), %rdx
cmovb %rdx, %r15
movq (64)(%rsp), %rdx
cmovb %rdx, %rax
xor %rcx, %rcx
addq (%rsi), %r8
adcq (8)(%rsi), %r9
adcq (16)(%rsi), %r10
adcq (24)(%rsi), %r11
adcq (32)(%rsi), %r12
adcq (40)(%rsi), %r13
adcq (48)(%rsi), %r14
adcq (56)(%rsi), %r15
adcq (64)(%rsi), %rax
adc $(0), %rcx
movq %r8, (%rsp)
movq %r9, (8)(%rsp)
movq %r10, (16)(%rsp)
movq %r11, (24)(%rsp)
movq %r12, (32)(%rsp)
movq %r13, (40)(%rsp)
movq %r14, (48)(%rsp)
movq %r15, (56)(%rsp)
movq %rax, (64)(%rsp)
subq Lpoly+0(%rip), %r8
sbbq Lpoly+8(%rip), %r9
sbbq Lpoly+16(%rip), %r10
sbbq Lpoly+24(%rip), %r11
sbbq Lpoly+32(%rip), %r12
sbbq Lpoly+40(%rip), %r13
sbbq Lpoly+48(%rip), %r14
sbbq Lpoly+56(%rip), %r15
sbbq Lpoly+64(%rip), %rax
sbb $(0), %rcx
movq (%rsp), %rdx
cmovb %rdx, %r8
movq (8)(%rsp), %rdx
cmovb %rdx, %r9
movq (16)(%rsp), %rdx
cmovb %rdx, %r10
movq (24)(%rsp), %rdx
cmovb %rdx, %r11
movq (32)(%rsp), %rdx
cmovb %rdx, %r12
movq (40)(%rsp), %rdx
cmovb %rdx, %r13
movq (48)(%rsp), %rdx
cmovb %rdx, %r14
movq (56)(%rsp), %rdx
cmovb %rdx, %r15
movq (64)(%rsp), %rdx
cmovb %rdx, %rax
movq %r8, (%rdi)
movq %r9, (8)(%rdi)
movq %r10, (16)(%rdi)
movq %r11, (24)(%rdi)
movq %r12, (32)(%rdi)
movq %r13, (40)(%rdi)
movq %r14, (48)(%rdi)
movq %r15, (56)(%rdi)
movq %rax, (64)(%rdi)
add $(88), %rsp
vzeroupper
pop %r15
pop %r14
pop %r13
pop %r12
ret
.Lfe3:
.size e9_p521r1_mul_by_3, .Lfe3-(e9_p521r1_mul_by_3)
.p2align 5, 0x90
.globl e9_p521r1_add
.type e9_p521r1_add, @function
e9_p521r1_add:
push %rbx
push %r12
push %r13
push %r14
push %r15
movq (%rsi), %r8
movq (8)(%rsi), %r9
movq (16)(%rsi), %r10
movq (24)(%rsi), %r11
movq (32)(%rsi), %r12
movq (40)(%rsi), %r13
movq (48)(%rsi), %r14
movq (56)(%rsi), %r15
movq (64)(%rsi), %rax
xor %rcx, %rcx
addq (%rdx), %r8
adcq (8)(%rdx), %r9
adcq (16)(%rdx), %r10
adcq (24)(%rdx), %r11
adcq (32)(%rdx), %r12
adcq (40)(%rdx), %r13
adcq (48)(%rdx), %r14
adcq (56)(%rdx), %r15
adcq (64)(%rdx), %rax
adc $(0), %rcx
movq %r8, (%rdi)
movq %r9, (8)(%rdi)
movq %r10, (16)(%rdi)
movq %r11, (24)(%rdi)
movq %r12, (32)(%rdi)
movq %r13, (40)(%rdi)
movq %r14, (48)(%rdi)
movq %r15, (56)(%rdi)
movq %rax, (64)(%rdi)
subq Lpoly+0(%rip), %r8
sbbq Lpoly+8(%rip), %r9
sbbq Lpoly+16(%rip), %r10
sbbq Lpoly+24(%rip), %r11
sbbq Lpoly+32(%rip), %r12
sbbq Lpoly+40(%rip), %r13
sbbq Lpoly+48(%rip), %r14
sbbq Lpoly+56(%rip), %r15
sbbq Lpoly+64(%rip), %rax
sbb $(0), %rcx
movq (%rdi), %rdx
cmovb %rdx, %r8
movq (8)(%rdi), %rdx
cmovb %rdx, %r9
movq (16)(%rdi), %rdx
cmovb %rdx, %r10
movq (24)(%rdi), %rdx
cmovb %rdx, %r11
movq (32)(%rdi), %rdx
cmovb %rdx, %r12
movq (40)(%rdi), %rdx
cmovb %rdx, %r13
movq (48)(%rdi), %rdx
cmovb %rdx, %r14
movq (56)(%rdi), %rdx
cmovb %rdx, %r15
movq (64)(%rdi), %rdx
cmovb %rdx, %rax
movq %r8, (%rdi)
movq %r9, (8)(%rdi)
movq %r10, (16)(%rdi)
movq %r11, (24)(%rdi)
movq %r12, (32)(%rdi)
movq %r13, (40)(%rdi)
movq %r14, (48)(%rdi)
movq %r15, (56)(%rdi)
movq %rax, (64)(%rdi)
vzeroupper
pop %r15
pop %r14
pop %r13
pop %r12
pop %rbx
ret
.Lfe4:
.size e9_p521r1_add, .Lfe4-(e9_p521r1_add)
.p2align 5, 0x90
.globl e9_p521r1_sub
.type e9_p521r1_sub, @function
e9_p521r1_sub:
push %rbx
push %r12
push %r13
push %r14
push %r15
movq (%rsi), %r8
movq (8)(%rsi), %r9
movq (16)(%rsi), %r10
movq (24)(%rsi), %r11
movq (32)(%rsi), %r12
movq (40)(%rsi), %r13
movq (48)(%rsi), %r14
movq (56)(%rsi), %r15
movq (64)(%rsi), %rax
xor %rcx, %rcx
subq (%rdx), %r8
sbbq (8)(%rdx), %r9
sbbq (16)(%rdx), %r10
sbbq (24)(%rdx), %r11
sbbq (32)(%rdx), %r12
sbbq (40)(%rdx), %r13
sbbq (48)(%rdx), %r14
sbbq (56)(%rdx), %r15
sbbq (64)(%rdx), %rax
sbb $(0), %rcx
movq %r8, (%rdi)
movq %r9, (8)(%rdi)
movq %r10, (16)(%rdi)
movq %r11, (24)(%rdi)
movq %r12, (32)(%rdi)
movq %r13, (40)(%rdi)
movq %r14, (48)(%rdi)
movq %r15, (56)(%rdi)
movq %rax, (64)(%rdi)
addq Lpoly+0(%rip), %r8
adcq Lpoly+8(%rip), %r9
adcq Lpoly+16(%rip), %r10
adcq Lpoly+24(%rip), %r11
adcq Lpoly+32(%rip), %r12
adcq Lpoly+40(%rip), %r13
adcq Lpoly+48(%rip), %r14
adcq Lpoly+56(%rip), %r15
adcq Lpoly+64(%rip), %rax
test %rcx, %rcx
movq (%rdi), %rdx
cmove %rdx, %r8
movq (8)(%rdi), %rdx
cmove %rdx, %r9
movq (16)(%rdi), %rdx
cmove %rdx, %r10
movq (24)(%rdi), %rdx
cmove %rdx, %r11
movq (32)(%rdi), %rdx
cmove %rdx, %r12
movq (40)(%rdi), %rdx
cmove %rdx, %r13
movq (48)(%rdi), %rdx
cmove %rdx, %r14
movq (56)(%rdi), %rdx
cmove %rdx, %r15
movq (64)(%rdi), %rdx
cmove %rdx, %rax
movq %r8, (%rdi)
movq %r9, (8)(%rdi)
movq %r10, (16)(%rdi)
movq %r11, (24)(%rdi)
movq %r12, (32)(%rdi)
movq %r13, (40)(%rdi)
movq %r14, (48)(%rdi)
movq %r15, (56)(%rdi)
movq %rax, (64)(%rdi)
vzeroupper
pop %r15
pop %r14
pop %r13
pop %r12
pop %rbx
ret
.Lfe5:
.size e9_p521r1_sub, .Lfe5-(e9_p521r1_sub)
.p2align 5, 0x90
.globl e9_p521r1_neg
.type e9_p521r1_neg, @function
e9_p521r1_neg:
push %r12
push %r13
push %r14
push %r15
xor %r8, %r8
xor %r9, %r9
xor %r10, %r10
xor %r11, %r11
xor %r12, %r12
xor %r13, %r13
xor %r14, %r14
xor %r15, %r15
xor %rax, %rax
xor %rcx, %rcx
subq (%rsi), %r8
sbbq (8)(%rsi), %r9
sbbq (16)(%rsi), %r10
sbbq (24)(%rsi), %r11
sbbq (32)(%rsi), %r12
sbbq (40)(%rsi), %r13
sbbq (48)(%rsi), %r14
sbbq (56)(%rsi), %r15
sbbq (64)(%rsi), %rax
sbb $(0), %rcx
movq %r8, (%rdi)
movq %r9, (8)(%rdi)
movq %r10, (16)(%rdi)
movq %r11, (24)(%rdi)
movq %r12, (32)(%rdi)
movq %r13, (40)(%rdi)
movq %r14, (48)(%rdi)
movq %r15, (56)(%rdi)
movq %rax, (64)(%rdi)
addq Lpoly+0(%rip), %r8
adcq Lpoly+8(%rip), %r9
adcq Lpoly+16(%rip), %r10
adcq Lpoly+24(%rip), %r11
adcq Lpoly+32(%rip), %r12
adcq Lpoly+40(%rip), %r13
adcq Lpoly+48(%rip), %r14
adcq Lpoly+56(%rip), %r15
adcq Lpoly+64(%rip), %rax
test %rcx, %rcx
movq (%rdi), %rdx
cmove %rdx, %r8
movq (8)(%rdi), %rdx
cmove %rdx, %r9
movq (16)(%rdi), %rdx
cmove %rdx, %r10
movq (24)(%rdi), %rdx
cmove %rdx, %r11
movq (32)(%rdi), %rdx
cmove %rdx, %r12
movq (40)(%rdi), %rdx
cmove %rdx, %r13
movq (48)(%rdi), %rdx
cmove %rdx, %r14
movq (56)(%rdi), %rdx
cmove %rdx, %r15
movq (64)(%rdi), %rdx
cmove %rdx, %rax
movq %r8, (%rdi)
movq %r9, (8)(%rdi)
movq %r10, (16)(%rdi)
movq %r11, (24)(%rdi)
movq %r12, (32)(%rdi)
movq %r13, (40)(%rdi)
movq %r14, (48)(%rdi)
movq %r15, (56)(%rdi)
movq %rax, (64)(%rdi)
vzeroupper
pop %r15
pop %r14
pop %r13
pop %r12
ret
.Lfe6:
.size e9_p521r1_neg, .Lfe6-(e9_p521r1_neg)
.p2align 5, 0x90
.globl e9_p521r1_mred
.type e9_p521r1_mred, @function
e9_p521r1_mred:
push %rbx
push %r12
push %r13
push %r14
push %r15
movq (%rsi), %r8
movq (8)(%rsi), %r9
movq (16)(%rsi), %r10
movq (24)(%rsi), %r11
movq (32)(%rsi), %r12
movq (40)(%rsi), %r13
movq (48)(%rsi), %r14
movq (56)(%rsi), %r15
movq (64)(%rsi), %rax
movq (72)(%rsi), %rcx
xor %rdx, %rdx
mov %r8, %rbx
shr $(55), %rbx
shl $(9), %r8
add %rdx, %rbx
add %r8, %rax
adc %rbx, %rcx
mov $(0), %rdx
adc $(0), %rdx
movq (80)(%rsi), %r8
mov %r9, %rbx
shr $(55), %rbx
shl $(9), %r9
add %rdx, %rbx
add %r9, %rcx
adc %rbx, %r8
mov $(0), %rdx
adc $(0), %rdx
movq (88)(%rsi), %r9
mov %r10, %rbx
shr $(55), %rbx
shl $(9), %r10
add %rdx, %rbx
add %r10, %r8
adc %rbx, %r9
mov $(0), %rdx
adc $(0), %rdx
movq (96)(%rsi), %r10
mov %r11, %rbx
shr $(55), %rbx
shl $(9), %r11
add %rdx, %rbx
add %r11, %r9
adc %rbx, %r10
mov $(0), %rdx
adc $(0), %rdx
movq (104)(%rsi), %r11
mov %r12, %rbx
shr $(55), %rbx
shl $(9), %r12
add %rdx, %rbx
add %r12, %r10
adc %rbx, %r11
mov $(0), %rdx
adc $(0), %rdx
movq (112)(%rsi), %r12
mov %r13, %rbx
shr $(55), %rbx
shl $(9), %r13
add %rdx, %rbx
add %r13, %r11
adc %rbx, %r12
mov $(0), %rdx
adc $(0), %rdx
movq (120)(%rsi), %r13
mov %r14, %rbx
shr $(55), %rbx
shl $(9), %r14
add %rdx, %rbx
add %r14, %r12
adc %rbx, %r13
mov $(0), %rdx
adc $(0), %rdx
movq (128)(%rsi), %r14
mov %r15, %rbx
shr $(55), %rbx
shl $(9), %r15
add %rdx, %rbx
add %r15, %r13
adc %rbx, %r14
mov $(0), %rdx
adc $(0), %rdx
movq (136)(%rsi), %r15
mov %rax, %rbx
shr $(55), %rbx
shl $(9), %rax
add %rdx, %rbx
add %rax, %r14
adc %rbx, %r15
mov $(0), %rdx
adc $(0), %rdx
movq %rcx, (%rdi)
movq %r8, (8)(%rdi)
movq %r9, (16)(%rdi)
movq %r10, (24)(%rdi)
movq %r11, (32)(%rdi)
movq %r12, (40)(%rdi)
movq %r13, (48)(%rdi)
movq %r14, (56)(%rdi)
movq %r15, (64)(%rdi)
subq Lpoly+0(%rip), %rcx
sbbq Lpoly+8(%rip), %r8
sbbq Lpoly+16(%rip), %r9
sbbq Lpoly+24(%rip), %r10
sbbq Lpoly+32(%rip), %r11
sbbq Lpoly+40(%rip), %r12
sbbq Lpoly+48(%rip), %r13
sbbq Lpoly+56(%rip), %r14
sbbq Lpoly+64(%rip), %r15
movq (%rdi), %rbx
cmovb %rbx, %rcx
movq (8)(%rdi), %rbx
cmovb %rbx, %r8
movq (16)(%rdi), %rbx
cmovb %rbx, %r9
movq (24)(%rdi), %rbx
cmovb %rbx, %r10
movq (32)(%rdi), %rbx
cmovb %rbx, %r11
movq (40)(%rdi), %rbx
cmovb %rbx, %r12
movq (48)(%rdi), %rbx
cmovb %rbx, %r13
movq (56)(%rdi), %rbx
cmovb %rbx, %r14
movq (64)(%rdi), %rbx
cmovb %rbx, %r15
movq %rcx, (%rdi)
movq %r8, (8)(%rdi)
movq %r9, (16)(%rdi)
movq %r10, (24)(%rdi)
movq %r11, (32)(%rdi)
movq %r12, (40)(%rdi)
movq %r13, (48)(%rdi)
movq %r14, (56)(%rdi)
movq %r15, (64)(%rdi)
vzeroupper
pop %r15
pop %r14
pop %r13
pop %r12
pop %rbx
ret
.Lfe7:
.size e9_p521r1_mred, .Lfe7-(e9_p521r1_mred)
.p2align 5, 0x90
.globl e9_p521r1_select_pp_w5
.type e9_p521r1_select_pp_w5, @function
e9_p521r1_select_pp_w5:
push %r12
push %r13
sub $(40), %rsp
movd %edx, %xmm15
pshufd $(0), %xmm15, %xmm15
movdqa %xmm15, (%rsp)
movdqa LOne(%rip), %xmm14
movdqa %xmm14, (16)(%rsp)
pxor %xmm0, %xmm0
pxor %xmm1, %xmm1
pxor %xmm2, %xmm2
pxor %xmm3, %xmm3
pxor %xmm4, %xmm4
pxor %xmm5, %xmm5
pxor %xmm6, %xmm6
pxor %xmm7, %xmm7
pxor %xmm8, %xmm8
pxor %xmm9, %xmm9
pxor %xmm10, %xmm10
pxor %xmm11, %xmm11
pxor %xmm12, %xmm12
pxor %xmm13, %xmm13
mov $(16), %rcx
.Lselect_loopgas_8:
movdqa (16)(%rsp), %xmm15
movdqa %xmm15, %xmm14
pcmpeqd (%rsp), %xmm15
paddd LOne(%rip), %xmm14
movdqa %xmm14, (16)(%rsp)
movdqu (%rsi), %xmm14
pand %xmm15, %xmm14
por %xmm14, %xmm0
movdqu (16)(%rsi), %xmm14
pand %xmm15, %xmm14
por %xmm14, %xmm1
movdqu (32)(%rsi), %xmm14
pand %xmm15, %xmm14
por %xmm14, %xmm2
movdqu (48)(%rsi), %xmm14
pand %xmm15, %xmm14
por %xmm14, %xmm3
movdqu (64)(%rsi), %xmm14
pand %xmm15, %xmm14
por %xmm14, %xmm4
movdqu (80)(%rsi), %xmm14
pand %xmm15, %xmm14
por %xmm14, %xmm5
movdqu (96)(%rsi), %xmm14
pand %xmm15, %xmm14
por %xmm14, %xmm6
movdqu (112)(%rsi), %xmm14
pand %xmm15, %xmm14
por %xmm14, %xmm7
movdqu (128)(%rsi), %xmm14
pand %xmm15, %xmm14
por %xmm14, %xmm8
movdqu (144)(%rsi), %xmm14
pand %xmm15, %xmm14
por %xmm14, %xmm9
movdqu (160)(%rsi), %xmm14
pand %xmm15, %xmm14
por %xmm14, %xmm10
movdqu (176)(%rsi), %xmm14
pand %xmm15, %xmm14
por %xmm14, %xmm11
movdqu (192)(%rsi), %xmm14
pand %xmm15, %xmm14
por %xmm14, %xmm12
movd (208)(%rsi), %xmm14
pand %xmm15, %xmm14
por %xmm14, %xmm13
add $(216), %rsi
dec %rcx
jnz .Lselect_loopgas_8
movdqu %xmm0, (%rdi)
movdqu %xmm1, (16)(%rdi)
movdqu %xmm2, (32)(%rdi)
movdqu %xmm3, (48)(%rdi)
movdqu %xmm4, (64)(%rdi)
movdqu %xmm5, (80)(%rdi)
movdqu %xmm6, (96)(%rdi)
movdqu %xmm7, (112)(%rdi)
movdqu %xmm8, (128)(%rdi)
movdqu %xmm9, (144)(%rdi)
movdqu %xmm10, (160)(%rdi)
movdqu %xmm11, (176)(%rdi)
movdqu %xmm12, (192)(%rdi)
movq %xmm13, (208)(%rdi)
add $(40), %rsp
vzeroupper
pop %r13
pop %r12
ret
.Lfe8:
.size e9_p521r1_select_pp_w5, .Lfe8-(e9_p521r1_select_pp_w5)
.p2align 5, 0x90
.globl e9_p521r1_select_ap_w5
.type e9_p521r1_select_ap_w5, @function
e9_p521r1_select_ap_w5:
push %r12
push %r13
movdqa LOne(%rip), %xmm10
movd %edx, %xmm9
pshufd $(0), %xmm9, %xmm9
pxor %xmm0, %xmm0
pxor %xmm1, %xmm1
pxor %xmm2, %xmm2
pxor %xmm3, %xmm3
pxor %xmm4, %xmm4
pxor %xmm5, %xmm5
pxor %xmm6, %xmm6
pxor %xmm7, %xmm7
pxor %xmm8, %xmm8
mov $(16), %rcx
.Lselect_loopgas_9:
movdqa %xmm10, %xmm11
pcmpeqd %xmm9, %xmm11
paddd LOne(%rip), %xmm10
movdqa (%rsi), %xmm12
pand %xmm11, %xmm12
por %xmm12, %xmm0
movdqa (16)(%rsi), %xmm12
pand %xmm11, %xmm12
por %xmm12, %xmm1
movdqa (32)(%rsi), %xmm12
pand %xmm11, %xmm12
por %xmm12, %xmm2
movdqa (48)(%rsi), %xmm12
pand %xmm11, %xmm12
por %xmm12, %xmm3
movdqa (64)(%rsi), %xmm12
pand %xmm11, %xmm12
por %xmm12, %xmm4
movdqa (80)(%rsi), %xmm12
pand %xmm11, %xmm12
por %xmm12, %xmm5
movdqa (96)(%rsi), %xmm12
pand %xmm11, %xmm12
por %xmm12, %xmm6
movdqa (112)(%rsi), %xmm12
pand %xmm11, %xmm12
por %xmm12, %xmm7
movdqa (128)(%rsi), %xmm12
pand %xmm11, %xmm12
por %xmm12, %xmm8
add $(144), %rsi
dec %rcx
jnz .Lselect_loopgas_9
movdqu %xmm0, (%rdi)
movdqu %xmm1, (16)(%rdi)
movdqu %xmm2, (32)(%rdi)
movdqu %xmm3, (48)(%rdi)
movdqu %xmm4, (64)(%rdi)
movdqu %xmm5, (80)(%rdi)
movdqu %xmm6, (96)(%rdi)
movdqu %xmm7, (112)(%rdi)
movdqu %xmm8, (128)(%rdi)
vzeroupper
pop %r13
pop %r12
ret
.Lfe9:
.size e9_p521r1_select_ap_w5, .Lfe9-(e9_p521r1_select_ap_w5)
|
; A117569: Expansion of (1+x+x^2)/(1+x^2).
; 1,1,0,-1,0,1,0,-1,0,1,0,-1,0,1,0,-1,0,1,0,-1,0,1,0,-1,0,1,0,-1,0,1,0,-1,0,1,0,-1,0,1,0,-1,0,1,0,-1,0,1,0,-1,0,1,0,-1,0,1,0,-1,0,1,0,-1,0,1,0,-1,0,1,0,-1,0,1,0,-1,0,1,0,-1,0,1,0,-1,0,1,0,-1,0,1,0,-1,0,1,0,-1,0,1,0,-1,0,1,0,-1,0,1,0,-1,0
trn $0,1
gcd $0,4
lpb $0
sub $0,3
mov $1,$0
lpe
|
#include "gtest/gtest.h"
#include "bepler/genomics/pwm.h"
#include <vector>
#include <string>
#include <sstream>
#include <algorithm>
#include <iterator>
#include <cmath>
const static std::string alph = "ACGT";
const static std::vector< std::vector< double > > probs = {
{ 0.001, 0.001, 0.001, 0.997 },
{ 0.25, 0.25, 0.25, 0.25 },
{ 0.7, 0.1, 0.1, 0.1 },
{ 0.33, 0.33, 0.33, 0.01 },
{ 0.25, 0.5, 0.24, 0.01 }
};
const static std::string text =
"A C G T\n0.001 0.001 0.001 0.997\n0.25 0.25 0.25 0.25\n0.7 0.1 0.1 0.1\n0.33 0.33 0.33 0.01\n0.25 0.5 0.24 0.01";
TEST( PositionWeightMatrixTest, Initialize ){
genomics::PWM pwm;
pwm.probabilities( alph, probs );
for( unsigned i = 0 ; i < 4 ; ++i ){
for( unsigned j = 0 ; j < 5 ; ++j ){
EXPECT_EQ( std::log( probs[j][i] ), pwm.loglikelihood( alph[i], j ) );
}
}
pwm.clear();
EXPECT_EQ( 0, pwm.length() );
std::stringstream ss( text );
ss >> pwm;
EXPECT_EQ( alph, pwm.alphabet() );
for( unsigned i = 0 ; i < 4 ; ++i ){
for( unsigned j = 0 ; j < 5 ; ++j ){
EXPECT_EQ( std::log( probs[j][i] ), pwm.loglikelihood( alph[i], j ) );
}
}
}
TEST( PositionWeightMatrixTest, Score ){
using std::log;
std::string str = "CCAGT";
double exp_score = log( 0.001 ) + log( 0.25 ) + log( 0.7 ) + log( 0.33 ) + log( 0.01 );
genomics::PWM pwm( alph, probs );
EXPECT_EQ( exp_score, pwm.score( str.c_str() ) );
EXPECT_EQ( exp_score, pwm.score( str ) );
//unsigned idxs[] = { 0, 1, 1, 0, 2, 0, 3, 3, 0, 1, 3, 3, 3, 3, 1, 3 };
str = "ACCAGATTACTTTTCT";
std::vector<double> exp_scores = {
log( probs[0][0] ) + log( probs[1][1] ) + log( probs[2][1] ) + log( probs[3][0] ) + log( probs[4][2] ),
log( probs[0][1] ) + log( probs[1][1] ) + log( probs[2][0] ) + log( probs[3][2] ) + log( probs[4][0] ),
log( probs[0][1] ) + log( probs[1][0] ) + log( probs[2][2] ) + log( probs[3][0] ) + log( probs[4][3] ),
log( probs[0][0] ) + log( probs[1][2] ) + log( probs[2][0] ) + log( probs[3][3] ) + log( probs[4][3] ),
log( probs[0][2] ) + log( probs[1][0] ) + log( probs[2][3] ) + log( probs[3][3] ) + log( probs[4][0] ),
log( probs[0][0] ) + log( probs[1][3] ) + log( probs[2][3] ) + log( probs[3][0] ) + log( probs[4][1] ),
log( probs[0][3] ) + log( probs[1][3] ) + log( probs[2][0] ) + log( probs[3][1] ) + log( probs[4][3] ),
log( probs[0][3] ) + log( probs[1][0] ) + log( probs[2][1] ) + log( probs[3][3] ) + log( probs[4][3] ),
log( probs[0][0] ) + log( probs[1][1] ) + log( probs[2][3] ) + log( probs[3][3] ) + log( probs[4][3] ),
log( probs[0][1] ) + log( probs[1][3] ) + log( probs[2][3] ) + log( probs[3][3] ) + log( probs[4][3] ),
log( probs[0][3] ) + log( probs[1][3] ) + log( probs[2][3] ) + log( probs[3][3] ) + log( probs[4][1] ),
log( probs[0][3] ) + log( probs[1][3] ) + log( probs[2][3] ) + log( probs[3][1] ) + log( probs[4][3] )
};
std::vector<double> scores;
pwm( functional::irange( str ), [&]( auto s ){
scores.push_back( s );
} );
EXPECT_EQ( exp_scores, scores );
scores.clear();
EXPECT_NE( exp_scores, scores );
pwm( str, [&]( auto s ){
scores.push_back( s );
} );
EXPECT_EQ( exp_scores, scores );
}
|
.global s_prepare_buffers
s_prepare_buffers:
push %r10
push %r12
push %r14
push %rbp
push %rcx
push %rdi
push %rdx
push %rsi
lea addresses_WT_ht+0x186f, %rsi
lea addresses_UC_ht+0xd9af, %rdi
nop
nop
nop
nop
nop
sub $59816, %rdx
mov $32, %rcx
rep movsq
nop
and %rdx, %rdx
lea addresses_UC_ht+0x6b0f, %rdi
add $28145, %rbp
mov $0x6162636465666768, %r14
movq %r14, %xmm5
vmovups %ymm5, (%rdi)
nop
nop
cmp %rbp, %rbp
lea addresses_A_ht+0x18adc, %rsi
lea addresses_WC_ht+0xfe9f, %rdi
and %r12, %r12
mov $38, %rcx
rep movsw
nop
nop
xor $28254, %rbp
lea addresses_UC_ht+0x39af, %rbp
sub %r12, %r12
movb $0x61, (%rbp)
nop
nop
sub $21473, %rdi
lea addresses_normal_ht+0x7e2f, %rsi
lea addresses_WT_ht+0x14daf, %rdi
add %r10, %r10
mov $8, %rcx
rep movsl
nop
nop
nop
and $51467, %r14
lea addresses_D_ht+0x14caf, %r12
clflush (%r12)
and $2726, %rsi
mov (%r12), %dx
nop
nop
nop
nop
nop
sub %rcx, %rcx
lea addresses_normal_ht+0x1ef21, %rbp
cmp $8633, %rcx
movw $0x6162, (%rbp)
nop
nop
nop
nop
cmp $6536, %r14
pop %rsi
pop %rdx
pop %rdi
pop %rcx
pop %rbp
pop %r14
pop %r12
pop %r10
ret
.global s_faulty_load
s_faulty_load:
push %r12
push %r14
push %r15
push %r8
push %r9
push %rcx
push %rdi
push %rsi
// Load
lea addresses_normal+0x9b8f, %r15
nop
cmp %rdi, %rdi
vmovups (%r15), %ymm3
vextracti128 $0, %ymm3, %xmm3
vpextrq $1, %xmm3, %r12
inc %r9
// REPMOV
lea addresses_normal+0x11ab7, %rsi
lea addresses_A+0x1e8af, %rdi
nop
add $54636, %r8
mov $12, %rcx
rep movsb
nop
nop
nop
cmp $45810, %rdi
// Store
lea addresses_normal+0x18eaf, %r14
nop
nop
sub $12356, %rdi
movl $0x51525354, (%r14)
nop
nop
nop
nop
add $15454, %r12
// Store
lea addresses_RW+0xa623, %r9
nop
and $26395, %r15
mov $0x5152535455565758, %rcx
movq %rcx, (%r9)
nop
nop
nop
add %r8, %r8
// Store
lea addresses_A+0x11af, %r15
nop
nop
nop
dec %r12
mov $0x5152535455565758, %r8
movq %r8, (%r15)
nop
nop
and $38414, %r14
// Store
lea addresses_WC+0x1102f, %r14
nop
nop
nop
nop
sub %r8, %r8
mov $0x5152535455565758, %rdi
movq %rdi, %xmm3
vmovaps %ymm3, (%r14)
add $12618, %r14
// Load
lea addresses_WT+0x1392f, %r12
nop
nop
nop
nop
sub %r14, %r14
mov (%r12), %rcx
nop
nop
cmp $52518, %rsi
// Faulty Load
mov $0x5a479a00000001af, %rsi
nop
nop
cmp $42872, %r12
mov (%rsi), %r9
lea oracles, %rsi
and $0xff, %r9
shlq $12, %r9
mov (%rsi,%r9,1), %r9
pop %rsi
pop %rdi
pop %rcx
pop %r9
pop %r8
pop %r15
pop %r14
pop %r12
ret
/*
<gen_faulty_load>
[REF]
{'src': {'type': 'addresses_NC', 'same': False, 'size': 8, 'congruent': 0, 'NT': False, 'AVXalign': False}, 'OP': 'LOAD'}
{'src': {'type': 'addresses_normal', 'same': False, 'size': 32, 'congruent': 2, 'NT': False, 'AVXalign': False}, 'OP': 'LOAD'}
{'src': {'type': 'addresses_normal', 'congruent': 3, 'same': False}, 'dst': {'type': 'addresses_A', 'congruent': 6, 'same': False}, 'OP': 'REPM'}
{'dst': {'type': 'addresses_normal', 'same': False, 'size': 4, 'congruent': 8, 'NT': False, 'AVXalign': False}, 'OP': 'STOR'}
{'dst': {'type': 'addresses_RW', 'same': False, 'size': 8, 'congruent': 0, 'NT': False, 'AVXalign': False}, 'OP': 'STOR'}
{'dst': {'type': 'addresses_A', 'same': False, 'size': 8, 'congruent': 11, 'NT': False, 'AVXalign': False}, 'OP': 'STOR'}
{'dst': {'type': 'addresses_WC', 'same': False, 'size': 32, 'congruent': 6, 'NT': False, 'AVXalign': True}, 'OP': 'STOR'}
{'src': {'type': 'addresses_WT', 'same': False, 'size': 8, 'congruent': 5, 'NT': False, 'AVXalign': False}, 'OP': 'LOAD'}
[Faulty Load]
{'src': {'type': 'addresses_NC', 'same': True, 'size': 8, 'congruent': 0, 'NT': False, 'AVXalign': False}, 'OP': 'LOAD'}
<gen_prepare_buffer>
{'src': {'type': 'addresses_WT_ht', 'congruent': 5, 'same': False}, 'dst': {'type': 'addresses_UC_ht', 'congruent': 11, 'same': False}, 'OP': 'REPM'}
{'dst': {'type': 'addresses_UC_ht', 'same': False, 'size': 32, 'congruent': 5, 'NT': False, 'AVXalign': False}, 'OP': 'STOR'}
{'src': {'type': 'addresses_A_ht', 'congruent': 0, 'same': False}, 'dst': {'type': 'addresses_WC_ht', 'congruent': 4, 'same': False}, 'OP': 'REPM'}
{'dst': {'type': 'addresses_UC_ht', 'same': False, 'size': 1, 'congruent': 11, 'NT': True, 'AVXalign': False}, 'OP': 'STOR'}
{'src': {'type': 'addresses_normal_ht', 'congruent': 4, 'same': True}, 'dst': {'type': 'addresses_WT_ht', 'congruent': 9, 'same': False}, 'OP': 'REPM'}
{'src': {'type': 'addresses_D_ht', 'same': False, 'size': 2, 'congruent': 6, 'NT': False, 'AVXalign': True}, 'OP': 'LOAD'}
{'dst': {'type': 'addresses_normal_ht', 'same': False, 'size': 2, 'congruent': 0, 'NT': False, 'AVXalign': False}, 'OP': 'STOR'}
{'00': 3471, '58': 18358}
58 58 58 58 58 58 58 58 58 58 58 58 58 00 58 58 58 58 58 58 58 58 58 58 58 00 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 00 58 58 00 58 58 58 58 58 58 58 58 58 58 58 00 58 58 58 58 00 00 00 58 00 58 58 58 58 58 58 00 58 00 00 58 58 58 58 58 58 58 58 58 00 58 58 58 58 00 00 00 58 00 58 58 58 58 58 58 58 58 58 00 58 58 00 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 00 58 00 58 58 58 58 58 00 58 58 58 58 58 58 58 58 58 58 58 58 00 58 58 58 58 58 58 58 58 58 58 58 58 00 58 58 00 58 58 58 58 58 58 58 00 58 58 58 58 58 58 58 58 58 58 58 58 58 58 00 58 58 58 00 58 58 00 58 00 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 00 58 58 58 58 58 58 58 00 58 58 58 58 00 58 58 58 58 00 58 58 58 58 58 00 58 58 58 00 00 58 00 58 00 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 00 58 58 58 58 58 00 58 58 58 58 58 58 58 00 58 58 58 58 58 58 00 58 58 58 58 58 58 58 58 00 58 58 00 00 58 58 58 58 58 58 58 00 00 58 58 58 00 58 58 58 58 58 58 58 58 58 00 00 58 58 58 58 58 00 58 58 58 58 00 58 58 58 58 58 00 58 58 58 58 58 00 58 58 00 58 58 00 58 58 58 00 00 58 58 58 58 58 58 58 58 58 58 58 58 00 58 58 58 58 00 58 00 58 58 58 58 58 58 58 58 58 58 58 58 58 00 00 58 58 58 58 00 00 00 58 58 58 00 58 58 58 58 00 58 58 58 58 58 58 58 58 58 58 58 58 58 58 00 58 58 58 00 58 00 58 58 58 58 58 00 58 58 58 58 58 58 58 58 58 58 00 58 58 58 58 58 00 58 00 58 58 58 58 58 58 58 58 00 58 58 58 00 00 58 58 58 58 58 58 58 00 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 00 58 58 58 58 00 58 58 58 58 58 58 58 58 58 58 58 58 00 58 58 58 58 58 58 58 58 58 58 58 58 58 58 00 58 58 00 00 58 58 58 58 58 58 58 58 58 00 58 58 58 58 58 58 58 58 58 00 00 58 58 58 58 58 58 58 00 58 00 58 58 00 58 00 58 58 58 58 58 58 00 58 00 58 58 58 00 58 00 58 58 58 58 58 58 58 58 58 58 00 58 58 00 00 58 58 58 58 00 58 58 00 58 58 58 58 00 58 58 58 58 58 58 00 58 58 58 00 00 58 00 00 58 58 58 58 00 58 58 58 58 58 58 00 58 58 58 58 58 58 58 58 00 00 00 58 58 58 58 58 58 58 58 00 58 58 58 58 58 58 58 58 58 00 58 58 58 58 58 58 00 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 00 00 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 00 58 58 58 58 58 00 58 58 58 58 58 00 00 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 00 00 00 58 58 58 00 58 58 58 58 58 58 58 58 58 58 58 58 58 58 00 58 58 58 00 58 58 58 58 58 58 58 58 00 00 58 58 58 58 00 58 58 58 58 58 00 58 58 58 58 58 58 58 58 58 58 58 58 00 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 00 58 00 58 58 58 58 58 00 58 58 58 00 58 58 58 00 58 58 58 58 58 58 58 00 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 00 58 58 58 58 58 58 00 58 00 58 58 58 58 58 58 58 58 58 58 58 58 58 00 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 00 00 58 00 58 58 58 58 58 58 00 58 58 58 58 00 00 58 58 58 58 58 58 58 58 00 58 00 00 58 58 58 58 00
*/
|
// Copyright 2018 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include <cstdio>
#include "garnet/public/lib/escher/util/check_vulkan_support.h"
int main(int argc, const char** argv) {
printf("%c\n", escher::VulkanIsSupported() ? '1' : '0');
}
|
;CodeVisionAVR C Compiler V3.12 Advanced
;(C) Copyright 1998-2014 Pavel Haiduc, HP InfoTech s.r.l.
;http://www.hpinfotech.com
;Build configuration : Debug
;Chip type : ATmega16A
;Program type : Application
;Clock frequency : 8.000000 MHz
;Memory model : Small
;Optimize for : Size
;(s)printf features : int, width
;(s)scanf features : int, width
;External RAM size : 0
;Data Stack size : 256 byte(s)
;Heap size : 0 byte(s)
;Promote 'char' to 'int': Yes
;'char' is unsigned : Yes
;8 bit enums : Yes
;Global 'const' stored in FLASH: Yes
;Enhanced function parameter passing: Yes
;Enhanced core instructions: On
;Automatic register allocation for global variables: On
;Smart register allocation: On
#define _MODEL_SMALL_
#pragma AVRPART ADMIN PART_NAME ATmega16A
#pragma AVRPART MEMORY PROG_FLASH 16384
#pragma AVRPART MEMORY EEPROM 512
#pragma AVRPART MEMORY INT_SRAM SIZE 1024
#pragma AVRPART MEMORY INT_SRAM START_ADDR 0x60
#define CALL_SUPPORTED 1
.LISTMAC
.EQU UDRE=0x5
.EQU RXC=0x7
.EQU USR=0xB
.EQU UDR=0xC
.EQU SPSR=0xE
.EQU SPDR=0xF
.EQU EERE=0x0
.EQU EEWE=0x1
.EQU EEMWE=0x2
.EQU EECR=0x1C
.EQU EEDR=0x1D
.EQU EEARL=0x1E
.EQU EEARH=0x1F
.EQU WDTCR=0x21
.EQU MCUCR=0x35
.EQU GICR=0x3B
.EQU SPL=0x3D
.EQU SPH=0x3E
.EQU SREG=0x3F
.DEF R0X0=R0
.DEF R0X1=R1
.DEF R0X2=R2
.DEF R0X3=R3
.DEF R0X4=R4
.DEF R0X5=R5
.DEF R0X6=R6
.DEF R0X7=R7
.DEF R0X8=R8
.DEF R0X9=R9
.DEF R0XA=R10
.DEF R0XB=R11
.DEF R0XC=R12
.DEF R0XD=R13
.DEF R0XE=R14
.DEF R0XF=R15
.DEF R0X10=R16
.DEF R0X11=R17
.DEF R0X12=R18
.DEF R0X13=R19
.DEF R0X14=R20
.DEF R0X15=R21
.DEF R0X16=R22
.DEF R0X17=R23
.DEF R0X18=R24
.DEF R0X19=R25
.DEF R0X1A=R26
.DEF R0X1B=R27
.DEF R0X1C=R28
.DEF R0X1D=R29
.DEF R0X1E=R30
.DEF R0X1F=R31
.EQU __SRAM_START=0x0060
.EQU __SRAM_END=0x045F
.EQU __DSTACK_SIZE=0x0100
.EQU __HEAP_SIZE=0x0000
.EQU __CLEAR_SRAM_SIZE=__SRAM_END-__SRAM_START+1
.MACRO __CPD1N
CPI R30,LOW(@0)
LDI R26,HIGH(@0)
CPC R31,R26
LDI R26,BYTE3(@0)
CPC R22,R26
LDI R26,BYTE4(@0)
CPC R23,R26
.ENDM
.MACRO __CPD2N
CPI R26,LOW(@0)
LDI R30,HIGH(@0)
CPC R27,R30
LDI R30,BYTE3(@0)
CPC R24,R30
LDI R30,BYTE4(@0)
CPC R25,R30
.ENDM
.MACRO __CPWRR
CP R@0,R@2
CPC R@1,R@3
.ENDM
.MACRO __CPWRN
CPI R@0,LOW(@2)
LDI R30,HIGH(@2)
CPC R@1,R30
.ENDM
.MACRO __ADDB1MN
SUBI R30,LOW(-@0-(@1))
.ENDM
.MACRO __ADDB2MN
SUBI R26,LOW(-@0-(@1))
.ENDM
.MACRO __ADDW1MN
SUBI R30,LOW(-@0-(@1))
SBCI R31,HIGH(-@0-(@1))
.ENDM
.MACRO __ADDW2MN
SUBI R26,LOW(-@0-(@1))
SBCI R27,HIGH(-@0-(@1))
.ENDM
.MACRO __ADDW1FN
SUBI R30,LOW(-2*@0-(@1))
SBCI R31,HIGH(-2*@0-(@1))
.ENDM
.MACRO __ADDD1FN
SUBI R30,LOW(-2*@0-(@1))
SBCI R31,HIGH(-2*@0-(@1))
SBCI R22,BYTE3(-2*@0-(@1))
.ENDM
.MACRO __ADDD1N
SUBI R30,LOW(-@0)
SBCI R31,HIGH(-@0)
SBCI R22,BYTE3(-@0)
SBCI R23,BYTE4(-@0)
.ENDM
.MACRO __ADDD2N
SUBI R26,LOW(-@0)
SBCI R27,HIGH(-@0)
SBCI R24,BYTE3(-@0)
SBCI R25,BYTE4(-@0)
.ENDM
.MACRO __SUBD1N
SUBI R30,LOW(@0)
SBCI R31,HIGH(@0)
SBCI R22,BYTE3(@0)
SBCI R23,BYTE4(@0)
.ENDM
.MACRO __SUBD2N
SUBI R26,LOW(@0)
SBCI R27,HIGH(@0)
SBCI R24,BYTE3(@0)
SBCI R25,BYTE4(@0)
.ENDM
.MACRO __ANDBMNN
LDS R30,@0+(@1)
ANDI R30,LOW(@2)
STS @0+(@1),R30
.ENDM
.MACRO __ANDWMNN
LDS R30,@0+(@1)
ANDI R30,LOW(@2)
STS @0+(@1),R30
LDS R30,@0+(@1)+1
ANDI R30,HIGH(@2)
STS @0+(@1)+1,R30
.ENDM
.MACRO __ANDD1N
ANDI R30,LOW(@0)
ANDI R31,HIGH(@0)
ANDI R22,BYTE3(@0)
ANDI R23,BYTE4(@0)
.ENDM
.MACRO __ANDD2N
ANDI R26,LOW(@0)
ANDI R27,HIGH(@0)
ANDI R24,BYTE3(@0)
ANDI R25,BYTE4(@0)
.ENDM
.MACRO __ORBMNN
LDS R30,@0+(@1)
ORI R30,LOW(@2)
STS @0+(@1),R30
.ENDM
.MACRO __ORWMNN
LDS R30,@0+(@1)
ORI R30,LOW(@2)
STS @0+(@1),R30
LDS R30,@0+(@1)+1
ORI R30,HIGH(@2)
STS @0+(@1)+1,R30
.ENDM
.MACRO __ORD1N
ORI R30,LOW(@0)
ORI R31,HIGH(@0)
ORI R22,BYTE3(@0)
ORI R23,BYTE4(@0)
.ENDM
.MACRO __ORD2N
ORI R26,LOW(@0)
ORI R27,HIGH(@0)
ORI R24,BYTE3(@0)
ORI R25,BYTE4(@0)
.ENDM
.MACRO __DELAY_USB
LDI R24,LOW(@0)
__DELAY_USB_LOOP:
DEC R24
BRNE __DELAY_USB_LOOP
.ENDM
.MACRO __DELAY_USW
LDI R24,LOW(@0)
LDI R25,HIGH(@0)
__DELAY_USW_LOOP:
SBIW R24,1
BRNE __DELAY_USW_LOOP
.ENDM
.MACRO __GETD1S
LDD R30,Y+@0
LDD R31,Y+@0+1
LDD R22,Y+@0+2
LDD R23,Y+@0+3
.ENDM
.MACRO __GETD2S
LDD R26,Y+@0
LDD R27,Y+@0+1
LDD R24,Y+@0+2
LDD R25,Y+@0+3
.ENDM
.MACRO __PUTD1S
STD Y+@0,R30
STD Y+@0+1,R31
STD Y+@0+2,R22
STD Y+@0+3,R23
.ENDM
.MACRO __PUTD2S
STD Y+@0,R26
STD Y+@0+1,R27
STD Y+@0+2,R24
STD Y+@0+3,R25
.ENDM
.MACRO __PUTDZ2
STD Z+@0,R26
STD Z+@0+1,R27
STD Z+@0+2,R24
STD Z+@0+3,R25
.ENDM
.MACRO __CLRD1S
STD Y+@0,R30
STD Y+@0+1,R30
STD Y+@0+2,R30
STD Y+@0+3,R30
.ENDM
.MACRO __POINTB1MN
LDI R30,LOW(@0+(@1))
.ENDM
.MACRO __POINTW1MN
LDI R30,LOW(@0+(@1))
LDI R31,HIGH(@0+(@1))
.ENDM
.MACRO __POINTD1M
LDI R30,LOW(@0)
LDI R31,HIGH(@0)
LDI R22,BYTE3(@0)
LDI R23,BYTE4(@0)
.ENDM
.MACRO __POINTW1FN
LDI R30,LOW(2*@0+(@1))
LDI R31,HIGH(2*@0+(@1))
.ENDM
.MACRO __POINTD1FN
LDI R30,LOW(2*@0+(@1))
LDI R31,HIGH(2*@0+(@1))
LDI R22,BYTE3(2*@0+(@1))
LDI R23,BYTE4(2*@0+(@1))
.ENDM
.MACRO __POINTB2MN
LDI R26,LOW(@0+(@1))
.ENDM
.MACRO __POINTW2MN
LDI R26,LOW(@0+(@1))
LDI R27,HIGH(@0+(@1))
.ENDM
.MACRO __POINTW2FN
LDI R26,LOW(2*@0+(@1))
LDI R27,HIGH(2*@0+(@1))
.ENDM
.MACRO __POINTD2FN
LDI R26,LOW(2*@0+(@1))
LDI R27,HIGH(2*@0+(@1))
LDI R24,BYTE3(2*@0+(@1))
LDI R25,BYTE4(2*@0+(@1))
.ENDM
.MACRO __POINTBRM
LDI R@0,LOW(@1)
.ENDM
.MACRO __POINTWRM
LDI R@0,LOW(@2)
LDI R@1,HIGH(@2)
.ENDM
.MACRO __POINTBRMN
LDI R@0,LOW(@1+(@2))
.ENDM
.MACRO __POINTWRMN
LDI R@0,LOW(@2+(@3))
LDI R@1,HIGH(@2+(@3))
.ENDM
.MACRO __POINTWRFN
LDI R@0,LOW(@2*2+(@3))
LDI R@1,HIGH(@2*2+(@3))
.ENDM
.MACRO __GETD1N
LDI R30,LOW(@0)
LDI R31,HIGH(@0)
LDI R22,BYTE3(@0)
LDI R23,BYTE4(@0)
.ENDM
.MACRO __GETD2N
LDI R26,LOW(@0)
LDI R27,HIGH(@0)
LDI R24,BYTE3(@0)
LDI R25,BYTE4(@0)
.ENDM
.MACRO __GETB1MN
LDS R30,@0+(@1)
.ENDM
.MACRO __GETB1HMN
LDS R31,@0+(@1)
.ENDM
.MACRO __GETW1MN
LDS R30,@0+(@1)
LDS R31,@0+(@1)+1
.ENDM
.MACRO __GETD1MN
LDS R30,@0+(@1)
LDS R31,@0+(@1)+1
LDS R22,@0+(@1)+2
LDS R23,@0+(@1)+3
.ENDM
.MACRO __GETBRMN
LDS R@0,@1+(@2)
.ENDM
.MACRO __GETWRMN
LDS R@0,@2+(@3)
LDS R@1,@2+(@3)+1
.ENDM
.MACRO __GETWRZ
LDD R@0,Z+@2
LDD R@1,Z+@2+1
.ENDM
.MACRO __GETD2Z
LDD R26,Z+@0
LDD R27,Z+@0+1
LDD R24,Z+@0+2
LDD R25,Z+@0+3
.ENDM
.MACRO __GETB2MN
LDS R26,@0+(@1)
.ENDM
.MACRO __GETW2MN
LDS R26,@0+(@1)
LDS R27,@0+(@1)+1
.ENDM
.MACRO __GETD2MN
LDS R26,@0+(@1)
LDS R27,@0+(@1)+1
LDS R24,@0+(@1)+2
LDS R25,@0+(@1)+3
.ENDM
.MACRO __PUTB1MN
STS @0+(@1),R30
.ENDM
.MACRO __PUTW1MN
STS @0+(@1),R30
STS @0+(@1)+1,R31
.ENDM
.MACRO __PUTD1MN
STS @0+(@1),R30
STS @0+(@1)+1,R31
STS @0+(@1)+2,R22
STS @0+(@1)+3,R23
.ENDM
.MACRO __PUTB1EN
LDI R26,LOW(@0+(@1))
LDI R27,HIGH(@0+(@1))
CALL __EEPROMWRB
.ENDM
.MACRO __PUTW1EN
LDI R26,LOW(@0+(@1))
LDI R27,HIGH(@0+(@1))
CALL __EEPROMWRW
.ENDM
.MACRO __PUTD1EN
LDI R26,LOW(@0+(@1))
LDI R27,HIGH(@0+(@1))
CALL __EEPROMWRD
.ENDM
.MACRO __PUTBR0MN
STS @0+(@1),R0
.ENDM
.MACRO __PUTBMRN
STS @0+(@1),R@2
.ENDM
.MACRO __PUTWMRN
STS @0+(@1),R@2
STS @0+(@1)+1,R@3
.ENDM
.MACRO __PUTBZR
STD Z+@1,R@0
.ENDM
.MACRO __PUTWZR
STD Z+@2,R@0
STD Z+@2+1,R@1
.ENDM
.MACRO __GETW1R
MOV R30,R@0
MOV R31,R@1
.ENDM
.MACRO __GETW2R
MOV R26,R@0
MOV R27,R@1
.ENDM
.MACRO __GETWRN
LDI R@0,LOW(@2)
LDI R@1,HIGH(@2)
.ENDM
.MACRO __PUTW1R
MOV R@0,R30
MOV R@1,R31
.ENDM
.MACRO __PUTW2R
MOV R@0,R26
MOV R@1,R27
.ENDM
.MACRO __ADDWRN
SUBI R@0,LOW(-@2)
SBCI R@1,HIGH(-@2)
.ENDM
.MACRO __ADDWRR
ADD R@0,R@2
ADC R@1,R@3
.ENDM
.MACRO __SUBWRN
SUBI R@0,LOW(@2)
SBCI R@1,HIGH(@2)
.ENDM
.MACRO __SUBWRR
SUB R@0,R@2
SBC R@1,R@3
.ENDM
.MACRO __ANDWRN
ANDI R@0,LOW(@2)
ANDI R@1,HIGH(@2)
.ENDM
.MACRO __ANDWRR
AND R@0,R@2
AND R@1,R@3
.ENDM
.MACRO __ORWRN
ORI R@0,LOW(@2)
ORI R@1,HIGH(@2)
.ENDM
.MACRO __ORWRR
OR R@0,R@2
OR R@1,R@3
.ENDM
.MACRO __EORWRR
EOR R@0,R@2
EOR R@1,R@3
.ENDM
.MACRO __GETWRS
LDD R@0,Y+@2
LDD R@1,Y+@2+1
.ENDM
.MACRO __PUTBSR
STD Y+@1,R@0
.ENDM
.MACRO __PUTWSR
STD Y+@2,R@0
STD Y+@2+1,R@1
.ENDM
.MACRO __MOVEWRR
MOV R@0,R@2
MOV R@1,R@3
.ENDM
.MACRO __INWR
IN R@0,@2
IN R@1,@2+1
.ENDM
.MACRO __OUTWR
OUT @2+1,R@1
OUT @2,R@0
.ENDM
.MACRO __CALL1MN
LDS R30,@0+(@1)
LDS R31,@0+(@1)+1
ICALL
.ENDM
.MACRO __CALL1FN
LDI R30,LOW(2*@0+(@1))
LDI R31,HIGH(2*@0+(@1))
CALL __GETW1PF
ICALL
.ENDM
.MACRO __CALL2EN
PUSH R26
PUSH R27
LDI R26,LOW(@0+(@1))
LDI R27,HIGH(@0+(@1))
CALL __EEPROMRDW
POP R27
POP R26
ICALL
.ENDM
.MACRO __CALL2EX
SUBI R26,LOW(-@0)
SBCI R27,HIGH(-@0)
CALL __EEPROMRDD
ICALL
.ENDM
.MACRO __GETW1STACK
IN R30,SPL
IN R31,SPH
ADIW R30,@0+1
LD R0,Z+
LD R31,Z
MOV R30,R0
.ENDM
.MACRO __GETD1STACK
IN R30,SPL
IN R31,SPH
ADIW R30,@0+1
LD R0,Z+
LD R1,Z+
LD R22,Z
MOVW R30,R0
.ENDM
.MACRO __NBST
BST R@0,@1
IN R30,SREG
LDI R31,0x40
EOR R30,R31
OUT SREG,R30
.ENDM
.MACRO __PUTB1SN
LDD R26,Y+@0
LDD R27,Y+@0+1
SUBI R26,LOW(-@1)
SBCI R27,HIGH(-@1)
ST X,R30
.ENDM
.MACRO __PUTW1SN
LDD R26,Y+@0
LDD R27,Y+@0+1
SUBI R26,LOW(-@1)
SBCI R27,HIGH(-@1)
ST X+,R30
ST X,R31
.ENDM
.MACRO __PUTD1SN
LDD R26,Y+@0
LDD R27,Y+@0+1
SUBI R26,LOW(-@1)
SBCI R27,HIGH(-@1)
CALL __PUTDP1
.ENDM
.MACRO __PUTB1SNS
LDD R26,Y+@0
LDD R27,Y+@0+1
ADIW R26,@1
ST X,R30
.ENDM
.MACRO __PUTW1SNS
LDD R26,Y+@0
LDD R27,Y+@0+1
ADIW R26,@1
ST X+,R30
ST X,R31
.ENDM
.MACRO __PUTD1SNS
LDD R26,Y+@0
LDD R27,Y+@0+1
ADIW R26,@1
CALL __PUTDP1
.ENDM
.MACRO __PUTB1PMN
LDS R26,@0
LDS R27,@0+1
SUBI R26,LOW(-@1)
SBCI R27,HIGH(-@1)
ST X,R30
.ENDM
.MACRO __PUTW1PMN
LDS R26,@0
LDS R27,@0+1
SUBI R26,LOW(-@1)
SBCI R27,HIGH(-@1)
ST X+,R30
ST X,R31
.ENDM
.MACRO __PUTD1PMN
LDS R26,@0
LDS R27,@0+1
SUBI R26,LOW(-@1)
SBCI R27,HIGH(-@1)
CALL __PUTDP1
.ENDM
.MACRO __PUTB1PMNS
LDS R26,@0
LDS R27,@0+1
ADIW R26,@1
ST X,R30
.ENDM
.MACRO __PUTW1PMNS
LDS R26,@0
LDS R27,@0+1
ADIW R26,@1
ST X+,R30
ST X,R31
.ENDM
.MACRO __PUTD1PMNS
LDS R26,@0
LDS R27,@0+1
ADIW R26,@1
CALL __PUTDP1
.ENDM
.MACRO __PUTB1RN
MOVW R26,R@0
SUBI R26,LOW(-@1)
SBCI R27,HIGH(-@1)
ST X,R30
.ENDM
.MACRO __PUTW1RN
MOVW R26,R@0
SUBI R26,LOW(-@1)
SBCI R27,HIGH(-@1)
ST X+,R30
ST X,R31
.ENDM
.MACRO __PUTD1RN
MOVW R26,R@0
SUBI R26,LOW(-@1)
SBCI R27,HIGH(-@1)
CALL __PUTDP1
.ENDM
.MACRO __PUTB1RNS
MOVW R26,R@0
ADIW R26,@1
ST X,R30
.ENDM
.MACRO __PUTW1RNS
MOVW R26,R@0
ADIW R26,@1
ST X+,R30
ST X,R31
.ENDM
.MACRO __PUTD1RNS
MOVW R26,R@0
ADIW R26,@1
CALL __PUTDP1
.ENDM
.MACRO __PUTB1RON
MOV R26,R@0
MOV R27,R@1
SUBI R26,LOW(-@2)
SBCI R27,HIGH(-@2)
ST X,R30
.ENDM
.MACRO __PUTW1RON
MOV R26,R@0
MOV R27,R@1
SUBI R26,LOW(-@2)
SBCI R27,HIGH(-@2)
ST X+,R30
ST X,R31
.ENDM
.MACRO __PUTD1RON
MOV R26,R@0
MOV R27,R@1
SUBI R26,LOW(-@2)
SBCI R27,HIGH(-@2)
CALL __PUTDP1
.ENDM
.MACRO __PUTB1RONS
MOV R26,R@0
MOV R27,R@1
ADIW R26,@2
ST X,R30
.ENDM
.MACRO __PUTW1RONS
MOV R26,R@0
MOV R27,R@1
ADIW R26,@2
ST X+,R30
ST X,R31
.ENDM
.MACRO __PUTD1RONS
MOV R26,R@0
MOV R27,R@1
ADIW R26,@2
CALL __PUTDP1
.ENDM
.MACRO __GETB1SX
MOVW R30,R28
SUBI R30,LOW(-@0)
SBCI R31,HIGH(-@0)
LD R30,Z
.ENDM
.MACRO __GETB1HSX
MOVW R30,R28
SUBI R30,LOW(-@0)
SBCI R31,HIGH(-@0)
LD R31,Z
.ENDM
.MACRO __GETW1SX
MOVW R30,R28
SUBI R30,LOW(-@0)
SBCI R31,HIGH(-@0)
LD R0,Z+
LD R31,Z
MOV R30,R0
.ENDM
.MACRO __GETD1SX
MOVW R30,R28
SUBI R30,LOW(-@0)
SBCI R31,HIGH(-@0)
LD R0,Z+
LD R1,Z+
LD R22,Z+
LD R23,Z
MOVW R30,R0
.ENDM
.MACRO __GETB2SX
MOVW R26,R28
SUBI R26,LOW(-@0)
SBCI R27,HIGH(-@0)
LD R26,X
.ENDM
.MACRO __GETW2SX
MOVW R26,R28
SUBI R26,LOW(-@0)
SBCI R27,HIGH(-@0)
LD R0,X+
LD R27,X
MOV R26,R0
.ENDM
.MACRO __GETD2SX
MOVW R26,R28
SUBI R26,LOW(-@0)
SBCI R27,HIGH(-@0)
LD R0,X+
LD R1,X+
LD R24,X+
LD R25,X
MOVW R26,R0
.ENDM
.MACRO __GETBRSX
MOVW R30,R28
SUBI R30,LOW(-@1)
SBCI R31,HIGH(-@1)
LD R@0,Z
.ENDM
.MACRO __GETWRSX
MOVW R30,R28
SUBI R30,LOW(-@2)
SBCI R31,HIGH(-@2)
LD R@0,Z+
LD R@1,Z
.ENDM
.MACRO __GETBRSX2
MOVW R26,R28
SUBI R26,LOW(-@1)
SBCI R27,HIGH(-@1)
LD R@0,X
.ENDM
.MACRO __GETWRSX2
MOVW R26,R28
SUBI R26,LOW(-@2)
SBCI R27,HIGH(-@2)
LD R@0,X+
LD R@1,X
.ENDM
.MACRO __LSLW8SX
MOVW R30,R28
SUBI R30,LOW(-@0)
SBCI R31,HIGH(-@0)
LD R31,Z
CLR R30
.ENDM
.MACRO __PUTB1SX
MOVW R26,R28
SUBI R26,LOW(-@0)
SBCI R27,HIGH(-@0)
ST X,R30
.ENDM
.MACRO __PUTW1SX
MOVW R26,R28
SUBI R26,LOW(-@0)
SBCI R27,HIGH(-@0)
ST X+,R30
ST X,R31
.ENDM
.MACRO __PUTD1SX
MOVW R26,R28
SUBI R26,LOW(-@0)
SBCI R27,HIGH(-@0)
ST X+,R30
ST X+,R31
ST X+,R22
ST X,R23
.ENDM
.MACRO __CLRW1SX
MOVW R26,R28
SUBI R26,LOW(-@0)
SBCI R27,HIGH(-@0)
ST X+,R30
ST X,R30
.ENDM
.MACRO __CLRD1SX
MOVW R26,R28
SUBI R26,LOW(-@0)
SBCI R27,HIGH(-@0)
ST X+,R30
ST X+,R30
ST X+,R30
ST X,R30
.ENDM
.MACRO __PUTB2SX
MOVW R30,R28
SUBI R30,LOW(-@0)
SBCI R31,HIGH(-@0)
ST Z,R26
.ENDM
.MACRO __PUTW2SX
MOVW R30,R28
SUBI R30,LOW(-@0)
SBCI R31,HIGH(-@0)
ST Z+,R26
ST Z,R27
.ENDM
.MACRO __PUTD2SX
MOVW R30,R28
SUBI R30,LOW(-@0)
SBCI R31,HIGH(-@0)
ST Z+,R26
ST Z+,R27
ST Z+,R24
ST Z,R25
.ENDM
.MACRO __PUTBSRX
MOVW R30,R28
SUBI R30,LOW(-@1)
SBCI R31,HIGH(-@1)
ST Z,R@0
.ENDM
.MACRO __PUTWSRX
MOVW R30,R28
SUBI R30,LOW(-@2)
SBCI R31,HIGH(-@2)
ST Z+,R@0
ST Z,R@1
.ENDM
.MACRO __PUTB1SNX
MOVW R26,R28
SUBI R26,LOW(-@0)
SBCI R27,HIGH(-@0)
LD R0,X+
LD R27,X
MOV R26,R0
SUBI R26,LOW(-@1)
SBCI R27,HIGH(-@1)
ST X,R30
.ENDM
.MACRO __PUTW1SNX
MOVW R26,R28
SUBI R26,LOW(-@0)
SBCI R27,HIGH(-@0)
LD R0,X+
LD R27,X
MOV R26,R0
SUBI R26,LOW(-@1)
SBCI R27,HIGH(-@1)
ST X+,R30
ST X,R31
.ENDM
.MACRO __PUTD1SNX
MOVW R26,R28
SUBI R26,LOW(-@0)
SBCI R27,HIGH(-@0)
LD R0,X+
LD R27,X
MOV R26,R0
SUBI R26,LOW(-@1)
SBCI R27,HIGH(-@1)
ST X+,R30
ST X+,R31
ST X+,R22
ST X,R23
.ENDM
.MACRO __MULBRR
MULS R@0,R@1
MOVW R30,R0
.ENDM
.MACRO __MULBRRU
MUL R@0,R@1
MOVW R30,R0
.ENDM
.MACRO __MULBRR0
MULS R@0,R@1
.ENDM
.MACRO __MULBRRU0
MUL R@0,R@1
.ENDM
.MACRO __MULBNWRU
LDI R26,@2
MUL R26,R@0
MOVW R30,R0
MUL R26,R@1
ADD R31,R0
.ENDM
.CSEG
.ORG 0x00
;START OF CODE MARKER
__START_OF_CODE:
;INTERRUPT VECTORS
JMP __RESET
JMP 0x00
JMP 0x00
JMP 0x00
JMP 0x00
JMP 0x00
JMP 0x00
JMP 0x00
JMP 0x00
JMP 0x00
JMP 0x00
JMP 0x00
JMP 0x00
JMP 0x00
JMP 0x00
JMP 0x00
JMP 0x00
JMP 0x00
JMP 0x00
JMP 0x00
JMP 0x00
_0x3:
.DB 0x3F,0x6,0x5B,0x4F,0x66,0x6D,0x7D,0x7
.DB 0x7F,0x6F
__RESET:
CLI
CLR R30
OUT EECR,R30
;INTERRUPT VECTORS ARE PLACED
;AT THE START OF FLASH
LDI R31,1
OUT GICR,R31
OUT GICR,R30
OUT MCUCR,R30
;CLEAR R2-R14
LDI R24,(14-2)+1
LDI R26,2
CLR R27
__CLEAR_REG:
ST X+,R30
DEC R24
BRNE __CLEAR_REG
;CLEAR SRAM
LDI R24,LOW(__CLEAR_SRAM_SIZE)
LDI R25,HIGH(__CLEAR_SRAM_SIZE)
LDI R26,__SRAM_START
__CLEAR_SRAM:
ST X+,R30
SBIW R24,1
BRNE __CLEAR_SRAM
;HARDWARE STACK POINTER INITIALIZATION
LDI R30,LOW(__SRAM_END-__HEAP_SIZE)
OUT SPL,R30
LDI R30,HIGH(__SRAM_END-__HEAP_SIZE)
OUT SPH,R30
;DATA STACK POINTER INITIALIZATION
LDI R28,LOW(__SRAM_START+__DSTACK_SIZE)
LDI R29,HIGH(__SRAM_START+__DSTACK_SIZE)
JMP _main
.ESEG
.ORG 0
.DSEG
.ORG 0x160
.CSEG
;
;#include <mega16a.h>
#ifndef __SLEEP_DEFINED__
#define __SLEEP_DEFINED__
.EQU __se_bit=0x40
.EQU __sm_mask=0xB0
.EQU __sm_powerdown=0x20
.EQU __sm_powersave=0x30
.EQU __sm_standby=0xA0
.EQU __sm_ext_standby=0xB0
.EQU __sm_adc_noise_red=0x10
.SET power_ctrl_reg=mcucr
#endif
;#include <delay.h>
;
;void main(void)
; 0000 0006 {
.CSEG
_main:
; .FSTART _main
; 0000 0007 unsigned int yekan,dahgan,sadgan,hezargan,i;
; 0000 0008 unsigned char seg_code[]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f};
; 0000 0009 unsigned int a,b;
; 0000 000A long int number;
; 0000 000B // Port C initialization
; 0000 000C // Function: Bit7=In Bit6=Out Bit5=Out Bit4=Out Bit3=Out Bit2=Out Bit1=Out Bit0=Out
; 0000 000D DDRC=(0<<DDC7) | (1<<DDC6) | (1<<DDC5) | (1<<DDC4) | (1<<DDC3) | (1<<DDC2) | (1<<DDC1) | (1<<DDC0);
SBIW R28,22
LDI R24,10
LDI R26,LOW(8)
LDI R27,HIGH(8)
LDI R30,LOW(_0x3*2)
LDI R31,HIGH(_0x3*2)
CALL __INITLOCB
; yekan -> R16,R17
; dahgan -> R18,R19
; sadgan -> R20,R21
; hezargan -> Y+20
; i -> Y+18
; seg_code -> Y+8
; a -> Y+6
; b -> Y+4
; number -> Y+0
LDI R30,LOW(127)
OUT 0x14,R30
; 0000 000E // State: Bit7=T Bit6=0 Bit5=0 Bit4=0 Bit3=0 Bit2=0 Bit1=0 Bit0=0
; 0000 000F PORTC=(0<<PORTC7) | (0<<PORTC6) | (0<<PORTC5) | (0<<PORTC4) | (0<<PORTC3) | (0<<PORTC2) | (0<<PORTC1) | (0<<PORTC0);
LDI R30,LOW(0)
OUT 0x15,R30
; 0000 0010
; 0000 0011 // Port D initialization
; 0000 0012 // Function: Bit7=In Bit6=In Bit5=Out Bit4=Out Bit3=Out Bit2=Out Bit1=Out Bit0=Out
; 0000 0013 DDRD=(0<<DDD7) | (0<<DDD6) | (1<<DDD5) | (1<<DDD4) | (1<<DDD3) | (1<<DDD2) | (1<<DDD1) | (1<<DDD0);
LDI R30,LOW(63)
OUT 0x11,R30
; 0000 0014 // State: Bit7=T Bit6=T Bit5=0 Bit4=0 Bit3=0 Bit2=0 Bit1=0 Bit0=0
; 0000 0015 PORTD=(0<<PORTD7) | (0<<PORTD6) | (0<<PORTD5) | (0<<PORTD4) | (0<<PORTD3) | (0<<PORTD2) | (0<<PORTD1) | (0<<PORTD0);
LDI R30,LOW(0)
OUT 0x12,R30
; 0000 0016
; 0000 0017 while (1)
_0x4:
; 0000 0018 {
; 0000 0019 for(number=0;number<1000000;number++)
LDI R30,LOW(0)
CALL __CLRD1S0
_0x8:
RCALL SUBOPT_0x0
__CPD2N 0xF4240
BRLT PC+2
RJMP _0x9
; 0000 001A {
; 0000 001B yekan=number%10;
RCALL SUBOPT_0x1
CALL __MODD21
MOVW R16,R30
; 0000 001C dahgan=number/10%10;
RCALL SUBOPT_0x1
RCALL SUBOPT_0x2
MOVW R18,R30
; 0000 001D sadgan=number/100%10;
RCALL SUBOPT_0x0
__GETD1N 0x64
RCALL SUBOPT_0x2
MOVW R20,R30
; 0000 001E hezargan=number/1000%10;
RCALL SUBOPT_0x0
__GETD1N 0x3E8
RCALL SUBOPT_0x2
STD Y+20,R30
STD Y+20+1,R31
; 0000 001F a=number/10000%10;
RCALL SUBOPT_0x0
__GETD1N 0x2710
RCALL SUBOPT_0x2
STD Y+6,R30
STD Y+6+1,R31
; 0000 0020 b=number/100000;
RCALL SUBOPT_0x0
__GETD1N 0x186A0
CALL __DIVD21
STD Y+4,R30
STD Y+4+1,R31
; 0000 0021 for(i=0;i<30;i++)
LDI R30,LOW(0)
STD Y+18,R30
STD Y+18+1,R30
_0xB:
LDD R26,Y+18
LDD R27,Y+18+1
SBIW R26,30
BRSH _0xC
; 0000 0022 {
; 0000 0023 PORTC=seg_code[yekan];
MOVW R26,R28
ADIW R26,8
ADD R26,R16
ADC R27,R17
LD R30,X
OUT 0x15,R30
; 0000 0024 PORTD=0XDF;
LDI R30,LOW(223)
RCALL SUBOPT_0x3
; 0000 0025 delay_ms(2);
; 0000 0026 PORTD=0xff;
; 0000 0027
; 0000 0028 PORTC=seg_code[dahgan];
ADD R26,R18
ADC R27,R19
LD R30,X
OUT 0x15,R30
; 0000 0029 PORTD=0XEF;
LDI R30,LOW(239)
RCALL SUBOPT_0x3
; 0000 002A delay_ms(2);
; 0000 002B PORTD=0xff;
; 0000 002C
; 0000 002D PORTC=seg_code[sadgan];
ADD R26,R20
ADC R27,R21
LD R30,X
OUT 0x15,R30
; 0000 002E PORTD=0XF7;
LDI R30,LOW(247)
RCALL SUBOPT_0x4
; 0000 002F delay_ms(2);
; 0000 0030 PORTD=0xff;
; 0000 0031
; 0000 0032 PORTC=seg_code[hezargan];
LDD R30,Y+20
LDD R31,Y+20+1
RCALL SUBOPT_0x5
; 0000 0033 PORTD=0XFB;
LDI R30,LOW(251)
RCALL SUBOPT_0x4
; 0000 0034 delay_ms(2);
; 0000 0035 PORTD=0xff;
; 0000 0036
; 0000 0037 PORTC=seg_code[a];
LDD R30,Y+6
LDD R31,Y+6+1
RCALL SUBOPT_0x5
; 0000 0038 PORTD=0XFD;
LDI R30,LOW(253)
RCALL SUBOPT_0x4
; 0000 0039 delay_ms(2);
; 0000 003A PORTD=0xff;
; 0000 003B
; 0000 003C PORTC=seg_code[b];
LDD R30,Y+4
LDD R31,Y+4+1
RCALL SUBOPT_0x5
; 0000 003D PORTD=0XFE;
LDI R30,LOW(254)
RCALL SUBOPT_0x4
; 0000 003E delay_ms(2);
; 0000 003F PORTD=0xff;
; 0000 0040 }
LDD R30,Y+18
LDD R31,Y+18+1
ADIW R30,1
STD Y+18,R30
STD Y+18+1,R31
RJMP _0xB
_0xC:
; 0000 0041 }
CALL __GETD1S0
__SUBD1N -1
CALL __PUTD1S0
RJMP _0x8
_0x9:
; 0000 0042 }
RJMP _0x4
; 0000 0043 }
_0xD:
RJMP _0xD
; .FEND
.CSEG
;OPTIMIZER ADDED SUBROUTINE, CALLED 7 TIMES, CODE SIZE REDUCTION:9 WORDS
SUBOPT_0x0:
CALL __GETD2S0
RET
;OPTIMIZER ADDED SUBROUTINE, CALLED 2 TIMES, CODE SIZE REDUCTION:1 WORDS
SUBOPT_0x1:
RCALL SUBOPT_0x0
__GETD1N 0xA
RET
;OPTIMIZER ADDED SUBROUTINE, CALLED 4 TIMES, CODE SIZE REDUCTION:21 WORDS
SUBOPT_0x2:
CALL __DIVD21
MOVW R26,R30
MOVW R24,R22
__GETD1N 0xA
CALL __MODD21
RET
;OPTIMIZER ADDED SUBROUTINE, CALLED 2 TIMES, CODE SIZE REDUCTION:4 WORDS
SUBOPT_0x3:
OUT 0x12,R30
LDI R26,LOW(2)
LDI R27,0
CALL _delay_ms
LDI R30,LOW(255)
OUT 0x12,R30
MOVW R26,R28
ADIW R26,8
RET
;OPTIMIZER ADDED SUBROUTINE, CALLED 4 TIMES, CODE SIZE REDUCTION:12 WORDS
SUBOPT_0x4:
OUT 0x12,R30
LDI R26,LOW(2)
LDI R27,0
CALL _delay_ms
LDI R30,LOW(255)
OUT 0x12,R30
RET
;OPTIMIZER ADDED SUBROUTINE, CALLED 3 TIMES, CODE SIZE REDUCTION:5 WORDS
SUBOPT_0x5:
MOVW R26,R28
ADIW R26,8
ADD R26,R30
ADC R27,R31
LD R30,X
OUT 0x15,R30
RET
.CSEG
_delay_ms:
adiw r26,0
breq __delay_ms1
__delay_ms0:
__DELAY_USW 0x7D0
wdr
sbiw r26,1
brne __delay_ms0
__delay_ms1:
ret
__ANEGD1:
COM R31
COM R22
COM R23
NEG R30
SBCI R31,-1
SBCI R22,-1
SBCI R23,-1
RET
__DIVD21U:
PUSH R19
PUSH R20
PUSH R21
CLR R0
CLR R1
CLR R20
CLR R21
LDI R19,32
__DIVD21U1:
LSL R26
ROL R27
ROL R24
ROL R25
ROL R0
ROL R1
ROL R20
ROL R21
SUB R0,R30
SBC R1,R31
SBC R20,R22
SBC R21,R23
BRCC __DIVD21U2
ADD R0,R30
ADC R1,R31
ADC R20,R22
ADC R21,R23
RJMP __DIVD21U3
__DIVD21U2:
SBR R26,1
__DIVD21U3:
DEC R19
BRNE __DIVD21U1
MOVW R30,R26
MOVW R22,R24
MOVW R26,R0
MOVW R24,R20
POP R21
POP R20
POP R19
RET
__DIVD21:
RCALL __CHKSIGND
RCALL __DIVD21U
BRTC __DIVD211
RCALL __ANEGD1
__DIVD211:
RET
__MODD21:
CLT
SBRS R25,7
RJMP __MODD211
COM R26
COM R27
COM R24
COM R25
SUBI R26,-1
SBCI R27,-1
SBCI R24,-1
SBCI R25,-1
SET
__MODD211:
SBRC R23,7
RCALL __ANEGD1
RCALL __DIVD21U
MOVW R30,R26
MOVW R22,R24
BRTC __MODD212
RCALL __ANEGD1
__MODD212:
RET
__CHKSIGND:
CLT
SBRS R23,7
RJMP __CHKSD1
RCALL __ANEGD1
SET
__CHKSD1:
SBRS R25,7
RJMP __CHKSD2
CLR R0
COM R26
COM R27
COM R24
COM R25
ADIW R26,1
ADC R24,R0
ADC R25,R0
BLD R0,0
INC R0
BST R0,0
__CHKSD2:
RET
__GETD1S0:
LD R30,Y
LDD R31,Y+1
LDD R22,Y+2
LDD R23,Y+3
RET
__GETD2S0:
LD R26,Y
LDD R27,Y+1
LDD R24,Y+2
LDD R25,Y+3
RET
__PUTD1S0:
ST Y,R30
STD Y+1,R31
STD Y+2,R22
STD Y+3,R23
RET
__CLRD1S0:
ST Y,R30
STD Y+1,R30
STD Y+2,R30
STD Y+3,R30
RET
__INITLOCB:
__INITLOCW:
ADD R26,R28
ADC R27,R29
__INITLOC0:
LPM R0,Z+
ST X+,R0
DEC R24
BRNE __INITLOC0
RET
;END OF CODE MARKER
__END_OF_CODE:
|
ADDI 1
STORE 1
LOAD 1
LOAD 0
|
_wc: file format elf32-i386
Disassembly of section .text:
00000000 <main>:
printf(1, "%d %d %d %s\n", l, w, c, name);
}
int
main(int argc, char *argv[])
{
0: 8d 4c 24 04 lea 0x4(%esp),%ecx
4: 83 e4 f0 and $0xfffffff0,%esp
7: ff 71 fc pushl -0x4(%ecx)
a: 55 push %ebp
b: 89 e5 mov %esp,%ebp
d: 57 push %edi
e: 56 push %esi
f: 53 push %ebx
10: 51 push %ecx
11: be 01 00 00 00 mov $0x1,%esi
16: 83 ec 18 sub $0x18,%esp
19: 8b 01 mov (%ecx),%eax
1b: 8b 59 04 mov 0x4(%ecx),%ebx
1e: 83 c3 04 add $0x4,%ebx
int fd, i;
if(argc <= 1){
21: 83 f8 01 cmp $0x1,%eax
{
24: 89 45 e4 mov %eax,-0x1c(%ebp)
if(argc <= 1){
27: 7e 56 jle 7f <main+0x7f>
29: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
wc(0, "");
exit();
}
for(i = 1; i < argc; i++){
if((fd = open(argv[i], 0)) < 0){
30: 83 ec 08 sub $0x8,%esp
33: 6a 00 push $0x0
35: ff 33 pushl (%ebx)
37: e8 d6 03 00 00 call 412 <open>
3c: 83 c4 10 add $0x10,%esp
3f: 85 c0 test %eax,%eax
41: 89 c7 mov %eax,%edi
43: 78 26 js 6b <main+0x6b>
printf(1, "wc: cannot open %s\n", argv[i]);
exit();
}
wc(fd, argv[i]);
45: 83 ec 08 sub $0x8,%esp
48: ff 33 pushl (%ebx)
for(i = 1; i < argc; i++){
4a: 83 c6 01 add $0x1,%esi
wc(fd, argv[i]);
4d: 50 push %eax
4e: 83 c3 04 add $0x4,%ebx
51: e8 4a 00 00 00 call a0 <wc>
close(fd);
56: 89 3c 24 mov %edi,(%esp)
59: e8 9c 03 00 00 call 3fa <close>
for(i = 1; i < argc; i++){
5e: 83 c4 10 add $0x10,%esp
61: 39 75 e4 cmp %esi,-0x1c(%ebp)
64: 75 ca jne 30 <main+0x30>
}
exit();
66: e8 67 03 00 00 call 3d2 <exit>
printf(1, "wc: cannot open %s\n", argv[i]);
6b: 50 push %eax
6c: ff 33 pushl (%ebx)
6e: 68 ab 08 00 00 push $0x8ab
73: 6a 01 push $0x1
75: e8 b6 04 00 00 call 530 <printf>
exit();
7a: e8 53 03 00 00 call 3d2 <exit>
wc(0, "");
7f: 52 push %edx
80: 52 push %edx
81: 68 9d 08 00 00 push $0x89d
86: 6a 00 push $0x0
88: e8 13 00 00 00 call a0 <wc>
exit();
8d: e8 40 03 00 00 call 3d2 <exit>
92: 66 90 xchg %ax,%ax
94: 66 90 xchg %ax,%ax
96: 66 90 xchg %ax,%ax
98: 66 90 xchg %ax,%ax
9a: 66 90 xchg %ax,%ax
9c: 66 90 xchg %ax,%ax
9e: 66 90 xchg %ax,%ax
000000a0 <wc>:
{
a0: 55 push %ebp
a1: 89 e5 mov %esp,%ebp
a3: 57 push %edi
a4: 56 push %esi
a5: 53 push %ebx
l = w = c = 0;
a6: 31 db xor %ebx,%ebx
{
a8: 83 ec 1c sub $0x1c,%esp
inword = 0;
ab: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp)
l = w = c = 0;
b2: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp)
b9: c7 45 dc 00 00 00 00 movl $0x0,-0x24(%ebp)
while((n = read(fd, buf, sizeof(buf))) > 0){
c0: 83 ec 04 sub $0x4,%esp
c3: 68 00 02 00 00 push $0x200
c8: 68 e0 0b 00 00 push $0xbe0
cd: ff 75 08 pushl 0x8(%ebp)
d0: e8 15 03 00 00 call 3ea <read>
d5: 83 c4 10 add $0x10,%esp
d8: 83 f8 00 cmp $0x0,%eax
db: 89 c6 mov %eax,%esi
dd: 7e 61 jle 140 <wc+0xa0>
for(i=0; i<n; i++){
df: 31 ff xor %edi,%edi
e1: eb 13 jmp f6 <wc+0x56>
e3: 90 nop
e4: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
inword = 0;
e8: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp)
for(i=0; i<n; i++){
ef: 83 c7 01 add $0x1,%edi
f2: 39 fe cmp %edi,%esi
f4: 74 42 je 138 <wc+0x98>
if(buf[i] == '\n')
f6: 0f be 87 e0 0b 00 00 movsbl 0xbe0(%edi),%eax
l++;
fd: 31 c9 xor %ecx,%ecx
ff: 3c 0a cmp $0xa,%al
101: 0f 94 c1 sete %cl
if(strchr(" \r\t\n\v", buf[i]))
104: 83 ec 08 sub $0x8,%esp
107: 50 push %eax
108: 68 88 08 00 00 push $0x888
l++;
10d: 01 cb add %ecx,%ebx
if(strchr(" \r\t\n\v", buf[i]))
10f: e8 3c 01 00 00 call 250 <strchr>
114: 83 c4 10 add $0x10,%esp
117: 85 c0 test %eax,%eax
119: 75 cd jne e8 <wc+0x48>
else if(!inword){
11b: 8b 55 e4 mov -0x1c(%ebp),%edx
11e: 85 d2 test %edx,%edx
120: 75 cd jne ef <wc+0x4f>
for(i=0; i<n; i++){
122: 83 c7 01 add $0x1,%edi
w++;
125: 83 45 dc 01 addl $0x1,-0x24(%ebp)
inword = 1;
129: c7 45 e4 01 00 00 00 movl $0x1,-0x1c(%ebp)
for(i=0; i<n; i++){
130: 39 fe cmp %edi,%esi
132: 75 c2 jne f6 <wc+0x56>
134: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
138: 01 75 e0 add %esi,-0x20(%ebp)
13b: eb 83 jmp c0 <wc+0x20>
13d: 8d 76 00 lea 0x0(%esi),%esi
if(n < 0){
140: 75 24 jne 166 <wc+0xc6>
printf(1, "%d %d %d %s\n", l, w, c, name);
142: 83 ec 08 sub $0x8,%esp
145: ff 75 0c pushl 0xc(%ebp)
148: ff 75 e0 pushl -0x20(%ebp)
14b: ff 75 dc pushl -0x24(%ebp)
14e: 53 push %ebx
14f: 68 9e 08 00 00 push $0x89e
154: 6a 01 push $0x1
156: e8 d5 03 00 00 call 530 <printf>
}
15b: 83 c4 20 add $0x20,%esp
15e: 8d 65 f4 lea -0xc(%ebp),%esp
161: 5b pop %ebx
162: 5e pop %esi
163: 5f pop %edi
164: 5d pop %ebp
165: c3 ret
printf(1, "wc: read error\n");
166: 50 push %eax
167: 50 push %eax
168: 68 8e 08 00 00 push $0x88e
16d: 6a 01 push $0x1
16f: e8 bc 03 00 00 call 530 <printf>
exit();
174: e8 59 02 00 00 call 3d2 <exit>
179: 66 90 xchg %ax,%ax
17b: 66 90 xchg %ax,%ax
17d: 66 90 xchg %ax,%ax
17f: 90 nop
00000180 <strcpy>:
#include "user.h"
#include "x86.h"
char*
strcpy(char *s, const char *t)
{
180: 55 push %ebp
181: 89 e5 mov %esp,%ebp
183: 53 push %ebx
184: 8b 45 08 mov 0x8(%ebp),%eax
187: 8b 4d 0c mov 0xc(%ebp),%ecx
char *os;
os = s;
while((*s++ = *t++) != 0)
18a: 89 c2 mov %eax,%edx
18c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
190: 83 c1 01 add $0x1,%ecx
193: 0f b6 59 ff movzbl -0x1(%ecx),%ebx
197: 83 c2 01 add $0x1,%edx
19a: 84 db test %bl,%bl
19c: 88 5a ff mov %bl,-0x1(%edx)
19f: 75 ef jne 190 <strcpy+0x10>
;
return os;
}
1a1: 5b pop %ebx
1a2: 5d pop %ebp
1a3: c3 ret
1a4: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
1aa: 8d bf 00 00 00 00 lea 0x0(%edi),%edi
000001b0 <strcmp>:
int
strcmp(const char *p, const char *q)
{
1b0: 55 push %ebp
1b1: 89 e5 mov %esp,%ebp
1b3: 53 push %ebx
1b4: 8b 55 08 mov 0x8(%ebp),%edx
1b7: 8b 4d 0c mov 0xc(%ebp),%ecx
while(*p && *p == *q)
1ba: 0f b6 02 movzbl (%edx),%eax
1bd: 0f b6 19 movzbl (%ecx),%ebx
1c0: 84 c0 test %al,%al
1c2: 75 1c jne 1e0 <strcmp+0x30>
1c4: eb 2a jmp 1f0 <strcmp+0x40>
1c6: 8d 76 00 lea 0x0(%esi),%esi
1c9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
p++, q++;
1d0: 83 c2 01 add $0x1,%edx
while(*p && *p == *q)
1d3: 0f b6 02 movzbl (%edx),%eax
p++, q++;
1d6: 83 c1 01 add $0x1,%ecx
1d9: 0f b6 19 movzbl (%ecx),%ebx
while(*p && *p == *q)
1dc: 84 c0 test %al,%al
1de: 74 10 je 1f0 <strcmp+0x40>
1e0: 38 d8 cmp %bl,%al
1e2: 74 ec je 1d0 <strcmp+0x20>
return (uchar)*p - (uchar)*q;
1e4: 29 d8 sub %ebx,%eax
}
1e6: 5b pop %ebx
1e7: 5d pop %ebp
1e8: c3 ret
1e9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1f0: 31 c0 xor %eax,%eax
return (uchar)*p - (uchar)*q;
1f2: 29 d8 sub %ebx,%eax
}
1f4: 5b pop %ebx
1f5: 5d pop %ebp
1f6: c3 ret
1f7: 89 f6 mov %esi,%esi
1f9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
00000200 <strlen>:
uint
strlen(const char *s)
{
200: 55 push %ebp
201: 89 e5 mov %esp,%ebp
203: 8b 4d 08 mov 0x8(%ebp),%ecx
int n;
for(n = 0; s[n]; n++)
206: 80 39 00 cmpb $0x0,(%ecx)
209: 74 15 je 220 <strlen+0x20>
20b: 31 d2 xor %edx,%edx
20d: 8d 76 00 lea 0x0(%esi),%esi
210: 83 c2 01 add $0x1,%edx
213: 80 3c 11 00 cmpb $0x0,(%ecx,%edx,1)
217: 89 d0 mov %edx,%eax
219: 75 f5 jne 210 <strlen+0x10>
;
return n;
}
21b: 5d pop %ebp
21c: c3 ret
21d: 8d 76 00 lea 0x0(%esi),%esi
for(n = 0; s[n]; n++)
220: 31 c0 xor %eax,%eax
}
222: 5d pop %ebp
223: c3 ret
224: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
22a: 8d bf 00 00 00 00 lea 0x0(%edi),%edi
00000230 <memset>:
void*
memset(void *dst, int c, uint n)
{
230: 55 push %ebp
231: 89 e5 mov %esp,%ebp
233: 57 push %edi
234: 8b 55 08 mov 0x8(%ebp),%edx
}
static inline void
stosb(void *addr, int data, int cnt)
{
asm volatile("cld; rep stosb" :
237: 8b 4d 10 mov 0x10(%ebp),%ecx
23a: 8b 45 0c mov 0xc(%ebp),%eax
23d: 89 d7 mov %edx,%edi
23f: fc cld
240: f3 aa rep stos %al,%es:(%edi)
stosb(dst, c, n);
return dst;
}
242: 89 d0 mov %edx,%eax
244: 5f pop %edi
245: 5d pop %ebp
246: c3 ret
247: 89 f6 mov %esi,%esi
249: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
00000250 <strchr>:
char*
strchr(const char *s, char c)
{
250: 55 push %ebp
251: 89 e5 mov %esp,%ebp
253: 53 push %ebx
254: 8b 45 08 mov 0x8(%ebp),%eax
257: 8b 5d 0c mov 0xc(%ebp),%ebx
for(; *s; s++)
25a: 0f b6 10 movzbl (%eax),%edx
25d: 84 d2 test %dl,%dl
25f: 74 1d je 27e <strchr+0x2e>
if(*s == c)
261: 38 d3 cmp %dl,%bl
263: 89 d9 mov %ebx,%ecx
265: 75 0d jne 274 <strchr+0x24>
267: eb 17 jmp 280 <strchr+0x30>
269: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
270: 38 ca cmp %cl,%dl
272: 74 0c je 280 <strchr+0x30>
for(; *s; s++)
274: 83 c0 01 add $0x1,%eax
277: 0f b6 10 movzbl (%eax),%edx
27a: 84 d2 test %dl,%dl
27c: 75 f2 jne 270 <strchr+0x20>
return (char*)s;
return 0;
27e: 31 c0 xor %eax,%eax
}
280: 5b pop %ebx
281: 5d pop %ebp
282: c3 ret
283: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
289: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
00000290 <gets>:
char*
gets(char *buf, int max)
{
290: 55 push %ebp
291: 89 e5 mov %esp,%ebp
293: 57 push %edi
294: 56 push %esi
295: 53 push %ebx
int i, cc;
char c;
for(i=0; i+1 < max; ){
296: 31 f6 xor %esi,%esi
298: 89 f3 mov %esi,%ebx
{
29a: 83 ec 1c sub $0x1c,%esp
29d: 8b 7d 08 mov 0x8(%ebp),%edi
for(i=0; i+1 < max; ){
2a0: eb 2f jmp 2d1 <gets+0x41>
2a2: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
cc = read(0, &c, 1);
2a8: 8d 45 e7 lea -0x19(%ebp),%eax
2ab: 83 ec 04 sub $0x4,%esp
2ae: 6a 01 push $0x1
2b0: 50 push %eax
2b1: 6a 00 push $0x0
2b3: e8 32 01 00 00 call 3ea <read>
if(cc < 1)
2b8: 83 c4 10 add $0x10,%esp
2bb: 85 c0 test %eax,%eax
2bd: 7e 1c jle 2db <gets+0x4b>
break;
buf[i++] = c;
2bf: 0f b6 45 e7 movzbl -0x19(%ebp),%eax
2c3: 83 c7 01 add $0x1,%edi
2c6: 88 47 ff mov %al,-0x1(%edi)
if(c == '\n' || c == '\r')
2c9: 3c 0a cmp $0xa,%al
2cb: 74 23 je 2f0 <gets+0x60>
2cd: 3c 0d cmp $0xd,%al
2cf: 74 1f je 2f0 <gets+0x60>
for(i=0; i+1 < max; ){
2d1: 83 c3 01 add $0x1,%ebx
2d4: 3b 5d 0c cmp 0xc(%ebp),%ebx
2d7: 89 fe mov %edi,%esi
2d9: 7c cd jl 2a8 <gets+0x18>
2db: 89 f3 mov %esi,%ebx
break;
}
buf[i] = '\0';
return buf;
}
2dd: 8b 45 08 mov 0x8(%ebp),%eax
buf[i] = '\0';
2e0: c6 03 00 movb $0x0,(%ebx)
}
2e3: 8d 65 f4 lea -0xc(%ebp),%esp
2e6: 5b pop %ebx
2e7: 5e pop %esi
2e8: 5f pop %edi
2e9: 5d pop %ebp
2ea: c3 ret
2eb: 90 nop
2ec: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
2f0: 8b 75 08 mov 0x8(%ebp),%esi
2f3: 8b 45 08 mov 0x8(%ebp),%eax
2f6: 01 de add %ebx,%esi
2f8: 89 f3 mov %esi,%ebx
buf[i] = '\0';
2fa: c6 03 00 movb $0x0,(%ebx)
}
2fd: 8d 65 f4 lea -0xc(%ebp),%esp
300: 5b pop %ebx
301: 5e pop %esi
302: 5f pop %edi
303: 5d pop %ebp
304: c3 ret
305: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
309: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
00000310 <stat>:
int
stat(const char *n, struct stat *st)
{
310: 55 push %ebp
311: 89 e5 mov %esp,%ebp
313: 56 push %esi
314: 53 push %ebx
int fd;
int r;
fd = open(n, O_RDONLY);
315: 83 ec 08 sub $0x8,%esp
318: 6a 00 push $0x0
31a: ff 75 08 pushl 0x8(%ebp)
31d: e8 f0 00 00 00 call 412 <open>
if(fd < 0)
322: 83 c4 10 add $0x10,%esp
325: 85 c0 test %eax,%eax
327: 78 27 js 350 <stat+0x40>
return -1;
r = fstat(fd, st);
329: 83 ec 08 sub $0x8,%esp
32c: ff 75 0c pushl 0xc(%ebp)
32f: 89 c3 mov %eax,%ebx
331: 50 push %eax
332: e8 f3 00 00 00 call 42a <fstat>
close(fd);
337: 89 1c 24 mov %ebx,(%esp)
r = fstat(fd, st);
33a: 89 c6 mov %eax,%esi
close(fd);
33c: e8 b9 00 00 00 call 3fa <close>
return r;
341: 83 c4 10 add $0x10,%esp
}
344: 8d 65 f8 lea -0x8(%ebp),%esp
347: 89 f0 mov %esi,%eax
349: 5b pop %ebx
34a: 5e pop %esi
34b: 5d pop %ebp
34c: c3 ret
34d: 8d 76 00 lea 0x0(%esi),%esi
return -1;
350: be ff ff ff ff mov $0xffffffff,%esi
355: eb ed jmp 344 <stat+0x34>
357: 89 f6 mov %esi,%esi
359: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
00000360 <atoi>:
int
atoi(const char *s)
{
360: 55 push %ebp
361: 89 e5 mov %esp,%ebp
363: 53 push %ebx
364: 8b 4d 08 mov 0x8(%ebp),%ecx
int n;
n = 0;
while('0' <= *s && *s <= '9')
367: 0f be 11 movsbl (%ecx),%edx
36a: 8d 42 d0 lea -0x30(%edx),%eax
36d: 3c 09 cmp $0x9,%al
n = 0;
36f: b8 00 00 00 00 mov $0x0,%eax
while('0' <= *s && *s <= '9')
374: 77 1f ja 395 <atoi+0x35>
376: 8d 76 00 lea 0x0(%esi),%esi
379: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
n = n*10 + *s++ - '0';
380: 8d 04 80 lea (%eax,%eax,4),%eax
383: 83 c1 01 add $0x1,%ecx
386: 8d 44 42 d0 lea -0x30(%edx,%eax,2),%eax
while('0' <= *s && *s <= '9')
38a: 0f be 11 movsbl (%ecx),%edx
38d: 8d 5a d0 lea -0x30(%edx),%ebx
390: 80 fb 09 cmp $0x9,%bl
393: 76 eb jbe 380 <atoi+0x20>
return n;
}
395: 5b pop %ebx
396: 5d pop %ebp
397: c3 ret
398: 90 nop
399: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
000003a0 <memmove>:
void*
memmove(void *vdst, const void *vsrc, int n)
{
3a0: 55 push %ebp
3a1: 89 e5 mov %esp,%ebp
3a3: 56 push %esi
3a4: 53 push %ebx
3a5: 8b 5d 10 mov 0x10(%ebp),%ebx
3a8: 8b 45 08 mov 0x8(%ebp),%eax
3ab: 8b 75 0c mov 0xc(%ebp),%esi
char *dst;
const char *src;
dst = vdst;
src = vsrc;
while(n-- > 0)
3ae: 85 db test %ebx,%ebx
3b0: 7e 14 jle 3c6 <memmove+0x26>
3b2: 31 d2 xor %edx,%edx
3b4: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
*dst++ = *src++;
3b8: 0f b6 0c 16 movzbl (%esi,%edx,1),%ecx
3bc: 88 0c 10 mov %cl,(%eax,%edx,1)
3bf: 83 c2 01 add $0x1,%edx
while(n-- > 0)
3c2: 39 d3 cmp %edx,%ebx
3c4: 75 f2 jne 3b8 <memmove+0x18>
return vdst;
}
3c6: 5b pop %ebx
3c7: 5e pop %esi
3c8: 5d pop %ebp
3c9: c3 ret
000003ca <fork>:
name: \
movl $SYS_ ## name, %eax; \
int $T_SYSCALL; \
ret
SYSCALL(fork)
3ca: b8 01 00 00 00 mov $0x1,%eax
3cf: cd 40 int $0x40
3d1: c3 ret
000003d2 <exit>:
SYSCALL(exit)
3d2: b8 02 00 00 00 mov $0x2,%eax
3d7: cd 40 int $0x40
3d9: c3 ret
000003da <wait>:
SYSCALL(wait)
3da: b8 03 00 00 00 mov $0x3,%eax
3df: cd 40 int $0x40
3e1: c3 ret
000003e2 <pipe>:
SYSCALL(pipe)
3e2: b8 04 00 00 00 mov $0x4,%eax
3e7: cd 40 int $0x40
3e9: c3 ret
000003ea <read>:
SYSCALL(read)
3ea: b8 05 00 00 00 mov $0x5,%eax
3ef: cd 40 int $0x40
3f1: c3 ret
000003f2 <write>:
SYSCALL(write)
3f2: b8 10 00 00 00 mov $0x10,%eax
3f7: cd 40 int $0x40
3f9: c3 ret
000003fa <close>:
SYSCALL(close)
3fa: b8 15 00 00 00 mov $0x15,%eax
3ff: cd 40 int $0x40
401: c3 ret
00000402 <kill>:
SYSCALL(kill)
402: b8 06 00 00 00 mov $0x6,%eax
407: cd 40 int $0x40
409: c3 ret
0000040a <exec>:
SYSCALL(exec)
40a: b8 07 00 00 00 mov $0x7,%eax
40f: cd 40 int $0x40
411: c3 ret
00000412 <open>:
SYSCALL(open)
412: b8 0f 00 00 00 mov $0xf,%eax
417: cd 40 int $0x40
419: c3 ret
0000041a <mknod>:
SYSCALL(mknod)
41a: b8 11 00 00 00 mov $0x11,%eax
41f: cd 40 int $0x40
421: c3 ret
00000422 <unlink>:
SYSCALL(unlink)
422: b8 12 00 00 00 mov $0x12,%eax
427: cd 40 int $0x40
429: c3 ret
0000042a <fstat>:
SYSCALL(fstat)
42a: b8 08 00 00 00 mov $0x8,%eax
42f: cd 40 int $0x40
431: c3 ret
00000432 <link>:
SYSCALL(link)
432: b8 13 00 00 00 mov $0x13,%eax
437: cd 40 int $0x40
439: c3 ret
0000043a <mkdir>:
SYSCALL(mkdir)
43a: b8 14 00 00 00 mov $0x14,%eax
43f: cd 40 int $0x40
441: c3 ret
00000442 <chdir>:
SYSCALL(chdir)
442: b8 09 00 00 00 mov $0x9,%eax
447: cd 40 int $0x40
449: c3 ret
0000044a <dup>:
SYSCALL(dup)
44a: b8 0a 00 00 00 mov $0xa,%eax
44f: cd 40 int $0x40
451: c3 ret
00000452 <getpid>:
SYSCALL(getpid)
452: b8 0b 00 00 00 mov $0xb,%eax
457: cd 40 int $0x40
459: c3 ret
0000045a <sbrk>:
SYSCALL(sbrk)
45a: b8 0c 00 00 00 mov $0xc,%eax
45f: cd 40 int $0x40
461: c3 ret
00000462 <sleep>:
SYSCALL(sleep)
462: b8 0d 00 00 00 mov $0xd,%eax
467: cd 40 int $0x40
469: c3 ret
0000046a <uptime>:
SYSCALL(uptime)
46a: b8 0e 00 00 00 mov $0xe,%eax
46f: cd 40 int $0x40
471: c3 ret
00000472 <info>:
SYSCALL(info)
472: b8 16 00 00 00 mov $0x16,%eax
477: cd 40 int $0x40
479: c3 ret
0000047a <settickets>:
SYSCALL(settickets)
47a: b8 17 00 00 00 mov $0x17,%eax
47f: cd 40 int $0x40
481: c3 ret
00000482 <getusage>:
SYSCALL(getusage)
482: b8 18 00 00 00 mov $0x18,%eax
487: cd 40 int $0x40
489: c3 ret
48a: 66 90 xchg %ax,%ax
48c: 66 90 xchg %ax,%ax
48e: 66 90 xchg %ax,%ax
00000490 <printint>:
write(fd, &c, 1);
}
static void
printint(int fd, int xx, int base, int sgn)
{
490: 55 push %ebp
491: 89 e5 mov %esp,%ebp
493: 57 push %edi
494: 56 push %esi
495: 53 push %ebx
496: 83 ec 3c sub $0x3c,%esp
char buf[16];
int i, neg;
uint x;
neg = 0;
if(sgn && xx < 0){
499: 85 d2 test %edx,%edx
{
49b: 89 45 c0 mov %eax,-0x40(%ebp)
neg = 1;
x = -xx;
49e: 89 d0 mov %edx,%eax
if(sgn && xx < 0){
4a0: 79 76 jns 518 <printint+0x88>
4a2: f6 45 08 01 testb $0x1,0x8(%ebp)
4a6: 74 70 je 518 <printint+0x88>
x = -xx;
4a8: f7 d8 neg %eax
neg = 1;
4aa: c7 45 c4 01 00 00 00 movl $0x1,-0x3c(%ebp)
} else {
x = xx;
}
i = 0;
4b1: 31 f6 xor %esi,%esi
4b3: 8d 5d d7 lea -0x29(%ebp),%ebx
4b6: eb 0a jmp 4c2 <printint+0x32>
4b8: 90 nop
4b9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
do{
buf[i++] = digits[x % base];
4c0: 89 fe mov %edi,%esi
4c2: 31 d2 xor %edx,%edx
4c4: 8d 7e 01 lea 0x1(%esi),%edi
4c7: f7 f1 div %ecx
4c9: 0f b6 92 c8 08 00 00 movzbl 0x8c8(%edx),%edx
}while((x /= base) != 0);
4d0: 85 c0 test %eax,%eax
buf[i++] = digits[x % base];
4d2: 88 14 3b mov %dl,(%ebx,%edi,1)
}while((x /= base) != 0);
4d5: 75 e9 jne 4c0 <printint+0x30>
if(neg)
4d7: 8b 45 c4 mov -0x3c(%ebp),%eax
4da: 85 c0 test %eax,%eax
4dc: 74 08 je 4e6 <printint+0x56>
buf[i++] = '-';
4de: c6 44 3d d8 2d movb $0x2d,-0x28(%ebp,%edi,1)
4e3: 8d 7e 02 lea 0x2(%esi),%edi
4e6: 8d 74 3d d7 lea -0x29(%ebp,%edi,1),%esi
4ea: 8b 7d c0 mov -0x40(%ebp),%edi
4ed: 8d 76 00 lea 0x0(%esi),%esi
4f0: 0f b6 06 movzbl (%esi),%eax
write(fd, &c, 1);
4f3: 83 ec 04 sub $0x4,%esp
4f6: 83 ee 01 sub $0x1,%esi
4f9: 6a 01 push $0x1
4fb: 53 push %ebx
4fc: 57 push %edi
4fd: 88 45 d7 mov %al,-0x29(%ebp)
500: e8 ed fe ff ff call 3f2 <write>
while(--i >= 0)
505: 83 c4 10 add $0x10,%esp
508: 39 de cmp %ebx,%esi
50a: 75 e4 jne 4f0 <printint+0x60>
putc(fd, buf[i]);
}
50c: 8d 65 f4 lea -0xc(%ebp),%esp
50f: 5b pop %ebx
510: 5e pop %esi
511: 5f pop %edi
512: 5d pop %ebp
513: c3 ret
514: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
neg = 0;
518: c7 45 c4 00 00 00 00 movl $0x0,-0x3c(%ebp)
51f: eb 90 jmp 4b1 <printint+0x21>
521: eb 0d jmp 530 <printf>
523: 90 nop
524: 90 nop
525: 90 nop
526: 90 nop
527: 90 nop
528: 90 nop
529: 90 nop
52a: 90 nop
52b: 90 nop
52c: 90 nop
52d: 90 nop
52e: 90 nop
52f: 90 nop
00000530 <printf>:
// Print to the given fd. Only understands %d, %x, %p, %s.
void
printf(int fd, const char *fmt, ...)
{
530: 55 push %ebp
531: 89 e5 mov %esp,%ebp
533: 57 push %edi
534: 56 push %esi
535: 53 push %ebx
536: 83 ec 2c sub $0x2c,%esp
int c, i, state;
uint *ap;
state = 0;
ap = (uint*)(void*)&fmt + 1;
for(i = 0; fmt[i]; i++){
539: 8b 75 0c mov 0xc(%ebp),%esi
53c: 0f b6 1e movzbl (%esi),%ebx
53f: 84 db test %bl,%bl
541: 0f 84 b3 00 00 00 je 5fa <printf+0xca>
ap = (uint*)(void*)&fmt + 1;
547: 8d 45 10 lea 0x10(%ebp),%eax
54a: 83 c6 01 add $0x1,%esi
state = 0;
54d: 31 ff xor %edi,%edi
ap = (uint*)(void*)&fmt + 1;
54f: 89 45 d4 mov %eax,-0x2c(%ebp)
552: eb 2f jmp 583 <printf+0x53>
554: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
c = fmt[i] & 0xff;
if(state == 0){
if(c == '%'){
558: 83 f8 25 cmp $0x25,%eax
55b: 0f 84 a7 00 00 00 je 608 <printf+0xd8>
write(fd, &c, 1);
561: 8d 45 e2 lea -0x1e(%ebp),%eax
564: 83 ec 04 sub $0x4,%esp
567: 88 5d e2 mov %bl,-0x1e(%ebp)
56a: 6a 01 push $0x1
56c: 50 push %eax
56d: ff 75 08 pushl 0x8(%ebp)
570: e8 7d fe ff ff call 3f2 <write>
575: 83 c4 10 add $0x10,%esp
578: 83 c6 01 add $0x1,%esi
for(i = 0; fmt[i]; i++){
57b: 0f b6 5e ff movzbl -0x1(%esi),%ebx
57f: 84 db test %bl,%bl
581: 74 77 je 5fa <printf+0xca>
if(state == 0){
583: 85 ff test %edi,%edi
c = fmt[i] & 0xff;
585: 0f be cb movsbl %bl,%ecx
588: 0f b6 c3 movzbl %bl,%eax
if(state == 0){
58b: 74 cb je 558 <printf+0x28>
state = '%';
} else {
putc(fd, c);
}
} else if(state == '%'){
58d: 83 ff 25 cmp $0x25,%edi
590: 75 e6 jne 578 <printf+0x48>
if(c == 'd'){
592: 83 f8 64 cmp $0x64,%eax
595: 0f 84 05 01 00 00 je 6a0 <printf+0x170>
printint(fd, *ap, 10, 1);
ap++;
} else if(c == 'x' || c == 'p'){
59b: 81 e1 f7 00 00 00 and $0xf7,%ecx
5a1: 83 f9 70 cmp $0x70,%ecx
5a4: 74 72 je 618 <printf+0xe8>
printint(fd, *ap, 16, 0);
ap++;
} else if(c == 's'){
5a6: 83 f8 73 cmp $0x73,%eax
5a9: 0f 84 99 00 00 00 je 648 <printf+0x118>
s = "(null)";
while(*s != 0){
putc(fd, *s);
s++;
}
} else if(c == 'c'){
5af: 83 f8 63 cmp $0x63,%eax
5b2: 0f 84 08 01 00 00 je 6c0 <printf+0x190>
putc(fd, *ap);
ap++;
} else if(c == '%'){
5b8: 83 f8 25 cmp $0x25,%eax
5bb: 0f 84 ef 00 00 00 je 6b0 <printf+0x180>
write(fd, &c, 1);
5c1: 8d 45 e7 lea -0x19(%ebp),%eax
5c4: 83 ec 04 sub $0x4,%esp
5c7: c6 45 e7 25 movb $0x25,-0x19(%ebp)
5cb: 6a 01 push $0x1
5cd: 50 push %eax
5ce: ff 75 08 pushl 0x8(%ebp)
5d1: e8 1c fe ff ff call 3f2 <write>
5d6: 83 c4 0c add $0xc,%esp
5d9: 8d 45 e6 lea -0x1a(%ebp),%eax
5dc: 88 5d e6 mov %bl,-0x1a(%ebp)
5df: 6a 01 push $0x1
5e1: 50 push %eax
5e2: ff 75 08 pushl 0x8(%ebp)
5e5: 83 c6 01 add $0x1,%esi
} else {
// Unknown % sequence. Print it to draw attention.
putc(fd, '%');
putc(fd, c);
}
state = 0;
5e8: 31 ff xor %edi,%edi
write(fd, &c, 1);
5ea: e8 03 fe ff ff call 3f2 <write>
for(i = 0; fmt[i]; i++){
5ef: 0f b6 5e ff movzbl -0x1(%esi),%ebx
write(fd, &c, 1);
5f3: 83 c4 10 add $0x10,%esp
for(i = 0; fmt[i]; i++){
5f6: 84 db test %bl,%bl
5f8: 75 89 jne 583 <printf+0x53>
}
}
}
5fa: 8d 65 f4 lea -0xc(%ebp),%esp
5fd: 5b pop %ebx
5fe: 5e pop %esi
5ff: 5f pop %edi
600: 5d pop %ebp
601: c3 ret
602: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
state = '%';
608: bf 25 00 00 00 mov $0x25,%edi
60d: e9 66 ff ff ff jmp 578 <printf+0x48>
612: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
printint(fd, *ap, 16, 0);
618: 83 ec 0c sub $0xc,%esp
61b: b9 10 00 00 00 mov $0x10,%ecx
620: 6a 00 push $0x0
622: 8b 7d d4 mov -0x2c(%ebp),%edi
625: 8b 45 08 mov 0x8(%ebp),%eax
628: 8b 17 mov (%edi),%edx
62a: e8 61 fe ff ff call 490 <printint>
ap++;
62f: 89 f8 mov %edi,%eax
631: 83 c4 10 add $0x10,%esp
state = 0;
634: 31 ff xor %edi,%edi
ap++;
636: 83 c0 04 add $0x4,%eax
639: 89 45 d4 mov %eax,-0x2c(%ebp)
63c: e9 37 ff ff ff jmp 578 <printf+0x48>
641: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
s = (char*)*ap;
648: 8b 45 d4 mov -0x2c(%ebp),%eax
64b: 8b 08 mov (%eax),%ecx
ap++;
64d: 83 c0 04 add $0x4,%eax
650: 89 45 d4 mov %eax,-0x2c(%ebp)
if(s == 0)
653: 85 c9 test %ecx,%ecx
655: 0f 84 8e 00 00 00 je 6e9 <printf+0x1b9>
while(*s != 0){
65b: 0f b6 01 movzbl (%ecx),%eax
state = 0;
65e: 31 ff xor %edi,%edi
s = (char*)*ap;
660: 89 cb mov %ecx,%ebx
while(*s != 0){
662: 84 c0 test %al,%al
664: 0f 84 0e ff ff ff je 578 <printf+0x48>
66a: 89 75 d0 mov %esi,-0x30(%ebp)
66d: 89 de mov %ebx,%esi
66f: 8b 5d 08 mov 0x8(%ebp),%ebx
672: 8d 7d e3 lea -0x1d(%ebp),%edi
675: 8d 76 00 lea 0x0(%esi),%esi
write(fd, &c, 1);
678: 83 ec 04 sub $0x4,%esp
s++;
67b: 83 c6 01 add $0x1,%esi
67e: 88 45 e3 mov %al,-0x1d(%ebp)
write(fd, &c, 1);
681: 6a 01 push $0x1
683: 57 push %edi
684: 53 push %ebx
685: e8 68 fd ff ff call 3f2 <write>
while(*s != 0){
68a: 0f b6 06 movzbl (%esi),%eax
68d: 83 c4 10 add $0x10,%esp
690: 84 c0 test %al,%al
692: 75 e4 jne 678 <printf+0x148>
694: 8b 75 d0 mov -0x30(%ebp),%esi
state = 0;
697: 31 ff xor %edi,%edi
699: e9 da fe ff ff jmp 578 <printf+0x48>
69e: 66 90 xchg %ax,%ax
printint(fd, *ap, 10, 1);
6a0: 83 ec 0c sub $0xc,%esp
6a3: b9 0a 00 00 00 mov $0xa,%ecx
6a8: 6a 01 push $0x1
6aa: e9 73 ff ff ff jmp 622 <printf+0xf2>
6af: 90 nop
write(fd, &c, 1);
6b0: 83 ec 04 sub $0x4,%esp
6b3: 88 5d e5 mov %bl,-0x1b(%ebp)
6b6: 8d 45 e5 lea -0x1b(%ebp),%eax
6b9: 6a 01 push $0x1
6bb: e9 21 ff ff ff jmp 5e1 <printf+0xb1>
putc(fd, *ap);
6c0: 8b 7d d4 mov -0x2c(%ebp),%edi
write(fd, &c, 1);
6c3: 83 ec 04 sub $0x4,%esp
putc(fd, *ap);
6c6: 8b 07 mov (%edi),%eax
write(fd, &c, 1);
6c8: 6a 01 push $0x1
ap++;
6ca: 83 c7 04 add $0x4,%edi
putc(fd, *ap);
6cd: 88 45 e4 mov %al,-0x1c(%ebp)
write(fd, &c, 1);
6d0: 8d 45 e4 lea -0x1c(%ebp),%eax
6d3: 50 push %eax
6d4: ff 75 08 pushl 0x8(%ebp)
6d7: e8 16 fd ff ff call 3f2 <write>
ap++;
6dc: 89 7d d4 mov %edi,-0x2c(%ebp)
6df: 83 c4 10 add $0x10,%esp
state = 0;
6e2: 31 ff xor %edi,%edi
6e4: e9 8f fe ff ff jmp 578 <printf+0x48>
s = "(null)";
6e9: bb bf 08 00 00 mov $0x8bf,%ebx
while(*s != 0){
6ee: b8 28 00 00 00 mov $0x28,%eax
6f3: e9 72 ff ff ff jmp 66a <printf+0x13a>
6f8: 66 90 xchg %ax,%ax
6fa: 66 90 xchg %ax,%ax
6fc: 66 90 xchg %ax,%ax
6fe: 66 90 xchg %ax,%ax
00000700 <free>:
static Header base;
static Header *freep;
void
free(void *ap)
{
700: 55 push %ebp
Header *bp, *p;
bp = (Header*)ap - 1;
for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
701: a1 c0 0b 00 00 mov 0xbc0,%eax
{
706: 89 e5 mov %esp,%ebp
708: 57 push %edi
709: 56 push %esi
70a: 53 push %ebx
70b: 8b 5d 08 mov 0x8(%ebp),%ebx
bp = (Header*)ap - 1;
70e: 8d 4b f8 lea -0x8(%ebx),%ecx
711: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
718: 39 c8 cmp %ecx,%eax
71a: 8b 10 mov (%eax),%edx
71c: 73 32 jae 750 <free+0x50>
71e: 39 d1 cmp %edx,%ecx
720: 72 04 jb 726 <free+0x26>
if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
722: 39 d0 cmp %edx,%eax
724: 72 32 jb 758 <free+0x58>
break;
if(bp + bp->s.size == p->s.ptr){
726: 8b 73 fc mov -0x4(%ebx),%esi
729: 8d 3c f1 lea (%ecx,%esi,8),%edi
72c: 39 fa cmp %edi,%edx
72e: 74 30 je 760 <free+0x60>
bp->s.size += p->s.ptr->s.size;
bp->s.ptr = p->s.ptr->s.ptr;
} else
bp->s.ptr = p->s.ptr;
730: 89 53 f8 mov %edx,-0x8(%ebx)
if(p + p->s.size == bp){
733: 8b 50 04 mov 0x4(%eax),%edx
736: 8d 34 d0 lea (%eax,%edx,8),%esi
739: 39 f1 cmp %esi,%ecx
73b: 74 3a je 777 <free+0x77>
p->s.size += bp->s.size;
p->s.ptr = bp->s.ptr;
} else
p->s.ptr = bp;
73d: 89 08 mov %ecx,(%eax)
freep = p;
73f: a3 c0 0b 00 00 mov %eax,0xbc0
}
744: 5b pop %ebx
745: 5e pop %esi
746: 5f pop %edi
747: 5d pop %ebp
748: c3 ret
749: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
750: 39 d0 cmp %edx,%eax
752: 72 04 jb 758 <free+0x58>
754: 39 d1 cmp %edx,%ecx
756: 72 ce jb 726 <free+0x26>
{
758: 89 d0 mov %edx,%eax
75a: eb bc jmp 718 <free+0x18>
75c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
bp->s.size += p->s.ptr->s.size;
760: 03 72 04 add 0x4(%edx),%esi
763: 89 73 fc mov %esi,-0x4(%ebx)
bp->s.ptr = p->s.ptr->s.ptr;
766: 8b 10 mov (%eax),%edx
768: 8b 12 mov (%edx),%edx
76a: 89 53 f8 mov %edx,-0x8(%ebx)
if(p + p->s.size == bp){
76d: 8b 50 04 mov 0x4(%eax),%edx
770: 8d 34 d0 lea (%eax,%edx,8),%esi
773: 39 f1 cmp %esi,%ecx
775: 75 c6 jne 73d <free+0x3d>
p->s.size += bp->s.size;
777: 03 53 fc add -0x4(%ebx),%edx
freep = p;
77a: a3 c0 0b 00 00 mov %eax,0xbc0
p->s.size += bp->s.size;
77f: 89 50 04 mov %edx,0x4(%eax)
p->s.ptr = bp->s.ptr;
782: 8b 53 f8 mov -0x8(%ebx),%edx
785: 89 10 mov %edx,(%eax)
}
787: 5b pop %ebx
788: 5e pop %esi
789: 5f pop %edi
78a: 5d pop %ebp
78b: c3 ret
78c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
00000790 <malloc>:
return freep;
}
void*
malloc(uint nbytes)
{
790: 55 push %ebp
791: 89 e5 mov %esp,%ebp
793: 57 push %edi
794: 56 push %esi
795: 53 push %ebx
796: 83 ec 0c sub $0xc,%esp
Header *p, *prevp;
uint nunits;
nunits = (nbytes + sizeof(Header) - 1)/sizeof(Header) + 1;
799: 8b 45 08 mov 0x8(%ebp),%eax
if((prevp = freep) == 0){
79c: 8b 15 c0 0b 00 00 mov 0xbc0,%edx
nunits = (nbytes + sizeof(Header) - 1)/sizeof(Header) + 1;
7a2: 8d 78 07 lea 0x7(%eax),%edi
7a5: c1 ef 03 shr $0x3,%edi
7a8: 83 c7 01 add $0x1,%edi
if((prevp = freep) == 0){
7ab: 85 d2 test %edx,%edx
7ad: 0f 84 9d 00 00 00 je 850 <malloc+0xc0>
7b3: 8b 02 mov (%edx),%eax
7b5: 8b 48 04 mov 0x4(%eax),%ecx
base.s.ptr = freep = prevp = &base;
base.s.size = 0;
}
for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
if(p->s.size >= nunits){
7b8: 39 cf cmp %ecx,%edi
7ba: 76 6c jbe 828 <malloc+0x98>
7bc: 81 ff 00 10 00 00 cmp $0x1000,%edi
7c2: bb 00 10 00 00 mov $0x1000,%ebx
7c7: 0f 43 df cmovae %edi,%ebx
p = sbrk(nu * sizeof(Header));
7ca: 8d 34 dd 00 00 00 00 lea 0x0(,%ebx,8),%esi
7d1: eb 0e jmp 7e1 <malloc+0x51>
7d3: 90 nop
7d4: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
7d8: 8b 02 mov (%edx),%eax
if(p->s.size >= nunits){
7da: 8b 48 04 mov 0x4(%eax),%ecx
7dd: 39 f9 cmp %edi,%ecx
7df: 73 47 jae 828 <malloc+0x98>
p->s.size = nunits;
}
freep = prevp;
return (void*)(p + 1);
}
if(p == freep)
7e1: 39 05 c0 0b 00 00 cmp %eax,0xbc0
7e7: 89 c2 mov %eax,%edx
7e9: 75 ed jne 7d8 <malloc+0x48>
p = sbrk(nu * sizeof(Header));
7eb: 83 ec 0c sub $0xc,%esp
7ee: 56 push %esi
7ef: e8 66 fc ff ff call 45a <sbrk>
if(p == (char*)-1)
7f4: 83 c4 10 add $0x10,%esp
7f7: 83 f8 ff cmp $0xffffffff,%eax
7fa: 74 1c je 818 <malloc+0x88>
hp->s.size = nu;
7fc: 89 58 04 mov %ebx,0x4(%eax)
free((void*)(hp + 1));
7ff: 83 ec 0c sub $0xc,%esp
802: 83 c0 08 add $0x8,%eax
805: 50 push %eax
806: e8 f5 fe ff ff call 700 <free>
return freep;
80b: 8b 15 c0 0b 00 00 mov 0xbc0,%edx
if((p = morecore(nunits)) == 0)
811: 83 c4 10 add $0x10,%esp
814: 85 d2 test %edx,%edx
816: 75 c0 jne 7d8 <malloc+0x48>
return 0;
}
}
818: 8d 65 f4 lea -0xc(%ebp),%esp
return 0;
81b: 31 c0 xor %eax,%eax
}
81d: 5b pop %ebx
81e: 5e pop %esi
81f: 5f pop %edi
820: 5d pop %ebp
821: c3 ret
822: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
if(p->s.size == nunits)
828: 39 cf cmp %ecx,%edi
82a: 74 54 je 880 <malloc+0xf0>
p->s.size -= nunits;
82c: 29 f9 sub %edi,%ecx
82e: 89 48 04 mov %ecx,0x4(%eax)
p += p->s.size;
831: 8d 04 c8 lea (%eax,%ecx,8),%eax
p->s.size = nunits;
834: 89 78 04 mov %edi,0x4(%eax)
freep = prevp;
837: 89 15 c0 0b 00 00 mov %edx,0xbc0
}
83d: 8d 65 f4 lea -0xc(%ebp),%esp
return (void*)(p + 1);
840: 83 c0 08 add $0x8,%eax
}
843: 5b pop %ebx
844: 5e pop %esi
845: 5f pop %edi
846: 5d pop %ebp
847: c3 ret
848: 90 nop
849: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
base.s.ptr = freep = prevp = &base;
850: c7 05 c0 0b 00 00 c4 movl $0xbc4,0xbc0
857: 0b 00 00
85a: c7 05 c4 0b 00 00 c4 movl $0xbc4,0xbc4
861: 0b 00 00
base.s.size = 0;
864: b8 c4 0b 00 00 mov $0xbc4,%eax
869: c7 05 c8 0b 00 00 00 movl $0x0,0xbc8
870: 00 00 00
873: e9 44 ff ff ff jmp 7bc <malloc+0x2c>
878: 90 nop
879: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
prevp->s.ptr = p->s.ptr;
880: 8b 08 mov (%eax),%ecx
882: 89 0a mov %ecx,(%edx)
884: eb b1 jmp 837 <malloc+0xa7>
|
; A019510: a(n) = gcd( binomial(n+3, n) + binomial(n+4, n+1), binomial(n+5, n+2) ).
; 2,5,1,7,20,3,5,11,2,65,7,5,8,17,15,19,10,7,11,115,4,25,13,9,70,29,5,31,16,55,17,35,6,37,95,13,20,41,7,215,22,15,23,47,40,49,25,17,26,265,9,55,28,19,145,59,10,61,31,105,32,65,11,67,170,23,35,71,12,365,37,25,38,77,65,79,40,27,41,415,14,85,43,29,220,89,15,91,46,155,47,95,16,97,245,33,50,101,17,515,52,35,53,107,90,109,55,37,56,565,19,115,58,39,295,119,20,121,61,205,62,125,21,127,320,43,65,131,22,665,67,45,68,137,115,139,70,47,71,715,24,145,73,49,370,149,25,151,76,255,77,155,26,157,395,53,80,161,27,815,82,55,83,167,140,169,85,57,86,865,29,175,88,59,445,179,30,181,91,305,92,185,31,187,470,63,95,191,32,965,97,65,98,197,165,199,100,67,101,1015,34,205,103,69,520,209,35,211,106,355,107,215,36,217,545,73,110,221,37,1115,112,75,113,227,190,229,115,77,116,1165,39,235,118,79,595,239,40,241,121,405,122,245,41,247,620,83,125,251,42,1265
add $0,3
mov $6,$0
bin $6,3
sub $6,$0
sub $6,$0
lpb $0
mul $6,3
lpb $0
add $$1,1
mul $0,$6
mul $0,100
sub $6,3
gcd $6,$0
mod $0,3
lpe
lpe
mov $1,$6
div $1,3
|
;------------------------------------------------------------------------------
;
; Copyright (c) 2016 - 2017, Intel Corporation. All rights reserved.<BR>
; SPDX-License-Identifier: BSD-2-Clause-Patent
;
;
; Module Name:
;
; SecEntry.nasm
;
; Abstract:
;
; This is the code that goes from real-mode to protected mode.
; It consumes the reset vector.
;
;------------------------------------------------------------------------------
SECTION .text
extern ASM_PFX(SecStartup)
extern ASM_PFX(PcdGet32(PcdStage1StackSize))
extern ASM_PFX(PcdGet32(PcdStage1DataSize))
extern ASM_PFX(PcdGet32(PcdStage1StackBaseOffset))
extern ASM_PFX(EarlyBoardInit)
extern ASM_PFX(FspTempRamInit)
global ASM_PFX(_ModuleEntryPoint)
ASM_PFX(_ModuleEntryPoint):
movd mm0, eax
;
; Read time stamp
;
rdtsc
mov esi, eax
mov edi, edx
;
; Early board hooks
;
mov esp, EarlyBoardInitRet
jmp ASM_PFX(EarlyBoardInit)
EarlyBoardInitRet:
mov esp, FspTempRamInitRet
jmp ASM_PFX(FspTempRamInit)
FspTempRamInitRet:
cmp eax, 8000000Eh ;Check if EFI_NOT_FOUND returned. Error code for Microcode Update not found.
je FspApiSuccess ;If microcode not found, don't hang, but continue.
cmp eax, 0 ;Check if EFI_SUCCESS returned.
jz FspApiSuccess
; FSP API failed:
jmp $
FspApiSuccess:
;
; Setup stack
; ECX: Bootloader stack base
; EDX: Bootloader stack top
;
mov esp, ecx
add esp, dword [ASM_PFX(PcdGet32(PcdStage1StackBaseOffset))]
add esp, dword [ASM_PFX(PcdGet32(PcdStage1StackSize))]
xor ebx, ebx ; Use EBX for Status
;
; Check stage1 stack base offset
;
mov eax, esp
add eax, dword [ASM_PFX(PcdGet32(PcdStage1DataSize))]
cmp eax, edx
jle CheckStackRangeDone
;
; Error in stack range
;
bts ebx, 1 ; Set BIT1 in Status
sub esp, dword [ASM_PFX(PcdGet32(PcdStage1StackBaseOffset))]
CheckStackRangeDone:
;
; CpuBist error check
;
movd eax, mm0
emms ; Exit MMX Instruction
cmp eax, 0
jz CheckStatusDone
;
; Error in CpuBist
;
bts ebx, 0 ; Set BIT0 in Status
CheckStatusDone:
;
; Setup HOB
; This structure has to match the layout of STAGE1A_ASM_PARAM
;
push $0 ; Status[63:32]
push ebx ; Status[31:0]
push edi ; TimeStamp[0] [63:32]
push esi ; TimeStamp[0] [31:0]
push edx ; CarTop
push ecx ; CarBase
push $0 ; Keep the stack 16-byte aligned
lea ecx, [esp + 4]
push ecx
call ASM_PFX(SecStartup) ; Jump to C code
jmp $
|
;THE COMPUTER CODE CONTAINED HEREIN IS THE SOLE PROPERTY OF PARALLAX
;SOFTWARE CORPORATION ("PARALLAX"). PARALLAX, IN DISTRIBUTING THE CODE TO
;END-USERS, AND SUBJECT TO ALL OF THE TERMS AND CONDITIONS HEREIN, GRANTS A
;ROYALTY-FREE, PERPETUAL LICENSE TO SUCH END-USERS FOR USE BY SUCH END-USERS
;IN USING, DISPLAYING, AND CREATING DERIVATIVE WORKS THEREOF, SO LONG AS
;SUCH USE, DISPLAY OR CREATION IS FOR NON-COMMERCIAL, ROYALTY OR REVENUE
;FREE PURPOSES. IN NO EVENT SHALL THE END-USER USE THE COMPUTER CODE
;CONTAINED HEREIN FOR REVENUE-BEARING PURPOSES. THE END-USER UNDERSTANDS
;AND AGREES TO THE TERMS HEREIN AND ACCEPTS THE SAME BY USE OF THIS FILE.
;COPYRIGHT 1993-1998 PARALLAX SOFTWARE CORPORATION. ALL RIGHTS RESERVED.
;
; $Source: f:/miner/source/texmap/rcs/tmap_16.asm $
; $Revision: 1.4 $
; $Author: mike $
; $Date: 1994/11/30 00:56:32 $
;
; 16 bits per pixel texture mapper
;
; $Log: tmap_16.asm $
; Revision 1.4 1994/11/30 00:56:32 mike
; optimization.
;
; Revision 1.3 1994/11/12 16:39:16 mike
; jae to ja.
;
; Revision 1.2 1993/11/22 10:23:49 mike
; *** empty log message ***
;
; Revision 1.1 1993/09/08 17:29:17 mike
; Initial revision
;
;
;
.386
public asm_tmap_scanline_lin_16_
include tmap_inc.asm
_DATA SEGMENT DWORD PUBLIC USE32 'DATA'
extrn _fx_u:dword
extrn _fx_v:dword
extrn _fx_du_dx:dword
extrn _fx_dv_dx:dword
extrn _fx_y:dword
extrn _fx_xleft:dword
extrn _fx_xright:dword
extrn _pixptr:dword
extrn _x:dword
extrn _loop_count:dword
_DATA ENDS
DGROUP GROUP _DATA
_TEXT SEGMENT PARA PUBLIC USE32 'CODE'
ASSUME DS:_DATA
ASSUME CS:_TEXT
; --------------------------------------------------------------------------------------------------
; Enter:
; _xleft fixed point left x coordinate
; _xright fixed point right x coordinate
; _y fixed point y coordinate
; _pixptr address of source pixel map
; _u fixed point initial u coordinate
; _v fixed point initial v coordinate
; _du_dx fixed point du/dx
; _dv_dx fixed point dv/dx
; for (x = (int) xleft; x <= (int) xright; x++) {
; _setcolor(read_pixel_from_tmap(srcb,((int) (u/z)) & 63,((int) (v/z)) & 63));
; _setpixel(x,y);
;
; u += du_dx;
; v += dv_dx;
; z += dz_dx;
; }
align 4
asm_tmap_scanline_lin_16_:
pusha
; Setup for loop: _loop_count iterations = (int) xright - (int) xleft
; esi source pixel pointer = pixptr
; edi initial row pointer = y*320+x
; set esi = pointer to start of texture map data
mov esi,_pixptr
; set edi = address of first pixel to modify
mov edi,_fx_y
cmp edi,_window_bottom
ja _none_to_do
sub edi,_window_top
imul edi,_bytes_per_row
mov eax,_fx_xleft
sar eax,16
jns eax_ok
sub eax,eax
eax_ok:
sub eax,_window_left
add edi,eax
add edi,eax ; add again because it's 2 bytes/pixel
add edi,write_buffer
; set _loop_count = # of iterations
mov eax,_fx_xright
sar eax,16
cmp eax,_window_right
jb eax_ok1
mov eax,_window_right
eax_ok1: cmp eax,_window_left
ja eax_ok2
mov eax,_window_left
eax_ok2:
mov ebx,_fx_xleft
sar ebx,16
sub eax,ebx
js _none_to_do
cmp eax,_window_width
jbe _ok_to_do
mov eax,_window_width
_ok_to_do:
mov _loop_count,eax
; edi destination pixel pointer
mov ebx,_fx_u
mov ecx,_fx_du_dx
mov edx,_fx_dv_dx
mov ebp,_fx_v
shl ebx,10
shl ebp,10
shl edx,10
shl ecx,10
; eax work
; ebx u
; ecx du_dx
; edx dv_dx
; ebp v
; esi read address
; edi write address
_size = (_end1 - _start1)/num_iters
mov eax,num_iters-1
sub eax,_loop_count
imul eax,eax,dword ptr _size
add eax,offset _start1
jmp eax
align 4
_start1:
; "OPTIMIZATIONS" maybe not worth making
; Getting rid of the esi from the mov al,[esi+eax] instruction.
; This would require moving into eax at the top of the loop, rather than doing the sub eax,eax.
; You would have to align your bitmaps so that the two shlds would create the proper base address.
; In other words, your bitmap data would have to begin at 4096x (for 64x64 bitmaps).
; I did timings without converting the sub to a mov eax,esi and setting esi to the proper value.
; There was a speedup of about 1% to 1.5% without converting the sub to a mov.
; Getting rid of the edi by doing a mov nnnn[edi],al instead of mov [edi],al.
; The problem with this is you would have a dword offset for nnnn. My timings indicate it is slower. (I think.)
; Combining u,v and du,dv into single longwords.
; The problem with this is you then must do a 16 bit operation to extract them, and you don't have enough
; instructions to separate a destination operand from being used by the next instruction. It shaves out one
; register instruction (an add reg,reg), but adds a 16 bit operation, and the setup is more complicated.
; usage:
; eax work
; ebx u coordinate
; ecx delta u
; edx delta v
; ebp v coordinate
; esi pointer to source bitmap
; edi write address
rept num_iters
mov eax,ebp ; clear for
add ebp,edx ; update v coordinate
shr eax,26 ; shift in v coordinate
shld eax,ebx,6 ; shift in u coordinate while shifting up v coordinate
add ebx,ecx ; update u coordinate
mov ax,[esi+2*eax] ; get pixel from source bitmap
mov [edi],ax
add edi,2
; inner loop if bitmaps are 256x256
; your register usage is bogus, and you must clear ecx
; fix your setup
; this is only about 10% faster in the inner loop
; this method would adapt to writing two pixels at a time better than
; the 64x64 method because you wouldn't run out of registers
; Note that this method assumes that both dv_dx and du_dx are in edx.
; edx = vi|vf|ui|uf
; where each field is 8 bits, vi = integer v coordinate, vf = fractional v coordinate, etc.
;** add ebx,edx
;** mov cl,bh
;** shld cx,bx,8
;** mov al,[esi+ecx]
;** mov [edi],al
;** inc edi
endm
_end1:
_none_to_do: popa
ret
_TEXT ends
end
; This is the inner loop to write two pixels at a time
; This is about 2.5% faster overall (on Mike's 66 MHz 80486 DX2, VLB)
; You must write code to even align edi and do half as many iterations, and write
; the beginning and ending extra pixels, if necessary.
; sub eax,eax ; clear for
; shld eax,ebp,6 ; shift in v coordinate
; add ebp,_fx_dv_dx ; update v coordinate
; shld eax,ebx,6 ; shift in u coordinate while shifting up v coordinate
; add ebx,ecx ; update u coordinate
; mov dl,[esi+eax] ; get pixel from source bitmap
;
; sub eax,eax ; clear for
; shld eax,ebp,6 ; shift in v coordinate
; add ebp,_fx_dv_dx ; update v coordinate
; shld eax,ebx,6 ; shift in u coordinate while shifting up v coordinate
; add ebx,ecx ; update u coordinate
; mov dh,[esi+eax] ; get pixel from source bitmap
;
; mov [edi],dx
; add edi,2
|
COMMENT @----------------------------------------------------------------------
Copyright (c) GeoWorks 1988 -- All Rights Reserved
PROJECT: PC GEOS
MODULE: UserInterface/Gen
FILE: genUIDocumentControl.asm
ROUTINES:
Name Description
---- -----------
GLB GenDocumentControlClass Document management
REVISION HISTORY:
Name Date Description
---- ---- -----------
Tony 1/90 Initial version
DESCRIPTION:
This file contains routines to implement the GenDocumentControl class.
$Id: genUIDocumentControl.asm,v 1.1 97/04/07 11:45:03 newdeal Exp $
------------------------------------------------------------------------------@
COMMENT @CLASS DESCRIPTION-----------------------------------------------------
GenDocumentControlClass:
Synopsis
--------
GenDocumentControlClass is the part of document control that runs in the
application thread. It manages GenDocument's and works with a
GenDocumentControl to give the user controls to manipulate the documents
(usually new, open, close, save, save as).
See the file "documentControl" for full documentation.
------------------------------------------------------------------------------@
UserClassStructures segment resource
GenDocumentControlClass
UserClassStructures ends
Build segment resource
COMMENT @----------------------------------------------------------------------
METHOD: GenDocumentControlBuild -- MSG_META_RESOLVE_VARIANT_SUPERCLASS for
GenDocumentControlClass
DESCRIPTION: Return the correct specific class for an object
PASS:
*ds:si - instance data (for object in a GenXXXX class)
es - segment of GenDocumentControlClass
ax - MSG_META_RESOLVE_VARIANT_SUPERCLASS
cx - master offset of variant class to build
RETURN: cx:dx - class for specific UI part of object (cx = 0 for no build)
ALLOWED TO DESTROY:
ax, bp
bx, si, di, ds, es
REGISTER/STACK USAGE:
PSEUDO CODE/STRATEGY:
KNOWN BUGS/SIDE EFFECTS/CAVEATS/IDEAS:
REVISION HISTORY:
Name Date Description
---- ---- -----------
Doug 2/89 Initial version
------------------------------------------------------------------------------@
GenDocumentControlBuild method GenDocumentControlClass, MSG_META_RESOLVE_VARIANT_SUPERCLASS
mov ax, SPIR_BUILD_UI_DOCUMENT_CONTROL
GOTO GenQueryUICallSpecificUI
GenDocumentControlBuild endm
COMMENT @%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
GenDocumentControlInitializeVarData
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
SYNOPSIS: Handle the initialization of ATTR_GEN_PATH_DATA, if such
this be.
CALLED BY: MSG_META_INITIALIZE_VAR_DATA
PASS: *ds:si = generic object
cx = variable data type
RETURN: ax = offset to extra data created
DESTROYED: cx, dx, bp
PSEUDO CODE/STRATEGY:
KNOWN BUGS/SIDE EFFECTS/IDEAS:
REVISION HISTORY:
Name Date Description
---- ---- -----------
ardeb 1/ 8/92 Initial version
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%@
GenDocumentControlInitializeVarData method dynamic GenDocumentControlClass,
MSG_META_INITIALIZE_VAR_DATA
cmp cx, ATTR_GEN_PATH_DATA
je initGenDocumentControlPathData
mov di, offset GenDocumentControlClass
GOTO ObjCallSuperNoLock
initGenDocumentControlPathData:
;
; Add the data to the object.
;
mov ax, ATTR_GEN_PATH_DATA or mask VDF_SAVE_TO_STATE
mov cx, size GenFilePath
call ObjVarAddData
;
; Initialize it to SP_DOCUMENT (SP_TOP for redwood)
;
if UNTITLED_DOCS_ON_SP_TOP
mov ds:[bx].GFP_disk, SP_TOP
else
mov ds:[bx].GFP_disk, SP_DOCUMENT
endif
mov ds:[bx].GFP_path[0], 0
;
; Return offset in ax
;
mov_tr ax, bx
ret
GenDocumentControlInitializeVarData endm
COMMENT @%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
GenDocumentControlRelocOrUnReloc
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
SYNOPSIS: Deal with the path bound to this object
CALLED BY: MSG_META_RELOCATE, MSG_META_UNRELOCATE
PASS: *ds:si = object
ax - MSG_META_RELOCATE/MSG_META_UNRELOCATE
cx - handle of block containing relocation
dx - VMRelocType:
VMRT_UNRELOCATE_BEFORE_WRITE
VMRT_RELOCATE_AFTER_READ
VMRT_RELOCATE_AFTER_WRITE
bp - data to pass to ObjRelocOrUnRelocSuper
RETURN:
carry - set if error
bp - unchanged
DESTROYED: ax, dx
PSEUDO CODE/STRATEGY:
KNOWN BUGS/SIDE EFFECTS/IDEAS:
REVISION HISTORY:
Name Date Description
---- ---- -----------
ardeb 1/10/92 Initial version
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%@
GenDocumentControlRelocOrUnReloc method GenDocumentControlClass, reloc
.enter
cmp ax, MSG_META_UNRELOCATE
jne done
mov ax, ATTR_GEN_PATH_DATA
mov dx, TEMP_GEN_PATH_SAVED_DISK_HANDLE
call GenPathUnrelocObjectPath
done:
clc
.leave
mov di, offset GenDocumentControlClass
call ObjRelocOrUnRelocSuper
ret
GenDocumentControlRelocOrUnReloc endm
Build ends
|
COMMENT @%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
PROJECT: PC GEOS
MODULE: Mouse Drivers - IntelliMouse-style PS/2 3-button wheel mice
FILE: imps2.asm
DESCRIPTION:
Device-dependent support for IntelliMouse PS2 mouse port. The PS2 BIOS
defines a protocol that all mice connected to the port employ. Rather
than interpreting it ourselves, we trust the BIOS to be efficient
and just register a routine with it. Keeps the driver smaller and
avoids problems with incompatibility etc.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%@
;
; The following constants are used in mouseCommon.asm -- see that
; file for documentation.
;
MOUSE_HAS_WHEEL = 1 ; define/uncomment this if GEOS
; has native wheel support in the kernel/ui,
; disable ...HAS_WHEEL_KEYS
;MOUSE_HAS_WHEEL_KEYS = 1 ; define/uncomment this for a version of the driver
; that has the wheel simulate keypresses,
; disable ...HAS_WHEEL
MOUSE_NUM_BUTTONS = 3 ; Wheel mice have at least 3 buttons
MIDDLE_IS_DOUBLE_PRESS = 1 ; fake double-press with middle button
MOUSE_SEPARATE_INIT = 1 ; We use a separate Init resource
include ../mouseCommon.asm ; Include common definitions/code.
include Internal/interrup.def
include Internal/dos.def ; for equipment configuration...
include system.def
;------------------------------------------------------------------------------
; DEVICE STRINGS
;------------------------------------------------------------------------------
MouseExtendedInfoSeg segment lmem LMEM_TYPE_GENERAL
mouseExtendedInfo DriverExtendedInfoTable <
{}, ; lmem header added by Esp
length mouseNameTable, ; Number of supported devices
offset mouseNameTable,
offset mouseInfoTable
>
ifdef MOUSE_HAS_WHEEL
mouseNameTable lptr.char imps2NativeMouse
lptr.char 0 ; null-terminator
imps2NativeMouse chunk.char 'Intellimouse-compatible PS/2 Wheel Mouse', 0
mouseInfoTable MouseExtendedInfo \
0 ; nativeMouse
endif
ifdef MOUSE_HAS_WHEEL_KEYS
mouseNameTable lptr.char imps2PageMouse,
imps2CursorMouse
lptr.char 0 ; null-terminator
imps2PageMouse chunk.char 'IM PS/2 Wheel Mouse (Wheel: Page Up/Down)', 0
imps2CursorMouse chunk.char 'IM PS/2 Wheel Mouse (Wheel: Cursor Up/Down)', 0
mouseInfoTable MouseExtendedInfo \
0, ; pageMouse
0 ; cursorMouse
endif
MouseExtendedInfoSeg ends
ForceRef mouseExtendedInfo
;------------------------------------------------------------------------------
; VARIABLES/DATA/CONSTANTS
;------------------------------------------------------------------------------
idata segment
;
; All the mouse BIOS calls are through interrupt 15h, function c2h.
; All functions return CF set on error, ah = MouseStatus
;
MOUSE_ENABLE_DISABLE equ 0c200h ; Enable or disable the mouse. BH = 0 to disable, 1 to enable.
MOUSE_ENABLE equ 1
MOUSE_DISABLE equ 0
MOUSE_RESET equ 0c201h ; Reset the mouse.
MAX_NUM_RESETS equ 3 ; # times we will send MOUSE_RESET command
MOUSE_RESET_RESEND_ERROR equ 04h ; Error returned from MOUSE_RESET call if it wants you to resend command
; Set report rate
MOUSE_SET_RATE equ 0c202h ; Set sample rate:
MOUSE_RATE_10 equ 0
MOUSE_RATE_20 equ 1
MOUSE_RATE_40 equ 2
MOUSE_RATE_60 equ 3
MOUSE_RATE_80 equ 4
MOUSE_RATE_100 equ 5
MOUSE_RATE_200 equ 6
; Resolution
MOUSE_SET_RESOLUTION equ 0c203h ; Set device resolution BH =
MOUSE_RES_1_PER_MM equ 0 ; 1 count per mm
MOUSE_RES_2_PER_MM equ 1 ; 2 counts per mm
MOUSE_RES_4_PER_MM equ 2 ; 4 counts per mm
MOUSE_RES_8_PER_MM equ 3 ; 8 counts per mm
; Device Type
MOUSE_GET_TYPE equ 0c204h ; Get device ID.
MOUSE_ONE_WHEEL equ 3 ; Device ID returned if Mouse has 1 Wheel
; Init packet size
MOUSE_INIT equ 0c205h ; Set interface parameters. BH = # bytes per packet.
MOUSE_PACKET_SIZE equ 4 ; We've got at least one wheel, hence 4 bytes!
; extended commands
MOUSE_EXTENDED_CMD equ 0c206h ; Extended command. BH =
MOUSE_EXTC_STATUS equ 0 ; Get device status
MOUSE_EXTC_SINGLE_SCALE equ 1 ; Set scaling to 1:1
MOUSE_EXTC_DOUBLE_SCALE equ 2 ; Set scaling to 2:1
; set handler
MOUSE_SET_HANDLER equ 0c207h ; Set mouse handler. ES:BX is address of routine
; original GeoWorks definitions
MouseStatus etype byte
MS_SUCCESSFUL enum MouseStatus, 0
MS_INVALID_FUNC enum MouseStatus, 1
MS_INVALID_INPUT enum MouseStatus, 2
MS_INTERFACE_ERROR enum MouseStatus, 3
MS_NEED_TO_RESEND enum MouseStatus, 4
MS_NO_HANDLER_INSTALLED enum MouseStatus, 5
mouseRates byte 10, 20, 40, 60, 80, 100, 200, 255
MOUSE_NUM_RATES equ size mouseRates
mouseRateCmds byte MOUSE_RATE_10, MOUSE_RATE_20, MOUSE_RATE_40
byte MOUSE_RATE_60, MOUSE_RATE_80, MOUSE_RATE_100
byte MOUSE_RATE_200, MOUSE_RATE_200
idata ends
MDHStatus record
MDHS_Y_OVERFLOW:1, ; Y overflow
MDHS_X_OVERFLOW:1, ; X overflow
MDHS_Y_NEGATIVE:1, ; Y delta is negative (just need to
; sign-extend, as delta is already in
; single-byte two's complement form)
MDHS_X_NEGATIVE:1, ; X delta is negative
MDHS_MUST_BE_ONE:1=1,
MDHS_MIDDLE_DOWN:1, ; Middle button is down
MDHS_RIGHT_DOWN:1, ; Right button is down
MDHS_LEFT_DOWN:1, ; Left button is down
MDHStatus end
Resident segment resource
COMMENT @%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
MouseDevHandler
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
SYNOPSIS: HandleMem the receipt of an interrupt
CALLED BY: BIOS
PASS: ON STACK:
RETURN: Nothing
DESTROYED: Nothing
PSEUDO CODE/STRATEGY:
Overflow is ignored.
For delta Y, positive => up, which is the opposite of what we think
KNOWN BUGS/SIDE EFFECTS/IDEAS:
Some BIOSes rely on DS not being altered, while others do not.
To err on the side of safety, we save everything we biff.
REVISION HISTORY:
Name Date Description
---- ---- -----------
ardeb 10/12/89 Initial version
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%@
MouseDevHandler proc far :byte, ; first byte is unused
:byte, ; second byte is unused
deltaZ:sbyte, ; wheel
:byte, ; unused
deltaY:sbyte, ; y axis
:byte, ; unused
status:MDHStatus, ; buttons
deltaX:sbyte ; x axis
uses ds, ax, bx, cx, dx, si, di, es
.enter
; Prevent switch while sending
call SysEnterInterrupt
;
; Store away the wheel info before the action really starts
; But first make sure we have access to the dgroup
;
mov ax, segment dgroup
mov ds, ax
clr ax
;
; Store away the wheel info before the action really starts
;
mov dh, ss:[deltaZ]
mov ds:[wheelData], dh
;
; The deltas are already two's-complement, so just sign extend them
; ourselves.
; XXX: verify sign against bits in status byte to confirm its validity?
; what if overflow bit is set?
;
mov al, ss:[deltaY]
cbw
xchg dx, ax ; (1-byte inst)
mov al, ss:[deltaX]
cbw
xchg cx, ax ; (1-byte inst)
; Fetch the status, copying the middle and right button bits
; into BH.
mov al, ss:[status]
test al, mask MDHS_Y_OVERFLOW or mask MDHS_X_OVERFLOW
jnz packetDone ; if overflow, drop the packet on the
; floor, since the semantics for such
; an event are undefined...
mov bh, al
and bh, 00000110b
; Make sure the packet makes sense by checking the ?_NEGATIVE bits
; against the actual signs of their respective deltas. If the two
; don't match (as indicated by the XOR of the sign bit of the delta
; with the ?_NEGATIVE bit resulting in a one), then hooey this packet.
shl al
shl al
tst dx
lahf
xor ah, al
js packetDone
shl al
tst cx
lahf
xor ah, al
js packetDone
; Mask out all but the left button and merge it into the
; middle and right buttons that are in BH. We then have
; 0000LMR0
; in BH, which is one bit off from what we need (and also
; the wrong polarity), so shift it right once and complement
; the thing.
and al, mask MDHS_LEFT_DOWN shl 3
or bh, al
shr bh, 1
not bh
; Make delta Y be positive if going down, rather than
; positive if up, as the BIOS provides it.
neg dx
; Registers now all loaded properly -- send the event.
call MouseSendEvents
packetDone:
call SysExitInterrupt
; Recover and return.
.leave
ret
MouseDevHandler endp
COMMENT @%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
MouseDevExit
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
SYNOPSIS: Finish things out
CALLED BY: MouseExit
PASS: DS=ES=CS
RETURN: Carry clear
DESTROYED: BX, AX
PSEUDO CODE/STRATEGY:
Just calls the serial driver to close down the port
KNOWN BUGS/SIDE EFFECTS/IDEAS:
REVISION HISTORY:
Name Date Description
---- ---- -----------
ardeb 5/20/89 Initial version
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%@
MouseDevExit proc near
; Disable the mouse by setting the handler to 0
; XXX: How can we restore it? Do we need to?
mov ax, MOUSE_ENABLE_DISABLE
mov bh, MOUSE_DISABLE ; Disable it please
int 15h
clr bx
mov es, bx
mov ax, MOUSE_SET_HANDLER
int 15h
ret
MouseDevExit endp
COMMENT @%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
MouseSetDevice
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
SYNOPSIS: Turn on the device.
CALLED BY: DRE_SET_DEVICE
PASS: dx:si = pointer to null-terminated device name string
RETURN: nothing
DESTROYED: nothing
PSEUDO CODE/STRATEGY:
KNOWN BUGS/SIDE EFFECTS/IDEAS:
REVISION HISTORY:
Name Date Description
---- ---- -----------
ardeb 9/27/90 Initial version
ayuen 10/17/00 Moved most of the code to MouseDevInit
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%@
MouseSetDevice proc near uses es, bx, ax, di, ds
.enter
ifdef MOUSE_HAS_WHEEL_KEYS
; fetch and save device variant
; if it fails, resets "device" to the PAGE variant (which should always work)
call MouseSetWheelAction
endif
; lock BIOS
call SysLockBIOS
; set packet size - must be called first!
mov ax, MOUSE_INIT ; Init mouse
mov bh, MOUSE_PACKET_SIZE ; We've got at least one wheel, hence 4 bytes!
int 15h
; strategy for wheel activation used in "InitializeWheel" by Bret E. Johnson
mov bh, MOUSE_RATE_200 ; Set Sample rate 200
mov ax, MOUSE_SET_RATE
int 15h
mov bh, MOUSE_RATE_100 ; Set Sample Rate 100
mov ax, MOUSE_SET_RATE
int 15h
mov bh, MOUSE_RATE_80 ; Set Sample Rate 80
mov ax, MOUSE_SET_RATE
int 15h
; install handler
segmov es, <segment Resident>
mov bx, offset Resident:MouseDevHandler
mov ax, MOUSE_SET_HANDLER
int 15h
; sampling
mov ax, MOUSE_SET_RATE
mov bh, MOUSE_RATE_60
int 15h
; resolution
mov ax, MOUSE_SET_RESOLUTION
mov bh, MOUSE_RES_8_PER_MM
int 15h
; scaling
mov ax, MOUSE_EXTENDED_CMD
mov bh, MOUSE_EXTC_SINGLE_SCALE
int 15h
; enable
mov ax, MOUSE_ENABLE_DISABLE
mov bh, MOUSE_ENABLE ; Enable it please
int 15h
call SysUnlockBIOS
.leave
ret
MouseSetDevice endp
COMMENT @%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
MouseTestDevice
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
SYNOPSIS: See if the device specified is present.
CALLED BY: DRE_TEST_DEVICE
PASS: dx:si = null-terminated name of device (ignored, here)
RETURN: ax = DevicePresent enum
carry set if string invalid, clear otherwise
DESTROYED: di
PSEUDO CODE/STRATEGY:
KNOWN BUGS/SIDE EFFECTS/IDEAS:
REVISION HISTORY:
Name Date Description
---- ---- -----------
ardeb 9/27/90 Initial version
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%@
MouseTestDevice proc near uses ax, bx, es, cx
.enter
;lock BIOS
call SysLockBIOS
; init to see if (wheel) mouse exists
mov ax, BIOS_DATA_SEG
mov es, ax
test es:[BIOS_EQUIPMENT], mask EC_POINTER
jz notPresent
; packet size
mov ax, MOUSE_INIT ; Init packet size
mov bh, MOUSE_PACKET_SIZE ; We've got at least one wheel, hence 4 bytes!
int 15h
;strategy used in "InitializeWheel" by Bret E. Johnson
mov bh, MOUSE_RATE_200 ; Set Sample rate 200
mov ax, MOUSE_SET_RATE
int 15h
mov bh, MOUSE_RATE_100 ; Set Sample Rate 100
mov ax, MOUSE_SET_RATE
int 15h
mov bh, MOUSE_RATE_80 ; Set Sample Rate 80
mov ax, MOUSE_SET_RATE
int 15h
; check if wheel mouse
mov ax, MOUSE_GET_TYPE ; Get the Device ID in BH
int 15h
cmp bh, MOUSE_ONE_WHEEL ; Is it an intellimouse with one wheel and three buttons?
jne notPresent ; if not, then got to notPresent
; reset
mov cx, MAX_NUM_RESETS ; # times we will resend this command
resetLoop:
mov ax, MOUSE_RESET
int 15h
jnc noerror ;If no error, branch
cmp ah, MS_NEED_TO_RESEND
jne notPresent ;If not "resend" error, just exit with carry set.
loop resetLoop
notPresent:
mov ax, DP_NOT_PRESENT
jmp done
noerror:
mov ax, DP_PRESENT
done:
call SysUnlockBIOS
clc
.leave
ret
MouseTestDevice endp
COMMENT @%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
MouseSetWheelAction
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
SYNOPSIS: Extract the wheel action
CALLED BY: MouseDevInit etc
PASS: dx:si = device string
DESTROYED: nothing
PSEUDO CODE/STRATEGY:
KNOWN BUGS/SIDE EFFECTS/IDEAS:
REVISION HISTORY:
Name Date Description
---- ---- -----------
MeyerK 10/2021 Initial version
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%@
ifdef MOUSE_HAS_WHEEL_KEYS
MouseSetWheelAction proc far uses cx, di, es, ds
.enter
;
; find driver variant aka "device"
;
EnumerateDevice MouseExtendedInfoSeg
;
; make sure we have access to the dgroup
;
mov cx, segment dgroup
mov ds, cx
;
; carry set if EnumerateDevice failed
;
jc error
;
; read out and store the driver variant
; we don't need the complicated setup of ct/ctmabs
; because the imps2 driver will always be separate
; from the other drivers and only offer support
; for wheel mice due to the different byte structure
; on the event handler...
;
cmp di, 0 ; pageMouse
je pageKey
cmp di, 2 ; cursorMouse
je cursorKey
pageKey:
mov ds:[driverVariant], MOUSE_WHEEL_ACTION_PAGE
jmp finish
cursorKey:
mov ds:[driverVariant], MOUSE_WHEEL_ACTION_CURSOR
finish:
;
; release the info block that has been locked by EnumerateDevice...
;
call MemUnlock
jmp exit
error:
;
; if error, set device index back to 0
;
mov ds:[driverVariant], MOUSE_WHEEL_ACTION_PAGE
exit:
.leave
ret
MouseSetWheelAction endp
endif
COMMENT @%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
MouseDevSetRate
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
SYNOPSIS: Set the report rate for the mouse
CALLED BY: MouseSetRate
PASS: CX = index of rate to set
RETURN: carry clear if successful
DESTROYED:
PSEUDO CODE/STRATEGY:
KNOWN BUGS/SIDE EFFECTS/IDEAS:
REVISION HISTORY:
Name Date Description
---- ---- -----------
ardeb 10/12/89 Initial version
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%@
MouseDevSetRate proc near
push ax, bx, cx, si
mov si, cx
mov bh, ds:mouseRateCmds[si]
mov ax, MOUSE_SET_RATE
int 15h
pop ax, bx, cx, si
ret
MouseDevSetRate endp
Resident ends
end
|
_pic_init:
;pic_init.c,5 :: void pic_init (void) {
;pic_init.c,7 :: ANSELA = 0; // all as digital
CLRF ANSELA+0
;pic_init.c,8 :: ANSELB = 0; // all as digital
CLRF ANSELB+0
;pic_init.c,9 :: ANSB0_bit = 1; // analog input
BSF ANSB0_bit+0, BitPos(ANSB0_bit+0)
;pic_init.c,10 :: ANSB1_bit = 1; // analog input
BSF ANSB1_bit+0, BitPos(ANSB1_bit+0)
;pic_init.c,11 :: ANSB2_bit = 1; // analog input
BSF ANSB2_bit+0, BitPos(ANSB2_bit+0)
;pic_init.c,12 :: ANSELC = 0; // all as digital
CLRF ANSELC+0
;pic_init.c,13 :: ANSELE = 0; // all as digital
CLRF ANSELE+0
;pic_init.c,14 :: ANSELD = 0; // all as digital
CLRF ANSELD+0
;pic_init.c,16 :: C1ON_bit = 0; // Disable comparators
BCF C1ON_bit+0, BitPos(C1ON_bit+0)
;pic_init.c,17 :: C2ON_bit = 0;
BCF C2ON_bit+0, BitPos(C2ON_bit+0)
;pic_init.c,19 :: PORTA = 0;
CLRF PORTA+0
;pic_init.c,20 :: PORTB = 0;
CLRF PORTB+0
;pic_init.c,21 :: PORTC = 0;
CLRF PORTC+0
;pic_init.c,22 :: PORTD = 0;
CLRF PORTD+0
;pic_init.c,23 :: PORTE = 0;
CLRF PORTE+0
;pic_init.c,24 :: LATA = 0b00000000;
CLRF LATA+0
;pic_init.c,25 :: LATB = 0b00000000;
CLRF LATB+0
;pic_init.c,26 :: LATC = 0b00010000;
MOVLW 16
MOVWF LATC+0
;pic_init.c,27 :: LATD = 0b00000110;
MOVLW 6
MOVWF LATD+0
;pic_init.c,28 :: LATE = 0b00000000;
CLRF LATE+0
;pic_init.c,29 :: TRISA = 0b00000000;
CLRF TRISA+0
;pic_init.c,30 :: TRISB = 0b00100111;
MOVLW 39
MOVWF TRISB+0
;pic_init.c,31 :: TRISC = 0b00000000;
CLRF TRISC+0
;pic_init.c,32 :: TRISD = 0b00000000;
CLRF TRISD+0
;pic_init.c,33 :: TRISE = 0b00000000;
CLRF TRISE+0
;pic_init.c,36 :: ODCA2_bit = 1;
BSF ODCA2_bit+0, BitPos(ODCA2_bit+0)
;pic_init.c,37 :: ODCA3_bit = 1;
BSF ODCA3_bit+0, BitPos(ODCA3_bit+0)
;pic_init.c,38 :: ODCD1_bit = 1;
BSF ODCD1_bit+0, BitPos(ODCD1_bit+0)
;pic_init.c,39 :: ODCD2_bit = 1;
BSF ODCD2_bit+0, BitPos(ODCD2_bit+0)
;pic_init.c,42 :: T0CS0_bit = 0; // Fosc/4
BCF T0CS0_bit+0, BitPos(T0CS0_bit+0)
;pic_init.c,43 :: T0CS1_bit = 1;
BSF T0CS1_bit+0, BitPos(T0CS1_bit+0)
;pic_init.c,44 :: T0CS2_bit = 0;
BCF T0CS2_bit+0, BitPos(T0CS2_bit+0)
;pic_init.c,45 :: T016BIT_bit = 1;
BSF T016BIT_bit+0, BitPos(T016BIT_bit+0)
;pic_init.c,46 :: TMR0L = 0xC0; // 8_000 cycles to OF
MOVLW 192
MOVWF TMR0L+0
;pic_init.c,47 :: TMR0H = 0xE0;
MOVLW 224
MOVWF TMR0H+0
;pic_init.c,48 :: TMR0IF_bit = 0;
BCF TMR0IF_bit+0, BitPos(TMR0IF_bit+0)
;pic_init.c,49 :: T0EN_bit = 1;
BSF T0EN_bit+0, BitPos(T0EN_bit+0)
;pic_init.c,50 :: TMR0IE_bit = 1;
BSF TMR0IE_bit+0, BitPos(TMR0IE_bit+0)
;pic_init.c,53 :: PMD0 = 0b00011110; //
MOVLW 30
MOVWF PMD0+0
;pic_init.c,54 :: PMD1 = 0b11111110;
MOVLW 254
MOVWF PMD1+0
;pic_init.c,55 :: PMD2 = 0b01000111;
MOVLW 71
MOVWF PMD2+0
;pic_init.c,56 :: PMD3 = 0b01111111;
MOVLW 127
MOVWF PMD3+0
;pic_init.c,57 :: PMD4 = 0b1110111;
MOVLW 119
MOVWF PMD4+0
;pic_init.c,58 :: PMD5 = 0b11011111;
MOVLW 223
MOVWF PMD5+0
;pic_init.c,60 :: GIE_bit = 1;
BSF GIE_bit+0, BitPos(GIE_bit+0)
;pic_init.c,61 :: Delay_ms (100);
MOVLW 5
MOVWF R11
MOVLW 15
MOVWF R12
MOVLW 241
MOVWF R13
L_pic_init0:
DECFSZ R13, 1
GOTO L_pic_init0
DECFSZ R12, 1
GOTO L_pic_init0
DECFSZ R11, 1
GOTO L_pic_init0
;pic_init.c,62 :: return;
;pic_init.c,63 :: }
L_end_pic_init:
RETURN
; end of _pic_init
|
; A010017: a(0) = 1, a(n) = 27*n^2 + 2 for n>0.
; 1,29,110,245,434,677,974,1325,1730,2189,2702,3269,3890,4565,5294,6077,6914,7805,8750,9749,10802,11909,13070,14285,15554,16877,18254,19685,21170,22709,24302,25949,27650,29405,31214,33077,34994,36965,38990,41069,43202,45389,47630,49925,52274,54677,57134,59645,62210,64829,67502,70229,73010,75845,78734,81677,84674,87725,90830,93989,97202,100469,103790,107165,110594,114077,117614,121205,124850,128549,132302,136109,139970,143885,147854,151877,155954,160085,164270,168509,172802,177149,181550,186005,190514,195077,199694,204365,209090,213869,218702,223589,228530,233525,238574,243677,248834,254045,259310,264629,270002,275429,280910,286445,292034,297677,303374,309125,314930,320789,326702,332669,338690,344765,350894,357077,363314,369605,375950,382349,388802,395309,401870,408485,415154,421877,428654,435485,442370,449309,456302,463349,470450,477605,484814,492077,499394,506765,514190,521669,529202,536789,544430,552125,559874,567677,575534,583445,591410,599429,607502,615629,623810,632045,640334,648677,657074,665525,674030,682589,691202,699869,708590,717365,726194,735077,744014,753005,762050,771149,780302,789509,798770,808085,817454,826877,836354,845885,855470,865109,874802,884549,894350,904205,914114,924077,934094,944165,954290,964469,974702,984989,995330,1005725,1016174,1026677,1037234,1047845,1058510,1069229,1080002,1090829,1101710,1112645,1123634,1134677,1145774,1156925,1168130,1179389,1190702,1202069,1213490,1224965,1236494,1248077,1259714,1271405,1283150,1294949,1306802,1318709,1330670,1342685,1354754,1366877,1379054,1391285,1403570,1415909,1428302,1440749,1453250,1465805,1478414,1491077,1503794,1516565,1529390,1542269,1555202,1568189,1581230,1594325,1607474,1620677,1633934,1647245,1660610,1674029
pow $1,$0
gcd $1,2
mov $3,$0
mul $3,$0
mov $2,$3
mul $2,27
add $1,$2
|
; TypeNames indexes (see data/types/names.asm)
; also used in:
; - PokedexTypeSearchConversionTable (see data/types/search_types.asm)
; - PokedexTypeSearchStrings (see data/types/search_strings.asm)
; - TypeMatchups (see data/types/type_matchups.asm)
; - TypeBoostItems (see data/types/type_boost_items.asm)
const_def
PHYSICAL EQU const_value
const NORMAL
const FIGHTING
const FLYING
const POISON
const GROUND
const ROCK
const BIRD
const BUG
const GHOST
const STEEL
UNUSED_TYPES EQU const_value
const TYPE_10
const TYPE_11
const TYPE_12
const TYPE_13
const TYPE_14
const TYPE_15
const TYPE_16
const TYPE_17
const TYPE_18
const CURSE_T
UNUSED_TYPES_END EQU const_value
SPECIAL EQU const_value
const FIRE
const WATER
const GRASS
const ELECTRIC
const PSYCHIC
const ICE
const DRAGON
const DARK
const FAIRY
TYPES_END EQU const_value
NUM_TYPES EQU TYPES_END + UNUSED_TYPES - UNUSED_TYPES_END
|
; A101776: Smallest k such that k^2 is equal to the sum of n not-necessarily-distinct primes plus 1.
; 1,2,3,3,3,4,4,4,5,5,5,5,5,6,6,6,6,6,7,7,7,7,7,7,7,8,8,8,8,8,8,8,9,9,9,9,9,9,9,9,9,10,10,10,10,10,10,10,10,10,11,11,11,11,11,11,11,11,11,11,11,12,12,12,12,12,12,12,12,12,12,12,13,13,13,13,13,13,13,13,13,13,13,13,13,14,14,14,14,14,14,14,14,14,14,14,14,14,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,23,23,23,23,23,23,23,23
add $0,1
mul $0,2
sub $0,1
mov $2,2
lpb $0
add $1,$2
sub $0,$1
lpe
div $1,2
add $1,1
|
_ln: file format elf64-x86-64
Disassembly of section .text:
0000000000001000 <main>:
#include "stat.h"
#include "user.h"
int
main(int argc, char *argv[])
{
1000: f3 0f 1e fa endbr64
1004: 55 push %rbp
1005: 48 89 e5 mov %rsp,%rbp
1008: 48 83 ec 10 sub $0x10,%rsp
100c: 89 7d fc mov %edi,-0x4(%rbp)
100f: 48 89 75 f0 mov %rsi,-0x10(%rbp)
if(argc != 3){
1013: 83 7d fc 03 cmpl $0x3,-0x4(%rbp)
1017: 74 2c je 1045 <main+0x45>
printf(2, "Usage: ln old new\n");
1019: 48 be 00 22 00 00 00 movabs $0x2200,%rsi
1020: 00 00 00
1023: bf 02 00 00 00 mov $0x2,%edi
1028: b8 00 00 00 00 mov $0x0,%eax
102d: 48 ba e7 16 00 00 00 movabs $0x16e7,%rdx
1034: 00 00 00
1037: ff d2 callq *%rdx
exit();
1039: 48 b8 fd 13 00 00 00 movabs $0x13fd,%rax
1040: 00 00 00
1043: ff d0 callq *%rax
}
if(link(argv[1], argv[2]) < 0)
1045: 48 8b 45 f0 mov -0x10(%rbp),%rax
1049: 48 83 c0 10 add $0x10,%rax
104d: 48 8b 10 mov (%rax),%rdx
1050: 48 8b 45 f0 mov -0x10(%rbp),%rax
1054: 48 83 c0 08 add $0x8,%rax
1058: 48 8b 00 mov (%rax),%rax
105b: 48 89 d6 mov %rdx,%rsi
105e: 48 89 c7 mov %rax,%rdi
1061: 48 b8 99 14 00 00 00 movabs $0x1499,%rax
1068: 00 00 00
106b: ff d0 callq *%rax
106d: 85 c0 test %eax,%eax
106f: 79 3d jns 10ae <main+0xae>
printf(2, "link %s %s: failed\n", argv[1], argv[2]);
1071: 48 8b 45 f0 mov -0x10(%rbp),%rax
1075: 48 83 c0 10 add $0x10,%rax
1079: 48 8b 10 mov (%rax),%rdx
107c: 48 8b 45 f0 mov -0x10(%rbp),%rax
1080: 48 83 c0 08 add $0x8,%rax
1084: 48 8b 00 mov (%rax),%rax
1087: 48 89 d1 mov %rdx,%rcx
108a: 48 89 c2 mov %rax,%rdx
108d: 48 be 13 22 00 00 00 movabs $0x2213,%rsi
1094: 00 00 00
1097: bf 02 00 00 00 mov $0x2,%edi
109c: b8 00 00 00 00 mov $0x0,%eax
10a1: 49 b8 e7 16 00 00 00 movabs $0x16e7,%r8
10a8: 00 00 00
10ab: 41 ff d0 callq *%r8
exit();
10ae: 48 b8 fd 13 00 00 00 movabs $0x13fd,%rax
10b5: 00 00 00
10b8: ff d0 callq *%rax
00000000000010ba <stosb>:
"cc");
}
static inline void
stosb(void *addr, int data, int cnt)
{
10ba: f3 0f 1e fa endbr64
10be: 55 push %rbp
10bf: 48 89 e5 mov %rsp,%rbp
10c2: 48 83 ec 10 sub $0x10,%rsp
10c6: 48 89 7d f8 mov %rdi,-0x8(%rbp)
10ca: 89 75 f4 mov %esi,-0xc(%rbp)
10cd: 89 55 f0 mov %edx,-0x10(%rbp)
asm volatile("cld; rep stosb" :
10d0: 48 8b 4d f8 mov -0x8(%rbp),%rcx
10d4: 8b 55 f0 mov -0x10(%rbp),%edx
10d7: 8b 45 f4 mov -0xc(%rbp),%eax
10da: 48 89 ce mov %rcx,%rsi
10dd: 48 89 f7 mov %rsi,%rdi
10e0: 89 d1 mov %edx,%ecx
10e2: fc cld
10e3: f3 aa rep stos %al,%es:(%rdi)
10e5: 89 ca mov %ecx,%edx
10e7: 48 89 fe mov %rdi,%rsi
10ea: 48 89 75 f8 mov %rsi,-0x8(%rbp)
10ee: 89 55 f0 mov %edx,-0x10(%rbp)
"=D" (addr), "=c" (cnt) :
"0" (addr), "1" (cnt), "a" (data) :
"memory", "cc");
}
10f1: 90 nop
10f2: c9 leaveq
10f3: c3 retq
00000000000010f4 <strcpy>:
#include "user.h"
#include "x86.h"
char*
strcpy(char *s, char *t)
{
10f4: f3 0f 1e fa endbr64
10f8: 55 push %rbp
10f9: 48 89 e5 mov %rsp,%rbp
10fc: 48 83 ec 20 sub $0x20,%rsp
1100: 48 89 7d e8 mov %rdi,-0x18(%rbp)
1104: 48 89 75 e0 mov %rsi,-0x20(%rbp)
char *os;
os = s;
1108: 48 8b 45 e8 mov -0x18(%rbp),%rax
110c: 48 89 45 f8 mov %rax,-0x8(%rbp)
while((*s++ = *t++) != 0)
1110: 90 nop
1111: 48 8b 55 e0 mov -0x20(%rbp),%rdx
1115: 48 8d 42 01 lea 0x1(%rdx),%rax
1119: 48 89 45 e0 mov %rax,-0x20(%rbp)
111d: 48 8b 45 e8 mov -0x18(%rbp),%rax
1121: 48 8d 48 01 lea 0x1(%rax),%rcx
1125: 48 89 4d e8 mov %rcx,-0x18(%rbp)
1129: 0f b6 12 movzbl (%rdx),%edx
112c: 88 10 mov %dl,(%rax)
112e: 0f b6 00 movzbl (%rax),%eax
1131: 84 c0 test %al,%al
1133: 75 dc jne 1111 <strcpy+0x1d>
;
return os;
1135: 48 8b 45 f8 mov -0x8(%rbp),%rax
}
1139: c9 leaveq
113a: c3 retq
000000000000113b <strcmp>:
int
strcmp(const char *p, const char *q)
{
113b: f3 0f 1e fa endbr64
113f: 55 push %rbp
1140: 48 89 e5 mov %rsp,%rbp
1143: 48 83 ec 10 sub $0x10,%rsp
1147: 48 89 7d f8 mov %rdi,-0x8(%rbp)
114b: 48 89 75 f0 mov %rsi,-0x10(%rbp)
while(*p && *p == *q)
114f: eb 0a jmp 115b <strcmp+0x20>
p++, q++;
1151: 48 83 45 f8 01 addq $0x1,-0x8(%rbp)
1156: 48 83 45 f0 01 addq $0x1,-0x10(%rbp)
while(*p && *p == *q)
115b: 48 8b 45 f8 mov -0x8(%rbp),%rax
115f: 0f b6 00 movzbl (%rax),%eax
1162: 84 c0 test %al,%al
1164: 74 12 je 1178 <strcmp+0x3d>
1166: 48 8b 45 f8 mov -0x8(%rbp),%rax
116a: 0f b6 10 movzbl (%rax),%edx
116d: 48 8b 45 f0 mov -0x10(%rbp),%rax
1171: 0f b6 00 movzbl (%rax),%eax
1174: 38 c2 cmp %al,%dl
1176: 74 d9 je 1151 <strcmp+0x16>
return (uchar)*p - (uchar)*q;
1178: 48 8b 45 f8 mov -0x8(%rbp),%rax
117c: 0f b6 00 movzbl (%rax),%eax
117f: 0f b6 d0 movzbl %al,%edx
1182: 48 8b 45 f0 mov -0x10(%rbp),%rax
1186: 0f b6 00 movzbl (%rax),%eax
1189: 0f b6 c0 movzbl %al,%eax
118c: 29 c2 sub %eax,%edx
118e: 89 d0 mov %edx,%eax
}
1190: c9 leaveq
1191: c3 retq
0000000000001192 <strlen>:
uint
strlen(char *s)
{
1192: f3 0f 1e fa endbr64
1196: 55 push %rbp
1197: 48 89 e5 mov %rsp,%rbp
119a: 48 83 ec 18 sub $0x18,%rsp
119e: 48 89 7d e8 mov %rdi,-0x18(%rbp)
int n;
for(n = 0; s[n]; n++)
11a2: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%rbp)
11a9: eb 04 jmp 11af <strlen+0x1d>
11ab: 83 45 fc 01 addl $0x1,-0x4(%rbp)
11af: 8b 45 fc mov -0x4(%rbp),%eax
11b2: 48 63 d0 movslq %eax,%rdx
11b5: 48 8b 45 e8 mov -0x18(%rbp),%rax
11b9: 48 01 d0 add %rdx,%rax
11bc: 0f b6 00 movzbl (%rax),%eax
11bf: 84 c0 test %al,%al
11c1: 75 e8 jne 11ab <strlen+0x19>
;
return n;
11c3: 8b 45 fc mov -0x4(%rbp),%eax
}
11c6: c9 leaveq
11c7: c3 retq
00000000000011c8 <memset>:
void*
memset(void *dst, int c, uint n)
{
11c8: f3 0f 1e fa endbr64
11cc: 55 push %rbp
11cd: 48 89 e5 mov %rsp,%rbp
11d0: 48 83 ec 10 sub $0x10,%rsp
11d4: 48 89 7d f8 mov %rdi,-0x8(%rbp)
11d8: 89 75 f4 mov %esi,-0xc(%rbp)
11db: 89 55 f0 mov %edx,-0x10(%rbp)
stosb(dst, c, n);
11de: 8b 55 f0 mov -0x10(%rbp),%edx
11e1: 8b 4d f4 mov -0xc(%rbp),%ecx
11e4: 48 8b 45 f8 mov -0x8(%rbp),%rax
11e8: 89 ce mov %ecx,%esi
11ea: 48 89 c7 mov %rax,%rdi
11ed: 48 b8 ba 10 00 00 00 movabs $0x10ba,%rax
11f4: 00 00 00
11f7: ff d0 callq *%rax
return dst;
11f9: 48 8b 45 f8 mov -0x8(%rbp),%rax
}
11fd: c9 leaveq
11fe: c3 retq
00000000000011ff <strchr>:
char*
strchr(const char *s, char c)
{
11ff: f3 0f 1e fa endbr64
1203: 55 push %rbp
1204: 48 89 e5 mov %rsp,%rbp
1207: 48 83 ec 10 sub $0x10,%rsp
120b: 48 89 7d f8 mov %rdi,-0x8(%rbp)
120f: 89 f0 mov %esi,%eax
1211: 88 45 f4 mov %al,-0xc(%rbp)
for(; *s; s++)
1214: eb 17 jmp 122d <strchr+0x2e>
if(*s == c)
1216: 48 8b 45 f8 mov -0x8(%rbp),%rax
121a: 0f b6 00 movzbl (%rax),%eax
121d: 38 45 f4 cmp %al,-0xc(%rbp)
1220: 75 06 jne 1228 <strchr+0x29>
return (char*)s;
1222: 48 8b 45 f8 mov -0x8(%rbp),%rax
1226: eb 15 jmp 123d <strchr+0x3e>
for(; *s; s++)
1228: 48 83 45 f8 01 addq $0x1,-0x8(%rbp)
122d: 48 8b 45 f8 mov -0x8(%rbp),%rax
1231: 0f b6 00 movzbl (%rax),%eax
1234: 84 c0 test %al,%al
1236: 75 de jne 1216 <strchr+0x17>
return 0;
1238: b8 00 00 00 00 mov $0x0,%eax
}
123d: c9 leaveq
123e: c3 retq
000000000000123f <gets>:
char*
gets(char *buf, int max)
{
123f: f3 0f 1e fa endbr64
1243: 55 push %rbp
1244: 48 89 e5 mov %rsp,%rbp
1247: 48 83 ec 20 sub $0x20,%rsp
124b: 48 89 7d e8 mov %rdi,-0x18(%rbp)
124f: 89 75 e4 mov %esi,-0x1c(%rbp)
int i, cc;
char c;
for(i=0; i+1 < max; ){
1252: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%rbp)
1259: eb 4f jmp 12aa <gets+0x6b>
cc = read(0, &c, 1);
125b: 48 8d 45 f7 lea -0x9(%rbp),%rax
125f: ba 01 00 00 00 mov $0x1,%edx
1264: 48 89 c6 mov %rax,%rsi
1267: bf 00 00 00 00 mov $0x0,%edi
126c: 48 b8 24 14 00 00 00 movabs $0x1424,%rax
1273: 00 00 00
1276: ff d0 callq *%rax
1278: 89 45 f8 mov %eax,-0x8(%rbp)
if(cc < 1)
127b: 83 7d f8 00 cmpl $0x0,-0x8(%rbp)
127f: 7e 36 jle 12b7 <gets+0x78>
break;
buf[i++] = c;
1281: 8b 45 fc mov -0x4(%rbp),%eax
1284: 8d 50 01 lea 0x1(%rax),%edx
1287: 89 55 fc mov %edx,-0x4(%rbp)
128a: 48 63 d0 movslq %eax,%rdx
128d: 48 8b 45 e8 mov -0x18(%rbp),%rax
1291: 48 01 c2 add %rax,%rdx
1294: 0f b6 45 f7 movzbl -0x9(%rbp),%eax
1298: 88 02 mov %al,(%rdx)
if(c == '\n' || c == '\r')
129a: 0f b6 45 f7 movzbl -0x9(%rbp),%eax
129e: 3c 0a cmp $0xa,%al
12a0: 74 16 je 12b8 <gets+0x79>
12a2: 0f b6 45 f7 movzbl -0x9(%rbp),%eax
12a6: 3c 0d cmp $0xd,%al
12a8: 74 0e je 12b8 <gets+0x79>
for(i=0; i+1 < max; ){
12aa: 8b 45 fc mov -0x4(%rbp),%eax
12ad: 83 c0 01 add $0x1,%eax
12b0: 39 45 e4 cmp %eax,-0x1c(%rbp)
12b3: 7f a6 jg 125b <gets+0x1c>
12b5: eb 01 jmp 12b8 <gets+0x79>
break;
12b7: 90 nop
break;
}
buf[i] = '\0';
12b8: 8b 45 fc mov -0x4(%rbp),%eax
12bb: 48 63 d0 movslq %eax,%rdx
12be: 48 8b 45 e8 mov -0x18(%rbp),%rax
12c2: 48 01 d0 add %rdx,%rax
12c5: c6 00 00 movb $0x0,(%rax)
return buf;
12c8: 48 8b 45 e8 mov -0x18(%rbp),%rax
}
12cc: c9 leaveq
12cd: c3 retq
00000000000012ce <stat>:
int
stat(char *n, struct stat *st)
{
12ce: f3 0f 1e fa endbr64
12d2: 55 push %rbp
12d3: 48 89 e5 mov %rsp,%rbp
12d6: 48 83 ec 20 sub $0x20,%rsp
12da: 48 89 7d e8 mov %rdi,-0x18(%rbp)
12de: 48 89 75 e0 mov %rsi,-0x20(%rbp)
int fd;
int r;
fd = open(n, O_RDONLY);
12e2: 48 8b 45 e8 mov -0x18(%rbp),%rax
12e6: be 00 00 00 00 mov $0x0,%esi
12eb: 48 89 c7 mov %rax,%rdi
12ee: 48 b8 65 14 00 00 00 movabs $0x1465,%rax
12f5: 00 00 00
12f8: ff d0 callq *%rax
12fa: 89 45 fc mov %eax,-0x4(%rbp)
if(fd < 0)
12fd: 83 7d fc 00 cmpl $0x0,-0x4(%rbp)
1301: 79 07 jns 130a <stat+0x3c>
return -1;
1303: b8 ff ff ff ff mov $0xffffffff,%eax
1308: eb 2f jmp 1339 <stat+0x6b>
r = fstat(fd, st);
130a: 48 8b 55 e0 mov -0x20(%rbp),%rdx
130e: 8b 45 fc mov -0x4(%rbp),%eax
1311: 48 89 d6 mov %rdx,%rsi
1314: 89 c7 mov %eax,%edi
1316: 48 b8 8c 14 00 00 00 movabs $0x148c,%rax
131d: 00 00 00
1320: ff d0 callq *%rax
1322: 89 45 f8 mov %eax,-0x8(%rbp)
close(fd);
1325: 8b 45 fc mov -0x4(%rbp),%eax
1328: 89 c7 mov %eax,%edi
132a: 48 b8 3e 14 00 00 00 movabs $0x143e,%rax
1331: 00 00 00
1334: ff d0 callq *%rax
return r;
1336: 8b 45 f8 mov -0x8(%rbp),%eax
}
1339: c9 leaveq
133a: c3 retq
000000000000133b <atoi>:
int
atoi(const char *s)
{
133b: f3 0f 1e fa endbr64
133f: 55 push %rbp
1340: 48 89 e5 mov %rsp,%rbp
1343: 48 83 ec 18 sub $0x18,%rsp
1347: 48 89 7d e8 mov %rdi,-0x18(%rbp)
int n;
n = 0;
134b: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%rbp)
while('0' <= *s && *s <= '9')
1352: eb 28 jmp 137c <atoi+0x41>
n = n*10 + *s++ - '0';
1354: 8b 55 fc mov -0x4(%rbp),%edx
1357: 89 d0 mov %edx,%eax
1359: c1 e0 02 shl $0x2,%eax
135c: 01 d0 add %edx,%eax
135e: 01 c0 add %eax,%eax
1360: 89 c1 mov %eax,%ecx
1362: 48 8b 45 e8 mov -0x18(%rbp),%rax
1366: 48 8d 50 01 lea 0x1(%rax),%rdx
136a: 48 89 55 e8 mov %rdx,-0x18(%rbp)
136e: 0f b6 00 movzbl (%rax),%eax
1371: 0f be c0 movsbl %al,%eax
1374: 01 c8 add %ecx,%eax
1376: 83 e8 30 sub $0x30,%eax
1379: 89 45 fc mov %eax,-0x4(%rbp)
while('0' <= *s && *s <= '9')
137c: 48 8b 45 e8 mov -0x18(%rbp),%rax
1380: 0f b6 00 movzbl (%rax),%eax
1383: 3c 2f cmp $0x2f,%al
1385: 7e 0b jle 1392 <atoi+0x57>
1387: 48 8b 45 e8 mov -0x18(%rbp),%rax
138b: 0f b6 00 movzbl (%rax),%eax
138e: 3c 39 cmp $0x39,%al
1390: 7e c2 jle 1354 <atoi+0x19>
return n;
1392: 8b 45 fc mov -0x4(%rbp),%eax
}
1395: c9 leaveq
1396: c3 retq
0000000000001397 <memmove>:
void*
memmove(void *vdst, void *vsrc, int n)
{
1397: f3 0f 1e fa endbr64
139b: 55 push %rbp
139c: 48 89 e5 mov %rsp,%rbp
139f: 48 83 ec 28 sub $0x28,%rsp
13a3: 48 89 7d e8 mov %rdi,-0x18(%rbp)
13a7: 48 89 75 e0 mov %rsi,-0x20(%rbp)
13ab: 89 55 dc mov %edx,-0x24(%rbp)
char *dst, *src;
dst = vdst;
13ae: 48 8b 45 e8 mov -0x18(%rbp),%rax
13b2: 48 89 45 f8 mov %rax,-0x8(%rbp)
src = vsrc;
13b6: 48 8b 45 e0 mov -0x20(%rbp),%rax
13ba: 48 89 45 f0 mov %rax,-0x10(%rbp)
while(n-- > 0)
13be: eb 1d jmp 13dd <memmove+0x46>
*dst++ = *src++;
13c0: 48 8b 55 f0 mov -0x10(%rbp),%rdx
13c4: 48 8d 42 01 lea 0x1(%rdx),%rax
13c8: 48 89 45 f0 mov %rax,-0x10(%rbp)
13cc: 48 8b 45 f8 mov -0x8(%rbp),%rax
13d0: 48 8d 48 01 lea 0x1(%rax),%rcx
13d4: 48 89 4d f8 mov %rcx,-0x8(%rbp)
13d8: 0f b6 12 movzbl (%rdx),%edx
13db: 88 10 mov %dl,(%rax)
while(n-- > 0)
13dd: 8b 45 dc mov -0x24(%rbp),%eax
13e0: 8d 50 ff lea -0x1(%rax),%edx
13e3: 89 55 dc mov %edx,-0x24(%rbp)
13e6: 85 c0 test %eax,%eax
13e8: 7f d6 jg 13c0 <memmove+0x29>
return vdst;
13ea: 48 8b 45 e8 mov -0x18(%rbp),%rax
}
13ee: c9 leaveq
13ef: c3 retq
00000000000013f0 <fork>:
mov $SYS_ ## name, %rax; \
mov %rcx, %r10 ;\
syscall ;\
ret
SYSCALL(fork)
13f0: 48 c7 c0 01 00 00 00 mov $0x1,%rax
13f7: 49 89 ca mov %rcx,%r10
13fa: 0f 05 syscall
13fc: c3 retq
00000000000013fd <exit>:
SYSCALL(exit)
13fd: 48 c7 c0 02 00 00 00 mov $0x2,%rax
1404: 49 89 ca mov %rcx,%r10
1407: 0f 05 syscall
1409: c3 retq
000000000000140a <wait>:
SYSCALL(wait)
140a: 48 c7 c0 03 00 00 00 mov $0x3,%rax
1411: 49 89 ca mov %rcx,%r10
1414: 0f 05 syscall
1416: c3 retq
0000000000001417 <pipe>:
SYSCALL(pipe)
1417: 48 c7 c0 04 00 00 00 mov $0x4,%rax
141e: 49 89 ca mov %rcx,%r10
1421: 0f 05 syscall
1423: c3 retq
0000000000001424 <read>:
SYSCALL(read)
1424: 48 c7 c0 05 00 00 00 mov $0x5,%rax
142b: 49 89 ca mov %rcx,%r10
142e: 0f 05 syscall
1430: c3 retq
0000000000001431 <write>:
SYSCALL(write)
1431: 48 c7 c0 10 00 00 00 mov $0x10,%rax
1438: 49 89 ca mov %rcx,%r10
143b: 0f 05 syscall
143d: c3 retq
000000000000143e <close>:
SYSCALL(close)
143e: 48 c7 c0 15 00 00 00 mov $0x15,%rax
1445: 49 89 ca mov %rcx,%r10
1448: 0f 05 syscall
144a: c3 retq
000000000000144b <kill>:
SYSCALL(kill)
144b: 48 c7 c0 06 00 00 00 mov $0x6,%rax
1452: 49 89 ca mov %rcx,%r10
1455: 0f 05 syscall
1457: c3 retq
0000000000001458 <exec>:
SYSCALL(exec)
1458: 48 c7 c0 07 00 00 00 mov $0x7,%rax
145f: 49 89 ca mov %rcx,%r10
1462: 0f 05 syscall
1464: c3 retq
0000000000001465 <open>:
SYSCALL(open)
1465: 48 c7 c0 0f 00 00 00 mov $0xf,%rax
146c: 49 89 ca mov %rcx,%r10
146f: 0f 05 syscall
1471: c3 retq
0000000000001472 <mknod>:
SYSCALL(mknod)
1472: 48 c7 c0 11 00 00 00 mov $0x11,%rax
1479: 49 89 ca mov %rcx,%r10
147c: 0f 05 syscall
147e: c3 retq
000000000000147f <unlink>:
SYSCALL(unlink)
147f: 48 c7 c0 12 00 00 00 mov $0x12,%rax
1486: 49 89 ca mov %rcx,%r10
1489: 0f 05 syscall
148b: c3 retq
000000000000148c <fstat>:
SYSCALL(fstat)
148c: 48 c7 c0 08 00 00 00 mov $0x8,%rax
1493: 49 89 ca mov %rcx,%r10
1496: 0f 05 syscall
1498: c3 retq
0000000000001499 <link>:
SYSCALL(link)
1499: 48 c7 c0 13 00 00 00 mov $0x13,%rax
14a0: 49 89 ca mov %rcx,%r10
14a3: 0f 05 syscall
14a5: c3 retq
00000000000014a6 <mkdir>:
SYSCALL(mkdir)
14a6: 48 c7 c0 14 00 00 00 mov $0x14,%rax
14ad: 49 89 ca mov %rcx,%r10
14b0: 0f 05 syscall
14b2: c3 retq
00000000000014b3 <chdir>:
SYSCALL(chdir)
14b3: 48 c7 c0 09 00 00 00 mov $0x9,%rax
14ba: 49 89 ca mov %rcx,%r10
14bd: 0f 05 syscall
14bf: c3 retq
00000000000014c0 <dup>:
SYSCALL(dup)
14c0: 48 c7 c0 0a 00 00 00 mov $0xa,%rax
14c7: 49 89 ca mov %rcx,%r10
14ca: 0f 05 syscall
14cc: c3 retq
00000000000014cd <getpid>:
SYSCALL(getpid)
14cd: 48 c7 c0 0b 00 00 00 mov $0xb,%rax
14d4: 49 89 ca mov %rcx,%r10
14d7: 0f 05 syscall
14d9: c3 retq
00000000000014da <sbrk>:
SYSCALL(sbrk)
14da: 48 c7 c0 0c 00 00 00 mov $0xc,%rax
14e1: 49 89 ca mov %rcx,%r10
14e4: 0f 05 syscall
14e6: c3 retq
00000000000014e7 <sleep>:
SYSCALL(sleep)
14e7: 48 c7 c0 0d 00 00 00 mov $0xd,%rax
14ee: 49 89 ca mov %rcx,%r10
14f1: 0f 05 syscall
14f3: c3 retq
00000000000014f4 <uptime>:
SYSCALL(uptime)
14f4: 48 c7 c0 0e 00 00 00 mov $0xe,%rax
14fb: 49 89 ca mov %rcx,%r10
14fe: 0f 05 syscall
1500: c3 retq
0000000000001501 <putc>:
#include <stdarg.h>
static void
putc(int fd, char c)
{
1501: f3 0f 1e fa endbr64
1505: 55 push %rbp
1506: 48 89 e5 mov %rsp,%rbp
1509: 48 83 ec 10 sub $0x10,%rsp
150d: 89 7d fc mov %edi,-0x4(%rbp)
1510: 89 f0 mov %esi,%eax
1512: 88 45 f8 mov %al,-0x8(%rbp)
write(fd, &c, 1);
1515: 48 8d 4d f8 lea -0x8(%rbp),%rcx
1519: 8b 45 fc mov -0x4(%rbp),%eax
151c: ba 01 00 00 00 mov $0x1,%edx
1521: 48 89 ce mov %rcx,%rsi
1524: 89 c7 mov %eax,%edi
1526: 48 b8 31 14 00 00 00 movabs $0x1431,%rax
152d: 00 00 00
1530: ff d0 callq *%rax
}
1532: 90 nop
1533: c9 leaveq
1534: c3 retq
0000000000001535 <print_x64>:
static char digits[] = "0123456789abcdef";
static void
print_x64(int fd, addr_t x)
{
1535: f3 0f 1e fa endbr64
1539: 55 push %rbp
153a: 48 89 e5 mov %rsp,%rbp
153d: 48 83 ec 20 sub $0x20,%rsp
1541: 89 7d ec mov %edi,-0x14(%rbp)
1544: 48 89 75 e0 mov %rsi,-0x20(%rbp)
int i;
for (i = 0; i < (sizeof(addr_t) * 2); i++, x <<= 4)
1548: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%rbp)
154f: eb 35 jmp 1586 <print_x64+0x51>
putc(fd, digits[x >> (sizeof(addr_t) * 8 - 4)]);
1551: 48 8b 45 e0 mov -0x20(%rbp),%rax
1555: 48 c1 e8 3c shr $0x3c,%rax
1559: 48 ba 20 26 00 00 00 movabs $0x2620,%rdx
1560: 00 00 00
1563: 0f b6 04 02 movzbl (%rdx,%rax,1),%eax
1567: 0f be d0 movsbl %al,%edx
156a: 8b 45 ec mov -0x14(%rbp),%eax
156d: 89 d6 mov %edx,%esi
156f: 89 c7 mov %eax,%edi
1571: 48 b8 01 15 00 00 00 movabs $0x1501,%rax
1578: 00 00 00
157b: ff d0 callq *%rax
for (i = 0; i < (sizeof(addr_t) * 2); i++, x <<= 4)
157d: 83 45 fc 01 addl $0x1,-0x4(%rbp)
1581: 48 c1 65 e0 04 shlq $0x4,-0x20(%rbp)
1586: 8b 45 fc mov -0x4(%rbp),%eax
1589: 83 f8 0f cmp $0xf,%eax
158c: 76 c3 jbe 1551 <print_x64+0x1c>
}
158e: 90 nop
158f: 90 nop
1590: c9 leaveq
1591: c3 retq
0000000000001592 <print_x32>:
static void
print_x32(int fd, uint x)
{
1592: f3 0f 1e fa endbr64
1596: 55 push %rbp
1597: 48 89 e5 mov %rsp,%rbp
159a: 48 83 ec 20 sub $0x20,%rsp
159e: 89 7d ec mov %edi,-0x14(%rbp)
15a1: 89 75 e8 mov %esi,-0x18(%rbp)
int i;
for (i = 0; i < (sizeof(uint) * 2); i++, x <<= 4)
15a4: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%rbp)
15ab: eb 36 jmp 15e3 <print_x32+0x51>
putc(fd, digits[x >> (sizeof(uint) * 8 - 4)]);
15ad: 8b 45 e8 mov -0x18(%rbp),%eax
15b0: c1 e8 1c shr $0x1c,%eax
15b3: 89 c2 mov %eax,%edx
15b5: 48 b8 20 26 00 00 00 movabs $0x2620,%rax
15bc: 00 00 00
15bf: 89 d2 mov %edx,%edx
15c1: 0f b6 04 10 movzbl (%rax,%rdx,1),%eax
15c5: 0f be d0 movsbl %al,%edx
15c8: 8b 45 ec mov -0x14(%rbp),%eax
15cb: 89 d6 mov %edx,%esi
15cd: 89 c7 mov %eax,%edi
15cf: 48 b8 01 15 00 00 00 movabs $0x1501,%rax
15d6: 00 00 00
15d9: ff d0 callq *%rax
for (i = 0; i < (sizeof(uint) * 2); i++, x <<= 4)
15db: 83 45 fc 01 addl $0x1,-0x4(%rbp)
15df: c1 65 e8 04 shll $0x4,-0x18(%rbp)
15e3: 8b 45 fc mov -0x4(%rbp),%eax
15e6: 83 f8 07 cmp $0x7,%eax
15e9: 76 c2 jbe 15ad <print_x32+0x1b>
}
15eb: 90 nop
15ec: 90 nop
15ed: c9 leaveq
15ee: c3 retq
00000000000015ef <print_d>:
static void
print_d(int fd, int v)
{
15ef: f3 0f 1e fa endbr64
15f3: 55 push %rbp
15f4: 48 89 e5 mov %rsp,%rbp
15f7: 48 83 ec 30 sub $0x30,%rsp
15fb: 89 7d dc mov %edi,-0x24(%rbp)
15fe: 89 75 d8 mov %esi,-0x28(%rbp)
char buf[16];
int64 x = v;
1601: 8b 45 d8 mov -0x28(%rbp),%eax
1604: 48 98 cltq
1606: 48 89 45 f8 mov %rax,-0x8(%rbp)
if (v < 0)
160a: 83 7d d8 00 cmpl $0x0,-0x28(%rbp)
160e: 79 04 jns 1614 <print_d+0x25>
x = -x;
1610: 48 f7 5d f8 negq -0x8(%rbp)
int i = 0;
1614: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%rbp)
do {
buf[i++] = digits[x % 10];
161b: 48 8b 4d f8 mov -0x8(%rbp),%rcx
161f: 48 ba 67 66 66 66 66 movabs $0x6666666666666667,%rdx
1626: 66 66 66
1629: 48 89 c8 mov %rcx,%rax
162c: 48 f7 ea imul %rdx
162f: 48 c1 fa 02 sar $0x2,%rdx
1633: 48 89 c8 mov %rcx,%rax
1636: 48 c1 f8 3f sar $0x3f,%rax
163a: 48 29 c2 sub %rax,%rdx
163d: 48 89 d0 mov %rdx,%rax
1640: 48 c1 e0 02 shl $0x2,%rax
1644: 48 01 d0 add %rdx,%rax
1647: 48 01 c0 add %rax,%rax
164a: 48 29 c1 sub %rax,%rcx
164d: 48 89 ca mov %rcx,%rdx
1650: 8b 45 f4 mov -0xc(%rbp),%eax
1653: 8d 48 01 lea 0x1(%rax),%ecx
1656: 89 4d f4 mov %ecx,-0xc(%rbp)
1659: 48 b9 20 26 00 00 00 movabs $0x2620,%rcx
1660: 00 00 00
1663: 0f b6 14 11 movzbl (%rcx,%rdx,1),%edx
1667: 48 98 cltq
1669: 88 54 05 e0 mov %dl,-0x20(%rbp,%rax,1)
x /= 10;
166d: 48 8b 4d f8 mov -0x8(%rbp),%rcx
1671: 48 ba 67 66 66 66 66 movabs $0x6666666666666667,%rdx
1678: 66 66 66
167b: 48 89 c8 mov %rcx,%rax
167e: 48 f7 ea imul %rdx
1681: 48 c1 fa 02 sar $0x2,%rdx
1685: 48 89 c8 mov %rcx,%rax
1688: 48 c1 f8 3f sar $0x3f,%rax
168c: 48 29 c2 sub %rax,%rdx
168f: 48 89 d0 mov %rdx,%rax
1692: 48 89 45 f8 mov %rax,-0x8(%rbp)
} while(x != 0);
1696: 48 83 7d f8 00 cmpq $0x0,-0x8(%rbp)
169b: 0f 85 7a ff ff ff jne 161b <print_d+0x2c>
if (v < 0)
16a1: 83 7d d8 00 cmpl $0x0,-0x28(%rbp)
16a5: 79 32 jns 16d9 <print_d+0xea>
buf[i++] = '-';
16a7: 8b 45 f4 mov -0xc(%rbp),%eax
16aa: 8d 50 01 lea 0x1(%rax),%edx
16ad: 89 55 f4 mov %edx,-0xc(%rbp)
16b0: 48 98 cltq
16b2: c6 44 05 e0 2d movb $0x2d,-0x20(%rbp,%rax,1)
while (--i >= 0)
16b7: eb 20 jmp 16d9 <print_d+0xea>
putc(fd, buf[i]);
16b9: 8b 45 f4 mov -0xc(%rbp),%eax
16bc: 48 98 cltq
16be: 0f b6 44 05 e0 movzbl -0x20(%rbp,%rax,1),%eax
16c3: 0f be d0 movsbl %al,%edx
16c6: 8b 45 dc mov -0x24(%rbp),%eax
16c9: 89 d6 mov %edx,%esi
16cb: 89 c7 mov %eax,%edi
16cd: 48 b8 01 15 00 00 00 movabs $0x1501,%rax
16d4: 00 00 00
16d7: ff d0 callq *%rax
while (--i >= 0)
16d9: 83 6d f4 01 subl $0x1,-0xc(%rbp)
16dd: 83 7d f4 00 cmpl $0x0,-0xc(%rbp)
16e1: 79 d6 jns 16b9 <print_d+0xca>
}
16e3: 90 nop
16e4: 90 nop
16e5: c9 leaveq
16e6: c3 retq
00000000000016e7 <printf>:
// Print to the given fd. Only understands %d, %x, %p, %s.
void
printf(int fd, char *fmt, ...)
{
16e7: f3 0f 1e fa endbr64
16eb: 55 push %rbp
16ec: 48 89 e5 mov %rsp,%rbp
16ef: 48 81 ec f0 00 00 00 sub $0xf0,%rsp
16f6: 89 bd 1c ff ff ff mov %edi,-0xe4(%rbp)
16fc: 48 89 b5 10 ff ff ff mov %rsi,-0xf0(%rbp)
1703: 48 89 95 60 ff ff ff mov %rdx,-0xa0(%rbp)
170a: 48 89 8d 68 ff ff ff mov %rcx,-0x98(%rbp)
1711: 4c 89 85 70 ff ff ff mov %r8,-0x90(%rbp)
1718: 4c 89 8d 78 ff ff ff mov %r9,-0x88(%rbp)
171f: 84 c0 test %al,%al
1721: 74 20 je 1743 <printf+0x5c>
1723: 0f 29 45 80 movaps %xmm0,-0x80(%rbp)
1727: 0f 29 4d 90 movaps %xmm1,-0x70(%rbp)
172b: 0f 29 55 a0 movaps %xmm2,-0x60(%rbp)
172f: 0f 29 5d b0 movaps %xmm3,-0x50(%rbp)
1733: 0f 29 65 c0 movaps %xmm4,-0x40(%rbp)
1737: 0f 29 6d d0 movaps %xmm5,-0x30(%rbp)
173b: 0f 29 75 e0 movaps %xmm6,-0x20(%rbp)
173f: 0f 29 7d f0 movaps %xmm7,-0x10(%rbp)
va_list ap;
int i, c;
char *s;
va_start(ap, fmt);
1743: c7 85 20 ff ff ff 10 movl $0x10,-0xe0(%rbp)
174a: 00 00 00
174d: c7 85 24 ff ff ff 30 movl $0x30,-0xdc(%rbp)
1754: 00 00 00
1757: 48 8d 45 10 lea 0x10(%rbp),%rax
175b: 48 89 85 28 ff ff ff mov %rax,-0xd8(%rbp)
1762: 48 8d 85 50 ff ff ff lea -0xb0(%rbp),%rax
1769: 48 89 85 30 ff ff ff mov %rax,-0xd0(%rbp)
for (i = 0; (c = fmt[i] & 0xff) != 0; i++) {
1770: c7 85 4c ff ff ff 00 movl $0x0,-0xb4(%rbp)
1777: 00 00 00
177a: e9 41 03 00 00 jmpq 1ac0 <printf+0x3d9>
if (c != '%') {
177f: 83 bd 3c ff ff ff 25 cmpl $0x25,-0xc4(%rbp)
1786: 74 24 je 17ac <printf+0xc5>
putc(fd, c);
1788: 8b 85 3c ff ff ff mov -0xc4(%rbp),%eax
178e: 0f be d0 movsbl %al,%edx
1791: 8b 85 1c ff ff ff mov -0xe4(%rbp),%eax
1797: 89 d6 mov %edx,%esi
1799: 89 c7 mov %eax,%edi
179b: 48 b8 01 15 00 00 00 movabs $0x1501,%rax
17a2: 00 00 00
17a5: ff d0 callq *%rax
continue;
17a7: e9 0d 03 00 00 jmpq 1ab9 <printf+0x3d2>
}
c = fmt[++i] & 0xff;
17ac: 83 85 4c ff ff ff 01 addl $0x1,-0xb4(%rbp)
17b3: 8b 85 4c ff ff ff mov -0xb4(%rbp),%eax
17b9: 48 63 d0 movslq %eax,%rdx
17bc: 48 8b 85 10 ff ff ff mov -0xf0(%rbp),%rax
17c3: 48 01 d0 add %rdx,%rax
17c6: 0f b6 00 movzbl (%rax),%eax
17c9: 0f be c0 movsbl %al,%eax
17cc: 25 ff 00 00 00 and $0xff,%eax
17d1: 89 85 3c ff ff ff mov %eax,-0xc4(%rbp)
if (c == 0)
17d7: 83 bd 3c ff ff ff 00 cmpl $0x0,-0xc4(%rbp)
17de: 0f 84 0f 03 00 00 je 1af3 <printf+0x40c>
break;
switch(c) {
17e4: 83 bd 3c ff ff ff 25 cmpl $0x25,-0xc4(%rbp)
17eb: 0f 84 74 02 00 00 je 1a65 <printf+0x37e>
17f1: 83 bd 3c ff ff ff 25 cmpl $0x25,-0xc4(%rbp)
17f8: 0f 8c 82 02 00 00 jl 1a80 <printf+0x399>
17fe: 83 bd 3c ff ff ff 78 cmpl $0x78,-0xc4(%rbp)
1805: 0f 8f 75 02 00 00 jg 1a80 <printf+0x399>
180b: 83 bd 3c ff ff ff 63 cmpl $0x63,-0xc4(%rbp)
1812: 0f 8c 68 02 00 00 jl 1a80 <printf+0x399>
1818: 8b 85 3c ff ff ff mov -0xc4(%rbp),%eax
181e: 83 e8 63 sub $0x63,%eax
1821: 83 f8 15 cmp $0x15,%eax
1824: 0f 87 56 02 00 00 ja 1a80 <printf+0x399>
182a: 89 c0 mov %eax,%eax
182c: 48 8d 14 c5 00 00 00 lea 0x0(,%rax,8),%rdx
1833: 00
1834: 48 b8 30 22 00 00 00 movabs $0x2230,%rax
183b: 00 00 00
183e: 48 01 d0 add %rdx,%rax
1841: 48 8b 00 mov (%rax),%rax
1844: 3e ff e0 notrack jmpq *%rax
case 'c':
putc(fd, va_arg(ap, int));
1847: 8b 85 20 ff ff ff mov -0xe0(%rbp),%eax
184d: 83 f8 2f cmp $0x2f,%eax
1850: 77 23 ja 1875 <printf+0x18e>
1852: 48 8b 85 30 ff ff ff mov -0xd0(%rbp),%rax
1859: 8b 95 20 ff ff ff mov -0xe0(%rbp),%edx
185f: 89 d2 mov %edx,%edx
1861: 48 01 d0 add %rdx,%rax
1864: 8b 95 20 ff ff ff mov -0xe0(%rbp),%edx
186a: 83 c2 08 add $0x8,%edx
186d: 89 95 20 ff ff ff mov %edx,-0xe0(%rbp)
1873: eb 12 jmp 1887 <printf+0x1a0>
1875: 48 8b 85 28 ff ff ff mov -0xd8(%rbp),%rax
187c: 48 8d 50 08 lea 0x8(%rax),%rdx
1880: 48 89 95 28 ff ff ff mov %rdx,-0xd8(%rbp)
1887: 8b 00 mov (%rax),%eax
1889: 0f be d0 movsbl %al,%edx
188c: 8b 85 1c ff ff ff mov -0xe4(%rbp),%eax
1892: 89 d6 mov %edx,%esi
1894: 89 c7 mov %eax,%edi
1896: 48 b8 01 15 00 00 00 movabs $0x1501,%rax
189d: 00 00 00
18a0: ff d0 callq *%rax
break;
18a2: e9 12 02 00 00 jmpq 1ab9 <printf+0x3d2>
case 'd':
print_d(fd, va_arg(ap, int));
18a7: 8b 85 20 ff ff ff mov -0xe0(%rbp),%eax
18ad: 83 f8 2f cmp $0x2f,%eax
18b0: 77 23 ja 18d5 <printf+0x1ee>
18b2: 48 8b 85 30 ff ff ff mov -0xd0(%rbp),%rax
18b9: 8b 95 20 ff ff ff mov -0xe0(%rbp),%edx
18bf: 89 d2 mov %edx,%edx
18c1: 48 01 d0 add %rdx,%rax
18c4: 8b 95 20 ff ff ff mov -0xe0(%rbp),%edx
18ca: 83 c2 08 add $0x8,%edx
18cd: 89 95 20 ff ff ff mov %edx,-0xe0(%rbp)
18d3: eb 12 jmp 18e7 <printf+0x200>
18d5: 48 8b 85 28 ff ff ff mov -0xd8(%rbp),%rax
18dc: 48 8d 50 08 lea 0x8(%rax),%rdx
18e0: 48 89 95 28 ff ff ff mov %rdx,-0xd8(%rbp)
18e7: 8b 10 mov (%rax),%edx
18e9: 8b 85 1c ff ff ff mov -0xe4(%rbp),%eax
18ef: 89 d6 mov %edx,%esi
18f1: 89 c7 mov %eax,%edi
18f3: 48 b8 ef 15 00 00 00 movabs $0x15ef,%rax
18fa: 00 00 00
18fd: ff d0 callq *%rax
break;
18ff: e9 b5 01 00 00 jmpq 1ab9 <printf+0x3d2>
case 'x':
print_x32(fd, va_arg(ap, uint));
1904: 8b 85 20 ff ff ff mov -0xe0(%rbp),%eax
190a: 83 f8 2f cmp $0x2f,%eax
190d: 77 23 ja 1932 <printf+0x24b>
190f: 48 8b 85 30 ff ff ff mov -0xd0(%rbp),%rax
1916: 8b 95 20 ff ff ff mov -0xe0(%rbp),%edx
191c: 89 d2 mov %edx,%edx
191e: 48 01 d0 add %rdx,%rax
1921: 8b 95 20 ff ff ff mov -0xe0(%rbp),%edx
1927: 83 c2 08 add $0x8,%edx
192a: 89 95 20 ff ff ff mov %edx,-0xe0(%rbp)
1930: eb 12 jmp 1944 <printf+0x25d>
1932: 48 8b 85 28 ff ff ff mov -0xd8(%rbp),%rax
1939: 48 8d 50 08 lea 0x8(%rax),%rdx
193d: 48 89 95 28 ff ff ff mov %rdx,-0xd8(%rbp)
1944: 8b 10 mov (%rax),%edx
1946: 8b 85 1c ff ff ff mov -0xe4(%rbp),%eax
194c: 89 d6 mov %edx,%esi
194e: 89 c7 mov %eax,%edi
1950: 48 b8 92 15 00 00 00 movabs $0x1592,%rax
1957: 00 00 00
195a: ff d0 callq *%rax
break;
195c: e9 58 01 00 00 jmpq 1ab9 <printf+0x3d2>
case 'p':
print_x64(fd, va_arg(ap, addr_t));
1961: 8b 85 20 ff ff ff mov -0xe0(%rbp),%eax
1967: 83 f8 2f cmp $0x2f,%eax
196a: 77 23 ja 198f <printf+0x2a8>
196c: 48 8b 85 30 ff ff ff mov -0xd0(%rbp),%rax
1973: 8b 95 20 ff ff ff mov -0xe0(%rbp),%edx
1979: 89 d2 mov %edx,%edx
197b: 48 01 d0 add %rdx,%rax
197e: 8b 95 20 ff ff ff mov -0xe0(%rbp),%edx
1984: 83 c2 08 add $0x8,%edx
1987: 89 95 20 ff ff ff mov %edx,-0xe0(%rbp)
198d: eb 12 jmp 19a1 <printf+0x2ba>
198f: 48 8b 85 28 ff ff ff mov -0xd8(%rbp),%rax
1996: 48 8d 50 08 lea 0x8(%rax),%rdx
199a: 48 89 95 28 ff ff ff mov %rdx,-0xd8(%rbp)
19a1: 48 8b 10 mov (%rax),%rdx
19a4: 8b 85 1c ff ff ff mov -0xe4(%rbp),%eax
19aa: 48 89 d6 mov %rdx,%rsi
19ad: 89 c7 mov %eax,%edi
19af: 48 b8 35 15 00 00 00 movabs $0x1535,%rax
19b6: 00 00 00
19b9: ff d0 callq *%rax
break;
19bb: e9 f9 00 00 00 jmpq 1ab9 <printf+0x3d2>
case 's':
if ((s = va_arg(ap, char*)) == 0)
19c0: 8b 85 20 ff ff ff mov -0xe0(%rbp),%eax
19c6: 83 f8 2f cmp $0x2f,%eax
19c9: 77 23 ja 19ee <printf+0x307>
19cb: 48 8b 85 30 ff ff ff mov -0xd0(%rbp),%rax
19d2: 8b 95 20 ff ff ff mov -0xe0(%rbp),%edx
19d8: 89 d2 mov %edx,%edx
19da: 48 01 d0 add %rdx,%rax
19dd: 8b 95 20 ff ff ff mov -0xe0(%rbp),%edx
19e3: 83 c2 08 add $0x8,%edx
19e6: 89 95 20 ff ff ff mov %edx,-0xe0(%rbp)
19ec: eb 12 jmp 1a00 <printf+0x319>
19ee: 48 8b 85 28 ff ff ff mov -0xd8(%rbp),%rax
19f5: 48 8d 50 08 lea 0x8(%rax),%rdx
19f9: 48 89 95 28 ff ff ff mov %rdx,-0xd8(%rbp)
1a00: 48 8b 00 mov (%rax),%rax
1a03: 48 89 85 40 ff ff ff mov %rax,-0xc0(%rbp)
1a0a: 48 83 bd 40 ff ff ff cmpq $0x0,-0xc0(%rbp)
1a11: 00
1a12: 75 41 jne 1a55 <printf+0x36e>
s = "(null)";
1a14: 48 b8 28 22 00 00 00 movabs $0x2228,%rax
1a1b: 00 00 00
1a1e: 48 89 85 40 ff ff ff mov %rax,-0xc0(%rbp)
while (*s)
1a25: eb 2e jmp 1a55 <printf+0x36e>
putc(fd, *(s++));
1a27: 48 8b 85 40 ff ff ff mov -0xc0(%rbp),%rax
1a2e: 48 8d 50 01 lea 0x1(%rax),%rdx
1a32: 48 89 95 40 ff ff ff mov %rdx,-0xc0(%rbp)
1a39: 0f b6 00 movzbl (%rax),%eax
1a3c: 0f be d0 movsbl %al,%edx
1a3f: 8b 85 1c ff ff ff mov -0xe4(%rbp),%eax
1a45: 89 d6 mov %edx,%esi
1a47: 89 c7 mov %eax,%edi
1a49: 48 b8 01 15 00 00 00 movabs $0x1501,%rax
1a50: 00 00 00
1a53: ff d0 callq *%rax
while (*s)
1a55: 48 8b 85 40 ff ff ff mov -0xc0(%rbp),%rax
1a5c: 0f b6 00 movzbl (%rax),%eax
1a5f: 84 c0 test %al,%al
1a61: 75 c4 jne 1a27 <printf+0x340>
break;
1a63: eb 54 jmp 1ab9 <printf+0x3d2>
case '%':
putc(fd, '%');
1a65: 8b 85 1c ff ff ff mov -0xe4(%rbp),%eax
1a6b: be 25 00 00 00 mov $0x25,%esi
1a70: 89 c7 mov %eax,%edi
1a72: 48 b8 01 15 00 00 00 movabs $0x1501,%rax
1a79: 00 00 00
1a7c: ff d0 callq *%rax
break;
1a7e: eb 39 jmp 1ab9 <printf+0x3d2>
default:
// Print unknown % sequence to draw attention.
putc(fd, '%');
1a80: 8b 85 1c ff ff ff mov -0xe4(%rbp),%eax
1a86: be 25 00 00 00 mov $0x25,%esi
1a8b: 89 c7 mov %eax,%edi
1a8d: 48 b8 01 15 00 00 00 movabs $0x1501,%rax
1a94: 00 00 00
1a97: ff d0 callq *%rax
putc(fd, c);
1a99: 8b 85 3c ff ff ff mov -0xc4(%rbp),%eax
1a9f: 0f be d0 movsbl %al,%edx
1aa2: 8b 85 1c ff ff ff mov -0xe4(%rbp),%eax
1aa8: 89 d6 mov %edx,%esi
1aaa: 89 c7 mov %eax,%edi
1aac: 48 b8 01 15 00 00 00 movabs $0x1501,%rax
1ab3: 00 00 00
1ab6: ff d0 callq *%rax
break;
1ab8: 90 nop
for (i = 0; (c = fmt[i] & 0xff) != 0; i++) {
1ab9: 83 85 4c ff ff ff 01 addl $0x1,-0xb4(%rbp)
1ac0: 8b 85 4c ff ff ff mov -0xb4(%rbp),%eax
1ac6: 48 63 d0 movslq %eax,%rdx
1ac9: 48 8b 85 10 ff ff ff mov -0xf0(%rbp),%rax
1ad0: 48 01 d0 add %rdx,%rax
1ad3: 0f b6 00 movzbl (%rax),%eax
1ad6: 0f be c0 movsbl %al,%eax
1ad9: 25 ff 00 00 00 and $0xff,%eax
1ade: 89 85 3c ff ff ff mov %eax,-0xc4(%rbp)
1ae4: 83 bd 3c ff ff ff 00 cmpl $0x0,-0xc4(%rbp)
1aeb: 0f 85 8e fc ff ff jne 177f <printf+0x98>
}
}
}
1af1: eb 01 jmp 1af4 <printf+0x40d>
break;
1af3: 90 nop
}
1af4: 90 nop
1af5: c9 leaveq
1af6: c3 retq
0000000000001af7 <free>:
static Header base;
static Header *freep;
void
free(void *ap)
{
1af7: f3 0f 1e fa endbr64
1afb: 55 push %rbp
1afc: 48 89 e5 mov %rsp,%rbp
1aff: 48 83 ec 18 sub $0x18,%rsp
1b03: 48 89 7d e8 mov %rdi,-0x18(%rbp)
Header *bp, *p;
bp = (Header*)ap - 1;
1b07: 48 8b 45 e8 mov -0x18(%rbp),%rax
1b0b: 48 83 e8 10 sub $0x10,%rax
1b0f: 48 89 45 f0 mov %rax,-0x10(%rbp)
for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
1b13: 48 b8 50 26 00 00 00 movabs $0x2650,%rax
1b1a: 00 00 00
1b1d: 48 8b 00 mov (%rax),%rax
1b20: 48 89 45 f8 mov %rax,-0x8(%rbp)
1b24: eb 2f jmp 1b55 <free+0x5e>
if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
1b26: 48 8b 45 f8 mov -0x8(%rbp),%rax
1b2a: 48 8b 00 mov (%rax),%rax
1b2d: 48 39 45 f8 cmp %rax,-0x8(%rbp)
1b31: 72 17 jb 1b4a <free+0x53>
1b33: 48 8b 45 f0 mov -0x10(%rbp),%rax
1b37: 48 3b 45 f8 cmp -0x8(%rbp),%rax
1b3b: 77 2f ja 1b6c <free+0x75>
1b3d: 48 8b 45 f8 mov -0x8(%rbp),%rax
1b41: 48 8b 00 mov (%rax),%rax
1b44: 48 39 45 f0 cmp %rax,-0x10(%rbp)
1b48: 72 22 jb 1b6c <free+0x75>
for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
1b4a: 48 8b 45 f8 mov -0x8(%rbp),%rax
1b4e: 48 8b 00 mov (%rax),%rax
1b51: 48 89 45 f8 mov %rax,-0x8(%rbp)
1b55: 48 8b 45 f0 mov -0x10(%rbp),%rax
1b59: 48 3b 45 f8 cmp -0x8(%rbp),%rax
1b5d: 76 c7 jbe 1b26 <free+0x2f>
1b5f: 48 8b 45 f8 mov -0x8(%rbp),%rax
1b63: 48 8b 00 mov (%rax),%rax
1b66: 48 39 45 f0 cmp %rax,-0x10(%rbp)
1b6a: 73 ba jae 1b26 <free+0x2f>
break;
if(bp + bp->s.size == p->s.ptr){
1b6c: 48 8b 45 f0 mov -0x10(%rbp),%rax
1b70: 8b 40 08 mov 0x8(%rax),%eax
1b73: 89 c0 mov %eax,%eax
1b75: 48 c1 e0 04 shl $0x4,%rax
1b79: 48 89 c2 mov %rax,%rdx
1b7c: 48 8b 45 f0 mov -0x10(%rbp),%rax
1b80: 48 01 c2 add %rax,%rdx
1b83: 48 8b 45 f8 mov -0x8(%rbp),%rax
1b87: 48 8b 00 mov (%rax),%rax
1b8a: 48 39 c2 cmp %rax,%rdx
1b8d: 75 2d jne 1bbc <free+0xc5>
bp->s.size += p->s.ptr->s.size;
1b8f: 48 8b 45 f0 mov -0x10(%rbp),%rax
1b93: 8b 50 08 mov 0x8(%rax),%edx
1b96: 48 8b 45 f8 mov -0x8(%rbp),%rax
1b9a: 48 8b 00 mov (%rax),%rax
1b9d: 8b 40 08 mov 0x8(%rax),%eax
1ba0: 01 c2 add %eax,%edx
1ba2: 48 8b 45 f0 mov -0x10(%rbp),%rax
1ba6: 89 50 08 mov %edx,0x8(%rax)
bp->s.ptr = p->s.ptr->s.ptr;
1ba9: 48 8b 45 f8 mov -0x8(%rbp),%rax
1bad: 48 8b 00 mov (%rax),%rax
1bb0: 48 8b 10 mov (%rax),%rdx
1bb3: 48 8b 45 f0 mov -0x10(%rbp),%rax
1bb7: 48 89 10 mov %rdx,(%rax)
1bba: eb 0e jmp 1bca <free+0xd3>
} else
bp->s.ptr = p->s.ptr;
1bbc: 48 8b 45 f8 mov -0x8(%rbp),%rax
1bc0: 48 8b 10 mov (%rax),%rdx
1bc3: 48 8b 45 f0 mov -0x10(%rbp),%rax
1bc7: 48 89 10 mov %rdx,(%rax)
if(p + p->s.size == bp){
1bca: 48 8b 45 f8 mov -0x8(%rbp),%rax
1bce: 8b 40 08 mov 0x8(%rax),%eax
1bd1: 89 c0 mov %eax,%eax
1bd3: 48 c1 e0 04 shl $0x4,%rax
1bd7: 48 89 c2 mov %rax,%rdx
1bda: 48 8b 45 f8 mov -0x8(%rbp),%rax
1bde: 48 01 d0 add %rdx,%rax
1be1: 48 39 45 f0 cmp %rax,-0x10(%rbp)
1be5: 75 27 jne 1c0e <free+0x117>
p->s.size += bp->s.size;
1be7: 48 8b 45 f8 mov -0x8(%rbp),%rax
1beb: 8b 50 08 mov 0x8(%rax),%edx
1bee: 48 8b 45 f0 mov -0x10(%rbp),%rax
1bf2: 8b 40 08 mov 0x8(%rax),%eax
1bf5: 01 c2 add %eax,%edx
1bf7: 48 8b 45 f8 mov -0x8(%rbp),%rax
1bfb: 89 50 08 mov %edx,0x8(%rax)
p->s.ptr = bp->s.ptr;
1bfe: 48 8b 45 f0 mov -0x10(%rbp),%rax
1c02: 48 8b 10 mov (%rax),%rdx
1c05: 48 8b 45 f8 mov -0x8(%rbp),%rax
1c09: 48 89 10 mov %rdx,(%rax)
1c0c: eb 0b jmp 1c19 <free+0x122>
} else
p->s.ptr = bp;
1c0e: 48 8b 45 f8 mov -0x8(%rbp),%rax
1c12: 48 8b 55 f0 mov -0x10(%rbp),%rdx
1c16: 48 89 10 mov %rdx,(%rax)
freep = p;
1c19: 48 ba 50 26 00 00 00 movabs $0x2650,%rdx
1c20: 00 00 00
1c23: 48 8b 45 f8 mov -0x8(%rbp),%rax
1c27: 48 89 02 mov %rax,(%rdx)
}
1c2a: 90 nop
1c2b: c9 leaveq
1c2c: c3 retq
0000000000001c2d <morecore>:
static Header*
morecore(uint nu)
{
1c2d: f3 0f 1e fa endbr64
1c31: 55 push %rbp
1c32: 48 89 e5 mov %rsp,%rbp
1c35: 48 83 ec 20 sub $0x20,%rsp
1c39: 89 7d ec mov %edi,-0x14(%rbp)
char *p;
Header *hp;
if(nu < 4096)
1c3c: 81 7d ec ff 0f 00 00 cmpl $0xfff,-0x14(%rbp)
1c43: 77 07 ja 1c4c <morecore+0x1f>
nu = 4096;
1c45: c7 45 ec 00 10 00 00 movl $0x1000,-0x14(%rbp)
p = sbrk(nu * sizeof(Header));
1c4c: 8b 45 ec mov -0x14(%rbp),%eax
1c4f: 48 c1 e0 04 shl $0x4,%rax
1c53: 48 89 c7 mov %rax,%rdi
1c56: 48 b8 da 14 00 00 00 movabs $0x14da,%rax
1c5d: 00 00 00
1c60: ff d0 callq *%rax
1c62: 48 89 45 f8 mov %rax,-0x8(%rbp)
if(p == (char*)-1)
1c66: 48 83 7d f8 ff cmpq $0xffffffffffffffff,-0x8(%rbp)
1c6b: 75 07 jne 1c74 <morecore+0x47>
return 0;
1c6d: b8 00 00 00 00 mov $0x0,%eax
1c72: eb 36 jmp 1caa <morecore+0x7d>
hp = (Header*)p;
1c74: 48 8b 45 f8 mov -0x8(%rbp),%rax
1c78: 48 89 45 f0 mov %rax,-0x10(%rbp)
hp->s.size = nu;
1c7c: 48 8b 45 f0 mov -0x10(%rbp),%rax
1c80: 8b 55 ec mov -0x14(%rbp),%edx
1c83: 89 50 08 mov %edx,0x8(%rax)
free((void*)(hp + 1));
1c86: 48 8b 45 f0 mov -0x10(%rbp),%rax
1c8a: 48 83 c0 10 add $0x10,%rax
1c8e: 48 89 c7 mov %rax,%rdi
1c91: 48 b8 f7 1a 00 00 00 movabs $0x1af7,%rax
1c98: 00 00 00
1c9b: ff d0 callq *%rax
return freep;
1c9d: 48 b8 50 26 00 00 00 movabs $0x2650,%rax
1ca4: 00 00 00
1ca7: 48 8b 00 mov (%rax),%rax
}
1caa: c9 leaveq
1cab: c3 retq
0000000000001cac <malloc>:
void*
malloc(uint nbytes)
{
1cac: f3 0f 1e fa endbr64
1cb0: 55 push %rbp
1cb1: 48 89 e5 mov %rsp,%rbp
1cb4: 48 83 ec 30 sub $0x30,%rsp
1cb8: 89 7d dc mov %edi,-0x24(%rbp)
Header *p, *prevp;
uint nunits;
nunits = (nbytes + sizeof(Header) - 1)/sizeof(Header) + 1;
1cbb: 8b 45 dc mov -0x24(%rbp),%eax
1cbe: 48 83 c0 0f add $0xf,%rax
1cc2: 48 c1 e8 04 shr $0x4,%rax
1cc6: 83 c0 01 add $0x1,%eax
1cc9: 89 45 ec mov %eax,-0x14(%rbp)
if((prevp = freep) == 0){
1ccc: 48 b8 50 26 00 00 00 movabs $0x2650,%rax
1cd3: 00 00 00
1cd6: 48 8b 00 mov (%rax),%rax
1cd9: 48 89 45 f0 mov %rax,-0x10(%rbp)
1cdd: 48 83 7d f0 00 cmpq $0x0,-0x10(%rbp)
1ce2: 75 4a jne 1d2e <malloc+0x82>
base.s.ptr = freep = prevp = &base;
1ce4: 48 b8 40 26 00 00 00 movabs $0x2640,%rax
1ceb: 00 00 00
1cee: 48 89 45 f0 mov %rax,-0x10(%rbp)
1cf2: 48 ba 50 26 00 00 00 movabs $0x2650,%rdx
1cf9: 00 00 00
1cfc: 48 8b 45 f0 mov -0x10(%rbp),%rax
1d00: 48 89 02 mov %rax,(%rdx)
1d03: 48 b8 50 26 00 00 00 movabs $0x2650,%rax
1d0a: 00 00 00
1d0d: 48 8b 00 mov (%rax),%rax
1d10: 48 ba 40 26 00 00 00 movabs $0x2640,%rdx
1d17: 00 00 00
1d1a: 48 89 02 mov %rax,(%rdx)
base.s.size = 0;
1d1d: 48 b8 40 26 00 00 00 movabs $0x2640,%rax
1d24: 00 00 00
1d27: c7 40 08 00 00 00 00 movl $0x0,0x8(%rax)
}
for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
1d2e: 48 8b 45 f0 mov -0x10(%rbp),%rax
1d32: 48 8b 00 mov (%rax),%rax
1d35: 48 89 45 f8 mov %rax,-0x8(%rbp)
if(p->s.size >= nunits){
1d39: 48 8b 45 f8 mov -0x8(%rbp),%rax
1d3d: 8b 40 08 mov 0x8(%rax),%eax
1d40: 39 45 ec cmp %eax,-0x14(%rbp)
1d43: 77 65 ja 1daa <malloc+0xfe>
if(p->s.size == nunits)
1d45: 48 8b 45 f8 mov -0x8(%rbp),%rax
1d49: 8b 40 08 mov 0x8(%rax),%eax
1d4c: 39 45 ec cmp %eax,-0x14(%rbp)
1d4f: 75 10 jne 1d61 <malloc+0xb5>
prevp->s.ptr = p->s.ptr;
1d51: 48 8b 45 f8 mov -0x8(%rbp),%rax
1d55: 48 8b 10 mov (%rax),%rdx
1d58: 48 8b 45 f0 mov -0x10(%rbp),%rax
1d5c: 48 89 10 mov %rdx,(%rax)
1d5f: eb 2e jmp 1d8f <malloc+0xe3>
else {
p->s.size -= nunits;
1d61: 48 8b 45 f8 mov -0x8(%rbp),%rax
1d65: 8b 40 08 mov 0x8(%rax),%eax
1d68: 2b 45 ec sub -0x14(%rbp),%eax
1d6b: 89 c2 mov %eax,%edx
1d6d: 48 8b 45 f8 mov -0x8(%rbp),%rax
1d71: 89 50 08 mov %edx,0x8(%rax)
p += p->s.size;
1d74: 48 8b 45 f8 mov -0x8(%rbp),%rax
1d78: 8b 40 08 mov 0x8(%rax),%eax
1d7b: 89 c0 mov %eax,%eax
1d7d: 48 c1 e0 04 shl $0x4,%rax
1d81: 48 01 45 f8 add %rax,-0x8(%rbp)
p->s.size = nunits;
1d85: 48 8b 45 f8 mov -0x8(%rbp),%rax
1d89: 8b 55 ec mov -0x14(%rbp),%edx
1d8c: 89 50 08 mov %edx,0x8(%rax)
}
freep = prevp;
1d8f: 48 ba 50 26 00 00 00 movabs $0x2650,%rdx
1d96: 00 00 00
1d99: 48 8b 45 f0 mov -0x10(%rbp),%rax
1d9d: 48 89 02 mov %rax,(%rdx)
return (void*)(p + 1);
1da0: 48 8b 45 f8 mov -0x8(%rbp),%rax
1da4: 48 83 c0 10 add $0x10,%rax
1da8: eb 4e jmp 1df8 <malloc+0x14c>
}
if(p == freep)
1daa: 48 b8 50 26 00 00 00 movabs $0x2650,%rax
1db1: 00 00 00
1db4: 48 8b 00 mov (%rax),%rax
1db7: 48 39 45 f8 cmp %rax,-0x8(%rbp)
1dbb: 75 23 jne 1de0 <malloc+0x134>
if((p = morecore(nunits)) == 0)
1dbd: 8b 45 ec mov -0x14(%rbp),%eax
1dc0: 89 c7 mov %eax,%edi
1dc2: 48 b8 2d 1c 00 00 00 movabs $0x1c2d,%rax
1dc9: 00 00 00
1dcc: ff d0 callq *%rax
1dce: 48 89 45 f8 mov %rax,-0x8(%rbp)
1dd2: 48 83 7d f8 00 cmpq $0x0,-0x8(%rbp)
1dd7: 75 07 jne 1de0 <malloc+0x134>
return 0;
1dd9: b8 00 00 00 00 mov $0x0,%eax
1dde: eb 18 jmp 1df8 <malloc+0x14c>
for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
1de0: 48 8b 45 f8 mov -0x8(%rbp),%rax
1de4: 48 89 45 f0 mov %rax,-0x10(%rbp)
1de8: 48 8b 45 f8 mov -0x8(%rbp),%rax
1dec: 48 8b 00 mov (%rax),%rax
1def: 48 89 45 f8 mov %rax,-0x8(%rbp)
if(p->s.size >= nunits){
1df3: e9 41 ff ff ff jmpq 1d39 <malloc+0x8d>
}
}
1df8: c9 leaveq
1df9: c3 retq
0000000000001dfa <co_new>:
// you need to call swtch() from co_yield() and co_run()
extern void swtch(struct co_context ** pp_old, struct co_context * p_new);
struct coroutine *
co_new(void (*func)(void))
{
1dfa: f3 0f 1e fa endbr64
1dfe: 55 push %rbp
1dff: 48 89 e5 mov %rsp,%rbp
1e02: 48 83 ec 30 sub $0x30,%rsp
1e06: 48 89 7d d8 mov %rdi,-0x28(%rbp)
struct coroutine * co1 = malloc(sizeof(*co1));
1e0a: bf 18 00 00 00 mov $0x18,%edi
1e0f: 48 b8 ac 1c 00 00 00 movabs $0x1cac,%rax
1e16: 00 00 00
1e19: ff d0 callq *%rax
1e1b: 48 89 45 f0 mov %rax,-0x10(%rbp)
if (co1 == 0)
1e1f: 48 83 7d f0 00 cmpq $0x0,-0x10(%rbp)
1e24: 75 0a jne 1e30 <co_new+0x36>
return 0;
1e26: b8 00 00 00 00 mov $0x0,%eax
1e2b: e9 e1 00 00 00 jmpq 1f11 <co_new+0x117>
// prepare the context
co1->stack = malloc(8192);
1e30: bf 00 20 00 00 mov $0x2000,%edi
1e35: 48 b8 ac 1c 00 00 00 movabs $0x1cac,%rax
1e3c: 00 00 00
1e3f: ff d0 callq *%rax
1e41: 48 8b 55 f0 mov -0x10(%rbp),%rdx
1e45: 48 89 42 10 mov %rax,0x10(%rdx)
if (co1->stack == 0) {
1e49: 48 8b 45 f0 mov -0x10(%rbp),%rax
1e4d: 48 8b 40 10 mov 0x10(%rax),%rax
1e51: 48 85 c0 test %rax,%rax
1e54: 75 1d jne 1e73 <co_new+0x79>
free(co1);
1e56: 48 8b 45 f0 mov -0x10(%rbp),%rax
1e5a: 48 89 c7 mov %rax,%rdi
1e5d: 48 b8 f7 1a 00 00 00 movabs $0x1af7,%rax
1e64: 00 00 00
1e67: ff d0 callq *%rax
return 0;
1e69: b8 00 00 00 00 mov $0x0,%eax
1e6e: e9 9e 00 00 00 jmpq 1f11 <co_new+0x117>
}
u64 * ptr = co1->stack + 1000;
1e73: 48 8b 45 f0 mov -0x10(%rbp),%rax
1e77: 48 8b 40 10 mov 0x10(%rax),%rax
1e7b: 48 05 e8 03 00 00 add $0x3e8,%rax
1e81: 48 89 45 e8 mov %rax,-0x18(%rbp)
ptr[6] = (u64)func;
1e85: 48 8b 45 e8 mov -0x18(%rbp),%rax
1e89: 48 8d 50 30 lea 0x30(%rax),%rdx
1e8d: 48 8b 45 d8 mov -0x28(%rbp),%rax
1e91: 48 89 02 mov %rax,(%rdx)
ptr[7] = (u64)co_exit;
1e94: 48 8b 45 e8 mov -0x18(%rbp),%rax
1e98: 48 83 c0 38 add $0x38,%rax
1e9c: 48 ba 83 20 00 00 00 movabs $0x2083,%rdx
1ea3: 00 00 00
1ea6: 48 89 10 mov %rdx,(%rax)
co1->context = (void*) ptr;
1ea9: 48 8b 45 f0 mov -0x10(%rbp),%rax
1ead: 48 8b 55 e8 mov -0x18(%rbp),%rdx
1eb1: 48 89 10 mov %rdx,(%rax)
if(co_list == 0)
1eb4: 48 b8 68 26 00 00 00 movabs $0x2668,%rax
1ebb: 00 00 00
1ebe: 48 8b 00 mov (%rax),%rax
1ec1: 48 85 c0 test %rax,%rax
1ec4: 75 13 jne 1ed9 <co_new+0xdf>
{
co_list = co1;
1ec6: 48 ba 68 26 00 00 00 movabs $0x2668,%rdx
1ecd: 00 00 00
1ed0: 48 8b 45 f0 mov -0x10(%rbp),%rax
1ed4: 48 89 02 mov %rax,(%rdx)
1ed7: eb 34 jmp 1f0d <co_new+0x113>
}else{
struct coroutine * head = co_list;
1ed9: 48 b8 68 26 00 00 00 movabs $0x2668,%rax
1ee0: 00 00 00
1ee3: 48 8b 00 mov (%rax),%rax
1ee6: 48 89 45 f8 mov %rax,-0x8(%rbp)
while(head->next != 0)
1eea: eb 0c jmp 1ef8 <co_new+0xfe>
{
head = head->next;
1eec: 48 8b 45 f8 mov -0x8(%rbp),%rax
1ef0: 48 8b 40 08 mov 0x8(%rax),%rax
1ef4: 48 89 45 f8 mov %rax,-0x8(%rbp)
while(head->next != 0)
1ef8: 48 8b 45 f8 mov -0x8(%rbp),%rax
1efc: 48 8b 40 08 mov 0x8(%rax),%rax
1f00: 48 85 c0 test %rax,%rax
1f03: 75 e7 jne 1eec <co_new+0xf2>
}
head = co1;
1f05: 48 8b 45 f0 mov -0x10(%rbp),%rax
1f09: 48 89 45 f8 mov %rax,-0x8(%rbp)
}
// done
return co1;
1f0d: 48 8b 45 f0 mov -0x10(%rbp),%rax
}
1f11: c9 leaveq
1f12: c3 retq
0000000000001f13 <co_run>:
int
co_run(void)
{
1f13: f3 0f 1e fa endbr64
1f17: 55 push %rbp
1f18: 48 89 e5 mov %rsp,%rbp
if(co_list != 0)
1f1b: 48 b8 68 26 00 00 00 movabs $0x2668,%rax
1f22: 00 00 00
1f25: 48 8b 00 mov (%rax),%rax
1f28: 48 85 c0 test %rax,%rax
1f2b: 74 4a je 1f77 <co_run+0x64>
{
co_current = co_list;
1f2d: 48 b8 68 26 00 00 00 movabs $0x2668,%rax
1f34: 00 00 00
1f37: 48 8b 00 mov (%rax),%rax
1f3a: 48 ba 60 26 00 00 00 movabs $0x2660,%rdx
1f41: 00 00 00
1f44: 48 89 02 mov %rax,(%rdx)
swtch(&host_context,co_current->context);
1f47: 48 b8 60 26 00 00 00 movabs $0x2660,%rax
1f4e: 00 00 00
1f51: 48 8b 00 mov (%rax),%rax
1f54: 48 8b 00 mov (%rax),%rax
1f57: 48 89 c6 mov %rax,%rsi
1f5a: 48 bf 58 26 00 00 00 movabs $0x2658,%rdi
1f61: 00 00 00
1f64: 48 b8 e5 21 00 00 00 movabs $0x21e5,%rax
1f6b: 00 00 00
1f6e: ff d0 callq *%rax
return 1;
1f70: b8 01 00 00 00 mov $0x1,%eax
1f75: eb 05 jmp 1f7c <co_run+0x69>
}
return 0;
1f77: b8 00 00 00 00 mov $0x0,%eax
}
1f7c: 5d pop %rbp
1f7d: c3 retq
0000000000001f7e <co_run_all>:
int
co_run_all(void)
{
1f7e: f3 0f 1e fa endbr64
1f82: 55 push %rbp
1f83: 48 89 e5 mov %rsp,%rbp
1f86: 48 83 ec 10 sub $0x10,%rsp
if(co_list == 0){
1f8a: 48 b8 68 26 00 00 00 movabs $0x2668,%rax
1f91: 00 00 00
1f94: 48 8b 00 mov (%rax),%rax
1f97: 48 85 c0 test %rax,%rax
1f9a: 75 07 jne 1fa3 <co_run_all+0x25>
return 0;
1f9c: b8 00 00 00 00 mov $0x0,%eax
1fa1: eb 37 jmp 1fda <co_run_all+0x5c>
}else{
struct coroutine * tmp = co_list;
1fa3: 48 b8 68 26 00 00 00 movabs $0x2668,%rax
1faa: 00 00 00
1fad: 48 8b 00 mov (%rax),%rax
1fb0: 48 89 45 f8 mov %rax,-0x8(%rbp)
while(tmp != 0){
1fb4: eb 18 jmp 1fce <co_run_all+0x50>
co_run();
1fb6: 48 b8 13 1f 00 00 00 movabs $0x1f13,%rax
1fbd: 00 00 00
1fc0: ff d0 callq *%rax
tmp = tmp->next;
1fc2: 48 8b 45 f8 mov -0x8(%rbp),%rax
1fc6: 48 8b 40 08 mov 0x8(%rax),%rax
1fca: 48 89 45 f8 mov %rax,-0x8(%rbp)
while(tmp != 0){
1fce: 48 83 7d f8 00 cmpq $0x0,-0x8(%rbp)
1fd3: 75 e1 jne 1fb6 <co_run_all+0x38>
}
return 1;
1fd5: b8 01 00 00 00 mov $0x1,%eax
}
}
1fda: c9 leaveq
1fdb: c3 retq
0000000000001fdc <co_yield>:
void
co_yield()
{
1fdc: f3 0f 1e fa endbr64
1fe0: 55 push %rbp
1fe1: 48 89 e5 mov %rsp,%rbp
1fe4: 48 83 ec 10 sub $0x10,%rsp
// TODO: your code here
// it must be safe to call co_yield() from a host context (or any non-coroutine)
struct coroutine * tmp = co_current;
1fe8: 48 b8 60 26 00 00 00 movabs $0x2660,%rax
1fef: 00 00 00
1ff2: 48 8b 00 mov (%rax),%rax
1ff5: 48 89 45 f8 mov %rax,-0x8(%rbp)
if(tmp->next != 0)
1ff9: 48 8b 45 f8 mov -0x8(%rbp),%rax
1ffd: 48 8b 40 08 mov 0x8(%rax),%rax
2001: 48 85 c0 test %rax,%rax
2004: 74 46 je 204c <co_yield+0x70>
{
co_current = co_current->next;
2006: 48 b8 60 26 00 00 00 movabs $0x2660,%rax
200d: 00 00 00
2010: 48 8b 00 mov (%rax),%rax
2013: 48 8b 40 08 mov 0x8(%rax),%rax
2017: 48 ba 60 26 00 00 00 movabs $0x2660,%rdx
201e: 00 00 00
2021: 48 89 02 mov %rax,(%rdx)
swtch(&tmp->context,co_current->context);
2024: 48 b8 60 26 00 00 00 movabs $0x2660,%rax
202b: 00 00 00
202e: 48 8b 00 mov (%rax),%rax
2031: 48 8b 10 mov (%rax),%rdx
2034: 48 8b 45 f8 mov -0x8(%rbp),%rax
2038: 48 89 d6 mov %rdx,%rsi
203b: 48 89 c7 mov %rax,%rdi
203e: 48 b8 e5 21 00 00 00 movabs $0x21e5,%rax
2045: 00 00 00
2048: ff d0 callq *%rax
}else{
co_current = 0;
swtch(&tmp->context,host_context);
}
}
204a: eb 34 jmp 2080 <co_yield+0xa4>
co_current = 0;
204c: 48 b8 60 26 00 00 00 movabs $0x2660,%rax
2053: 00 00 00
2056: 48 c7 00 00 00 00 00 movq $0x0,(%rax)
swtch(&tmp->context,host_context);
205d: 48 b8 58 26 00 00 00 movabs $0x2658,%rax
2064: 00 00 00
2067: 48 8b 10 mov (%rax),%rdx
206a: 48 8b 45 f8 mov -0x8(%rbp),%rax
206e: 48 89 d6 mov %rdx,%rsi
2071: 48 89 c7 mov %rax,%rdi
2074: 48 b8 e5 21 00 00 00 movabs $0x21e5,%rax
207b: 00 00 00
207e: ff d0 callq *%rax
}
2080: 90 nop
2081: c9 leaveq
2082: c3 retq
0000000000002083 <co_exit>:
void
co_exit(void)
{
2083: f3 0f 1e fa endbr64
2087: 55 push %rbp
2088: 48 89 e5 mov %rsp,%rbp
208b: 48 83 ec 10 sub $0x10,%rsp
// TODO: your code here
// it makes no sense to co_exit from non-coroutine.
if(!co_current)
208f: 48 b8 60 26 00 00 00 movabs $0x2660,%rax
2096: 00 00 00
2099: 48 8b 00 mov (%rax),%rax
209c: 48 85 c0 test %rax,%rax
209f: 0f 84 ec 00 00 00 je 2191 <co_exit+0x10e>
return;
struct coroutine *tmp = co_list;
20a5: 48 b8 68 26 00 00 00 movabs $0x2668,%rax
20ac: 00 00 00
20af: 48 8b 00 mov (%rax),%rax
20b2: 48 89 45 f8 mov %rax,-0x8(%rbp)
struct coroutine *prev;
while(tmp){
20b6: e9 c9 00 00 00 jmpq 2184 <co_exit+0x101>
if(tmp == co_current)
20bb: 48 b8 60 26 00 00 00 movabs $0x2660,%rax
20c2: 00 00 00
20c5: 48 8b 00 mov (%rax),%rax
20c8: 48 39 45 f8 cmp %rax,-0x8(%rbp)
20cc: 0f 85 9e 00 00 00 jne 2170 <co_exit+0xed>
{
if(tmp->next)
20d2: 48 8b 45 f8 mov -0x8(%rbp),%rax
20d6: 48 8b 40 08 mov 0x8(%rax),%rax
20da: 48 85 c0 test %rax,%rax
20dd: 74 54 je 2133 <co_exit+0xb0>
{
if(prev)
20df: 48 83 7d f0 00 cmpq $0x0,-0x10(%rbp)
20e4: 74 10 je 20f6 <co_exit+0x73>
{
prev->next = tmp->next;
20e6: 48 8b 45 f8 mov -0x8(%rbp),%rax
20ea: 48 8b 50 08 mov 0x8(%rax),%rdx
20ee: 48 8b 45 f0 mov -0x10(%rbp),%rax
20f2: 48 89 50 08 mov %rdx,0x8(%rax)
}
co_list = tmp->next;
20f6: 48 8b 45 f8 mov -0x8(%rbp),%rax
20fa: 48 8b 40 08 mov 0x8(%rax),%rax
20fe: 48 ba 68 26 00 00 00 movabs $0x2668,%rdx
2105: 00 00 00
2108: 48 89 02 mov %rax,(%rdx)
swtch(&co_current->context,tmp->context);
210b: 48 8b 45 f8 mov -0x8(%rbp),%rax
210f: 48 8b 00 mov (%rax),%rax
2112: 48 ba 60 26 00 00 00 movabs $0x2660,%rdx
2119: 00 00 00
211c: 48 8b 12 mov (%rdx),%rdx
211f: 48 89 c6 mov %rax,%rsi
2122: 48 89 d7 mov %rdx,%rdi
2125: 48 b8 e5 21 00 00 00 movabs $0x21e5,%rax
212c: 00 00 00
212f: ff d0 callq *%rax
2131: eb 3d jmp 2170 <co_exit+0xed>
}else{
co_list = 0;
2133: 48 b8 68 26 00 00 00 movabs $0x2668,%rax
213a: 00 00 00
213d: 48 c7 00 00 00 00 00 movq $0x0,(%rax)
swtch(&co_current->context,host_context);
2144: 48 b8 58 26 00 00 00 movabs $0x2658,%rax
214b: 00 00 00
214e: 48 8b 00 mov (%rax),%rax
2151: 48 ba 60 26 00 00 00 movabs $0x2660,%rdx
2158: 00 00 00
215b: 48 8b 12 mov (%rdx),%rdx
215e: 48 89 c6 mov %rax,%rsi
2161: 48 89 d7 mov %rdx,%rdi
2164: 48 b8 e5 21 00 00 00 movabs $0x21e5,%rax
216b: 00 00 00
216e: ff d0 callq *%rax
}
}
prev = tmp;
2170: 48 8b 45 f8 mov -0x8(%rbp),%rax
2174: 48 89 45 f0 mov %rax,-0x10(%rbp)
tmp = tmp->next;
2178: 48 8b 45 f8 mov -0x8(%rbp),%rax
217c: 48 8b 40 08 mov 0x8(%rax),%rax
2180: 48 89 45 f8 mov %rax,-0x8(%rbp)
while(tmp){
2184: 48 83 7d f8 00 cmpq $0x0,-0x8(%rbp)
2189: 0f 85 2c ff ff ff jne 20bb <co_exit+0x38>
218f: eb 01 jmp 2192 <co_exit+0x10f>
return;
2191: 90 nop
}
}
2192: c9 leaveq
2193: c3 retq
0000000000002194 <co_destroy>:
void
co_destroy(struct coroutine * const co)
{
2194: f3 0f 1e fa endbr64
2198: 55 push %rbp
2199: 48 89 e5 mov %rsp,%rbp
219c: 48 83 ec 10 sub $0x10,%rsp
21a0: 48 89 7d f8 mov %rdi,-0x8(%rbp)
if (co) {
21a4: 48 83 7d f8 00 cmpq $0x0,-0x8(%rbp)
21a9: 74 37 je 21e2 <co_destroy+0x4e>
if (co->stack)
21ab: 48 8b 45 f8 mov -0x8(%rbp),%rax
21af: 48 8b 40 10 mov 0x10(%rax),%rax
21b3: 48 85 c0 test %rax,%rax
21b6: 74 17 je 21cf <co_destroy+0x3b>
free(co->stack);
21b8: 48 8b 45 f8 mov -0x8(%rbp),%rax
21bc: 48 8b 40 10 mov 0x10(%rax),%rax
21c0: 48 89 c7 mov %rax,%rdi
21c3: 48 b8 f7 1a 00 00 00 movabs $0x1af7,%rax
21ca: 00 00 00
21cd: ff d0 callq *%rax
free(co);
21cf: 48 8b 45 f8 mov -0x8(%rbp),%rax
21d3: 48 89 c7 mov %rax,%rdi
21d6: 48 b8 f7 1a 00 00 00 movabs $0x1af7,%rax
21dd: 00 00 00
21e0: ff d0 callq *%rax
}
}
21e2: 90 nop
21e3: c9 leaveq
21e4: c3 retq
00000000000021e5 <swtch>:
# and then load register context from new.
.global swtch
swtch:
# Save old callee-save registers
pushq %rbp
21e5: 55 push %rbp
pushq %rbx
21e6: 53 push %rbx
pushq %r12
21e7: 41 54 push %r12
pushq %r13
21e9: 41 55 push %r13
pushq %r14
21eb: 41 56 push %r14
pushq %r15
21ed: 41 57 push %r15
# Switch stacks
movq %rsp, (%rdi)
21ef: 48 89 27 mov %rsp,(%rdi)
movq %rsi, %rsp
21f2: 48 89 f4 mov %rsi,%rsp
# Load new callee-save registers
popq %r15
21f5: 41 5f pop %r15
popq %r14
21f7: 41 5e pop %r14
popq %r13
21f9: 41 5d pop %r13
popq %r12
21fb: 41 5c pop %r12
popq %rbx
21fd: 5b pop %rbx
popq %rbp
21fe: 5d pop %rbp
retq #??
21ff: c3 retq
|
; A260683: Number of 2's in the expansion of 2^n in base 3.
; Submitted by Jamie Morken(s4)
; 0,1,0,2,1,1,1,2,0,4,2,4,3,3,2,6,5,5,3,7,4,7,5,4,1,5,2,8,8,7,9,9,8,7,7,8,4,6,8,9,11,11,7,11,10,8,9,8,8,10,11,16,13,10,9,12,13,16,12,13,15,15,11,15,16,14,14,12,14,15,14,16,11,18,11,17,10,23,15,27,19,22,21,17,23,25,20,25,16,25,22,18,23,23,21,26,20,25,24,26
seq $0,79 ; Powers of 2: a(n) = 2^n.
seq $0,81603 ; Number of 2's in ternary representation of n.
|
/home/weihuan/Documents/testsuits-for-oskernel-preliminary/riscv-syscalls-testing/user/build/riscv64/fork: file format elf64-littleriscv
Disassembly of section .text:
0000000000001000 <_start>:
.section .text.entry
.globl _start
_start:
mv a0, sp
1000: 850a mv a0,sp
tail __start_main
1002: a05d j 10a8 <__start_main>
0000000000001004 <test_fork>:
* 成功测试时子进程的输出：
* " child process."
*/
static int fd[2];
void test_fork(void){
1004: 1101 addi sp,sp,-32
TEST_START(__func__);
1006: 00001517 auipc a0,0x1
100a: ee250513 addi a0,a0,-286 # 1ee8 <__clone+0x2e>
void test_fork(void){
100e: ec06 sd ra,24(sp)
TEST_START(__func__);
1010: 30a000ef jal ra,131a <puts>
1014: 00001517 auipc a0,0x1
1018: f8450513 addi a0,a0,-124 # 1f98 <__func__.0>
101c: 2fe000ef jal ra,131a <puts>
1020: 00001517 auipc a0,0x1
1024: ee050513 addi a0,a0,-288 # 1f00 <__clone+0x46>
1028: 2f2000ef jal ra,131a <puts>
int cpid, wstatus;
cpid = fork();
102c: 485000ef jal ra,1cb0 <fork>
assert(cpid != -1);
1030: 57fd li a5,-1
1032: 04f50363 beq a0,a5,1078 <test_fork+0x74>
if(cpid > 0){
1036: 04a05763 blez a0,1084 <test_fork+0x80>
wait(&wstatus);
103a: 0068 addi a0,sp,12
103c: 55b000ef jal ra,1d96 <wait>
printf(" parent process. wstatus:%d\n", wstatus);
1040: 45b2 lw a1,12(sp)
1042: 00001517 auipc a0,0x1
1046: eee50513 addi a0,a0,-274 # 1f30 <__clone+0x76>
104a: 2f2000ef jal ra,133c <printf>
}else{
printf(" child process.\n");
exit(0);
}
TEST_END(__func__);
104e: 00001517 auipc a0,0x1
1052: f1a50513 addi a0,a0,-230 # 1f68 <__clone+0xae>
1056: 2c4000ef jal ra,131a <puts>
105a: 00001517 auipc a0,0x1
105e: f3e50513 addi a0,a0,-194 # 1f98 <__func__.0>
1062: 2b8000ef jal ra,131a <puts>
1066: 00001517 auipc a0,0x1
106a: e9a50513 addi a0,a0,-358 # 1f00 <__clone+0x46>
106e: 2ac000ef jal ra,131a <puts>
}
1072: 60e2 ld ra,24(sp)
1074: 6105 addi sp,sp,32
1076: 8082 ret
assert(cpid != -1);
1078: 00001517 auipc a0,0x1
107c: e9850513 addi a0,a0,-360 # 1f10 <__clone+0x56>
1080: 540000ef jal ra,15c0 <panic>
printf(" child process.\n");
1084: 00001517 auipc a0,0x1
1088: ecc50513 addi a0,a0,-308 # 1f50 <__clone+0x96>
108c: 2b0000ef jal ra,133c <printf>
exit(0);
1090: 4501 li a0,0
1092: 441000ef jal ra,1cd2 <exit>
1096: bf65 j 104e <test_fork+0x4a>
0000000000001098 <main>:
int main(void){
1098: 1141 addi sp,sp,-16
109a: e406 sd ra,8(sp)
test_fork();
109c: f69ff0ef jal ra,1004 <test_fork>
return 0;
}
10a0: 60a2 ld ra,8(sp)
10a2: 4501 li a0,0
10a4: 0141 addi sp,sp,16
10a6: 8082 ret
00000000000010a8 <__start_main>:
#include <unistd.h>
extern int main();
int __start_main(long *p)
{
10a8: 85aa mv a1,a0
int argc = p[0];
char **argv = (void *)(p+1);
exit(main(argc, argv));
10aa: 4108 lw a0,0(a0)
{
10ac: 1141 addi sp,sp,-16
exit(main(argc, argv));
10ae: 05a1 addi a1,a1,8
{
10b0: e406 sd ra,8(sp)
exit(main(argc, argv));
10b2: fe7ff0ef jal ra,1098 <main>
10b6: 41d000ef jal ra,1cd2 <exit>
return 0;
}
10ba: 60a2 ld ra,8(sp)
10bc: 4501 li a0,0
10be: 0141 addi sp,sp,16
10c0: 8082 ret
00000000000010c2 <printint.constprop.0>:
write(f, s, l);
}
static char digits[] = "0123456789abcdef";
static void printint(int xx, int base, int sign)
10c2: 7179 addi sp,sp,-48
10c4: f406 sd ra,40(sp)
{
char buf[16 + 1];
int i;
uint x;
if (sign && (sign = xx < 0))
10c6: 12054b63 bltz a0,11fc <printint.constprop.0+0x13a>
buf[16] = 0;
i = 15;
do
{
buf[i--] = digits[x % base];
10ca: 02b577bb remuw a5,a0,a1
10ce: 00001617 auipc a2,0x1
10d2: eda60613 addi a2,a2,-294 # 1fa8 <digits>
buf[16] = 0;
10d6: 00010c23 sb zero,24(sp)
buf[i--] = digits[x % base];
10da: 0005871b sext.w a4,a1
10de: 1782 slli a5,a5,0x20
10e0: 9381 srli a5,a5,0x20
10e2: 97b2 add a5,a5,a2
10e4: 0007c783 lbu a5,0(a5)
} while ((x /= base) != 0);
10e8: 02b5583b divuw a6,a0,a1
buf[i--] = digits[x % base];
10ec: 00f10ba3 sb a5,23(sp)
} while ((x /= base) != 0);
10f0: 1cb56363 bltu a0,a1,12b6 <printint.constprop.0+0x1f4>
buf[i--] = digits[x % base];
10f4: 45b9 li a1,14
10f6: 02e877bb remuw a5,a6,a4
10fa: 1782 slli a5,a5,0x20
10fc: 9381 srli a5,a5,0x20
10fe: 97b2 add a5,a5,a2
1100: 0007c783 lbu a5,0(a5)
} while ((x /= base) != 0);
1104: 02e856bb divuw a3,a6,a4
buf[i--] = digits[x % base];
1108: 00f10b23 sb a5,22(sp)
} while ((x /= base) != 0);
110c: 0ce86e63 bltu a6,a4,11e8 <printint.constprop.0+0x126>
buf[i--] = digits[x % base];
1110: 02e6f5bb remuw a1,a3,a4
} while ((x /= base) != 0);
1114: 02e6d7bb divuw a5,a3,a4
buf[i--] = digits[x % base];
1118: 1582 slli a1,a1,0x20
111a: 9181 srli a1,a1,0x20
111c: 95b2 add a1,a1,a2
111e: 0005c583 lbu a1,0(a1)
1122: 00b10aa3 sb a1,21(sp)
} while ((x /= base) != 0);
1126: 0007859b sext.w a1,a5
112a: 12e6ec63 bltu a3,a4,1262 <printint.constprop.0+0x1a0>
buf[i--] = digits[x % base];
112e: 02e7f6bb remuw a3,a5,a4
1132: 1682 slli a3,a3,0x20
1134: 9281 srli a3,a3,0x20
1136: 96b2 add a3,a3,a2
1138: 0006c683 lbu a3,0(a3)
} while ((x /= base) != 0);
113c: 02e7d83b divuw a6,a5,a4
buf[i--] = digits[x % base];
1140: 00d10a23 sb a3,20(sp)
} while ((x /= base) != 0);
1144: 12e5e863 bltu a1,a4,1274 <printint.constprop.0+0x1b2>
buf[i--] = digits[x % base];
1148: 02e876bb remuw a3,a6,a4
114c: 1682 slli a3,a3,0x20
114e: 9281 srli a3,a3,0x20
1150: 96b2 add a3,a3,a2
1152: 0006c683 lbu a3,0(a3)
} while ((x /= base) != 0);
1156: 02e855bb divuw a1,a6,a4
buf[i--] = digits[x % base];
115a: 00d109a3 sb a3,19(sp)
} while ((x /= base) != 0);
115e: 12e86463 bltu a6,a4,1286 <printint.constprop.0+0x1c4>
buf[i--] = digits[x % base];
1162: 02e5f6bb remuw a3,a1,a4
1166: 1682 slli a3,a3,0x20
1168: 9281 srli a3,a3,0x20
116a: 96b2 add a3,a3,a2
116c: 0006c683 lbu a3,0(a3)
} while ((x /= base) != 0);
1170: 02e5d83b divuw a6,a1,a4
buf[i--] = digits[x % base];
1174: 00d10923 sb a3,18(sp)
} while ((x /= base) != 0);
1178: 0ce5ec63 bltu a1,a4,1250 <printint.constprop.0+0x18e>
buf[i--] = digits[x % base];
117c: 02e876bb remuw a3,a6,a4
1180: 1682 slli a3,a3,0x20
1182: 9281 srli a3,a3,0x20
1184: 96b2 add a3,a3,a2
1186: 0006c683 lbu a3,0(a3)
} while ((x /= base) != 0);
118a: 02e855bb divuw a1,a6,a4
buf[i--] = digits[x % base];
118e: 00d108a3 sb a3,17(sp)
} while ((x /= base) != 0);
1192: 10e86963 bltu a6,a4,12a4 <printint.constprop.0+0x1e2>
buf[i--] = digits[x % base];
1196: 02e5f6bb remuw a3,a1,a4
119a: 1682 slli a3,a3,0x20
119c: 9281 srli a3,a3,0x20
119e: 96b2 add a3,a3,a2
11a0: 0006c683 lbu a3,0(a3)
} while ((x /= base) != 0);
11a4: 02e5d83b divuw a6,a1,a4
buf[i--] = digits[x % base];
11a8: 00d10823 sb a3,16(sp)
} while ((x /= base) != 0);
11ac: 10e5e763 bltu a1,a4,12ba <printint.constprop.0+0x1f8>
buf[i--] = digits[x % base];
11b0: 02e876bb remuw a3,a6,a4
11b4: 1682 slli a3,a3,0x20
11b6: 9281 srli a3,a3,0x20
11b8: 96b2 add a3,a3,a2
11ba: 0006c683 lbu a3,0(a3)
} while ((x /= base) != 0);
11be: 02e857bb divuw a5,a6,a4
buf[i--] = digits[x % base];
11c2: 00d107a3 sb a3,15(sp)
} while ((x /= base) != 0);
11c6: 10e86363 bltu a6,a4,12cc <printint.constprop.0+0x20a>
buf[i--] = digits[x % base];
11ca: 1782 slli a5,a5,0x20
11cc: 9381 srli a5,a5,0x20
11ce: 97b2 add a5,a5,a2
11d0: 0007c783 lbu a5,0(a5)
11d4: 4599 li a1,6
11d6: 00f10723 sb a5,14(sp)
if (sign)
11da: 00055763 bgez a0,11e8 <printint.constprop.0+0x126>
buf[i--] = '-';
11de: 02d00793 li a5,45
11e2: 00f106a3 sb a5,13(sp)
buf[i--] = digits[x % base];
11e6: 4595 li a1,5
write(f, s, l);
11e8: 003c addi a5,sp,8
11ea: 4641 li a2,16
11ec: 9e0d subw a2,a2,a1
11ee: 4505 li a0,1
11f0: 95be add a1,a1,a5
11f2: 291000ef jal ra,1c82 <write>
i++;
if (i < 0)
puts("printint error");
out(stdout, buf + i, 16 - i);
}
11f6: 70a2 ld ra,40(sp)
11f8: 6145 addi sp,sp,48
11fa: 8082 ret
x = -xx;
11fc: 40a0083b negw a6,a0
buf[i--] = digits[x % base];
1200: 02b877bb remuw a5,a6,a1
1204: 00001617 auipc a2,0x1
1208: da460613 addi a2,a2,-604 # 1fa8 <digits>
buf[16] = 0;
120c: 00010c23 sb zero,24(sp)
buf[i--] = digits[x % base];
1210: 0005871b sext.w a4,a1
1214: 1782 slli a5,a5,0x20
1216: 9381 srli a5,a5,0x20
1218: 97b2 add a5,a5,a2
121a: 0007c783 lbu a5,0(a5)
} while ((x /= base) != 0);
121e: 02b858bb divuw a7,a6,a1
buf[i--] = digits[x % base];
1222: 00f10ba3 sb a5,23(sp)
} while ((x /= base) != 0);
1226: 06b86963 bltu a6,a1,1298 <printint.constprop.0+0x1d6>
buf[i--] = digits[x % base];
122a: 02e8f7bb remuw a5,a7,a4
122e: 1782 slli a5,a5,0x20
1230: 9381 srli a5,a5,0x20
1232: 97b2 add a5,a5,a2
1234: 0007c783 lbu a5,0(a5)
} while ((x /= base) != 0);
1238: 02e8d6bb divuw a3,a7,a4
buf[i--] = digits[x % base];
123c: 00f10b23 sb a5,22(sp)
} while ((x /= base) != 0);
1240: ece8f8e3 bgeu a7,a4,1110 <printint.constprop.0+0x4e>
buf[i--] = '-';
1244: 02d00793 li a5,45
1248: 00f10aa3 sb a5,21(sp)
buf[i--] = digits[x % base];
124c: 45b5 li a1,13
124e: bf69 j 11e8 <printint.constprop.0+0x126>
1250: 45a9 li a1,10
if (sign)
1252: f8055be3 bgez a0,11e8 <printint.constprop.0+0x126>
buf[i--] = '-';
1256: 02d00793 li a5,45
125a: 00f108a3 sb a5,17(sp)
buf[i--] = digits[x % base];
125e: 45a5 li a1,9
1260: b761 j 11e8 <printint.constprop.0+0x126>
1262: 45b5 li a1,13
if (sign)
1264: f80552e3 bgez a0,11e8 <printint.constprop.0+0x126>
buf[i--] = '-';
1268: 02d00793 li a5,45
126c: 00f10a23 sb a5,20(sp)
buf[i--] = digits[x % base];
1270: 45b1 li a1,12
1272: bf9d j 11e8 <printint.constprop.0+0x126>
1274: 45b1 li a1,12
if (sign)
1276: f60559e3 bgez a0,11e8 <printint.constprop.0+0x126>
buf[i--] = '-';
127a: 02d00793 li a5,45
127e: 00f109a3 sb a5,19(sp)
buf[i--] = digits[x % base];
1282: 45ad li a1,11
1284: b795 j 11e8 <printint.constprop.0+0x126>
1286: 45ad li a1,11
if (sign)
1288: f60550e3 bgez a0,11e8 <printint.constprop.0+0x126>
buf[i--] = '-';
128c: 02d00793 li a5,45
1290: 00f10923 sb a5,18(sp)
buf[i--] = digits[x % base];
1294: 45a9 li a1,10
1296: bf89 j 11e8 <printint.constprop.0+0x126>
buf[i--] = '-';
1298: 02d00793 li a5,45
129c: 00f10b23 sb a5,22(sp)
buf[i--] = digits[x % base];
12a0: 45b9 li a1,14
12a2: b799 j 11e8 <printint.constprop.0+0x126>
12a4: 45a5 li a1,9
if (sign)
12a6: f40551e3 bgez a0,11e8 <printint.constprop.0+0x126>
buf[i--] = '-';
12aa: 02d00793 li a5,45
12ae: 00f10823 sb a5,16(sp)
buf[i--] = digits[x % base];
12b2: 45a1 li a1,8
12b4: bf15 j 11e8 <printint.constprop.0+0x126>
i = 15;
12b6: 45bd li a1,15
12b8: bf05 j 11e8 <printint.constprop.0+0x126>
buf[i--] = digits[x % base];
12ba: 45a1 li a1,8
if (sign)
12bc: f20556e3 bgez a0,11e8 <printint.constprop.0+0x126>
buf[i--] = '-';
12c0: 02d00793 li a5,45
12c4: 00f107a3 sb a5,15(sp)
buf[i--] = digits[x % base];
12c8: 459d li a1,7
12ca: bf39 j 11e8 <printint.constprop.0+0x126>
12cc: 459d li a1,7
if (sign)
12ce: f0055de3 bgez a0,11e8 <printint.constprop.0+0x126>
buf[i--] = '-';
12d2: 02d00793 li a5,45
12d6: 00f10723 sb a5,14(sp)
buf[i--] = digits[x % base];
12da: 4599 li a1,6
12dc: b731 j 11e8 <printint.constprop.0+0x126>
00000000000012de <getchar>:
{
12de: 1101 addi sp,sp,-32
read(stdin, &byte, 1);
12e0: 00f10593 addi a1,sp,15
12e4: 4605 li a2,1
12e6: 4501 li a0,0
{
12e8: ec06 sd ra,24(sp)
char byte = 0;
12ea: 000107a3 sb zero,15(sp)
read(stdin, &byte, 1);
12ee: 18b000ef jal ra,1c78 <read>
}
12f2: 60e2 ld ra,24(sp)
12f4: 00f14503 lbu a0,15(sp)
12f8: 6105 addi sp,sp,32
12fa: 8082 ret
00000000000012fc <putchar>:
{
12fc: 1101 addi sp,sp,-32
12fe: 87aa mv a5,a0
return write(stdout, &byte, 1);
1300: 00f10593 addi a1,sp,15
1304: 4605 li a2,1
1306: 4505 li a0,1
{
1308: ec06 sd ra,24(sp)
char byte = c;
130a: 00f107a3 sb a5,15(sp)
return write(stdout, &byte, 1);
130e: 175000ef jal ra,1c82 <write>
}
1312: 60e2 ld ra,24(sp)
1314: 2501 sext.w a0,a0
1316: 6105 addi sp,sp,32
1318: 8082 ret
000000000000131a <puts>:
{
131a: 1141 addi sp,sp,-16
131c: e406 sd ra,8(sp)
131e: e022 sd s0,0(sp)
1320: 842a mv s0,a0
r = -(write(stdout, s, strlen(s)) < 0);
1322: 57c000ef jal ra,189e <strlen>
1326: 862a mv a2,a0
1328: 85a2 mv a1,s0
132a: 4505 li a0,1
132c: 157000ef jal ra,1c82 <write>
}
1330: 60a2 ld ra,8(sp)
1332: 6402 ld s0,0(sp)
r = -(write(stdout, s, strlen(s)) < 0);
1334: 957d srai a0,a0,0x3f
return r;
1336: 2501 sext.w a0,a0
}
1338: 0141 addi sp,sp,16
133a: 8082 ret
000000000000133c <printf>:
out(stdout, buf, i);
}
// Print to the console. only understands %d, %x, %p, %s.
void printf(const char *fmt, ...)
{
133c: 7171 addi sp,sp,-176
133e: fc56 sd s5,56(sp)
1340: ed3e sd a5,152(sp)
buf[i++] = '0';
1342: 7ae1 lui s5,0xffff8
va_list ap;
int cnt = 0, l = 0;
char *a, *z, *s = (char *)fmt, str;
int f = stdout;
va_start(ap, fmt);
1344: 18bc addi a5,sp,120
{
1346: e8ca sd s2,80(sp)
1348: e4ce sd s3,72(sp)
134a: e0d2 sd s4,64(sp)
134c: f85a sd s6,48(sp)
134e: f486 sd ra,104(sp)
1350: f0a2 sd s0,96(sp)
1352: eca6 sd s1,88(sp)
1354: fcae sd a1,120(sp)
1356: e132 sd a2,128(sp)
1358: e536 sd a3,136(sp)
135a: e93a sd a4,144(sp)
135c: f142 sd a6,160(sp)
135e: f546 sd a7,168(sp)
va_start(ap, fmt);
1360: e03e sd a5,0(sp)
for (;;)
{
if (!*s)
break;
for (a = s; *s && *s != '%'; s++)
1362: 02500913 li s2,37
out(f, a, l);
if (l)
continue;
if (s[1] == 0)
break;
switch (s[1])
1366: 07300a13 li s4,115
case 'p':
printptr(va_arg(ap, uint64));
break;
case 's':
if ((a = va_arg(ap, char *)) == 0)
a = "(null)";
136a: 00001b17 auipc s6,0x1
136e: c0eb0b13 addi s6,s6,-1010 # 1f78 <__clone+0xbe>
buf[i++] = '0';
1372: 830aca93 xori s5,s5,-2000
buf[i++] = digits[x >> (sizeof(uint64) * 8 - 4)];
1376: 00001997 auipc s3,0x1
137a: c3298993 addi s3,s3,-974 # 1fa8 <digits>
if (!*s)
137e: 00054783 lbu a5,0(a0)
1382: 16078a63 beqz a5,14f6 <printf+0x1ba>
1386: 862a mv a2,a0
for (a = s; *s && *s != '%'; s++)
1388: 19278163 beq a5,s2,150a <printf+0x1ce>
138c: 00164783 lbu a5,1(a2)
1390: 0605 addi a2,a2,1
1392: fbfd bnez a5,1388 <printf+0x4c>
1394: 84b2 mv s1,a2
l = z - a;
1396: 40a6043b subw s0,a2,a0
write(f, s, l);
139a: 85aa mv a1,a0
139c: 8622 mv a2,s0
139e: 4505 li a0,1
13a0: 0e3000ef jal ra,1c82 <write>
if (l)
13a4: 18041c63 bnez s0,153c <printf+0x200>
if (s[1] == 0)
13a8: 0014c783 lbu a5,1(s1)
13ac: 14078563 beqz a5,14f6 <printf+0x1ba>
switch (s[1])
13b0: 1d478063 beq a5,s4,1570 <printf+0x234>
13b4: 18fa6663 bltu s4,a5,1540 <printf+0x204>
13b8: 06400713 li a4,100
13bc: 1ae78063 beq a5,a4,155c <printf+0x220>
13c0: 07000713 li a4,112
13c4: 1ce79963 bne a5,a4,1596 <printf+0x25a>
printptr(va_arg(ap, uint64));
13c8: 6702 ld a4,0(sp)
buf[i++] = '0';
13ca: 01511423 sh s5,8(sp)
write(f, s, l);
13ce: 4649 li a2,18
printptr(va_arg(ap, uint64));
13d0: 631c ld a5,0(a4)
13d2: 0721 addi a4,a4,8
13d4: e03a sd a4,0(sp)
for (j = 0; j < (sizeof(uint64) * 2); j++, x <<= 4)
13d6: 00479293 slli t0,a5,0x4
13da: 00879f93 slli t6,a5,0x8
13de: 00c79f13 slli t5,a5,0xc
13e2: 01079e93 slli t4,a5,0x10
13e6: 01479e13 slli t3,a5,0x14
13ea: 01879313 slli t1,a5,0x18
13ee: 01c79893 slli a7,a5,0x1c
13f2: 02479813 slli a6,a5,0x24
13f6: 02879513 slli a0,a5,0x28
13fa: 02c79593 slli a1,a5,0x2c
13fe: 03079693 slli a3,a5,0x30
1402: 03479713 slli a4,a5,0x34
buf[i++] = digits[x >> (sizeof(uint64) * 8 - 4)];
1406: 03c7d413 srli s0,a5,0x3c
140a: 01c7d39b srliw t2,a5,0x1c
140e: 03c2d293 srli t0,t0,0x3c
1412: 03cfdf93 srli t6,t6,0x3c
1416: 03cf5f13 srli t5,t5,0x3c
141a: 03cede93 srli t4,t4,0x3c
141e: 03ce5e13 srli t3,t3,0x3c
1422: 03c35313 srli t1,t1,0x3c
1426: 03c8d893 srli a7,a7,0x3c
142a: 03c85813 srli a6,a6,0x3c
142e: 9171 srli a0,a0,0x3c
1430: 91f1 srli a1,a1,0x3c
1432: 92f1 srli a3,a3,0x3c
1434: 9371 srli a4,a4,0x3c
1436: 96ce add a3,a3,s3
1438: 974e add a4,a4,s3
143a: 944e add s0,s0,s3
143c: 92ce add t0,t0,s3
143e: 9fce add t6,t6,s3
1440: 9f4e add t5,t5,s3
1442: 9ece add t4,t4,s3
1444: 9e4e add t3,t3,s3
1446: 934e add t1,t1,s3
1448: 98ce add a7,a7,s3
144a: 93ce add t2,t2,s3
144c: 984e add a6,a6,s3
144e: 954e add a0,a0,s3
1450: 95ce add a1,a1,s3
1452: 0006c083 lbu ra,0(a3)
1456: 0002c283 lbu t0,0(t0)
145a: 00074683 lbu a3,0(a4)
145e: 000fcf83 lbu t6,0(t6)
1462: 000f4f03 lbu t5,0(t5)
1466: 000ece83 lbu t4,0(t4)
146a: 000e4e03 lbu t3,0(t3)
146e: 00034303 lbu t1,0(t1)
1472: 0008c883 lbu a7,0(a7)
1476: 0003c383 lbu t2,0(t2)
147a: 00084803 lbu a6,0(a6)
147e: 00054503 lbu a0,0(a0)
1482: 0005c583 lbu a1,0(a1)
1486: 00044403 lbu s0,0(s0)
for (j = 0; j < (sizeof(uint64) * 2); j++, x <<= 4)
148a: 03879713 slli a4,a5,0x38
buf[i++] = digits[x >> (sizeof(uint64) * 8 - 4)];
148e: 9371 srli a4,a4,0x3c
1490: 8bbd andi a5,a5,15
1492: 974e add a4,a4,s3
1494: 97ce add a5,a5,s3
1496: 005105a3 sb t0,11(sp)
149a: 01f10623 sb t6,12(sp)
149e: 01e106a3 sb t5,13(sp)
14a2: 01d10723 sb t4,14(sp)
14a6: 01c107a3 sb t3,15(sp)
14aa: 00610823 sb t1,16(sp)
14ae: 011108a3 sb a7,17(sp)
14b2: 00710923 sb t2,18(sp)
14b6: 010109a3 sb a6,19(sp)
14ba: 00a10a23 sb a0,20(sp)
14be: 00b10aa3 sb a1,21(sp)
14c2: 00110b23 sb ra,22(sp)
14c6: 00d10ba3 sb a3,23(sp)
14ca: 00810523 sb s0,10(sp)
14ce: 00074703 lbu a4,0(a4)
14d2: 0007c783 lbu a5,0(a5)
write(f, s, l);
14d6: 002c addi a1,sp,8
14d8: 4505 li a0,1
buf[i++] = digits[x >> (sizeof(uint64) * 8 - 4)];
14da: 00e10c23 sb a4,24(sp)
14de: 00f10ca3 sb a5,25(sp)
buf[i] = 0;
14e2: 00010d23 sb zero,26(sp)
write(f, s, l);
14e6: 79c000ef jal ra,1c82 <write>
// Print unknown % sequence to draw attention.
putchar('%');
putchar(s[1]);
break;
}
s += 2;
14ea: 00248513 addi a0,s1,2
if (!*s)
14ee: 00054783 lbu a5,0(a0)
14f2: e8079ae3 bnez a5,1386 <printf+0x4a>
}
va_end(ap);
}
14f6: 70a6 ld ra,104(sp)
14f8: 7406 ld s0,96(sp)
14fa: 64e6 ld s1,88(sp)
14fc: 6946 ld s2,80(sp)
14fe: 69a6 ld s3,72(sp)
1500: 6a06 ld s4,64(sp)
1502: 7ae2 ld s5,56(sp)
1504: 7b42 ld s6,48(sp)
1506: 614d addi sp,sp,176
1508: 8082 ret
for (z = s; s[0] == '%' && s[1] == '%'; z++, s += 2)
150a: 00064783 lbu a5,0(a2)
150e: 84b2 mv s1,a2
1510: 01278963 beq a5,s2,1522 <printf+0x1e6>
1514: b549 j 1396 <printf+0x5a>
1516: 0024c783 lbu a5,2(s1)
151a: 0605 addi a2,a2,1
151c: 0489 addi s1,s1,2
151e: e7279ce3 bne a5,s2,1396 <printf+0x5a>
1522: 0014c783 lbu a5,1(s1)
1526: ff2788e3 beq a5,s2,1516 <printf+0x1da>
l = z - a;
152a: 40a6043b subw s0,a2,a0
write(f, s, l);
152e: 85aa mv a1,a0
1530: 8622 mv a2,s0
1532: 4505 li a0,1
1534: 74e000ef jal ra,1c82 <write>
if (l)
1538: e60408e3 beqz s0,13a8 <printf+0x6c>
153c: 8526 mv a0,s1
153e: b581 j 137e <printf+0x42>
switch (s[1])
1540: 07800713 li a4,120
1544: 04e79963 bne a5,a4,1596 <printf+0x25a>
printint(va_arg(ap, int), 16, 1);
1548: 6782 ld a5,0(sp)
154a: 45c1 li a1,16
154c: 4388 lw a0,0(a5)
154e: 07a1 addi a5,a5,8
1550: e03e sd a5,0(sp)
1552: b71ff0ef jal ra,10c2 <printint.constprop.0>
s += 2;
1556: 00248513 addi a0,s1,2
155a: bf51 j 14ee <printf+0x1b2>
printint(va_arg(ap, int), 10, 1);
155c: 6782 ld a5,0(sp)
155e: 45a9 li a1,10
1560: 4388 lw a0,0(a5)
1562: 07a1 addi a5,a5,8
1564: e03e sd a5,0(sp)
1566: b5dff0ef jal ra,10c2 <printint.constprop.0>
s += 2;
156a: 00248513 addi a0,s1,2
156e: b741 j 14ee <printf+0x1b2>
if ((a = va_arg(ap, char *)) == 0)
1570: 6782 ld a5,0(sp)
1572: 6380 ld s0,0(a5)
1574: 07a1 addi a5,a5,8
1576: e03e sd a5,0(sp)
1578: c031 beqz s0,15bc <printf+0x280>
l = strnlen(a, 200);
157a: 0c800593 li a1,200
157e: 8522 mv a0,s0
1580: 40a000ef jal ra,198a <strnlen>
write(f, s, l);
1584: 0005061b sext.w a2,a0
1588: 85a2 mv a1,s0
158a: 4505 li a0,1
158c: 6f6000ef jal ra,1c82 <write>
s += 2;
1590: 00248513 addi a0,s1,2
1594: bfa9 j 14ee <printf+0x1b2>
return write(stdout, &byte, 1);
1596: 4605 li a2,1
1598: 002c addi a1,sp,8
159a: 4505 li a0,1
char byte = c;
159c: 01210423 sb s2,8(sp)
return write(stdout, &byte, 1);
15a0: 6e2000ef jal ra,1c82 <write>
char byte = c;
15a4: 0014c783 lbu a5,1(s1)
return write(stdout, &byte, 1);
15a8: 4605 li a2,1
15aa: 002c addi a1,sp,8
15ac: 4505 li a0,1
char byte = c;
15ae: 00f10423 sb a5,8(sp)
return write(stdout, &byte, 1);
15b2: 6d0000ef jal ra,1c82 <write>
s += 2;
15b6: 00248513 addi a0,s1,2
15ba: bf15 j 14ee <printf+0x1b2>
a = "(null)";
15bc: 845a mv s0,s6
15be: bf75 j 157a <printf+0x23e>
00000000000015c0 <panic>:
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
void panic(char *m)
{
15c0: 1141 addi sp,sp,-16
15c2: e406 sd ra,8(sp)
puts(m);
15c4: d57ff0ef jal ra,131a <puts>
exit(-100);
}
15c8: 60a2 ld ra,8(sp)
exit(-100);
15ca: f9c00513 li a0,-100
}
15ce: 0141 addi sp,sp,16
exit(-100);
15d0: a709 j 1cd2 <exit>
00000000000015d2 <isspace>:
#define HIGHS (ONES * (UCHAR_MAX / 2 + 1))
#define HASZERO(x) (((x)-ONES) & ~(x)&HIGHS)
int isspace(int c)
{
return c == ' ' || (unsigned)c - '\t' < 5;
15d2: 02000793 li a5,32
15d6: 00f50663 beq a0,a5,15e2 <isspace+0x10>
15da: 355d addiw a0,a0,-9
15dc: 00553513 sltiu a0,a0,5
15e0: 8082 ret
15e2: 4505 li a0,1
}
15e4: 8082 ret
00000000000015e6 <isdigit>:
int isdigit(int c)
{
return (unsigned)c - '0' < 10;
15e6: fd05051b addiw a0,a0,-48
}
15ea: 00a53513 sltiu a0,a0,10
15ee: 8082 ret
00000000000015f0 <atoi>:
return c == ' ' || (unsigned)c - '\t' < 5;
15f0: 02000613 li a2,32
15f4: 4591 li a1,4
int atoi(const char *s)
{
int n = 0, neg = 0;
while (isspace(*s))
15f6: 00054703 lbu a4,0(a0)
return c == ' ' || (unsigned)c - '\t' < 5;
15fa: ff77069b addiw a3,a4,-9
15fe: 04c70d63 beq a4,a2,1658 <atoi+0x68>
1602: 0007079b sext.w a5,a4
1606: 04d5f963 bgeu a1,a3,1658 <atoi+0x68>
s++;
switch (*s)
160a: 02b00693 li a3,43
160e: 04d70a63 beq a4,a3,1662 <atoi+0x72>
1612: 02d00693 li a3,45
1616: 06d70463 beq a4,a3,167e <atoi+0x8e>
neg = 1;
case '+':
s++;
}
/* Compute n as a negative number to avoid overflow on INT_MIN */
while (isdigit(*s))
161a: fd07859b addiw a1,a5,-48
161e: 4625 li a2,9
1620: 873e mv a4,a5
1622: 86aa mv a3,a0
int n = 0, neg = 0;
1624: 4e01 li t3,0
while (isdigit(*s))
1626: 04b66a63 bltu a2,a1,167a <atoi+0x8a>
int n = 0, neg = 0;
162a: 4501 li a0,0
while (isdigit(*s))
162c: 4825 li a6,9
162e: 0016c603 lbu a2,1(a3)
n = 10 * n - (*s++ - '0');
1632: 0025179b slliw a5,a0,0x2
1636: 9d3d addw a0,a0,a5
1638: fd07031b addiw t1,a4,-48
163c: 0015189b slliw a7,a0,0x1
while (isdigit(*s))
1640: fd06059b addiw a1,a2,-48
n = 10 * n - (*s++ - '0');
1644: 0685 addi a3,a3,1
1646: 4068853b subw a0,a7,t1
while (isdigit(*s))
164a: 0006071b sext.w a4,a2
164e: feb870e3 bgeu a6,a1,162e <atoi+0x3e>
return neg ? n : -n;
1652: 000e0563 beqz t3,165c <atoi+0x6c>
}
1656: 8082 ret
s++;
1658: 0505 addi a0,a0,1
165a: bf71 j 15f6 <atoi+0x6>
return neg ? n : -n;
165c: 4113053b subw a0,t1,a7
1660: 8082 ret
while (isdigit(*s))
1662: 00154783 lbu a5,1(a0)
1666: 4625 li a2,9
s++;
1668: 00150693 addi a3,a0,1
while (isdigit(*s))
166c: fd07859b addiw a1,a5,-48
1670: 0007871b sext.w a4,a5
int n = 0, neg = 0;
1674: 4e01 li t3,0
while (isdigit(*s))
1676: fab67ae3 bgeu a2,a1,162a <atoi+0x3a>
167a: 4501 li a0,0
}
167c: 8082 ret
while (isdigit(*s))
167e: 00154783 lbu a5,1(a0)
1682: 4625 li a2,9
s++;
1684: 00150693 addi a3,a0,1
while (isdigit(*s))
1688: fd07859b addiw a1,a5,-48
168c: 0007871b sext.w a4,a5
1690: feb665e3 bltu a2,a1,167a <atoi+0x8a>
neg = 1;
1694: 4e05 li t3,1
1696: bf51 j 162a <atoi+0x3a>
0000000000001698 <memset>:
void *memset(void *dest, int c, size_t n)
{
char *p = dest;
for (int i = 0; i < n; ++i, *(p++) = c)
1698: 16060d63 beqz a2,1812 <memset+0x17a>
169c: 40a007b3 neg a5,a0
16a0: 8b9d andi a5,a5,7
16a2: 00778713 addi a4,a5,7
16a6: 482d li a6,11
16a8: 0ff5f593 zext.b a1,a1
16ac: fff60693 addi a3,a2,-1
16b0: 17076263 bltu a4,a6,1814 <memset+0x17c>
16b4: 16e6ea63 bltu a3,a4,1828 <memset+0x190>
16b8: 16078563 beqz a5,1822 <memset+0x18a>
16bc: 00b50023 sb a1,0(a0)
16c0: 4705 li a4,1
16c2: 00150e93 addi t4,a0,1
16c6: 14e78c63 beq a5,a4,181e <memset+0x186>
16ca: 00b500a3 sb a1,1(a0)
16ce: 4709 li a4,2
16d0: 00250e93 addi t4,a0,2
16d4: 14e78d63 beq a5,a4,182e <memset+0x196>
16d8: 00b50123 sb a1,2(a0)
16dc: 470d li a4,3
16de: 00350e93 addi t4,a0,3
16e2: 12e78b63 beq a5,a4,1818 <memset+0x180>
16e6: 00b501a3 sb a1,3(a0)
16ea: 4711 li a4,4
16ec: 00450e93 addi t4,a0,4
16f0: 14e78163 beq a5,a4,1832 <memset+0x19a>
16f4: 00b50223 sb a1,4(a0)
16f8: 4715 li a4,5
16fa: 00550e93 addi t4,a0,5
16fe: 12e78c63 beq a5,a4,1836 <memset+0x19e>
1702: 00b502a3 sb a1,5(a0)
1706: 471d li a4,7
1708: 00650e93 addi t4,a0,6
170c: 12e79763 bne a5,a4,183a <memset+0x1a2>
1710: 00750e93 addi t4,a0,7
1714: 00b50323 sb a1,6(a0)
1718: 4f1d li t5,7
171a: 00859713 slli a4,a1,0x8
171e: 8f4d or a4,a4,a1
1720: 01059e13 slli t3,a1,0x10
1724: 01c76e33 or t3,a4,t3
1728: 01859313 slli t1,a1,0x18
172c: 006e6333 or t1,t3,t1
1730: 02059893 slli a7,a1,0x20
1734: 011368b3 or a7,t1,a7
1738: 02859813 slli a6,a1,0x28
173c: 40f60333 sub t1,a2,a5
1740: 0108e833 or a6,a7,a6
1744: 03059693 slli a3,a1,0x30
1748: 00d866b3 or a3,a6,a3
174c: 03859713 slli a4,a1,0x38
1750: 97aa add a5,a5,a0
1752: ff837813 andi a6,t1,-8
1756: 8f55 or a4,a4,a3
1758: 00f806b3 add a3,a6,a5
175c: e398 sd a4,0(a5)
175e: 07a1 addi a5,a5,8
1760: fed79ee3 bne a5,a3,175c <memset+0xc4>
1764: ff837693 andi a3,t1,-8
1768: 00de87b3 add a5,t4,a3
176c: 01e6873b addw a4,a3,t5
1770: 0ad30663 beq t1,a3,181c <memset+0x184>
1774: 00b78023 sb a1,0(a5)
1778: 0017069b addiw a3,a4,1
177c: 08c6fb63 bgeu a3,a2,1812 <memset+0x17a>
1780: 00b780a3 sb a1,1(a5)
1784: 0027069b addiw a3,a4,2
1788: 08c6f563 bgeu a3,a2,1812 <memset+0x17a>
178c: 00b78123 sb a1,2(a5)
1790: 0037069b addiw a3,a4,3
1794: 06c6ff63 bgeu a3,a2,1812 <memset+0x17a>
1798: 00b781a3 sb a1,3(a5)
179c: 0047069b addiw a3,a4,4
17a0: 06c6f963 bgeu a3,a2,1812 <memset+0x17a>
17a4: 00b78223 sb a1,4(a5)
17a8: 0057069b addiw a3,a4,5
17ac: 06c6f363 bgeu a3,a2,1812 <memset+0x17a>
17b0: 00b782a3 sb a1,5(a5)
17b4: 0067069b addiw a3,a4,6
17b8: 04c6fd63 bgeu a3,a2,1812 <memset+0x17a>
17bc: 00b78323 sb a1,6(a5)
17c0: 0077069b addiw a3,a4,7
17c4: 04c6f763 bgeu a3,a2,1812 <memset+0x17a>
17c8: 00b783a3 sb a1,7(a5)
17cc: 0087069b addiw a3,a4,8
17d0: 04c6f163 bgeu a3,a2,1812 <memset+0x17a>
17d4: 00b78423 sb a1,8(a5)
17d8: 0097069b addiw a3,a4,9
17dc: 02c6fb63 bgeu a3,a2,1812 <memset+0x17a>
17e0: 00b784a3 sb a1,9(a5)
17e4: 00a7069b addiw a3,a4,10
17e8: 02c6f563 bgeu a3,a2,1812 <memset+0x17a>
17ec: 00b78523 sb a1,10(a5)
17f0: 00b7069b addiw a3,a4,11
17f4: 00c6ff63 bgeu a3,a2,1812 <memset+0x17a>
17f8: 00b785a3 sb a1,11(a5)
17fc: 00c7069b addiw a3,a4,12
1800: 00c6f963 bgeu a3,a2,1812 <memset+0x17a>
1804: 00b78623 sb a1,12(a5)
1808: 2735 addiw a4,a4,13
180a: 00c77463 bgeu a4,a2,1812 <memset+0x17a>
180e: 00b786a3 sb a1,13(a5)
;
return dest;
}
1812: 8082 ret
1814: 472d li a4,11
1816: bd79 j 16b4 <memset+0x1c>
for (int i = 0; i < n; ++i, *(p++) = c)
1818: 4f0d li t5,3
181a: b701 j 171a <memset+0x82>
181c: 8082 ret
181e: 4f05 li t5,1
1820: bded j 171a <memset+0x82>
1822: 8eaa mv t4,a0
1824: 4f01 li t5,0
1826: bdd5 j 171a <memset+0x82>
1828: 87aa mv a5,a0
182a: 4701 li a4,0
182c: b7a1 j 1774 <memset+0xdc>
182e: 4f09 li t5,2
1830: b5ed j 171a <memset+0x82>
1832: 4f11 li t5,4
1834: b5dd j 171a <memset+0x82>
1836: 4f15 li t5,5
1838: b5cd j 171a <memset+0x82>
183a: 4f19 li t5,6
183c: bdf9 j 171a <memset+0x82>
000000000000183e <strcmp>:
int strcmp(const char *l, const char *r)
{
for (; *l == *r && *l; l++, r++)
183e: 00054783 lbu a5,0(a0)
1842: 0005c703 lbu a4,0(a1)
1846: 00e79863 bne a5,a4,1856 <strcmp+0x18>
184a: 0505 addi a0,a0,1
184c: 0585 addi a1,a1,1
184e: fbe5 bnez a5,183e <strcmp>
1850: 4501 li a0,0
;
return *(unsigned char *)l - *(unsigned char *)r;
}
1852: 9d19 subw a0,a0,a4
1854: 8082 ret
return *(unsigned char *)l - *(unsigned char *)r;
1856: 0007851b sext.w a0,a5
185a: bfe5 j 1852 <strcmp+0x14>
000000000000185c <strncmp>:
int strncmp(const char *_l, const char *_r, size_t n)
{
const unsigned char *l = (void *)_l, *r = (void *)_r;
if (!n--)
185c: ce05 beqz a2,1894 <strncmp+0x38>
return 0;
for (; *l && *r && n && *l == *r; l++, r++, n--)
185e: 00054703 lbu a4,0(a0)
1862: 0005c783 lbu a5,0(a1)
1866: cb0d beqz a4,1898 <strncmp+0x3c>
if (!n--)
1868: 167d addi a2,a2,-1
186a: 00c506b3 add a3,a0,a2
186e: a819 j 1884 <strncmp+0x28>
for (; *l && *r && n && *l == *r; l++, r++, n--)
1870: 00a68e63 beq a3,a0,188c <strncmp+0x30>
1874: 0505 addi a0,a0,1
1876: 00e79b63 bne a5,a4,188c <strncmp+0x30>
187a: 00054703 lbu a4,0(a0)
;
return *l - *r;
187e: 0005c783 lbu a5,0(a1)
for (; *l && *r && n && *l == *r; l++, r++, n--)
1882: cb19 beqz a4,1898 <strncmp+0x3c>
1884: 0005c783 lbu a5,0(a1)
1888: 0585 addi a1,a1,1
188a: f3fd bnez a5,1870 <strncmp+0x14>
return *l - *r;
188c: 0007051b sext.w a0,a4
1890: 9d1d subw a0,a0,a5
1892: 8082 ret
return 0;
1894: 4501 li a0,0
}
1896: 8082 ret
1898: 4501 li a0,0
return *l - *r;
189a: 9d1d subw a0,a0,a5
189c: 8082 ret
000000000000189e <strlen>:
size_t strlen(const char *s)
{
const char *a = s;
typedef size_t __attribute__((__may_alias__)) word;
const word *w;
for (; (uintptr_t)s % SS; s++)
189e: 00757793 andi a5,a0,7
18a2: cf89 beqz a5,18bc <strlen+0x1e>
18a4: 87aa mv a5,a0
18a6: a029 j 18b0 <strlen+0x12>
18a8: 0785 addi a5,a5,1
18aa: 0077f713 andi a4,a5,7
18ae: cb01 beqz a4,18be <strlen+0x20>
if (!*s)
18b0: 0007c703 lbu a4,0(a5)
18b4: fb75 bnez a4,18a8 <strlen+0xa>
for (w = (const void *)s; !HASZERO(*w); w++)
;
s = (const void *)w;
for (; *s; s++)
;
return s - a;
18b6: 40a78533 sub a0,a5,a0
}
18ba: 8082 ret
for (; (uintptr_t)s % SS; s++)
18bc: 87aa mv a5,a0
for (w = (const void *)s; !HASZERO(*w); w++)
18be: 6394 ld a3,0(a5)
18c0: 00000597 auipc a1,0x0
18c4: 6c05b583 ld a1,1728(a1) # 1f80 <__clone+0xc6>
18c8: 00000617 auipc a2,0x0
18cc: 6c063603 ld a2,1728(a2) # 1f88 <__clone+0xce>
18d0: a019 j 18d6 <strlen+0x38>
18d2: 6794 ld a3,8(a5)
18d4: 07a1 addi a5,a5,8
18d6: 00b68733 add a4,a3,a1
18da: fff6c693 not a3,a3
18de: 8f75 and a4,a4,a3
18e0: 8f71 and a4,a4,a2
18e2: db65 beqz a4,18d2 <strlen+0x34>
for (; *s; s++)
18e4: 0007c703 lbu a4,0(a5)
18e8: d779 beqz a4,18b6 <strlen+0x18>
18ea: 0017c703 lbu a4,1(a5)
18ee: 0785 addi a5,a5,1
18f0: d379 beqz a4,18b6 <strlen+0x18>
18f2: 0017c703 lbu a4,1(a5)
18f6: 0785 addi a5,a5,1
18f8: fb6d bnez a4,18ea <strlen+0x4c>
18fa: bf75 j 18b6 <strlen+0x18>
00000000000018fc <memchr>:
void *memchr(const void *src, int c, size_t n)
{
const unsigned char *s = src;
c = (unsigned char)c;
for (; ((uintptr_t)s & ALIGN) && n && *s != c; s++, n--)
18fc: 00757713 andi a4,a0,7
{
1900: 87aa mv a5,a0
c = (unsigned char)c;
1902: 0ff5f593 zext.b a1,a1
for (; ((uintptr_t)s & ALIGN) && n && *s != c; s++, n--)
1906: cb19 beqz a4,191c <memchr+0x20>
1908: ce25 beqz a2,1980 <memchr+0x84>
190a: 0007c703 lbu a4,0(a5)
190e: 04b70e63 beq a4,a1,196a <memchr+0x6e>
1912: 0785 addi a5,a5,1
1914: 0077f713 andi a4,a5,7
1918: 167d addi a2,a2,-1
191a: f77d bnez a4,1908 <memchr+0xc>
;
s = (const void *)w;
}
for (; n && *s != c; s++, n--)
;
return n ? (void *)s : 0;
191c: 4501 li a0,0
if (n && *s != c)
191e: c235 beqz a2,1982 <memchr+0x86>
1920: 0007c703 lbu a4,0(a5)
1924: 04b70363 beq a4,a1,196a <memchr+0x6e>
size_t k = ONES * c;
1928: 00000517 auipc a0,0x0
192c: 66853503 ld a0,1640(a0) # 1f90 <__clone+0xd6>
for (w = (const void *)s; n >= SS && !HASZERO(*w ^ k); w++, n -= SS)
1930: 471d li a4,7
size_t k = ONES * c;
1932: 02a58533 mul a0,a1,a0
for (w = (const void *)s; n >= SS && !HASZERO(*w ^ k); w++, n -= SS)
1936: 02c77a63 bgeu a4,a2,196a <memchr+0x6e>
193a: 00000897 auipc a7,0x0
193e: 6468b883 ld a7,1606(a7) # 1f80 <__clone+0xc6>
1942: 00000817 auipc a6,0x0
1946: 64683803 ld a6,1606(a6) # 1f88 <__clone+0xce>
194a: 431d li t1,7
194c: a029 j 1956 <memchr+0x5a>
194e: 1661 addi a2,a2,-8
1950: 07a1 addi a5,a5,8
1952: 02c37963 bgeu t1,a2,1984 <memchr+0x88>
1956: 6398 ld a4,0(a5)
1958: 8f29 xor a4,a4,a0
195a: 011706b3 add a3,a4,a7
195e: fff74713 not a4,a4
1962: 8f75 and a4,a4,a3
1964: 01077733 and a4,a4,a6
1968: d37d beqz a4,194e <memchr+0x52>
196a: 853e mv a0,a5
196c: 97b2 add a5,a5,a2
196e: a021 j 1976 <memchr+0x7a>
for (; n && *s != c; s++, n--)
1970: 0505 addi a0,a0,1
1972: 00f50763 beq a0,a5,1980 <memchr+0x84>
1976: 00054703 lbu a4,0(a0)
197a: feb71be3 bne a4,a1,1970 <memchr+0x74>
197e: 8082 ret
return n ? (void *)s : 0;
1980: 4501 li a0,0
}
1982: 8082 ret
return n ? (void *)s : 0;
1984: 4501 li a0,0
for (; n && *s != c; s++, n--)
1986: f275 bnez a2,196a <memchr+0x6e>
}
1988: 8082 ret
000000000000198a <strnlen>:
size_t strnlen(const char *s, size_t n)
{
198a: 1101 addi sp,sp,-32
198c: e822 sd s0,16(sp)
const char *p = memchr(s, 0, n);
198e: 862e mv a2,a1
{
1990: 842e mv s0,a1
const char *p = memchr(s, 0, n);
1992: 4581 li a1,0
{
1994: e426 sd s1,8(sp)
1996: ec06 sd ra,24(sp)
1998: 84aa mv s1,a0
const char *p = memchr(s, 0, n);
199a: f63ff0ef jal ra,18fc <memchr>
return p ? p - s : n;
199e: c519 beqz a0,19ac <strnlen+0x22>
}
19a0: 60e2 ld ra,24(sp)
19a2: 6442 ld s0,16(sp)
return p ? p - s : n;
19a4: 8d05 sub a0,a0,s1
}
19a6: 64a2 ld s1,8(sp)
19a8: 6105 addi sp,sp,32
19aa: 8082 ret
19ac: 60e2 ld ra,24(sp)
return p ? p - s : n;
19ae: 8522 mv a0,s0
}
19b0: 6442 ld s0,16(sp)
19b2: 64a2 ld s1,8(sp)
19b4: 6105 addi sp,sp,32
19b6: 8082 ret
00000000000019b8 <strcpy>:
char *strcpy(char *restrict d, const char *s)
{
typedef size_t __attribute__((__may_alias__)) word;
word *wd;
const word *ws;
if ((uintptr_t)s % SS == (uintptr_t)d % SS)
19b8: 00b547b3 xor a5,a0,a1
19bc: 8b9d andi a5,a5,7
19be: eb95 bnez a5,19f2 <strcpy+0x3a>
{
for (; (uintptr_t)s % SS; s++, d++)
19c0: 0075f793 andi a5,a1,7
19c4: e7b1 bnez a5,1a10 <strcpy+0x58>
if (!(*d = *s))
return d;
wd = (void *)d;
ws = (const void *)s;
for (; !HASZERO(*ws); *wd++ = *ws++)
19c6: 6198 ld a4,0(a1)
19c8: 00000617 auipc a2,0x0
19cc: 5b863603 ld a2,1464(a2) # 1f80 <__clone+0xc6>
19d0: 00000817 auipc a6,0x0
19d4: 5b883803 ld a6,1464(a6) # 1f88 <__clone+0xce>
19d8: a029 j 19e2 <strcpy+0x2a>
19da: e118 sd a4,0(a0)
19dc: 6598 ld a4,8(a1)
19de: 05a1 addi a1,a1,8
19e0: 0521 addi a0,a0,8
19e2: 00c707b3 add a5,a4,a2
19e6: fff74693 not a3,a4
19ea: 8ff5 and a5,a5,a3
19ec: 0107f7b3 and a5,a5,a6
19f0: d7ed beqz a5,19da <strcpy+0x22>
;
d = (void *)wd;
s = (const void *)ws;
}
for (; (*d = *s); s++, d++)
19f2: 0005c783 lbu a5,0(a1)
19f6: 00f50023 sb a5,0(a0)
19fa: c785 beqz a5,1a22 <strcpy+0x6a>
19fc: 0015c783 lbu a5,1(a1)
1a00: 0505 addi a0,a0,1
1a02: 0585 addi a1,a1,1
1a04: 00f50023 sb a5,0(a0)
1a08: fbf5 bnez a5,19fc <strcpy+0x44>
;
return d;
}
1a0a: 8082 ret
for (; (uintptr_t)s % SS; s++, d++)
1a0c: 0505 addi a0,a0,1
1a0e: df45 beqz a4,19c6 <strcpy+0xe>
if (!(*d = *s))
1a10: 0005c783 lbu a5,0(a1)
for (; (uintptr_t)s % SS; s++, d++)
1a14: 0585 addi a1,a1,1
1a16: 0075f713 andi a4,a1,7
if (!(*d = *s))
1a1a: 00f50023 sb a5,0(a0)
1a1e: f7fd bnez a5,1a0c <strcpy+0x54>
}
1a20: 8082 ret
1a22: 8082 ret
0000000000001a24 <strncpy>:
char *strncpy(char *restrict d, const char *s, size_t n)
{
typedef size_t __attribute__((__may_alias__)) word;
word *wd;
const word *ws;
if (((uintptr_t)s & ALIGN) == ((uintptr_t)d & ALIGN))
1a24: 00b547b3 xor a5,a0,a1
1a28: 8b9d andi a5,a5,7
1a2a: 1a079863 bnez a5,1bda <strncpy+0x1b6>
{
for (; ((uintptr_t)s & ALIGN) && n && (*d = *s); n--, s++, d++)
1a2e: 0075f793 andi a5,a1,7
1a32: 16078463 beqz a5,1b9a <strncpy+0x176>
1a36: ea01 bnez a2,1a46 <strncpy+0x22>
1a38: a421 j 1c40 <strncpy+0x21c>
1a3a: 167d addi a2,a2,-1
1a3c: 0505 addi a0,a0,1
1a3e: 14070e63 beqz a4,1b9a <strncpy+0x176>
1a42: 1a060863 beqz a2,1bf2 <strncpy+0x1ce>
1a46: 0005c783 lbu a5,0(a1)
1a4a: 0585 addi a1,a1,1
1a4c: 0075f713 andi a4,a1,7
1a50: 00f50023 sb a5,0(a0)
1a54: f3fd bnez a5,1a3a <strncpy+0x16>
1a56: 4805 li a6,1
1a58: 1a061863 bnez a2,1c08 <strncpy+0x1e4>
1a5c: 40a007b3 neg a5,a0
1a60: 8b9d andi a5,a5,7
1a62: 4681 li a3,0
1a64: 18061a63 bnez a2,1bf8 <strncpy+0x1d4>
1a68: 00778713 addi a4,a5,7
1a6c: 45ad li a1,11
1a6e: 18b76363 bltu a4,a1,1bf4 <strncpy+0x1d0>
1a72: 1ae6eb63 bltu a3,a4,1c28 <strncpy+0x204>
1a76: 1a078363 beqz a5,1c1c <strncpy+0x1f8>
for (int i = 0; i < n; ++i, *(p++) = c)
1a7a: 00050023 sb zero,0(a0)
1a7e: 4685 li a3,1
1a80: 00150713 addi a4,a0,1
1a84: 18d78f63 beq a5,a3,1c22 <strncpy+0x1fe>
1a88: 000500a3 sb zero,1(a0)
1a8c: 4689 li a3,2
1a8e: 00250713 addi a4,a0,2
1a92: 18d78e63 beq a5,a3,1c2e <strncpy+0x20a>
1a96: 00050123 sb zero,2(a0)
1a9a: 468d li a3,3
1a9c: 00350713 addi a4,a0,3
1aa0: 16d78c63 beq a5,a3,1c18 <strncpy+0x1f4>
1aa4: 000501a3 sb zero,3(a0)
1aa8: 4691 li a3,4
1aaa: 00450713 addi a4,a0,4
1aae: 18d78263 beq a5,a3,1c32 <strncpy+0x20e>
1ab2: 00050223 sb zero,4(a0)
1ab6: 4695 li a3,5
1ab8: 00550713 addi a4,a0,5
1abc: 16d78d63 beq a5,a3,1c36 <strncpy+0x212>
1ac0: 000502a3 sb zero,5(a0)
1ac4: 469d li a3,7
1ac6: 00650713 addi a4,a0,6
1aca: 16d79863 bne a5,a3,1c3a <strncpy+0x216>
1ace: 00750713 addi a4,a0,7
1ad2: 00050323 sb zero,6(a0)
1ad6: 40f80833 sub a6,a6,a5
1ada: ff887593 andi a1,a6,-8
1ade: 97aa add a5,a5,a0
1ae0: 95be add a1,a1,a5
1ae2: 0007b023 sd zero,0(a5)
1ae6: 07a1 addi a5,a5,8
1ae8: feb79de3 bne a5,a1,1ae2 <strncpy+0xbe>
1aec: ff887593 andi a1,a6,-8
1af0: 9ead addw a3,a3,a1
1af2: 00b707b3 add a5,a4,a1
1af6: 12b80863 beq a6,a1,1c26 <strncpy+0x202>
1afa: 00078023 sb zero,0(a5)
1afe: 0016871b addiw a4,a3,1
1b02: 0ec77863 bgeu a4,a2,1bf2 <strncpy+0x1ce>
1b06: 000780a3 sb zero,1(a5)
1b0a: 0026871b addiw a4,a3,2
1b0e: 0ec77263 bgeu a4,a2,1bf2 <strncpy+0x1ce>
1b12: 00078123 sb zero,2(a5)
1b16: 0036871b addiw a4,a3,3
1b1a: 0cc77c63 bgeu a4,a2,1bf2 <strncpy+0x1ce>
1b1e: 000781a3 sb zero,3(a5)
1b22: 0046871b addiw a4,a3,4
1b26: 0cc77663 bgeu a4,a2,1bf2 <strncpy+0x1ce>
1b2a: 00078223 sb zero,4(a5)
1b2e: 0056871b addiw a4,a3,5
1b32: 0cc77063 bgeu a4,a2,1bf2 <strncpy+0x1ce>
1b36: 000782a3 sb zero,5(a5)
1b3a: 0066871b addiw a4,a3,6
1b3e: 0ac77a63 bgeu a4,a2,1bf2 <strncpy+0x1ce>
1b42: 00078323 sb zero,6(a5)
1b46: 0076871b addiw a4,a3,7
1b4a: 0ac77463 bgeu a4,a2,1bf2 <strncpy+0x1ce>
1b4e: 000783a3 sb zero,7(a5)
1b52: 0086871b addiw a4,a3,8
1b56: 08c77e63 bgeu a4,a2,1bf2 <strncpy+0x1ce>
1b5a: 00078423 sb zero,8(a5)
1b5e: 0096871b addiw a4,a3,9
1b62: 08c77863 bgeu a4,a2,1bf2 <strncpy+0x1ce>
1b66: 000784a3 sb zero,9(a5)
1b6a: 00a6871b addiw a4,a3,10
1b6e: 08c77263 bgeu a4,a2,1bf2 <strncpy+0x1ce>
1b72: 00078523 sb zero,10(a5)
1b76: 00b6871b addiw a4,a3,11
1b7a: 06c77c63 bgeu a4,a2,1bf2 <strncpy+0x1ce>
1b7e: 000785a3 sb zero,11(a5)
1b82: 00c6871b addiw a4,a3,12
1b86: 06c77663 bgeu a4,a2,1bf2 <strncpy+0x1ce>
1b8a: 00078623 sb zero,12(a5)
1b8e: 26b5 addiw a3,a3,13
1b90: 06c6f163 bgeu a3,a2,1bf2 <strncpy+0x1ce>
1b94: 000786a3 sb zero,13(a5)
1b98: 8082 ret
;
if (!n || !*s)
1b9a: c645 beqz a2,1c42 <strncpy+0x21e>
1b9c: 0005c783 lbu a5,0(a1)
1ba0: ea078be3 beqz a5,1a56 <strncpy+0x32>
goto tail;
wd = (void *)d;
ws = (const void *)s;
for (; n >= sizeof(size_t) && !HASZERO(*ws); n -= sizeof(size_t), ws++, wd++)
1ba4: 479d li a5,7
1ba6: 02c7ff63 bgeu a5,a2,1be4 <strncpy+0x1c0>
1baa: 00000897 auipc a7,0x0
1bae: 3d68b883 ld a7,982(a7) # 1f80 <__clone+0xc6>
1bb2: 00000817 auipc a6,0x0
1bb6: 3d683803 ld a6,982(a6) # 1f88 <__clone+0xce>
1bba: 431d li t1,7
1bbc: 6198 ld a4,0(a1)
1bbe: 011707b3 add a5,a4,a7
1bc2: fff74693 not a3,a4
1bc6: 8ff5 and a5,a5,a3
1bc8: 0107f7b3 and a5,a5,a6
1bcc: ef81 bnez a5,1be4 <strncpy+0x1c0>
*wd = *ws;
1bce: e118 sd a4,0(a0)
for (; n >= sizeof(size_t) && !HASZERO(*ws); n -= sizeof(size_t), ws++, wd++)
1bd0: 1661 addi a2,a2,-8
1bd2: 05a1 addi a1,a1,8
1bd4: 0521 addi a0,a0,8
1bd6: fec363e3 bltu t1,a2,1bbc <strncpy+0x198>
d = (void *)wd;
s = (const void *)ws;
}
for (; n && (*d = *s); n--, s++, d++)
1bda: e609 bnez a2,1be4 <strncpy+0x1c0>
1bdc: a08d j 1c3e <strncpy+0x21a>
1bde: 167d addi a2,a2,-1
1be0: 0505 addi a0,a0,1
1be2: ca01 beqz a2,1bf2 <strncpy+0x1ce>
1be4: 0005c783 lbu a5,0(a1)
1be8: 0585 addi a1,a1,1
1bea: 00f50023 sb a5,0(a0)
1bee: fbe5 bnez a5,1bde <strncpy+0x1ba>
;
tail:
1bf0: b59d j 1a56 <strncpy+0x32>
memset(d, 0, n);
return d;
}
1bf2: 8082 ret
1bf4: 472d li a4,11
1bf6: bdb5 j 1a72 <strncpy+0x4e>
1bf8: 00778713 addi a4,a5,7
1bfc: 45ad li a1,11
1bfe: fff60693 addi a3,a2,-1
1c02: e6b778e3 bgeu a4,a1,1a72 <strncpy+0x4e>
1c06: b7fd j 1bf4 <strncpy+0x1d0>
1c08: 40a007b3 neg a5,a0
1c0c: 8832 mv a6,a2
1c0e: 8b9d andi a5,a5,7
1c10: 4681 li a3,0
1c12: e4060be3 beqz a2,1a68 <strncpy+0x44>
1c16: b7cd j 1bf8 <strncpy+0x1d4>
for (int i = 0; i < n; ++i, *(p++) = c)
1c18: 468d li a3,3
1c1a: bd75 j 1ad6 <strncpy+0xb2>
1c1c: 872a mv a4,a0
1c1e: 4681 li a3,0
1c20: bd5d j 1ad6 <strncpy+0xb2>
1c22: 4685 li a3,1
1c24: bd4d j 1ad6 <strncpy+0xb2>
1c26: 8082 ret
1c28: 87aa mv a5,a0
1c2a: 4681 li a3,0
1c2c: b5f9 j 1afa <strncpy+0xd6>
1c2e: 4689 li a3,2
1c30: b55d j 1ad6 <strncpy+0xb2>
1c32: 4691 li a3,4
1c34: b54d j 1ad6 <strncpy+0xb2>
1c36: 4695 li a3,5
1c38: bd79 j 1ad6 <strncpy+0xb2>
1c3a: 4699 li a3,6
1c3c: bd69 j 1ad6 <strncpy+0xb2>
1c3e: 8082 ret
1c40: 8082 ret
1c42: 8082 ret
0000000000001c44 <open>:
#include <unistd.h>
#include "syscall.h"
int open(const char *path, int flags)
{
1c44: 87aa mv a5,a0
1c46: 862e mv a2,a1
__asm_syscall("r"(a7), "0"(a0), "r"(a1), "r"(a2))
}
static inline long __syscall4(long n, long a, long b, long c, long d)
{
register long a7 __asm__("a7") = n;
1c48: 03800893 li a7,56
register long a0 __asm__("a0") = a;
1c4c: f9c00513 li a0,-100
register long a1 __asm__("a1") = b;
1c50: 85be mv a1,a5
register long a2 __asm__("a2") = c;
register long a3 __asm__("a3") = d;
1c52: 4689 li a3,2
__asm_syscall("r"(a7), "0"(a0), "r"(a1), "r"(a2), "r"(a3))
1c54: 00000073 ecall
return syscall(SYS_openat, AT_FDCWD, path, flags, O_RDWR);
}
1c58: 2501 sext.w a0,a0
1c5a: 8082 ret
0000000000001c5c <openat>:
register long a7 __asm__("a7") = n;
1c5c: 03800893 li a7,56
register long a3 __asm__("a3") = d;
1c60: 18000693 li a3,384
__asm_syscall("r"(a7), "0"(a0), "r"(a1), "r"(a2), "r"(a3))
1c64: 00000073 ecall
int openat(int dirfd,const char *path, int flags)
{
return syscall(SYS_openat, dirfd, path, flags, 0600);
}
1c68: 2501 sext.w a0,a0
1c6a: 8082 ret
0000000000001c6c <close>:
register long a7 __asm__("a7") = n;
1c6c: 03900893 li a7,57
__asm_syscall("r"(a7), "0"(a0))
1c70: 00000073 ecall
int close(int fd)
{
return syscall(SYS_close, fd);
}
1c74: 2501 sext.w a0,a0
1c76: 8082 ret
0000000000001c78 <read>:
register long a7 __asm__("a7") = n;
1c78: 03f00893 li a7,63
__asm_syscall("r"(a7), "0"(a0), "r"(a1), "r"(a2))
1c7c: 00000073 ecall
ssize_t read(int fd, void *buf, size_t len)
{
return syscall(SYS_read, fd, buf, len);
}
1c80: 8082 ret
0000000000001c82 <write>:
register long a7 __asm__("a7") = n;
1c82: 04000893 li a7,64
__asm_syscall("r"(a7), "0"(a0), "r"(a1), "r"(a2))
1c86: 00000073 ecall
ssize_t write(int fd, const void *buf, size_t len)
{
return syscall(SYS_write, fd, buf, len);
}
1c8a: 8082 ret
0000000000001c8c <getpid>:
register long a7 __asm__("a7") = n;
1c8c: 0ac00893 li a7,172
__asm_syscall("r"(a7))
1c90: 00000073 ecall
pid_t getpid(void)
{
return syscall(SYS_getpid);
}
1c94: 2501 sext.w a0,a0
1c96: 8082 ret
0000000000001c98 <getppid>:
register long a7 __asm__("a7") = n;
1c98: 0ad00893 li a7,173
__asm_syscall("r"(a7))
1c9c: 00000073 ecall
pid_t getppid(void)
{
return syscall(SYS_getppid);
}
1ca0: 2501 sext.w a0,a0
1ca2: 8082 ret
0000000000001ca4 <sched_yield>:
register long a7 __asm__("a7") = n;
1ca4: 07c00893 li a7,124
__asm_syscall("r"(a7))
1ca8: 00000073 ecall
int sched_yield(void)
{
return syscall(SYS_sched_yield);
}
1cac: 2501 sext.w a0,a0
1cae: 8082 ret
0000000000001cb0 <fork>:
register long a7 __asm__("a7") = n;
1cb0: 0dc00893 li a7,220
register long a0 __asm__("a0") = a;
1cb4: 4545 li a0,17
register long a1 __asm__("a1") = b;
1cb6: 4581 li a1,0
__asm_syscall("r"(a7), "0"(a0), "r"(a1))
1cb8: 00000073 ecall
pid_t fork(void)
{
return syscall(SYS_clone, SIGCHLD, 0);
}
1cbc: 2501 sext.w a0,a0
1cbe: 8082 ret
0000000000001cc0 <clone>:
pid_t clone(int (*fn)(void *arg), void *arg, void *stack, size_t stack_size, unsigned long flags)
{
1cc0: 85b2 mv a1,a2
1cc2: 863a mv a2,a4
if (stack)
1cc4: c191 beqz a1,1cc8 <clone+0x8>
stack += stack_size;
1cc6: 95b6 add a1,a1,a3
return __clone(fn, stack, flags, NULL, NULL, NULL);
1cc8: 4781 li a5,0
1cca: 4701 li a4,0
1ccc: 4681 li a3,0
1cce: 2601 sext.w a2,a2
1cd0: a2ed j 1eba <__clone>
0000000000001cd2 <exit>:
register long a7 __asm__("a7") = n;
1cd2: 05d00893 li a7,93
__asm_syscall("r"(a7), "0"(a0))
1cd6: 00000073 ecall
//return syscall(SYS_clone, fn, stack, flags, NULL, NULL, NULL);
}
void exit(int code)
{
syscall(SYS_exit, code);
}
1cda: 8082 ret
0000000000001cdc <waitpid>:
register long a7 __asm__("a7") = n;
1cdc: 10400893 li a7,260
register long a3 __asm__("a3") = d;
1ce0: 4681 li a3,0
__asm_syscall("r"(a7), "0"(a0), "r"(a1), "r"(a2), "r"(a3))
1ce2: 00000073 ecall
int waitpid(int pid, int *code, int options)
{
return syscall(SYS_wait4, pid, code, options, 0);
}
1ce6: 2501 sext.w a0,a0
1ce8: 8082 ret
0000000000001cea <exec>:
register long a7 __asm__("a7") = n;
1cea: 0dd00893 li a7,221
__asm_syscall("r"(a7), "0"(a0))
1cee: 00000073 ecall
int exec(char *name)
{
return syscall(SYS_execve, name);
}
1cf2: 2501 sext.w a0,a0
1cf4: 8082 ret
0000000000001cf6 <execve>:
register long a7 __asm__("a7") = n;
1cf6: 0dd00893 li a7,221
__asm_syscall("r"(a7), "0"(a0), "r"(a1), "r"(a2))
1cfa: 00000073 ecall
int execve(const char *name, char *const argv[], char *const argp[])
{
return syscall(SYS_execve, name, argv, argp);
}
1cfe: 2501 sext.w a0,a0
1d00: 8082 ret
0000000000001d02 <times>:
register long a7 __asm__("a7") = n;
1d02: 09900893 li a7,153
__asm_syscall("r"(a7), "0"(a0))
1d06: 00000073 ecall
int times(void *mytimes)
{
return syscall(SYS_times, mytimes);
}
1d0a: 2501 sext.w a0,a0
1d0c: 8082 ret
0000000000001d0e <get_time>:
int64 get_time()
{
1d0e: 1141 addi sp,sp,-16
register long a7 __asm__("a7") = n;
1d10: 0a900893 li a7,169
register long a0 __asm__("a0") = a;
1d14: 850a mv a0,sp
register long a1 __asm__("a1") = b;
1d16: 4581 li a1,0
__asm_syscall("r"(a7), "0"(a0), "r"(a1))
1d18: 00000073 ecall
TimeVal time;
int err = sys_get_time(&time, 0);
if (err == 0)
1d1c: 2501 sext.w a0,a0
1d1e: ed09 bnez a0,1d38 <get_time+0x2a>
{
return ((time.sec & 0xffff) * 1000 + time.usec / 1000);
1d20: 67a2 ld a5,8(sp)
1d22: 3e800713 li a4,1000
1d26: 00015503 lhu a0,0(sp)
1d2a: 02e7d7b3 divu a5,a5,a4
1d2e: 02e50533 mul a0,a0,a4
1d32: 953e add a0,a0,a5
}
else
{
return -1;
}
}
1d34: 0141 addi sp,sp,16
1d36: 8082 ret
return -1;
1d38: 557d li a0,-1
1d3a: bfed j 1d34 <get_time+0x26>
0000000000001d3c <sys_get_time>:
register long a7 __asm__("a7") = n;
1d3c: 0a900893 li a7,169
__asm_syscall("r"(a7), "0"(a0), "r"(a1))
1d40: 00000073 ecall
int sys_get_time(TimeVal *ts, int tz)
{
return syscall(SYS_gettimeofday, ts, tz);
}
1d44: 2501 sext.w a0,a0
1d46: 8082 ret
0000000000001d48 <time>:
register long a7 __asm__("a7") = n;
1d48: 42600893 li a7,1062
__asm_syscall("r"(a7), "0"(a0))
1d4c: 00000073 ecall
int time(unsigned long *tloc)
{
return syscall(SYS_time, tloc);
}
1d50: 2501 sext.w a0,a0
1d52: 8082 ret
0000000000001d54 <sleep>:
int sleep(unsigned long long time)
{
1d54: 1141 addi sp,sp,-16
TimeVal tv = {.sec = time, .usec = 0};
1d56: e02a sd a0,0(sp)
register long a0 __asm__("a0") = a;
1d58: 850a mv a0,sp
1d5a: e402 sd zero,8(sp)
register long a7 __asm__("a7") = n;
1d5c: 06500893 li a7,101
register long a1 __asm__("a1") = b;
1d60: 85aa mv a1,a0
__asm_syscall("r"(a7), "0"(a0), "r"(a1))
1d62: 00000073 ecall
if (syscall(SYS_nanosleep, &tv, &tv)) return tv.sec;
1d66: e501 bnez a0,1d6e <sleep+0x1a>
return 0;
1d68: 4501 li a0,0
}
1d6a: 0141 addi sp,sp,16
1d6c: 8082 ret
if (syscall(SYS_nanosleep, &tv, &tv)) return tv.sec;
1d6e: 4502 lw a0,0(sp)
}
1d70: 0141 addi sp,sp,16
1d72: 8082 ret
0000000000001d74 <set_priority>:
register long a7 __asm__("a7") = n;
1d74: 08c00893 li a7,140
__asm_syscall("r"(a7), "0"(a0))
1d78: 00000073 ecall
int set_priority(int prio)
{
return syscall(SYS_setpriority, prio);
}
1d7c: 2501 sext.w a0,a0
1d7e: 8082 ret
0000000000001d80 <mmap>:
__asm_syscall("r"(a7), "0"(a0), "r"(a1), "r"(a2), "r"(a3), "r"(a4))
}
static inline long __syscall6(long n, long a, long b, long c, long d, long e, long f)
{
register long a7 __asm__("a7") = n;
1d80: 0de00893 li a7,222
register long a1 __asm__("a1") = b;
register long a2 __asm__("a2") = c;
register long a3 __asm__("a3") = d;
register long a4 __asm__("a4") = e;
register long a5 __asm__("a5") = f;
__asm_syscall("r"(a7), "0"(a0), "r"(a1), "r"(a2), "r"(a3), "r"(a4), "r"(a5))
1d84: 00000073 ecall
void *mmap(void *start, size_t len, int prot, int flags, int fd, off_t off)
{
return syscall(SYS_mmap, start, len, prot, flags, fd, off);
}
1d88: 8082 ret
0000000000001d8a <munmap>:
register long a7 __asm__("a7") = n;
1d8a: 0d700893 li a7,215
__asm_syscall("r"(a7), "0"(a0), "r"(a1))
1d8e: 00000073 ecall
int munmap(void *start, size_t len)
{
return syscall(SYS_munmap, start, len);
}
1d92: 2501 sext.w a0,a0
1d94: 8082 ret
0000000000001d96 <wait>:
int wait(int *code)
{
1d96: 85aa mv a1,a0
register long a7 __asm__("a7") = n;
1d98: 10400893 li a7,260
register long a0 __asm__("a0") = a;
1d9c: 557d li a0,-1
register long a2 __asm__("a2") = c;
1d9e: 4601 li a2,0
register long a3 __asm__("a3") = d;
1da0: 4681 li a3,0
__asm_syscall("r"(a7), "0"(a0), "r"(a1), "r"(a2), "r"(a3))
1da2: 00000073 ecall
return waitpid((int)-1, code, 0);
}
1da6: 2501 sext.w a0,a0
1da8: 8082 ret
0000000000001daa <spawn>:
register long a7 __asm__("a7") = n;
1daa: 19000893 li a7,400
__asm_syscall("r"(a7), "0"(a0))
1dae: 00000073 ecall
int spawn(char *file)
{
return syscall(SYS_spawn, file);
}
1db2: 2501 sext.w a0,a0
1db4: 8082 ret
0000000000001db6 <mailread>:
register long a7 __asm__("a7") = n;
1db6: 19100893 li a7,401
__asm_syscall("r"(a7), "0"(a0), "r"(a1))
1dba: 00000073 ecall
int mailread(void *buf, int len)
{
return syscall(SYS_mailread, buf, len);
}
1dbe: 2501 sext.w a0,a0
1dc0: 8082 ret
0000000000001dc2 <mailwrite>:
register long a7 __asm__("a7") = n;
1dc2: 19200893 li a7,402
__asm_syscall("r"(a7), "0"(a0), "r"(a1), "r"(a2))
1dc6: 00000073 ecall
int mailwrite(int pid, void *buf, int len)
{
return syscall(SYS_mailwrite, pid, buf, len);
}
1dca: 2501 sext.w a0,a0
1dcc: 8082 ret
0000000000001dce <fstat>:
register long a7 __asm__("a7") = n;
1dce: 05000893 li a7,80
__asm_syscall("r"(a7), "0"(a0), "r"(a1))
1dd2: 00000073 ecall
int fstat(int fd, struct kstat *st)
{
return syscall(SYS_fstat, fd, st);
}
1dd6: 2501 sext.w a0,a0
1dd8: 8082 ret
0000000000001dda <sys_linkat>:
register long a4 __asm__("a4") = e;
1dda: 1702 slli a4,a4,0x20
register long a7 __asm__("a7") = n;
1ddc: 02500893 li a7,37
register long a4 __asm__("a4") = e;
1de0: 9301 srli a4,a4,0x20
__asm_syscall("r"(a7), "0"(a0), "r"(a1), "r"(a2), "r"(a3), "r"(a4))
1de2: 00000073 ecall
int sys_linkat(int olddirfd, char *oldpath, int newdirfd, char *newpath, unsigned int flags)
{
return syscall(SYS_linkat, olddirfd, oldpath, newdirfd, newpath, flags);
}
1de6: 2501 sext.w a0,a0
1de8: 8082 ret
0000000000001dea <sys_unlinkat>:
register long a2 __asm__("a2") = c;
1dea: 1602 slli a2,a2,0x20
register long a7 __asm__("a7") = n;
1dec: 02300893 li a7,35
register long a2 __asm__("a2") = c;
1df0: 9201 srli a2,a2,0x20
__asm_syscall("r"(a7), "0"(a0), "r"(a1), "r"(a2))
1df2: 00000073 ecall
int sys_unlinkat(int dirfd, char *path, unsigned int flags)
{
return syscall(SYS_unlinkat, dirfd, path, flags);
}
1df6: 2501 sext.w a0,a0
1df8: 8082 ret
0000000000001dfa <link>:
int link(char *old_path, char *new_path)
{
1dfa: 87aa mv a5,a0
1dfc: 86ae mv a3,a1
register long a7 __asm__("a7") = n;
1dfe: 02500893 li a7,37
register long a0 __asm__("a0") = a;
1e02: f9c00513 li a0,-100
register long a1 __asm__("a1") = b;
1e06: 85be mv a1,a5
register long a2 __asm__("a2") = c;
1e08: f9c00613 li a2,-100
register long a4 __asm__("a4") = e;
1e0c: 4701 li a4,0
__asm_syscall("r"(a7), "0"(a0), "r"(a1), "r"(a2), "r"(a3), "r"(a4))
1e0e: 00000073 ecall
return sys_linkat(AT_FDCWD, old_path, AT_FDCWD, new_path, 0);
}
1e12: 2501 sext.w a0,a0
1e14: 8082 ret
0000000000001e16 <unlink>:
int unlink(char *path)
{
1e16: 85aa mv a1,a0
register long a7 __asm__("a7") = n;
1e18: 02300893 li a7,35
register long a0 __asm__("a0") = a;
1e1c: f9c00513 li a0,-100
register long a2 __asm__("a2") = c;
1e20: 4601 li a2,0
__asm_syscall("r"(a7), "0"(a0), "r"(a1), "r"(a2))
1e22: 00000073 ecall
return sys_unlinkat(AT_FDCWD, path, 0);
}
1e26: 2501 sext.w a0,a0
1e28: 8082 ret
0000000000001e2a <uname>:
register long a7 __asm__("a7") = n;
1e2a: 0a000893 li a7,160
__asm_syscall("r"(a7), "0"(a0))
1e2e: 00000073 ecall
int uname(void *buf)
{
return syscall(SYS_uname, buf);
}
1e32: 2501 sext.w a0,a0
1e34: 8082 ret
0000000000001e36 <brk>:
register long a7 __asm__("a7") = n;
1e36: 0d600893 li a7,214
__asm_syscall("r"(a7), "0"(a0))
1e3a: 00000073 ecall
int brk(void *addr)
{
return syscall(SYS_brk, addr);
}
1e3e: 2501 sext.w a0,a0
1e40: 8082 ret
0000000000001e42 <getcwd>:
register long a7 __asm__("a7") = n;
1e42: 48c5 li a7,17
__asm_syscall("r"(a7), "0"(a0), "r"(a1))
1e44: 00000073 ecall
char *getcwd(char *buf, size_t size){
return syscall(SYS_getcwd, buf, size);
}
1e48: 8082 ret
0000000000001e4a <chdir>:
register long a7 __asm__("a7") = n;
1e4a: 03100893 li a7,49
__asm_syscall("r"(a7), "0"(a0))
1e4e: 00000073 ecall
int chdir(const char *path){
return syscall(SYS_chdir, path);
}
1e52: 2501 sext.w a0,a0
1e54: 8082 ret
0000000000001e56 <mkdir>:
int mkdir(const char *path, mode_t mode){
1e56: 862e mv a2,a1
1e58: 87aa mv a5,a0
register long a2 __asm__("a2") = c;
1e5a: 1602 slli a2,a2,0x20
register long a7 __asm__("a7") = n;
1e5c: 02200893 li a7,34
register long a0 __asm__("a0") = a;
1e60: f9c00513 li a0,-100
register long a1 __asm__("a1") = b;
1e64: 85be mv a1,a5
register long a2 __asm__("a2") = c;
1e66: 9201 srli a2,a2,0x20
__asm_syscall("r"(a7), "0"(a0), "r"(a1), "r"(a2))
1e68: 00000073 ecall
return syscall(SYS_mkdirat, AT_FDCWD, path, mode);
}
1e6c: 2501 sext.w a0,a0
1e6e: 8082 ret
0000000000001e70 <getdents>:
register long a7 __asm__("a7") = n;
1e70: 03d00893 li a7,61
__asm_syscall("r"(a7), "0"(a0), "r"(a1), "r"(a2))
1e74: 00000073 ecall
int getdents(int fd, struct linux_dirent64 *dirp64, unsigned long len){
//return syscall(SYS_getdents64, fd, dirp64, len);
return syscall(SYS_getdents64, fd, dirp64, len);
}
1e78: 2501 sext.w a0,a0
1e7a: 8082 ret
0000000000001e7c <pipe>:
register long a7 __asm__("a7") = n;
1e7c: 03b00893 li a7,59
register long a1 __asm__("a1") = b;
1e80: 4581 li a1,0
__asm_syscall("r"(a7), "0"(a0), "r"(a1))
1e82: 00000073 ecall
int pipe(int fd[2]){
return syscall(SYS_pipe2, fd, 0);
}
1e86: 2501 sext.w a0,a0
1e88: 8082 ret
0000000000001e8a <dup>:
register long a7 __asm__("a7") = n;
1e8a: 48dd li a7,23
__asm_syscall("r"(a7), "0"(a0))
1e8c: 00000073 ecall
int dup(int fd){
return syscall(SYS_dup, fd);
}
1e90: 2501 sext.w a0,a0
1e92: 8082 ret
0000000000001e94 <dup2>:
register long a7 __asm__("a7") = n;
1e94: 48e1 li a7,24
register long a2 __asm__("a2") = c;
1e96: 4601 li a2,0
__asm_syscall("r"(a7), "0"(a0), "r"(a1), "r"(a2))
1e98: 00000073 ecall
int dup2(int old, int new){
return syscall(SYS_dup3, old, new, 0);
}
1e9c: 2501 sext.w a0,a0
1e9e: 8082 ret
0000000000001ea0 <mount>:
register long a7 __asm__("a7") = n;
1ea0: 02800893 li a7,40
__asm_syscall("r"(a7), "0"(a0), "r"(a1), "r"(a2), "r"(a3), "r"(a4))
1ea4: 00000073 ecall
int mount(const char *special, const char *dir, const char *fstype, unsigned long flags, const void *data)
{
return syscall(SYS_mount, special, dir, fstype, flags, data);
}
1ea8: 2501 sext.w a0,a0
1eaa: 8082 ret
0000000000001eac <umount>:
register long a7 __asm__("a7") = n;
1eac: 02700893 li a7,39
register long a1 __asm__("a1") = b;
1eb0: 4581 li a1,0
__asm_syscall("r"(a7), "0"(a0), "r"(a1))
1eb2: 00000073 ecall
int umount(const char *special)
{
return syscall(SYS_umount2, special, 0);
}
1eb6: 2501 sext.w a0,a0
1eb8: 8082 ret
0000000000001eba <__clone>:
.global __clone
.type __clone, %function
__clone:
# Save func and arg to stack
addi a1, a1, -16
1eba: 15c1 addi a1,a1,-16
sd a0, 0(a1)
1ebc: e188 sd a0,0(a1)
sd a3, 8(a1)
1ebe: e594 sd a3,8(a1)
# Call SYS_clone
mv a0, a2
1ec0: 8532 mv a0,a2
mv a2, a4
1ec2: 863a mv a2,a4
mv a3, a5
1ec4: 86be mv a3,a5
mv a4, a6
1ec6: 8742 mv a4,a6
li a7, 220 # SYS_clone
1ec8: 0dc00893 li a7,220
ecall
1ecc: 00000073 ecall
beqz a0, 1f
1ed0: c111 beqz a0,1ed4 <__clone+0x1a>
# Parent
ret
1ed2: 8082 ret
# Child
1: ld a1, 0(sp)
1ed4: 6582 ld a1,0(sp)
ld a0, 8(sp)
1ed6: 6522 ld a0,8(sp)
jalr a1
1ed8: 9582 jalr a1
# Exit
li a7, 93 # SYS_exit
1eda: 05d00893 li a7,93
ecall
1ede: 00000073 ecall
|
;;
;; Copyright (c) 2020-2021, Intel Corporation
;;
;; Redistribution and use in source and binary forms, with or without
;; modification, are permitted provided that the following conditions are met:
;;
;; * Redistributions of source code must retain the above copyright notice,
;; this list of conditions and the following disclaimer.
;; * Redistributions in binary form must reproduce the above copyright
;; notice, this list of conditions and the following disclaimer in the
;; documentation and/or other materials provided with the distribution.
;; * Neither the name of Intel Corporation nor the names of its contributors
;; may be used to endorse or promote products derived from this software
;; without specific prior written permission.
;;
;; THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
;; AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
;; IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
;; DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
;; FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
;; DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
;; SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
;; CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
;; OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
;; OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
;;
%include "include/os.asm"
%include "include/reg_sizes.asm"
%include "include/crc32_const.inc"
%include "include/clear_regs.asm"
%include "include/cet.inc"
[bits 64]
default rel
%ifndef CRC10_IUUP_DATA_FN
%define CRC10_IUUP_DATA_FN crc10_iuup_data_sse
%endif
%ifndef CRC6_IUUP_HEADER_FN
%define CRC6_IUUP_HEADER_FN crc6_iuup_header_sse
%endif
%ifndef CRC32_FN
%define CRC32_FN crc32_by8_sse
%endif
%ifdef LINUX
%define arg1 rdi
%define arg2 rsi
%define arg3 rdx
%define arg4 rcx
%else
%define arg1 rcx
%define arg2 rdx
%define arg3 r8
%define arg4 r9
%endif
struc STACK_FRAME
_xmm_save: resq 8 * 2
_rsp_save: resq 1
endstruc
section .text
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; arg1 - buffer pointer
;; arg2 - buffer size in bytes
;; Returns CRC value through RAX
align 32
MKGLOBAL(CRC10_IUUP_DATA_FN, function,)
CRC10_IUUP_DATA_FN:
endbranch64
%ifdef SAFE_PARAM
or arg1, arg1
jz .wrong_param
%endif
%ifndef LINUX
mov rax, rsp
sub rsp, STACK_FRAME_size
and rsp, -16
mov [rsp + _rsp_save], rax
movdqa [rsp + _xmm_save + 16*0], xmm6
movdqa [rsp + _xmm_save + 16*1], xmm7
movdqa [rsp + _xmm_save + 16*2], xmm8
movdqa [rsp + _xmm_save + 16*3], xmm9
movdqa [rsp + _xmm_save + 16*4], xmm10
movdqa [rsp + _xmm_save + 16*5], xmm11
movdqa [rsp + _xmm_save + 16*6], xmm12
movdqa [rsp + _xmm_save + 16*7], xmm13
%endif
lea arg4, [rel crc32_iuup_data_crc10_const]
mov arg3, arg2
mov arg2, arg1
xor DWORD(arg1), DWORD(arg1)
call CRC32_FN
shr eax, 22 ; adjust to 10-bit poly
%ifdef SAFE_DATA
clear_scratch_xmms_sse_asm
%endif
%ifndef LINUX
movdqa xmm6, [rsp + _xmm_save + 16*0]
movdqa xmm7, [rsp + _xmm_save + 16*1]
movdqa xmm8, [rsp + _xmm_save + 16*2]
movdqa xmm9, [rsp + _xmm_save + 16*3]
movdqa xmm10, [rsp + _xmm_save + 16*4]
movdqa xmm11, [rsp + _xmm_save + 16*5]
movdqa xmm12, [rsp + _xmm_save + 16*6]
movdqa xmm13, [rsp + _xmm_save + 16*7]
mov rsp, [rsp + _rsp_save]
%endif
.wrong_param:
ret
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; arg1 - buffer pointer
;; arg2 - buffer size in bytes
;; Returns CRC value through RAX
align 32
MKGLOBAL(CRC6_IUUP_HEADER_FN, function,)
CRC6_IUUP_HEADER_FN:
endbranch64
%ifdef SAFE_PARAM
or arg1, arg1
jz .wrong_param
%endif
%ifndef LINUX
mov rax, rsp
sub rsp, STACK_FRAME_size
and rsp, -16
mov [rsp + _rsp_save], rax
movdqa [rsp + _xmm_save + 16*0], xmm6
movdqa [rsp + _xmm_save + 16*1], xmm7
movdqa [rsp + _xmm_save + 16*2], xmm8
movdqa [rsp + _xmm_save + 16*3], xmm9
movdqa [rsp + _xmm_save + 16*4], xmm10
movdqa [rsp + _xmm_save + 16*5], xmm11
movdqa [rsp + _xmm_save + 16*6], xmm12
movdqa [rsp + _xmm_save + 16*7], xmm13
%endif
lea arg4, [rel crc32_iuup_header_crc6_const]
mov arg3, arg2
mov arg2, arg1
xor DWORD(arg1), DWORD(arg1)
call CRC32_FN
shr eax, 26 ; adjust to 7-bit poly
%ifdef SAFE_DATA
clear_scratch_xmms_sse_asm
%endif
%ifndef LINUX
movdqa xmm6, [rsp + _xmm_save + 16*0]
movdqa xmm7, [rsp + _xmm_save + 16*1]
movdqa xmm8, [rsp + _xmm_save + 16*2]
movdqa xmm9, [rsp + _xmm_save + 16*3]
movdqa xmm10, [rsp + _xmm_save + 16*4]
movdqa xmm11, [rsp + _xmm_save + 16*5]
movdqa xmm12, [rsp + _xmm_save + 16*6]
movdqa xmm13, [rsp + _xmm_save + 16*7]
mov rsp, [rsp + _rsp_save]
%endif
.wrong_param:
ret
%ifdef LINUX
section .note.GNU-stack noalloc noexec nowrite progbits
%endif
|
; uchar tshc_saddr2cy(void *saddr)
SECTION code_clib
SECTION code_arch
PUBLIC tshc_saddr2cy
EXTERN zx_saddr2cy
defc tshc_saddr2cy = zx_saddr2cy
|
#include "../CPU.asm"
#bank rom
; tests jmz, jmc, jnz. does not test jnc, jmn, jnn
; ** jmz tests ***
; first test case
test1:
load a, #0xAA
assert a, #0xAA
add a, #0x00
; jump if zero. should evaluate to false
jmz .b
; assert a reg is still correct
assert a, #0xAA
; go to next test case
jmp test2
; if we jump here, we should error out
.b:
load a, #0x00
assert a, #0xBB;
; second test case
test2:
load a, #0x00
assert a, #0x00
add a, #0x00
; jump if zero. should evaluate to true
jmz .b
; we should error out if we end up here
assert a, #0xFF
halt
; jump here is correct
.b:
load a, #0xCC
assert a, #0xCC
; ** JMC tests ***
; third test case
test3:
load a, #0xAA
assert a, #0xAA
add a, #0x00
; jump if carry. should evaluate to false
jmc .b
; assert a reg is still correct
assert a, #0xAA
; go to next test case
jmp test4
; if we jump here, we should error out
.b:
load a, #0x00
assert a, #0xBB;
; fourth test case
test4:
load a, #0xFF
assert a, #0xFF
add a, #0x01
; jump if carry. should evaluate to true
jmc .b
; we should error out if we end up here
assert a, #0x12
halt
; jump here is correct
.b:
load a, #0xDD
assert a, #0xDD
; ** JNZ tests ***
; fifth test case
test5:
load a, #0x00
assert a, #0x00
add a, #0x00
; jump if not zero. should evaluate to false
jnz .b
; assert a reg is still correct
assert a, #0x00
; go to next test case
jmp test6
; if we jump here, we should error out
.b:
load a, #0x00
assert a, #0x05;
; sixth test case
test6:
load a, #0x01
assert a, #0x01
add a, #0x00
; jump if not zero. should evaluate to true
jnz .b
; we should error out if we end up here
assert a, #0x06
halt
; jump here is correct
.b:
load a, #0x06
assert a, #0x06
halt |
copyright zengfr site:http://github.com/zengfr/romhack
00042A move.l D1, (A0)+
00042C dbra D0, $42a
004D94 move.l D1, (A1)+
004D96 dbra D0, $4d94
004DE8 move.l #$20000, ($4,A0)
004DF0 move.w #$64, ($6c,A0) [123p+ 4, 123p+ 6]
004E12 clr.l ($4,A6)
004E16 clr.w ($10c,A6) [123p+ 4, 123p+ 6]
00687A move.l #$200001a, ($4,A6) [123p+ C1]
006882 clr.w ($90,A6) [123p+ 4, 123p+ 6]
0068F0 move.b (A1)+, ($6,A0)
0068F4 move.b (A1)+, ($7,A0) [123p+ 6]
01073A move.l #$2020000, ($4,A3) [123p+ 0]
010742 moveq #$0, D0 [123p+ 4, 123p+ 6]
0107C2 move.b D0, ($6,A3) [123p+ 7B]
0107C6 clr.b ($7,A3) [123p+ 6]
0108C0 move.l #$2040000, ($4,A2) [123p+ 73]
0108C8 move.b #$c, ($2e,A2) [123p+ 4, 123p+ 6]
010E94 move.l #$2020000, ($4,A3) [123p+ 0]
010E9C moveq #$0, D0 [123p+ 4, 123p+ 6]
010F48 move.b D0, ($6,A3) [123p+ 7B]
010F4C clr.b ($7,A3) [123p+ 6]
011688 move.l #$2020000, ($4,A3) [123p+ 0]
011690 moveq #$0, D0 [123p+ 4, 123p+ 6]
01170A move.b D0, ($6,A3) [123p+ 7B]
01170E clr.b ($7,A3) [123p+ 6]
011DA0 move.l #$2020000, ($4,A3) [123p+ 0]
011DA8 moveq #$0, D0 [123p+ 4, 123p+ 6]
011E22 move.b D0, ($6,A3) [123p+ 7B]
011E26 clr.b ($7,A3) [123p+ 6]
0125E8 move.l #$2020000, ($4,A3) [123p+ 0]
0125F0 moveq #$0, D0 [123p+ 4, 123p+ 6]
012658 move.b D0, ($6,A3)
01265C clr.b ($7,A3)
018B2E move.l #$2000432, ($4,A6) [123p+ 25]
018B36 rts [123p+ 4, 123p+ 6]
018B3A move.b ($6,A6), D0
018B3E move.w ($6,PC,D0.w), D0 [123p+ 6]
018B96 addq.b #2, ($6,A6) [123p+ C]
018B9A bsr $18c82 [123p+ 6]
018BA4 addq.b #2, ($6,A6) [123p+ EC]
018BA8 move.b #$1, ($24,A6) [123p+ 6]
018BEE move.l #$2000000, ($4,A6)
018BF6 tst.b ($518,A5) [123p+ 4, 123p+ 6]
018E36 cmpi.b #$2, ($6,A6)
018E3C beq $18e4c [123p+ 6]
0190B8 move.b ($6,A6), D0
0190BC move.w ($6,PC,D0.w), D1 [123p+ 6]
019122 move.l #$2000000, ($4,A6)
01912A moveq #$0, D0 [123p+ 4, 123p+ 6]
0192C6 move.l #$2000002, ($4,A6)
0192CE moveq #$0, D0 [123p+ 4, 123p+ 6]
0193EA move.l #$2000004, ($4,A6)
0193F2 move.b #$0, ($58,A6) [123p+ 4, 123p+ 6]
019464 move.l #$2000006, ($4,A6)
01946C clr.b ($ad,A6) [123p+ 4, 123p+ 6]
019516 move.l #$2000008, ($4,A6)
01951E move.b #$0, ($58,A6) [123p+ 4, 123p+ 6]
019574 move.l #$200000a, ($4,A6)
01957C move.b #$2, ($58,A6) [123p+ 4, 123p+ 6]
019632 move.l #$200000c, ($4,A6)
01963A move.b #$4, ($58,A6) [123p+ 4, 123p+ 6]
0196B8 move.l #$200000e, ($4,A6)
0196C0 move.b #$12, ($58,A6) [123p+ 4, 123p+ 6]
01973E move.l #$2000010, ($4,A6)
019746 move.b #$14, ($58,A6) [123p+ 4, 123p+ 6]
019812 move.l #$2000012, ($4,A6)
01981A moveq #$d, D0 [123p+ 4, 123p+ 6]
019832 move.l #$2000014, ($4,A6)
01983A jsr $9c20.l [123p+ 4, 123p+ 6]
019904 move.l #$2000016, ($4,A6)
01990C clr.b ($25,A6) [123p+ 4, 123p+ 6]
019996 move.l #$2000018, ($4,A6)
01999E clr.b ($25,A6) [123p+ 4, 123p+ 6]
019ACC move.l #$200001c, ($4,A6)
019AD4 move.b #$1, ($c4,A6) [123p+ 4, 123p+ 6]
019B60 move.l #$200001e, ($4,A6)
019B68 clr.b ($25,A6) [123p+ 4, 123p+ 6]
019C36 move.l #$2000020, ($4,A6)
019C3E clr.b ($25,A6) [123p+ 4, 123p+ 6]
019D00 move.l #$2000022, ($4,A6)
019D08 clr.b ($25,A6) [123p+ 4, 123p+ 6]
019DDA move.l #$2000024, ($4,A6)
019DE2 moveq #$f, D0 [123p+ 4, 123p+ 6]
019E8A move.l #$2000028, ($4,A6)
019E92 moveq #$f, D0 [123p+ 4, 123p+ 6]
019FF2 move.l #$2000200, ($4,A6)
019FFA move.b #$3, ($a9,A6) [123p+ 4, 123p+ 6]
01A18C move.l #$2000202, ($4,A6)
01A194 move.w ($20,A6), D0 [123p+ 4, 123p+ 6]
01A5DA move.l #$2000400, ($4,A6)
01A5E2 move.b #$1, ($51,A6) [123p+ 4, 123p+ 6]
01A822 move.l #$2000404, ($4,A6)
01A82A jsr $9c0c.l [123p+ 4, 123p+ 6]
01A848 cmpi.b #$2, ($6,A6)
01A84E bne $1a866
01A866 move.l #$2000406, ($4,A6)
01A86E move.b #$1, ($51,A6) [123p+ 4, 123p+ 6]
01A906 move.l #$2000408, ($4,A6)
01A90E move.b #$1, ($51,A6) [123p+ 4, 123p+ 6]
01A9A4 move.l #$200040a, ($4,A6)
01A9AC clr.b ($25,A6) [123p+ 4, 123p+ 6]
01AA54 move.l #$200040c, ($4,A6)
01AA5C clr.b ($25,A6) [123p+ 4, 123p+ 6]
01AAE6 move.l #$200040e, ($4,A6)
01AAEE clr.b ($25,A6) [123p+ 4, 123p+ 6]
01AB74 move.l #$2000410, ($4,A6) [123p+ 80]
01AB7C move.b ($59,A6), D3 [123p+ 4, 123p+ 6]
01ABD4 move.l #$2000412, ($4,A6)
01ABDC move.b #$14, ($58,A6) [123p+ 4, 123p+ 6]
01AD06 move.l #$2000416, ($4,A6)
01AD0E moveq #$d, D0 [123p+ 4, 123p+ 6]
01AE62 move.l #$200041a, ($4,A6)
01AE6A moveq #$0, D0 [123p+ 4, 123p+ 6]
01AF82 move.l #$200041c, ($4,A6)
01AF8A jsr $655e.l [123p+ 4, 123p+ 6]
01B496 move.l #$2000428, ($4,A6)
01B49E moveq #$d, D0 [123p+ 4, 123p+ 6]
01B568 move.l #$200042a, ($4,A6)
01B570 moveq #$d, D0 [123p+ 4, 123p+ 6]
01B5D4 move.l #$200042c, ($4,A6)
01B5DC moveq #$d, D0 [123p+ 4, 123p+ 6]
01B67C move.l #$200042e, ($4,A6)
01B684 move.b #$1, ($51,A6) [123p+ 4, 123p+ 6]
01B6EC move.l #$2000430, ($4,A6)
01B6F4 moveq #$0, D0 [123p+ 4, 123p+ 6]
01BBCA move.l #$2000434, ($4,A6)
01BBD2 jsr $655e.l [123p+ 4, 123p+ 6]
01BD5E move.l #$2000436, ($4,A6)
01BD66 jsr $9c0c.l [123p+ 4, 123p+ 6]
01BFE8 move.l D0, ($4,A6)
01BFEC addq.b #1, ($a3,A6)
01C032 move.b ($6,A6), D0
01C036 move.w ($6,PC,D0.w), D1 [123p+ 6]
01C19C move.w #$400, ($6,A6)
01C1A2 moveq #$0, D0 [123p+ 6]
01C37C move.w #$600, ($6,A6)
01C382 moveq #$0, D0 [123p+ 6]
01C8CC cmpi.b #$e, ($6,A6)
01C8D2 beq $1c8e4 [123p+ 6]
01C8D8 cmpi.b #$10, ($6,A6)
01C8DE beq $1c8e4 [123p+ 6]
01CB78 move.b #$1a, ($6,A6)
01CB7E clr.b ($7,A6) [123p+ 6]
01CBE6 move.b #$1c, ($6,A6)
01CBEC clr.b ($7,A6) [123p+ 6]
01CDA0 move.l #$4000000, ($4,A6)
01CDA8 clr.b ($23,A6) [123p+ 4, 123p+ 6]
01CDAE move.l #$2020000, ($4,A6)
01CDB6 move.b #$1e, ($6,A6) [123p+ 4, 123p+ 6]
01CDBC move.w #$78, ($f6,A6) [123p+ 6]
01CF9C move.b #$20, ($6,A6)
01CFA2 clr.b ($7,A6) [123p+ 6]
01D2C0 move.b ($6,A6), D0
01D2C4 move.w ($6,PC,D0.w), D0 [123p+ 6]
01D2FE move.w #$200, ($6,A6)
01D304 clr.b ($62,A6) [123p+ 6]
01D662 move.b ($6,A6), D0
01D666 move.w ($6,PC,D0.w), D1 [123p+ 6]
01D694 move.l #$2040002, ($4,A6) [123p+ A9]
01D69C movea.w ($70,A6), A0 [123p+ 4, 123p+ 6]
01D74E move.l #$2040200, ($4,A6)
01D756 moveq #$1, D0 [123p+ 4, 123p+ 6]
01D7E6 move.l #$2040400, ($4,A6)
01D7EE moveq #$2, D0 [123p+ 4, 123p+ 6]
01D890 move.l #$2040600, ($4,A6)
01D898 move.b #$a, ($58,A6) [123p+ 4, 123p+ 6]
024798 cmpi.l #$2000014, ($4,A0)
0247A0 bne $247ea [123p+ 4, 123p+ 6]
024984 cmpi.l #$2000014, ($4,A0)
02498C bne $249a4 [123p+ 4, 123p+ 6]
024A42 cmpi.l #$2000014, ($4,A0)
024A4A bne $24a62 [123p+ 4, 123p+ 6]
03224A cmpi.b #$2, ($327a,A5)
032250 bne $32258 [123p+ 6]
0322C0 cmpi.b #$2, ($33fa,A5)
0322C6 bne $322ce [123p+ 6]
032336 cmpi.b #$2, ($357a,A5)
03233C bne $32344 [123p+ 6]
0355E0 cmpi.b #$2, ($6,A0)
0355E6 bne $35634 [123p+ 6]
048EAA move.l #$2060000, ($4,A0) [123p+ 70]
048EB2 move.b #$40, ($c8,A0) [123p+ 4, 123p+ 6]
048FB2 move.l #$2020000, ($4,A0)
048FBA move.b #$8, ($6,A0) [123p+ 4, 123p+ 6]
048FC0 move.w #$18, D0 [123p+ 6]
04EF8C move.l #$2060000, ($4,A0) [123p+ 70]
04EF94 move.b #$40, ($c8,A0) [123p+ 4, 123p+ 6]
04F094 move.l #$2020000, ($4,A0)
04F09C move.b #$8, ($6,A0) [123p+ 4, 123p+ 6]
04F0A2 move.w #$18, D0 [123p+ 6]
0944A0 move.l ($4,A0), D0
0944A4 cmp.l ($5c,A6), D0 [123p+ 4, 123p+ 6, enemy+ 4, enemy+ 6]
0AAACA move.l (A0), D2
0AAACC move.w D0, (A0) [123p+11A, 123p+11C, 123p+11E, 123p+120, 123p+122, 123p+124, 123p+126, 123p+128, 123p+12A, enemy+BC, enemy+C0, enemy+C2, enemy+C4, enemy+CC, enemy+CE, enemy+D0, enemy+D2, enemy+D4, enemy+D6, enemy+D8, enemy+DA, enemy+DE, item+86, item+88, item+8A, item+98, item+9A, item+9C, item+9E, item+A0, item+A2, item+A4, item+A6, scr1]
0AAACE move.w D0, ($2,A0)
0AAAD2 cmp.l (A0), D0
0AAAD4 bne $aaafc
0AAAD8 move.l D2, (A0)+
0AAADA cmpa.l A0, A1 [123p+11A, 123p+11C, 123p+11E, 123p+120, 123p+122, 123p+124, 123p+126, 123p+128, 123p+12A, enemy+BC, enemy+C0, enemy+C2, enemy+C4, enemy+CC, enemy+CE, enemy+D0, enemy+D2, enemy+D4, enemy+D6, enemy+D8, enemy+DA, enemy+DE, item+86, item+88, item+8A, item+98, item+9A, item+9C, item+9E, item+A0, item+A2, item+A4, item+A6, scr1]
0AAAE6 move.l (A0), D2
0AAAE8 move.w D0, (A0) [123p+11A, 123p+11C, 123p+11E, 123p+120, 123p+122, 123p+124, 123p+126, 123p+128, 123p+12A, enemy+BC, enemy+C0, enemy+C2, enemy+C4, enemy+CC, enemy+CE, enemy+D0, enemy+D2, enemy+D4, enemy+D6, enemy+D8, enemy+DA, enemy+DE, item+86, item+88, item+8A, item+98, item+9A, item+9C, item+9E, item+A0, item+A2, item+A4, item+A6, scr1]
0AAAF4 move.l D2, (A0)+
0AAAF6 cmpa.l A0, A1 [123p+11A, 123p+11C, 123p+11E, 123p+120, 123p+122, 123p+124, 123p+126, 123p+128, 123p+12A, enemy+BC, enemy+C0, enemy+C2, enemy+C4, enemy+CC, enemy+CE, enemy+D0, enemy+D2, enemy+D4, enemy+D6, enemy+D8, enemy+DA, enemy+DE, item+86, item+88, item+8A, item+98, item+9A, item+9C, item+9E, item+A0, item+A2, item+A4, item+A6, scr1]
copyright zengfr site:http://github.com/zengfr/romhack
|
.global s_prepare_buffers
s_prepare_buffers:
push %r10
push %rax
push %rbp
push %rbx
lea addresses_WT_ht+0x195c0, %rbp
nop
xor $54790, %rbx
movups (%rbp), %xmm0
vpextrq $0, %xmm0, %rax
sub $5691, %r10
pop %rbx
pop %rbp
pop %rax
pop %r10
ret
.global s_faulty_load
s_faulty_load:
push %r10
push %r9
push %rax
push %rcx
push %rdi
push %rdx
push %rsi
// Load
lea addresses_RW+0x11217, %rsi
clflush (%rsi)
nop
sub $30955, %rdi
movups (%rsi), %xmm5
vpextrq $1, %xmm5, %rcx
and $46848, %r9
// Store
lea addresses_D+0x1fe17, %r9
nop
nop
nop
nop
nop
xor %rsi, %rsi
mov $0x5152535455565758, %rdi
movq %rdi, %xmm5
movups %xmm5, (%r9)
nop
xor %r10, %r10
// Faulty Load
lea addresses_D+0x1fe17, %rdi
nop
nop
nop
add $22065, %rdx
mov (%rdi), %ecx
lea oracles, %rdi
and $0xff, %rcx
shlq $12, %rcx
mov (%rdi,%rcx,1), %rcx
pop %rsi
pop %rdx
pop %rdi
pop %rcx
pop %rax
pop %r9
pop %r10
ret
/*
<gen_faulty_load>
[REF]
{'src': {'type': 'addresses_D', 'AVXalign': False, 'size': 32, 'NT': False, 'same': False, 'congruent': 0}, 'OP': 'LOAD'}
{'src': {'type': 'addresses_RW', 'AVXalign': False, 'size': 16, 'NT': False, 'same': False, 'congruent': 9}, 'OP': 'LOAD'}
{'OP': 'STOR', 'dst': {'type': 'addresses_D', 'AVXalign': False, 'size': 16, 'NT': False, 'same': True, 'congruent': 0}}
[Faulty Load]
{'src': {'type': 'addresses_D', 'AVXalign': False, 'size': 4, 'NT': False, 'same': True, 'congruent': 0}, 'OP': 'LOAD'}
<gen_prepare_buffer>
{'src': {'type': 'addresses_WT_ht', 'AVXalign': False, 'size': 16, 'NT': False, 'same': False, 'congruent': 0}, 'OP': 'LOAD'}
{'58': 21829}
58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58
*/
|
#include <jni.h>
#include <string>
#include <android/log.h>
extern "C" JNIEXPORT jint JNICALL
Java_com_example_pluginhelloworld_HelloJni_calculate(
JNIEnv* env,
jclass /* this */,
jint x,
jint y) {
int ret = x + y;
__android_log_print(ANDROID_LOG_INFO, "HelloJni", "pluginhelloworld %i + %i = %i", x, y, ret);
return ret;
}
|
;------------------------------------------------------------------------------
;
; Copyright (c) 2006, Intel Corporation. All rights reserved.<BR>
; This program and the accompanying materials
; are licensed and made available under the terms and conditions of the BSD License
; which accompanies this distribution. The full text of the license may be found at
; http://opensource.org/licenses/bsd-license.php.
;
; THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
; WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
;
; Module Name:
;
; WriteDr7.Asm
;
; Abstract:
;
; AsmWriteDr7 function
;
; Notes:
;
;------------------------------------------------------------------------------
.586p
.model flat,C
.code
;------------------------------------------------------------------------------
; UINTN
; EFIAPI
; AsmWriteDr7 (
; IN UINTN Value
; );
;------------------------------------------------------------------------------
AsmWriteDr7 PROC
mov eax, [esp + 4]
mov dr7, eax
ret
AsmWriteDr7 ENDP
END
|
; A238236: Expansion of (1-x-x^2)/((x-1)*(x^3+3*x^2+2*x-1)).
; Submitted by Christian Krause
; 1,2,6,18,55,169,520,1601,4930,15182,46754,143983,443409,1365520,4205249,12950466,39882198,122821042,378239143,1164823609,3587185688,11047081345,34020543362,104769516446,322647744322,993624581343,3059961912097,9423445312544,29020400942721,89371099735170,275226847611046,847587395370322,2610226433308951,8038441900339913,24755150495977000,76235853126282689,234775599640836290,723013909156497646,2226590470361786850,6856998267833902927,21116781855909664049,65031148985682823728,200269641806928542529
mul $0,2
add $0,1
mov $2,1
mov $3,2
lpb $0
sub $0,1
add $1,$3
sub $1,$2
add $3,$2
add $2,2
add $2,$1
lpe
mov $0,$2
div $0,5
add $0,1
|
_usertests: file format elf32-i386
Disassembly of section .text:
00000000 <main>:
return randstate;
}
int
main(int argc, char *argv[])
{
0: f3 0f 1e fb endbr32
4: 8d 4c 24 04 lea 0x4(%esp),%ecx
8: 83 e4 f0 and $0xfffffff0,%esp
b: ff 71 fc pushl -0x4(%ecx)
e: 55 push %ebp
f: 89 e5 mov %esp,%ebp
11: 51 push %ecx
12: 83 ec 0c sub $0xc,%esp
printf(1, "usertests starting\n");
15: 68 46 4e 00 00 push $0x4e46
1a: 6a 01 push $0x1
1c: e8 cf 3a 00 00 call 3af0 <printf>
if(open("usertests.ran", 0) >= 0){
21: 59 pop %ecx
22: 58 pop %eax
23: 6a 00 push $0x0
25: 68 5a 4e 00 00 push $0x4e5a
2a: e8 9c 39 00 00 call 39cb <open>
2f: 83 c4 10 add $0x10,%esp
32: 85 c0 test %eax,%eax
34: 78 13 js 49 <main+0x49>
printf(1, "already ran user tests -- rebuild fs.img\n");
36: 52 push %edx
37: 52 push %edx
38: 68 c4 55 00 00 push $0x55c4
3d: 6a 01 push $0x1
3f: e8 ac 3a 00 00 call 3af0 <printf>
exit();
44: e8 3a 39 00 00 call 3983 <exit>
}
close(open("usertests.ran", O_CREATE));
49: 50 push %eax
4a: 50 push %eax
4b: 68 00 02 00 00 push $0x200
50: 68 5a 4e 00 00 push $0x4e5a
55: e8 71 39 00 00 call 39cb <open>
5a: 89 04 24 mov %eax,(%esp)
5d: e8 51 39 00 00 call 39b3 <close>
argptest();
62: e8 29 36 00 00 call 3690 <argptest>
createdelete();
67: e8 04 12 00 00 call 1270 <createdelete>
linkunlink();
6c: e8 df 1a 00 00 call 1b50 <linkunlink>
concreate();
71: e8 da 17 00 00 call 1850 <concreate>
fourfiles();
76: e8 f5 0f 00 00 call 1070 <fourfiles>
sharedfd();
7b: e8 30 0e 00 00 call eb0 <sharedfd>
bigargtest();
80: e8 ab 32 00 00 call 3330 <bigargtest>
bigwrite();
85: e8 06 24 00 00 call 2490 <bigwrite>
bigargtest();
8a: e8 a1 32 00 00 call 3330 <bigargtest>
bsstest();
8f: e8 2c 32 00 00 call 32c0 <bsstest>
sbrktest();
94: e8 37 2d 00 00 call 2dd0 <sbrktest>
validatetest();
99: e8 62 31 00 00 call 3200 <validatetest>
opentest();
9e: e8 6d 03 00 00 call 410 <opentest>
writetest();
a3: e8 08 04 00 00 call 4b0 <writetest>
writetest1();
a8: e8 e3 05 00 00 call 690 <writetest1>
createtest();
ad: e8 ae 07 00 00 call 860 <createtest>
openiputtest();
b2: e8 59 02 00 00 call 310 <openiputtest>
exitiputtest();
b7: e8 54 01 00 00 call 210 <exitiputtest>
iputtest();
bc: e8 5f 00 00 00 call 120 <iputtest>
mem();
c1: e8 1a 0d 00 00 call de0 <mem>
pipe1();
c6: e8 95 09 00 00 call a60 <pipe1>
preempt();
cb: e8 30 0b 00 00 call c00 <preempt>
exitwait();
d0: e8 8b 0c 00 00 call d60 <exitwait>
rmdot();
d5: e8 a6 27 00 00 call 2880 <rmdot>
fourteen();
da: e8 61 26 00 00 call 2740 <fourteen>
bigfile();
df: e8 8c 24 00 00 call 2570 <bigfile>
subdir();
e4: e8 b7 1c 00 00 call 1da0 <subdir>
linktest();
e9: e8 42 15 00 00 call 1630 <linktest>
unlinkread();
ee: e8 ad 13 00 00 call 14a0 <unlinkread>
dirfile();
f3: e8 08 29 00 00 call 2a00 <dirfile>
iref();
f8: e8 03 2b 00 00 call 2c00 <iref>
forktest();
fd: e8 1e 2c 00 00 call 2d20 <forktest>
bigdir(); // slow
102: e8 59 1b 00 00 call 1c60 <bigdir>
uio();
107: e8 04 35 00 00 call 3610 <uio>
exectest();
10c: e8 ff 08 00 00 call a10 <exectest>
exit();
111: e8 6d 38 00 00 call 3983 <exit>
116: 66 90 xchg %ax,%ax
118: 66 90 xchg %ax,%ax
11a: 66 90 xchg %ax,%ax
11c: 66 90 xchg %ax,%ax
11e: 66 90 xchg %ax,%ax
00000120 <iputtest>:
{
120: f3 0f 1e fb endbr32
124: 55 push %ebp
125: 89 e5 mov %esp,%ebp
127: 83 ec 10 sub $0x10,%esp
printf(stdout, "iput test\n");
12a: 68 ec 3e 00 00 push $0x3eec
12f: ff 35 f0 5e 00 00 pushl 0x5ef0
135: e8 b6 39 00 00 call 3af0 <printf>
if(mkdir("iputdir") < 0){
13a: c7 04 24 7f 3e 00 00 movl $0x3e7f,(%esp)
141: e8 ad 38 00 00 call 39f3 <mkdir>
146: 83 c4 10 add $0x10,%esp
149: 85 c0 test %eax,%eax
14b: 78 58 js 1a5 <iputtest+0x85>
if(chdir("iputdir") < 0){
14d: 83 ec 0c sub $0xc,%esp
150: 68 7f 3e 00 00 push $0x3e7f
155: e8 a1 38 00 00 call 39fb <chdir>
15a: 83 c4 10 add $0x10,%esp
15d: 85 c0 test %eax,%eax
15f: 0f 88 85 00 00 00 js 1ea <iputtest+0xca>
if(unlink("../iputdir") < 0){
165: 83 ec 0c sub $0xc,%esp
168: 68 7c 3e 00 00 push $0x3e7c
16d: e8 69 38 00 00 call 39db <unlink>
172: 83 c4 10 add $0x10,%esp
175: 85 c0 test %eax,%eax
177: 78 5a js 1d3 <iputtest+0xb3>
if(chdir("/") < 0){
179: 83 ec 0c sub $0xc,%esp
17c: 68 a1 3e 00 00 push $0x3ea1
181: e8 75 38 00 00 call 39fb <chdir>
186: 83 c4 10 add $0x10,%esp
189: 85 c0 test %eax,%eax
18b: 78 2f js 1bc <iputtest+0x9c>
printf(stdout, "iput test ok\n");
18d: 83 ec 08 sub $0x8,%esp
190: 68 24 3f 00 00 push $0x3f24
195: ff 35 f0 5e 00 00 pushl 0x5ef0
19b: e8 50 39 00 00 call 3af0 <printf>
}
1a0: 83 c4 10 add $0x10,%esp
1a3: c9 leave
1a4: c3 ret
printf(stdout, "mkdir failed\n");
1a5: 50 push %eax
1a6: 50 push %eax
1a7: 68 58 3e 00 00 push $0x3e58
1ac: ff 35 f0 5e 00 00 pushl 0x5ef0
1b2: e8 39 39 00 00 call 3af0 <printf>
exit();
1b7: e8 c7 37 00 00 call 3983 <exit>
printf(stdout, "chdir / failed\n");
1bc: 50 push %eax
1bd: 50 push %eax
1be: 68 a3 3e 00 00 push $0x3ea3
1c3: ff 35 f0 5e 00 00 pushl 0x5ef0
1c9: e8 22 39 00 00 call 3af0 <printf>
exit();
1ce: e8 b0 37 00 00 call 3983 <exit>
printf(stdout, "unlink ../iputdir failed\n");
1d3: 52 push %edx
1d4: 52 push %edx
1d5: 68 87 3e 00 00 push $0x3e87
1da: ff 35 f0 5e 00 00 pushl 0x5ef0
1e0: e8 0b 39 00 00 call 3af0 <printf>
exit();
1e5: e8 99 37 00 00 call 3983 <exit>
printf(stdout, "chdir iputdir failed\n");
1ea: 51 push %ecx
1eb: 51 push %ecx
1ec: 68 66 3e 00 00 push $0x3e66
1f1: ff 35 f0 5e 00 00 pushl 0x5ef0
1f7: e8 f4 38 00 00 call 3af0 <printf>
exit();
1fc: e8 82 37 00 00 call 3983 <exit>
201: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
208: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
20f: 90 nop
00000210 <exitiputtest>:
{
210: f3 0f 1e fb endbr32
214: 55 push %ebp
215: 89 e5 mov %esp,%ebp
217: 83 ec 10 sub $0x10,%esp
printf(stdout, "exitiput test\n");
21a: 68 b3 3e 00 00 push $0x3eb3
21f: ff 35 f0 5e 00 00 pushl 0x5ef0
225: e8 c6 38 00 00 call 3af0 <printf>
pid = fork();
22a: e8 4c 37 00 00 call 397b <fork>
if(pid < 0){
22f: 83 c4 10 add $0x10,%esp
232: 85 c0 test %eax,%eax
234: 0f 88 86 00 00 00 js 2c0 <exitiputtest+0xb0>
if(pid == 0){
23a: 75 4c jne 288 <exitiputtest+0x78>
if(mkdir("iputdir") < 0){
23c: 83 ec 0c sub $0xc,%esp
23f: 68 7f 3e 00 00 push $0x3e7f
244: e8 aa 37 00 00 call 39f3 <mkdir>
249: 83 c4 10 add $0x10,%esp
24c: 85 c0 test %eax,%eax
24e: 0f 88 83 00 00 00 js 2d7 <exitiputtest+0xc7>
if(chdir("iputdir") < 0){
254: 83 ec 0c sub $0xc,%esp
257: 68 7f 3e 00 00 push $0x3e7f
25c: e8 9a 37 00 00 call 39fb <chdir>
261: 83 c4 10 add $0x10,%esp
264: 85 c0 test %eax,%eax
266: 0f 88 82 00 00 00 js 2ee <exitiputtest+0xde>
if(unlink("../iputdir") < 0){
26c: 83 ec 0c sub $0xc,%esp
26f: 68 7c 3e 00 00 push $0x3e7c
274: e8 62 37 00 00 call 39db <unlink>
279: 83 c4 10 add $0x10,%esp
27c: 85 c0 test %eax,%eax
27e: 78 28 js 2a8 <exitiputtest+0x98>
exit();
280: e8 fe 36 00 00 call 3983 <exit>
285: 8d 76 00 lea 0x0(%esi),%esi
wait();
288: e8 fe 36 00 00 call 398b <wait>
printf(stdout, "exitiput test ok\n");
28d: 83 ec 08 sub $0x8,%esp
290: 68 d6 3e 00 00 push $0x3ed6
295: ff 35 f0 5e 00 00 pushl 0x5ef0
29b: e8 50 38 00 00 call 3af0 <printf>
}
2a0: 83 c4 10 add $0x10,%esp
2a3: c9 leave
2a4: c3 ret
2a5: 8d 76 00 lea 0x0(%esi),%esi
printf(stdout, "unlink ../iputdir failed\n");
2a8: 83 ec 08 sub $0x8,%esp
2ab: 68 87 3e 00 00 push $0x3e87
2b0: ff 35 f0 5e 00 00 pushl 0x5ef0
2b6: e8 35 38 00 00 call 3af0 <printf>
exit();
2bb: e8 c3 36 00 00 call 3983 <exit>
printf(stdout, "fork failed\n");
2c0: 51 push %ecx
2c1: 51 push %ecx
2c2: 68 99 4d 00 00 push $0x4d99
2c7: ff 35 f0 5e 00 00 pushl 0x5ef0
2cd: e8 1e 38 00 00 call 3af0 <printf>
exit();
2d2: e8 ac 36 00 00 call 3983 <exit>
printf(stdout, "mkdir failed\n");
2d7: 52 push %edx
2d8: 52 push %edx
2d9: 68 58 3e 00 00 push $0x3e58
2de: ff 35 f0 5e 00 00 pushl 0x5ef0
2e4: e8 07 38 00 00 call 3af0 <printf>
exit();
2e9: e8 95 36 00 00 call 3983 <exit>
printf(stdout, "child chdir failed\n");
2ee: 50 push %eax
2ef: 50 push %eax
2f0: 68 c2 3e 00 00 push $0x3ec2
2f5: ff 35 f0 5e 00 00 pushl 0x5ef0
2fb: e8 f0 37 00 00 call 3af0 <printf>
exit();
300: e8 7e 36 00 00 call 3983 <exit>
305: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
30c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
00000310 <openiputtest>:
{
310: f3 0f 1e fb endbr32
314: 55 push %ebp
315: 89 e5 mov %esp,%ebp
317: 83 ec 10 sub $0x10,%esp
printf(stdout, "openiput test\n");
31a: 68 e8 3e 00 00 push $0x3ee8
31f: ff 35 f0 5e 00 00 pushl 0x5ef0
325: e8 c6 37 00 00 call 3af0 <printf>
if(mkdir("oidir") < 0){
32a: c7 04 24 f7 3e 00 00 movl $0x3ef7,(%esp)
331: e8 bd 36 00 00 call 39f3 <mkdir>
336: 83 c4 10 add $0x10,%esp
339: 85 c0 test %eax,%eax
33b: 0f 88 9b 00 00 00 js 3dc <openiputtest+0xcc>
pid = fork();
341: e8 35 36 00 00 call 397b <fork>
if(pid < 0){
346: 85 c0 test %eax,%eax
348: 78 7b js 3c5 <openiputtest+0xb5>
if(pid == 0){
34a: 75 34 jne 380 <openiputtest+0x70>
int fd = open("oidir", O_RDWR);
34c: 83 ec 08 sub $0x8,%esp
34f: 6a 02 push $0x2
351: 68 f7 3e 00 00 push $0x3ef7
356: e8 70 36 00 00 call 39cb <open>
if(fd >= 0){
35b: 83 c4 10 add $0x10,%esp
35e: 85 c0 test %eax,%eax
360: 78 5e js 3c0 <openiputtest+0xb0>
printf(stdout, "open directory for write succeeded\n");
362: 83 ec 08 sub $0x8,%esp
365: 68 7c 4e 00 00 push $0x4e7c
36a: ff 35 f0 5e 00 00 pushl 0x5ef0
370: e8 7b 37 00 00 call 3af0 <printf>
exit();
375: e8 09 36 00 00 call 3983 <exit>
37a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
sleep(1);
380: 83 ec 0c sub $0xc,%esp
383: 6a 01 push $0x1
385: e8 91 36 00 00 call 3a1b <sleep>
if(unlink("oidir") != 0){
38a: c7 04 24 f7 3e 00 00 movl $0x3ef7,(%esp)
391: e8 45 36 00 00 call 39db <unlink>
396: 83 c4 10 add $0x10,%esp
399: 85 c0 test %eax,%eax
39b: 75 56 jne 3f3 <openiputtest+0xe3>
wait();
39d: e8 e9 35 00 00 call 398b <wait>
printf(stdout, "openiput test ok\n");
3a2: 83 ec 08 sub $0x8,%esp
3a5: 68 20 3f 00 00 push $0x3f20
3aa: ff 35 f0 5e 00 00 pushl 0x5ef0
3b0: e8 3b 37 00 00 call 3af0 <printf>
3b5: 83 c4 10 add $0x10,%esp
}
3b8: c9 leave
3b9: c3 ret
3ba: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
exit();
3c0: e8 be 35 00 00 call 3983 <exit>
printf(stdout, "fork failed\n");
3c5: 52 push %edx
3c6: 52 push %edx
3c7: 68 99 4d 00 00 push $0x4d99
3cc: ff 35 f0 5e 00 00 pushl 0x5ef0
3d2: e8 19 37 00 00 call 3af0 <printf>
exit();
3d7: e8 a7 35 00 00 call 3983 <exit>
printf(stdout, "mkdir oidir failed\n");
3dc: 51 push %ecx
3dd: 51 push %ecx
3de: 68 fd 3e 00 00 push $0x3efd
3e3: ff 35 f0 5e 00 00 pushl 0x5ef0
3e9: e8 02 37 00 00 call 3af0 <printf>
exit();
3ee: e8 90 35 00 00 call 3983 <exit>
printf(stdout, "unlink failed\n");
3f3: 50 push %eax
3f4: 50 push %eax
3f5: 68 11 3f 00 00 push $0x3f11
3fa: ff 35 f0 5e 00 00 pushl 0x5ef0
400: e8 eb 36 00 00 call 3af0 <printf>
exit();
405: e8 79 35 00 00 call 3983 <exit>
40a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
00000410 <opentest>:
{
410: f3 0f 1e fb endbr32
414: 55 push %ebp
415: 89 e5 mov %esp,%ebp
417: 83 ec 10 sub $0x10,%esp
printf(stdout, "open test\n");
41a: 68 32 3f 00 00 push $0x3f32
41f: ff 35 f0 5e 00 00 pushl 0x5ef0
425: e8 c6 36 00 00 call 3af0 <printf>
fd = open("echo", 0);
42a: 58 pop %eax
42b: 5a pop %edx
42c: 6a 00 push $0x0
42e: 68 3d 3f 00 00 push $0x3f3d
433: e8 93 35 00 00 call 39cb <open>
if(fd < 0){
438: 83 c4 10 add $0x10,%esp
43b: 85 c0 test %eax,%eax
43d: 78 36 js 475 <opentest+0x65>
close(fd);
43f: 83 ec 0c sub $0xc,%esp
442: 50 push %eax
443: e8 6b 35 00 00 call 39b3 <close>
fd = open("doesnotexist", 0);
448: 5a pop %edx
449: 59 pop %ecx
44a: 6a 00 push $0x0
44c: 68 55 3f 00 00 push $0x3f55
451: e8 75 35 00 00 call 39cb <open>
if(fd >= 0){
456: 83 c4 10 add $0x10,%esp
459: 85 c0 test %eax,%eax
45b: 79 2f jns 48c <opentest+0x7c>
printf(stdout, "open test ok\n");
45d: 83 ec 08 sub $0x8,%esp
460: 68 80 3f 00 00 push $0x3f80
465: ff 35 f0 5e 00 00 pushl 0x5ef0
46b: e8 80 36 00 00 call 3af0 <printf>
}
470: 83 c4 10 add $0x10,%esp
473: c9 leave
474: c3 ret
printf(stdout, "open echo failed!\n");
475: 50 push %eax
476: 50 push %eax
477: 68 42 3f 00 00 push $0x3f42
47c: ff 35 f0 5e 00 00 pushl 0x5ef0
482: e8 69 36 00 00 call 3af0 <printf>
exit();
487: e8 f7 34 00 00 call 3983 <exit>
printf(stdout, "open doesnotexist succeeded!\n");
48c: 50 push %eax
48d: 50 push %eax
48e: 68 62 3f 00 00 push $0x3f62
493: ff 35 f0 5e 00 00 pushl 0x5ef0
499: e8 52 36 00 00 call 3af0 <printf>
exit();
49e: e8 e0 34 00 00 call 3983 <exit>
4a3: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
4aa: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
000004b0 <writetest>:
{
4b0: f3 0f 1e fb endbr32
4b4: 55 push %ebp
4b5: 89 e5 mov %esp,%ebp
4b7: 56 push %esi
4b8: 53 push %ebx
printf(stdout, "small file test\n");
4b9: 83 ec 08 sub $0x8,%esp
4bc: 68 8e 3f 00 00 push $0x3f8e
4c1: ff 35 f0 5e 00 00 pushl 0x5ef0
4c7: e8 24 36 00 00 call 3af0 <printf>
fd = open("small", O_CREATE|O_RDWR);
4cc: 58 pop %eax
4cd: 5a pop %edx
4ce: 68 02 02 00 00 push $0x202
4d3: 68 9f 3f 00 00 push $0x3f9f
4d8: e8 ee 34 00 00 call 39cb <open>
if(fd >= 0){
4dd: 83 c4 10 add $0x10,%esp
4e0: 85 c0 test %eax,%eax
4e2: 0f 88 8c 01 00 00 js 674 <writetest+0x1c4>
printf(stdout, "creat small succeeded; ok\n");
4e8: 83 ec 08 sub $0x8,%esp
4eb: 89 c6 mov %eax,%esi
for(i = 0; i < 100; i++){
4ed: 31 db xor %ebx,%ebx
printf(stdout, "creat small succeeded; ok\n");
4ef: 68 a5 3f 00 00 push $0x3fa5
4f4: ff 35 f0 5e 00 00 pushl 0x5ef0
4fa: e8 f1 35 00 00 call 3af0 <printf>
4ff: 83 c4 10 add $0x10,%esp
502: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
if(write(fd, "aaaaaaaaaa", 10) != 10){
508: 83 ec 04 sub $0x4,%esp
50b: 6a 0a push $0xa
50d: 68 dc 3f 00 00 push $0x3fdc
512: 56 push %esi
513: e8 93 34 00 00 call 39ab <write>
518: 83 c4 10 add $0x10,%esp
51b: 83 f8 0a cmp $0xa,%eax
51e: 0f 85 d9 00 00 00 jne 5fd <writetest+0x14d>
if(write(fd, "bbbbbbbbbb", 10) != 10){
524: 83 ec 04 sub $0x4,%esp
527: 6a 0a push $0xa
529: 68 e7 3f 00 00 push $0x3fe7
52e: 56 push %esi
52f: e8 77 34 00 00 call 39ab <write>
534: 83 c4 10 add $0x10,%esp
537: 83 f8 0a cmp $0xa,%eax
53a: 0f 85 d6 00 00 00 jne 616 <writetest+0x166>
for(i = 0; i < 100; i++){
540: 83 c3 01 add $0x1,%ebx
543: 83 fb 64 cmp $0x64,%ebx
546: 75 c0 jne 508 <writetest+0x58>
printf(stdout, "writes ok\n");
548: 83 ec 08 sub $0x8,%esp
54b: 68 f2 3f 00 00 push $0x3ff2
550: ff 35 f0 5e 00 00 pushl 0x5ef0
556: e8 95 35 00 00 call 3af0 <printf>
close(fd);
55b: 89 34 24 mov %esi,(%esp)
55e: e8 50 34 00 00 call 39b3 <close>
fd = open("small", O_RDONLY);
563: 5b pop %ebx
564: 5e pop %esi
565: 6a 00 push $0x0
567: 68 9f 3f 00 00 push $0x3f9f
56c: e8 5a 34 00 00 call 39cb <open>
if(fd >= 0){
571: 83 c4 10 add $0x10,%esp
fd = open("small", O_RDONLY);
574: 89 c3 mov %eax,%ebx
if(fd >= 0){
576: 85 c0 test %eax,%eax
578: 0f 88 b1 00 00 00 js 62f <writetest+0x17f>
printf(stdout, "open small succeeded ok\n");
57e: 83 ec 08 sub $0x8,%esp
581: 68 fd 3f 00 00 push $0x3ffd
586: ff 35 f0 5e 00 00 pushl 0x5ef0
58c: e8 5f 35 00 00 call 3af0 <printf>
i = read(fd, buf, 2000);
591: 83 c4 0c add $0xc,%esp
594: 68 d0 07 00 00 push $0x7d0
599: 68 e0 86 00 00 push $0x86e0
59e: 53 push %ebx
59f: e8 ff 33 00 00 call 39a3 <read>
if(i == 2000){
5a4: 83 c4 10 add $0x10,%esp
5a7: 3d d0 07 00 00 cmp $0x7d0,%eax
5ac: 0f 85 94 00 00 00 jne 646 <writetest+0x196>
printf(stdout, "read succeeded ok\n");
5b2: 83 ec 08 sub $0x8,%esp
5b5: 68 31 40 00 00 push $0x4031
5ba: ff 35 f0 5e 00 00 pushl 0x5ef0
5c0: e8 2b 35 00 00 call 3af0 <printf>
close(fd);
5c5: 89 1c 24 mov %ebx,(%esp)
5c8: e8 e6 33 00 00 call 39b3 <close>
if(unlink("small") < 0){
5cd: c7 04 24 9f 3f 00 00 movl $0x3f9f,(%esp)
5d4: e8 02 34 00 00 call 39db <unlink>
5d9: 83 c4 10 add $0x10,%esp
5dc: 85 c0 test %eax,%eax
5de: 78 7d js 65d <writetest+0x1ad>
printf(stdout, "small file test ok\n");
5e0: 83 ec 08 sub $0x8,%esp
5e3: 68 59 40 00 00 push $0x4059
5e8: ff 35 f0 5e 00 00 pushl 0x5ef0
5ee: e8 fd 34 00 00 call 3af0 <printf>
}
5f3: 83 c4 10 add $0x10,%esp
5f6: 8d 65 f8 lea -0x8(%ebp),%esp
5f9: 5b pop %ebx
5fa: 5e pop %esi
5fb: 5d pop %ebp
5fc: c3 ret
printf(stdout, "error: write aa %d new file failed\n", i);
5fd: 83 ec 04 sub $0x4,%esp
600: 53 push %ebx
601: 68 a0 4e 00 00 push $0x4ea0
606: ff 35 f0 5e 00 00 pushl 0x5ef0
60c: e8 df 34 00 00 call 3af0 <printf>
exit();
611: e8 6d 33 00 00 call 3983 <exit>
printf(stdout, "error: write bb %d new file failed\n", i);
616: 83 ec 04 sub $0x4,%esp
619: 53 push %ebx
61a: 68 c4 4e 00 00 push $0x4ec4
61f: ff 35 f0 5e 00 00 pushl 0x5ef0
625: e8 c6 34 00 00 call 3af0 <printf>
exit();
62a: e8 54 33 00 00 call 3983 <exit>
printf(stdout, "error: open small failed!\n");
62f: 51 push %ecx
630: 51 push %ecx
631: 68 16 40 00 00 push $0x4016
636: ff 35 f0 5e 00 00 pushl 0x5ef0
63c: e8 af 34 00 00 call 3af0 <printf>
exit();
641: e8 3d 33 00 00 call 3983 <exit>
printf(stdout, "read failed\n");
646: 52 push %edx
647: 52 push %edx
648: 68 5d 43 00 00 push $0x435d
64d: ff 35 f0 5e 00 00 pushl 0x5ef0
653: e8 98 34 00 00 call 3af0 <printf>
exit();
658: e8 26 33 00 00 call 3983 <exit>
printf(stdout, "unlink small failed\n");
65d: 50 push %eax
65e: 50 push %eax
65f: 68 44 40 00 00 push $0x4044
664: ff 35 f0 5e 00 00 pushl 0x5ef0
66a: e8 81 34 00 00 call 3af0 <printf>
exit();
66f: e8 0f 33 00 00 call 3983 <exit>
printf(stdout, "error: creat small failed!\n");
674: 50 push %eax
675: 50 push %eax
676: 68 c0 3f 00 00 push $0x3fc0
67b: ff 35 f0 5e 00 00 pushl 0x5ef0
681: e8 6a 34 00 00 call 3af0 <printf>
exit();
686: e8 f8 32 00 00 call 3983 <exit>
68b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
68f: 90 nop
00000690 <writetest1>:
{
690: f3 0f 1e fb endbr32
694: 55 push %ebp
695: 89 e5 mov %esp,%ebp
697: 56 push %esi
698: 53 push %ebx
printf(stdout, "big files test\n");
699: 83 ec 08 sub $0x8,%esp
69c: 68 6d 40 00 00 push $0x406d
6a1: ff 35 f0 5e 00 00 pushl 0x5ef0
6a7: e8 44 34 00 00 call 3af0 <printf>
fd = open("big", O_CREATE|O_RDWR);
6ac: 58 pop %eax
6ad: 5a pop %edx
6ae: 68 02 02 00 00 push $0x202
6b3: 68 e7 40 00 00 push $0x40e7
6b8: e8 0e 33 00 00 call 39cb <open>
if(fd < 0){
6bd: 83 c4 10 add $0x10,%esp
6c0: 85 c0 test %eax,%eax
6c2: 0f 88 5d 01 00 00 js 825 <writetest1+0x195>
6c8: 89 c6 mov %eax,%esi
for(i = 0; i < MAXFILE; i++){
6ca: 31 db xor %ebx,%ebx
6cc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
if(write(fd, buf, 512) != 512){
6d0: 83 ec 04 sub $0x4,%esp
((int*)buf)[0] = i;
6d3: 89 1d e0 86 00 00 mov %ebx,0x86e0
if(write(fd, buf, 512) != 512){
6d9: 68 00 02 00 00 push $0x200
6de: 68 e0 86 00 00 push $0x86e0
6e3: 56 push %esi
6e4: e8 c2 32 00 00 call 39ab <write>
6e9: 83 c4 10 add $0x10,%esp
6ec: 3d 00 02 00 00 cmp $0x200,%eax
6f1: 0f 85 b3 00 00 00 jne 7aa <writetest1+0x11a>
for(i = 0; i < MAXFILE; i++){
6f7: 83 c3 01 add $0x1,%ebx
6fa: 81 fb 8c 00 00 00 cmp $0x8c,%ebx
700: 75 ce jne 6d0 <writetest1+0x40>
close(fd);
702: 83 ec 0c sub $0xc,%esp
705: 56 push %esi
706: e8 a8 32 00 00 call 39b3 <close>
fd = open("big", O_RDONLY);
70b: 5b pop %ebx
70c: 5e pop %esi
70d: 6a 00 push $0x0
70f: 68 e7 40 00 00 push $0x40e7
714: e8 b2 32 00 00 call 39cb <open>
if(fd < 0){
719: 83 c4 10 add $0x10,%esp
fd = open("big", O_RDONLY);
71c: 89 c3 mov %eax,%ebx
if(fd < 0){
71e: 85 c0 test %eax,%eax
720: 0f 88 e8 00 00 00 js 80e <writetest1+0x17e>
n = 0;
726: 31 f6 xor %esi,%esi
728: eb 1d jmp 747 <writetest1+0xb7>
72a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
} else if(i != 512){
730: 3d 00 02 00 00 cmp $0x200,%eax
735: 0f 85 9f 00 00 00 jne 7da <writetest1+0x14a>
if(((int*)buf)[0] != n){
73b: a1 e0 86 00 00 mov 0x86e0,%eax
740: 39 f0 cmp %esi,%eax
742: 75 7f jne 7c3 <writetest1+0x133>
n++;
744: 83 c6 01 add $0x1,%esi
i = read(fd, buf, 512);
747: 83 ec 04 sub $0x4,%esp
74a: 68 00 02 00 00 push $0x200
74f: 68 e0 86 00 00 push $0x86e0
754: 53 push %ebx
755: e8 49 32 00 00 call 39a3 <read>
if(i == 0){
75a: 83 c4 10 add $0x10,%esp
75d: 85 c0 test %eax,%eax
75f: 75 cf jne 730 <writetest1+0xa0>
if(n == MAXFILE - 1){
761: 81 fe 8b 00 00 00 cmp $0x8b,%esi
767: 0f 84 86 00 00 00 je 7f3 <writetest1+0x163>
close(fd);
76d: 83 ec 0c sub $0xc,%esp
770: 53 push %ebx
771: e8 3d 32 00 00 call 39b3 <close>
if(unlink("big") < 0){
776: c7 04 24 e7 40 00 00 movl $0x40e7,(%esp)
77d: e8 59 32 00 00 call 39db <unlink>
782: 83 c4 10 add $0x10,%esp
785: 85 c0 test %eax,%eax
787: 0f 88 af 00 00 00 js 83c <writetest1+0x1ac>
printf(stdout, "big files ok\n");
78d: 83 ec 08 sub $0x8,%esp
790: 68 0e 41 00 00 push $0x410e
795: ff 35 f0 5e 00 00 pushl 0x5ef0
79b: e8 50 33 00 00 call 3af0 <printf>
}
7a0: 83 c4 10 add $0x10,%esp
7a3: 8d 65 f8 lea -0x8(%ebp),%esp
7a6: 5b pop %ebx
7a7: 5e pop %esi
7a8: 5d pop %ebp
7a9: c3 ret
printf(stdout, "error: write big file failed\n", i);
7aa: 83 ec 04 sub $0x4,%esp
7ad: 53 push %ebx
7ae: 68 97 40 00 00 push $0x4097
7b3: ff 35 f0 5e 00 00 pushl 0x5ef0
7b9: e8 32 33 00 00 call 3af0 <printf>
exit();
7be: e8 c0 31 00 00 call 3983 <exit>
printf(stdout, "read content of block %d is %d\n",
7c3: 50 push %eax
7c4: 56 push %esi
7c5: 68 e8 4e 00 00 push $0x4ee8
7ca: ff 35 f0 5e 00 00 pushl 0x5ef0
7d0: e8 1b 33 00 00 call 3af0 <printf>
exit();
7d5: e8 a9 31 00 00 call 3983 <exit>
printf(stdout, "read failed %d\n", i);
7da: 83 ec 04 sub $0x4,%esp
7dd: 50 push %eax
7de: 68 eb 40 00 00 push $0x40eb
7e3: ff 35 f0 5e 00 00 pushl 0x5ef0
7e9: e8 02 33 00 00 call 3af0 <printf>
exit();
7ee: e8 90 31 00 00 call 3983 <exit>
printf(stdout, "read only %d blocks from big", n);
7f3: 52 push %edx
7f4: 68 8b 00 00 00 push $0x8b
7f9: 68 ce 40 00 00 push $0x40ce
7fe: ff 35 f0 5e 00 00 pushl 0x5ef0
804: e8 e7 32 00 00 call 3af0 <printf>
exit();
809: e8 75 31 00 00 call 3983 <exit>
printf(stdout, "error: open big failed!\n");
80e: 51 push %ecx
80f: 51 push %ecx
810: 68 b5 40 00 00 push $0x40b5
815: ff 35 f0 5e 00 00 pushl 0x5ef0
81b: e8 d0 32 00 00 call 3af0 <printf>
exit();
820: e8 5e 31 00 00 call 3983 <exit>
printf(stdout, "error: creat big failed!\n");
825: 50 push %eax
826: 50 push %eax
827: 68 7d 40 00 00 push $0x407d
82c: ff 35 f0 5e 00 00 pushl 0x5ef0
832: e8 b9 32 00 00 call 3af0 <printf>
exit();
837: e8 47 31 00 00 call 3983 <exit>
printf(stdout, "unlink big failed\n");
83c: 50 push %eax
83d: 50 push %eax
83e: 68 fb 40 00 00 push $0x40fb
843: ff 35 f0 5e 00 00 pushl 0x5ef0
849: e8 a2 32 00 00 call 3af0 <printf>
exit();
84e: e8 30 31 00 00 call 3983 <exit>
853: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
85a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
00000860 <createtest>:
{
860: f3 0f 1e fb endbr32
864: 55 push %ebp
865: 89 e5 mov %esp,%ebp
867: 53 push %ebx
name[2] = '\0';
868: bb 30 00 00 00 mov $0x30,%ebx
{
86d: 83 ec 0c sub $0xc,%esp
printf(stdout, "many creates, followed by unlink test\n");
870: 68 08 4f 00 00 push $0x4f08
875: ff 35 f0 5e 00 00 pushl 0x5ef0
87b: e8 70 32 00 00 call 3af0 <printf>
name[0] = 'a';
880: c6 05 e0 a6 00 00 61 movb $0x61,0xa6e0
name[2] = '\0';
887: 83 c4 10 add $0x10,%esp
88a: c6 05 e2 a6 00 00 00 movb $0x0,0xa6e2
for(i = 0; i < 52; i++){
891: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
fd = open(name, O_CREATE|O_RDWR);
898: 83 ec 08 sub $0x8,%esp
name[1] = '0' + i;
89b: 88 1d e1 a6 00 00 mov %bl,0xa6e1
fd = open(name, O_CREATE|O_RDWR);
8a1: 83 c3 01 add $0x1,%ebx
8a4: 68 02 02 00 00 push $0x202
8a9: 68 e0 a6 00 00 push $0xa6e0
8ae: e8 18 31 00 00 call 39cb <open>
close(fd);
8b3: 89 04 24 mov %eax,(%esp)
8b6: e8 f8 30 00 00 call 39b3 <close>
for(i = 0; i < 52; i++){
8bb: 83 c4 10 add $0x10,%esp
8be: 80 fb 64 cmp $0x64,%bl
8c1: 75 d5 jne 898 <createtest+0x38>
name[0] = 'a';
8c3: c6 05 e0 a6 00 00 61 movb $0x61,0xa6e0
name[2] = '\0';
8ca: bb 30 00 00 00 mov $0x30,%ebx
8cf: c6 05 e2 a6 00 00 00 movb $0x0,0xa6e2
for(i = 0; i < 52; i++){
8d6: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
8dd: 8d 76 00 lea 0x0(%esi),%esi
unlink(name);
8e0: 83 ec 0c sub $0xc,%esp
name[1] = '0' + i;
8e3: 88 1d e1 a6 00 00 mov %bl,0xa6e1
unlink(name);
8e9: 83 c3 01 add $0x1,%ebx
8ec: 68 e0 a6 00 00 push $0xa6e0
8f1: e8 e5 30 00 00 call 39db <unlink>
for(i = 0; i < 52; i++){
8f6: 83 c4 10 add $0x10,%esp
8f9: 80 fb 64 cmp $0x64,%bl
8fc: 75 e2 jne 8e0 <createtest+0x80>
printf(stdout, "many creates, followed by unlink; ok\n");
8fe: 83 ec 08 sub $0x8,%esp
901: 68 30 4f 00 00 push $0x4f30
906: ff 35 f0 5e 00 00 pushl 0x5ef0
90c: e8 df 31 00 00 call 3af0 <printf>
}
911: 8b 5d fc mov -0x4(%ebp),%ebx
914: 83 c4 10 add $0x10,%esp
917: c9 leave
918: c3 ret
919: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
00000920 <dirtest>:
{
920: f3 0f 1e fb endbr32
924: 55 push %ebp
925: 89 e5 mov %esp,%ebp
927: 83 ec 10 sub $0x10,%esp
printf(stdout, "mkdir test\n");
92a: 68 1c 41 00 00 push $0x411c
92f: ff 35 f0 5e 00 00 pushl 0x5ef0
935: e8 b6 31 00 00 call 3af0 <printf>
if(mkdir("dir0") < 0){
93a: c7 04 24 28 41 00 00 movl $0x4128,(%esp)
941: e8 ad 30 00 00 call 39f3 <mkdir>
946: 83 c4 10 add $0x10,%esp
949: 85 c0 test %eax,%eax
94b: 78 58 js 9a5 <dirtest+0x85>
if(chdir("dir0") < 0){
94d: 83 ec 0c sub $0xc,%esp
950: 68 28 41 00 00 push $0x4128
955: e8 a1 30 00 00 call 39fb <chdir>
95a: 83 c4 10 add $0x10,%esp
95d: 85 c0 test %eax,%eax
95f: 0f 88 85 00 00 00 js 9ea <dirtest+0xca>
if(chdir("..") < 0){
965: 83 ec 0c sub $0xc,%esp
968: 68 cd 46 00 00 push $0x46cd
96d: e8 89 30 00 00 call 39fb <chdir>
972: 83 c4 10 add $0x10,%esp
975: 85 c0 test %eax,%eax
977: 78 5a js 9d3 <dirtest+0xb3>
if(unlink("dir0") < 0){
979: 83 ec 0c sub $0xc,%esp
97c: 68 28 41 00 00 push $0x4128
981: e8 55 30 00 00 call 39db <unlink>
986: 83 c4 10 add $0x10,%esp
989: 85 c0 test %eax,%eax
98b: 78 2f js 9bc <dirtest+0x9c>
printf(stdout, "mkdir test ok\n");
98d: 83 ec 08 sub $0x8,%esp
990: 68 65 41 00 00 push $0x4165
995: ff 35 f0 5e 00 00 pushl 0x5ef0
99b: e8 50 31 00 00 call 3af0 <printf>
}
9a0: 83 c4 10 add $0x10,%esp
9a3: c9 leave
9a4: c3 ret
printf(stdout, "mkdir failed\n");
9a5: 50 push %eax
9a6: 50 push %eax
9a7: 68 58 3e 00 00 push $0x3e58
9ac: ff 35 f0 5e 00 00 pushl 0x5ef0
9b2: e8 39 31 00 00 call 3af0 <printf>
exit();
9b7: e8 c7 2f 00 00 call 3983 <exit>
printf(stdout, "unlink dir0 failed\n");
9bc: 50 push %eax
9bd: 50 push %eax
9be: 68 51 41 00 00 push $0x4151
9c3: ff 35 f0 5e 00 00 pushl 0x5ef0
9c9: e8 22 31 00 00 call 3af0 <printf>
exit();
9ce: e8 b0 2f 00 00 call 3983 <exit>
printf(stdout, "chdir .. failed\n");
9d3: 52 push %edx
9d4: 52 push %edx
9d5: 68 40 41 00 00 push $0x4140
9da: ff 35 f0 5e 00 00 pushl 0x5ef0
9e0: e8 0b 31 00 00 call 3af0 <printf>
exit();
9e5: e8 99 2f 00 00 call 3983 <exit>
printf(stdout, "chdir dir0 failed\n");
9ea: 51 push %ecx
9eb: 51 push %ecx
9ec: 68 2d 41 00 00 push $0x412d
9f1: ff 35 f0 5e 00 00 pushl 0x5ef0
9f7: e8 f4 30 00 00 call 3af0 <printf>
exit();
9fc: e8 82 2f 00 00 call 3983 <exit>
a01: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
a08: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
a0f: 90 nop
00000a10 <exectest>:
{
a10: f3 0f 1e fb endbr32
a14: 55 push %ebp
a15: 89 e5 mov %esp,%ebp
a17: 83 ec 10 sub $0x10,%esp
printf(stdout, "exec test\n");
a1a: 68 74 41 00 00 push $0x4174
a1f: ff 35 f0 5e 00 00 pushl 0x5ef0
a25: e8 c6 30 00 00 call 3af0 <printf>
if(exec("echo", echoargv) < 0){
a2a: 5a pop %edx
a2b: 59 pop %ecx
a2c: 68 f4 5e 00 00 push $0x5ef4
a31: 68 3d 3f 00 00 push $0x3f3d
a36: e8 88 2f 00 00 call 39c3 <exec>
a3b: 83 c4 10 add $0x10,%esp
a3e: 85 c0 test %eax,%eax
a40: 78 02 js a44 <exectest+0x34>
}
a42: c9 leave
a43: c3 ret
printf(stdout, "exec echo failed\n");
a44: 50 push %eax
a45: 50 push %eax
a46: 68 7f 41 00 00 push $0x417f
a4b: ff 35 f0 5e 00 00 pushl 0x5ef0
a51: e8 9a 30 00 00 call 3af0 <printf>
exit();
a56: e8 28 2f 00 00 call 3983 <exit>
a5b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
a5f: 90 nop
00000a60 <pipe1>:
{
a60: f3 0f 1e fb endbr32
a64: 55 push %ebp
a65: 89 e5 mov %esp,%ebp
a67: 57 push %edi
a68: 56 push %esi
if(pipe(fds) != 0){
a69: 8d 45 e0 lea -0x20(%ebp),%eax
{
a6c: 53 push %ebx
a6d: 83 ec 38 sub $0x38,%esp
if(pipe(fds) != 0){
a70: 50 push %eax
a71: e8 25 2f 00 00 call 399b <pipe>
a76: 83 c4 10 add $0x10,%esp
a79: 85 c0 test %eax,%eax
a7b: 0f 85 38 01 00 00 jne bb9 <pipe1+0x159>
pid = fork();
a81: e8 f5 2e 00 00 call 397b <fork>
if(pid == 0){
a86: 85 c0 test %eax,%eax
a88: 0f 84 8d 00 00 00 je b1b <pipe1+0xbb>
} else if(pid > 0){
a8e: 0f 8e 38 01 00 00 jle bcc <pipe1+0x16c>
close(fds[1]);
a94: 83 ec 0c sub $0xc,%esp
a97: ff 75 e4 pushl -0x1c(%ebp)
seq = 0;
a9a: 31 db xor %ebx,%ebx
cc = 1;
a9c: be 01 00 00 00 mov $0x1,%esi
close(fds[1]);
aa1: e8 0d 2f 00 00 call 39b3 <close>
total = 0;
aa6: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp)
while((n = read(fds[0], buf, cc)) > 0){
aad: 83 c4 10 add $0x10,%esp
ab0: 83 ec 04 sub $0x4,%esp
ab3: 56 push %esi
ab4: 68 e0 86 00 00 push $0x86e0
ab9: ff 75 e0 pushl -0x20(%ebp)
abc: e8 e2 2e 00 00 call 39a3 <read>
ac1: 83 c4 10 add $0x10,%esp
ac4: 89 c7 mov %eax,%edi
ac6: 85 c0 test %eax,%eax
ac8: 0f 8e a7 00 00 00 jle b75 <pipe1+0x115>
ace: 8d 0c 3b lea (%ebx,%edi,1),%ecx
for(i = 0; i < n; i++){
ad1: 31 c0 xor %eax,%eax
ad3: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
ad7: 90 nop
if((buf[i] & 0xff) != (seq++ & 0xff)){
ad8: 89 da mov %ebx,%edx
ada: 83 c3 01 add $0x1,%ebx
add: 38 90 e0 86 00 00 cmp %dl,0x86e0(%eax)
ae3: 75 1c jne b01 <pipe1+0xa1>
for(i = 0; i < n; i++){
ae5: 83 c0 01 add $0x1,%eax
ae8: 39 d9 cmp %ebx,%ecx
aea: 75 ec jne ad8 <pipe1+0x78>
cc = cc * 2;
aec: 01 f6 add %esi,%esi
total += n;
aee: 01 7d d4 add %edi,-0x2c(%ebp)
af1: b8 00 20 00 00 mov $0x2000,%eax
af6: 81 fe 00 20 00 00 cmp $0x2000,%esi
afc: 0f 4f f0 cmovg %eax,%esi
aff: eb af jmp ab0 <pipe1+0x50>
printf(1, "pipe1 oops 2\n");
b01: 83 ec 08 sub $0x8,%esp
b04: 68 ae 41 00 00 push $0x41ae
b09: 6a 01 push $0x1
b0b: e8 e0 2f 00 00 call 3af0 <printf>
return;
b10: 83 c4 10 add $0x10,%esp
}
b13: 8d 65 f4 lea -0xc(%ebp),%esp
b16: 5b pop %ebx
b17: 5e pop %esi
b18: 5f pop %edi
b19: 5d pop %ebp
b1a: c3 ret
close(fds[0]);
b1b: 83 ec 0c sub $0xc,%esp
b1e: ff 75 e0 pushl -0x20(%ebp)
seq = 0;
b21: 31 db xor %ebx,%ebx
close(fds[0]);
b23: e8 8b 2e 00 00 call 39b3 <close>
b28: 83 c4 10 add $0x10,%esp
for(i = 0; i < 1033; i++)
b2b: 31 c0 xor %eax,%eax
b2d: 8d 76 00 lea 0x0(%esi),%esi
buf[i] = seq++;
b30: 8d 14 18 lea (%eax,%ebx,1),%edx
for(i = 0; i < 1033; i++)
b33: 83 c0 01 add $0x1,%eax
buf[i] = seq++;
b36: 88 90 df 86 00 00 mov %dl,0x86df(%eax)
for(i = 0; i < 1033; i++)
b3c: 3d 09 04 00 00 cmp $0x409,%eax
b41: 75 ed jne b30 <pipe1+0xd0>
if(write(fds[1], buf, 1033) != 1033){
b43: 83 ec 04 sub $0x4,%esp
b46: 81 c3 09 04 00 00 add $0x409,%ebx
b4c: 68 09 04 00 00 push $0x409
b51: 68 e0 86 00 00 push $0x86e0
b56: ff 75 e4 pushl -0x1c(%ebp)
b59: e8 4d 2e 00 00 call 39ab <write>
b5e: 83 c4 10 add $0x10,%esp
b61: 3d 09 04 00 00 cmp $0x409,%eax
b66: 75 77 jne bdf <pipe1+0x17f>
for(n = 0; n < 5; n++){
b68: 81 fb 2d 14 00 00 cmp $0x142d,%ebx
b6e: 75 bb jne b2b <pipe1+0xcb>
exit();
b70: e8 0e 2e 00 00 call 3983 <exit>
if(total != 5 * 1033){
b75: 81 7d d4 2d 14 00 00 cmpl $0x142d,-0x2c(%ebp)
b7c: 75 26 jne ba4 <pipe1+0x144>
close(fds[0]);
b7e: 83 ec 0c sub $0xc,%esp
b81: ff 75 e0 pushl -0x20(%ebp)
b84: e8 2a 2e 00 00 call 39b3 <close>
wait();
b89: e8 fd 2d 00 00 call 398b <wait>
printf(1, "pipe1 ok\n");
b8e: 5a pop %edx
b8f: 59 pop %ecx
b90: 68 d3 41 00 00 push $0x41d3
b95: 6a 01 push $0x1
b97: e8 54 2f 00 00 call 3af0 <printf>
b9c: 83 c4 10 add $0x10,%esp
b9f: e9 6f ff ff ff jmp b13 <pipe1+0xb3>
printf(1, "pipe1 oops 3 total %d\n", total);
ba4: 53 push %ebx
ba5: ff 75 d4 pushl -0x2c(%ebp)
ba8: 68 bc 41 00 00 push $0x41bc
bad: 6a 01 push $0x1
baf: e8 3c 2f 00 00 call 3af0 <printf>
exit();
bb4: e8 ca 2d 00 00 call 3983 <exit>
printf(1, "pipe() failed\n");
bb9: 57 push %edi
bba: 57 push %edi
bbb: 68 91 41 00 00 push $0x4191
bc0: 6a 01 push $0x1
bc2: e8 29 2f 00 00 call 3af0 <printf>
exit();
bc7: e8 b7 2d 00 00 call 3983 <exit>
printf(1, "fork() failed\n");
bcc: 50 push %eax
bcd: 50 push %eax
bce: 68 dd 41 00 00 push $0x41dd
bd3: 6a 01 push $0x1
bd5: e8 16 2f 00 00 call 3af0 <printf>
exit();
bda: e8 a4 2d 00 00 call 3983 <exit>
printf(1, "pipe1 oops 1\n");
bdf: 56 push %esi
be0: 56 push %esi
be1: 68 a0 41 00 00 push $0x41a0
be6: 6a 01 push $0x1
be8: e8 03 2f 00 00 call 3af0 <printf>
exit();
bed: e8 91 2d 00 00 call 3983 <exit>
bf2: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
bf9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
00000c00 <preempt>:
{
c00: f3 0f 1e fb endbr32
c04: 55 push %ebp
c05: 89 e5 mov %esp,%ebp
c07: 57 push %edi
c08: 56 push %esi
c09: 53 push %ebx
c0a: 83 ec 24 sub $0x24,%esp
printf(1, "preempt: ");
c0d: 68 ec 41 00 00 push $0x41ec
c12: 6a 01 push $0x1
c14: e8 d7 2e 00 00 call 3af0 <printf>
pid1 = fork();
c19: e8 5d 2d 00 00 call 397b <fork>
if(pid1 == 0)
c1e: 83 c4 10 add $0x10,%esp
c21: 85 c0 test %eax,%eax
c23: 75 0b jne c30 <preempt+0x30>
for(;;)
c25: eb fe jmp c25 <preempt+0x25>
c27: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
c2e: 66 90 xchg %ax,%ax
c30: 89 c7 mov %eax,%edi
pid2 = fork();
c32: e8 44 2d 00 00 call 397b <fork>
c37: 89 c6 mov %eax,%esi
if(pid2 == 0)
c39: 85 c0 test %eax,%eax
c3b: 75 03 jne c40 <preempt+0x40>
for(;;)
c3d: eb fe jmp c3d <preempt+0x3d>
c3f: 90 nop
pipe(pfds);
c40: 83 ec 0c sub $0xc,%esp
c43: 8d 45 e0 lea -0x20(%ebp),%eax
c46: 50 push %eax
c47: e8 4f 2d 00 00 call 399b <pipe>
pid3 = fork();
c4c: e8 2a 2d 00 00 call 397b <fork>
if(pid3 == 0){
c51: 83 c4 10 add $0x10,%esp
pid3 = fork();
c54: 89 c3 mov %eax,%ebx
if(pid3 == 0){
c56: 85 c0 test %eax,%eax
c58: 75 3e jne c98 <preempt+0x98>
close(pfds[0]);
c5a: 83 ec 0c sub $0xc,%esp
c5d: ff 75 e0 pushl -0x20(%ebp)
c60: e8 4e 2d 00 00 call 39b3 <close>
if(write(pfds[1], "x", 1) != 1)
c65: 83 c4 0c add $0xc,%esp
c68: 6a 01 push $0x1
c6a: 68 b1 47 00 00 push $0x47b1
c6f: ff 75 e4 pushl -0x1c(%ebp)
c72: e8 34 2d 00 00 call 39ab <write>
c77: 83 c4 10 add $0x10,%esp
c7a: 83 f8 01 cmp $0x1,%eax
c7d: 0f 85 a4 00 00 00 jne d27 <preempt+0x127>
close(pfds[1]);
c83: 83 ec 0c sub $0xc,%esp
c86: ff 75 e4 pushl -0x1c(%ebp)
c89: e8 25 2d 00 00 call 39b3 <close>
c8e: 83 c4 10 add $0x10,%esp
for(;;)
c91: eb fe jmp c91 <preempt+0x91>
c93: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
c97: 90 nop
close(pfds[1]);
c98: 83 ec 0c sub $0xc,%esp
c9b: ff 75 e4 pushl -0x1c(%ebp)
c9e: e8 10 2d 00 00 call 39b3 <close>
if(read(pfds[0], buf, sizeof(buf)) != 1){
ca3: 83 c4 0c add $0xc,%esp
ca6: 68 00 20 00 00 push $0x2000
cab: 68 e0 86 00 00 push $0x86e0
cb0: ff 75 e0 pushl -0x20(%ebp)
cb3: e8 eb 2c 00 00 call 39a3 <read>
cb8: 83 c4 10 add $0x10,%esp
cbb: 83 f8 01 cmp $0x1,%eax
cbe: 75 7e jne d3e <preempt+0x13e>
close(pfds[0]);
cc0: 83 ec 0c sub $0xc,%esp
cc3: ff 75 e0 pushl -0x20(%ebp)
cc6: e8 e8 2c 00 00 call 39b3 <close>
printf(1, "kill... ");
ccb: 58 pop %eax
ccc: 5a pop %edx
ccd: 68 1d 42 00 00 push $0x421d
cd2: 6a 01 push $0x1
cd4: e8 17 2e 00 00 call 3af0 <printf>
kill(pid1);
cd9: 89 3c 24 mov %edi,(%esp)
cdc: e8 da 2c 00 00 call 39bb <kill>
kill(pid2);
ce1: 89 34 24 mov %esi,(%esp)
ce4: e8 d2 2c 00 00 call 39bb <kill>
kill(pid3);
ce9: 89 1c 24 mov %ebx,(%esp)
cec: e8 ca 2c 00 00 call 39bb <kill>
printf(1, "wait... ");
cf1: 59 pop %ecx
cf2: 5b pop %ebx
cf3: 68 26 42 00 00 push $0x4226
cf8: 6a 01 push $0x1
cfa: e8 f1 2d 00 00 call 3af0 <printf>
wait();
cff: e8 87 2c 00 00 call 398b <wait>
wait();
d04: e8 82 2c 00 00 call 398b <wait>
wait();
d09: e8 7d 2c 00 00 call 398b <wait>
printf(1, "preempt ok\n");
d0e: 5e pop %esi
d0f: 5f pop %edi
d10: 68 2f 42 00 00 push $0x422f
d15: 6a 01 push $0x1
d17: e8 d4 2d 00 00 call 3af0 <printf>
d1c: 83 c4 10 add $0x10,%esp
}
d1f: 8d 65 f4 lea -0xc(%ebp),%esp
d22: 5b pop %ebx
d23: 5e pop %esi
d24: 5f pop %edi
d25: 5d pop %ebp
d26: c3 ret
printf(1, "preempt write error");
d27: 83 ec 08 sub $0x8,%esp
d2a: 68 f6 41 00 00 push $0x41f6
d2f: 6a 01 push $0x1
d31: e8 ba 2d 00 00 call 3af0 <printf>
d36: 83 c4 10 add $0x10,%esp
d39: e9 45 ff ff ff jmp c83 <preempt+0x83>
printf(1, "preempt read error");
d3e: 83 ec 08 sub $0x8,%esp
d41: 68 0a 42 00 00 push $0x420a
d46: 6a 01 push $0x1
d48: e8 a3 2d 00 00 call 3af0 <printf>
return;
d4d: 83 c4 10 add $0x10,%esp
d50: eb cd jmp d1f <preempt+0x11f>
d52: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
d59: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
00000d60 <exitwait>:
{
d60: f3 0f 1e fb endbr32
d64: 55 push %ebp
d65: 89 e5 mov %esp,%ebp
d67: 56 push %esi
d68: be 64 00 00 00 mov $0x64,%esi
d6d: 53 push %ebx
d6e: eb 10 jmp d80 <exitwait+0x20>
if(pid){
d70: 74 68 je dda <exitwait+0x7a>
if(wait() != pid){
d72: e8 14 2c 00 00 call 398b <wait>
d77: 39 d8 cmp %ebx,%eax
d79: 75 2d jne da8 <exitwait+0x48>
for(i = 0; i < 100; i++){
d7b: 83 ee 01 sub $0x1,%esi
d7e: 74 41 je dc1 <exitwait+0x61>
pid = fork();
d80: e8 f6 2b 00 00 call 397b <fork>
d85: 89 c3 mov %eax,%ebx
if(pid < 0){
d87: 85 c0 test %eax,%eax
d89: 79 e5 jns d70 <exitwait+0x10>
printf(1, "fork failed\n");
d8b: 83 ec 08 sub $0x8,%esp
d8e: 68 99 4d 00 00 push $0x4d99
d93: 6a 01 push $0x1
d95: e8 56 2d 00 00 call 3af0 <printf>
return;
d9a: 83 c4 10 add $0x10,%esp
}
d9d: 8d 65 f8 lea -0x8(%ebp),%esp
da0: 5b pop %ebx
da1: 5e pop %esi
da2: 5d pop %ebp
da3: c3 ret
da4: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
printf(1, "wait wrong pid\n");
da8: 83 ec 08 sub $0x8,%esp
dab: 68 3b 42 00 00 push $0x423b
db0: 6a 01 push $0x1
db2: e8 39 2d 00 00 call 3af0 <printf>
return;
db7: 83 c4 10 add $0x10,%esp
}
dba: 8d 65 f8 lea -0x8(%ebp),%esp
dbd: 5b pop %ebx
dbe: 5e pop %esi
dbf: 5d pop %ebp
dc0: c3 ret
printf(1, "exitwait ok\n");
dc1: 83 ec 08 sub $0x8,%esp
dc4: 68 4b 42 00 00 push $0x424b
dc9: 6a 01 push $0x1
dcb: e8 20 2d 00 00 call 3af0 <printf>
dd0: 83 c4 10 add $0x10,%esp
}
dd3: 8d 65 f8 lea -0x8(%ebp),%esp
dd6: 5b pop %ebx
dd7: 5e pop %esi
dd8: 5d pop %ebp
dd9: c3 ret
exit();
dda: e8 a4 2b 00 00 call 3983 <exit>
ddf: 90 nop
00000de0 <mem>:
{
de0: f3 0f 1e fb endbr32
de4: 55 push %ebp
de5: 89 e5 mov %esp,%ebp
de7: 56 push %esi
de8: 31 f6 xor %esi,%esi
dea: 53 push %ebx
printf(1, "mem test\n");
deb: 83 ec 08 sub $0x8,%esp
dee: 68 58 42 00 00 push $0x4258
df3: 6a 01 push $0x1
df5: e8 f6 2c 00 00 call 3af0 <printf>
ppid = getpid();
dfa: e8 0c 2c 00 00 call 3a0b <getpid>
dff: 89 c3 mov %eax,%ebx
if((pid = fork()) == 0){
e01: e8 75 2b 00 00 call 397b <fork>
e06: 83 c4 10 add $0x10,%esp
e09: 85 c0 test %eax,%eax
e0b: 74 0f je e1c <mem+0x3c>
e0d: e9 8e 00 00 00 jmp ea0 <mem+0xc0>
e12: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
*(char**)m2 = m1;
e18: 89 30 mov %esi,(%eax)
e1a: 89 c6 mov %eax,%esi
while((m2 = malloc(10001)) != 0){
e1c: 83 ec 0c sub $0xc,%esp
e1f: 68 11 27 00 00 push $0x2711
e24: e8 27 2f 00 00 call 3d50 <malloc>
e29: 83 c4 10 add $0x10,%esp
e2c: 85 c0 test %eax,%eax
e2e: 75 e8 jne e18 <mem+0x38>
while(m1){
e30: 85 f6 test %esi,%esi
e32: 74 18 je e4c <mem+0x6c>
e34: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
m2 = *(char**)m1;
e38: 89 f0 mov %esi,%eax
free(m1);
e3a: 83 ec 0c sub $0xc,%esp
m2 = *(char**)m1;
e3d: 8b 36 mov (%esi),%esi
free(m1);
e3f: 50 push %eax
e40: e8 7b 2e 00 00 call 3cc0 <free>
while(m1){
e45: 83 c4 10 add $0x10,%esp
e48: 85 f6 test %esi,%esi
e4a: 75 ec jne e38 <mem+0x58>
m1 = malloc(1024*20);
e4c: 83 ec 0c sub $0xc,%esp
e4f: 68 00 50 00 00 push $0x5000
e54: e8 f7 2e 00 00 call 3d50 <malloc>
if(m1 == 0){
e59: 83 c4 10 add $0x10,%esp
e5c: 85 c0 test %eax,%eax
e5e: 74 20 je e80 <mem+0xa0>
free(m1);
e60: 83 ec 0c sub $0xc,%esp
e63: 50 push %eax
e64: e8 57 2e 00 00 call 3cc0 <free>
printf(1, "mem ok\n");
e69: 58 pop %eax
e6a: 5a pop %edx
e6b: 68 7c 42 00 00 push $0x427c
e70: 6a 01 push $0x1
e72: e8 79 2c 00 00 call 3af0 <printf>
exit();
e77: e8 07 2b 00 00 call 3983 <exit>
e7c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
printf(1, "couldn't allocate mem?!!\n");
e80: 83 ec 08 sub $0x8,%esp
e83: 68 62 42 00 00 push $0x4262
e88: 6a 01 push $0x1
e8a: e8 61 2c 00 00 call 3af0 <printf>
kill(ppid);
e8f: 89 1c 24 mov %ebx,(%esp)
e92: e8 24 2b 00 00 call 39bb <kill>
exit();
e97: e8 e7 2a 00 00 call 3983 <exit>
e9c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
}
ea0: 8d 65 f8 lea -0x8(%ebp),%esp
ea3: 5b pop %ebx
ea4: 5e pop %esi
ea5: 5d pop %ebp
wait();
ea6: e9 e0 2a 00 00 jmp 398b <wait>
eab: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
eaf: 90 nop
00000eb0 <sharedfd>:
{
eb0: f3 0f 1e fb endbr32
eb4: 55 push %ebp
eb5: 89 e5 mov %esp,%ebp
eb7: 57 push %edi
eb8: 56 push %esi
eb9: 53 push %ebx
eba: 83 ec 34 sub $0x34,%esp
printf(1, "sharedfd test\n");
ebd: 68 84 42 00 00 push $0x4284
ec2: 6a 01 push $0x1
ec4: e8 27 2c 00 00 call 3af0 <printf>
unlink("sharedfd");
ec9: c7 04 24 93 42 00 00 movl $0x4293,(%esp)
ed0: e8 06 2b 00 00 call 39db <unlink>
fd = open("sharedfd", O_CREATE|O_RDWR);
ed5: 5b pop %ebx
ed6: 5e pop %esi
ed7: 68 02 02 00 00 push $0x202
edc: 68 93 42 00 00 push $0x4293
ee1: e8 e5 2a 00 00 call 39cb <open>
if(fd < 0){
ee6: 83 c4 10 add $0x10,%esp
ee9: 85 c0 test %eax,%eax
eeb: 0f 88 26 01 00 00 js 1017 <sharedfd+0x167>
ef1: 89 c7 mov %eax,%edi
memset(buf, pid==0?'c':'p', sizeof(buf));
ef3: 8d 75 de lea -0x22(%ebp),%esi
ef6: bb e8 03 00 00 mov $0x3e8,%ebx
pid = fork();
efb: e8 7b 2a 00 00 call 397b <fork>
memset(buf, pid==0?'c':'p', sizeof(buf));
f00: 83 f8 01 cmp $0x1,%eax
pid = fork();
f03: 89 45 d4 mov %eax,-0x2c(%ebp)
memset(buf, pid==0?'c':'p', sizeof(buf));
f06: 19 c0 sbb %eax,%eax
f08: 83 ec 04 sub $0x4,%esp
f0b: 83 e0 f3 and $0xfffffff3,%eax
f0e: 6a 0a push $0xa
f10: 83 c0 70 add $0x70,%eax
f13: 50 push %eax
f14: 56 push %esi
f15: e8 c6 28 00 00 call 37e0 <memset>
f1a: 83 c4 10 add $0x10,%esp
f1d: eb 06 jmp f25 <sharedfd+0x75>
f1f: 90 nop
for(i = 0; i < 1000; i++){
f20: 83 eb 01 sub $0x1,%ebx
f23: 74 26 je f4b <sharedfd+0x9b>
if(write(fd, buf, sizeof(buf)) != sizeof(buf)){
f25: 83 ec 04 sub $0x4,%esp
f28: 6a 0a push $0xa
f2a: 56 push %esi
f2b: 57 push %edi
f2c: e8 7a 2a 00 00 call 39ab <write>
f31: 83 c4 10 add $0x10,%esp
f34: 83 f8 0a cmp $0xa,%eax
f37: 74 e7 je f20 <sharedfd+0x70>
printf(1, "fstests: write sharedfd failed\n");
f39: 83 ec 08 sub $0x8,%esp
f3c: 68 84 4f 00 00 push $0x4f84
f41: 6a 01 push $0x1
f43: e8 a8 2b 00 00 call 3af0 <printf>
break;
f48: 83 c4 10 add $0x10,%esp
if(pid == 0)
f4b: 8b 4d d4 mov -0x2c(%ebp),%ecx
f4e: 85 c9 test %ecx,%ecx
f50: 0f 84 f5 00 00 00 je 104b <sharedfd+0x19b>
wait();
f56: e8 30 2a 00 00 call 398b <wait>
close(fd);
f5b: 83 ec 0c sub $0xc,%esp
nc = np = 0;
f5e: 31 db xor %ebx,%ebx
close(fd);
f60: 57 push %edi
f61: 8d 7d e8 lea -0x18(%ebp),%edi
f64: e8 4a 2a 00 00 call 39b3 <close>
fd = open("sharedfd", 0);
f69: 58 pop %eax
f6a: 5a pop %edx
f6b: 6a 00 push $0x0
f6d: 68 93 42 00 00 push $0x4293
f72: e8 54 2a 00 00 call 39cb <open>
if(fd < 0){
f77: 83 c4 10 add $0x10,%esp
nc = np = 0;
f7a: 31 d2 xor %edx,%edx
fd = open("sharedfd", 0);
f7c: 89 45 d0 mov %eax,-0x30(%ebp)
if(fd < 0){
f7f: 85 c0 test %eax,%eax
f81: 0f 88 aa 00 00 00 js 1031 <sharedfd+0x181>
f87: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
f8e: 66 90 xchg %ax,%ax
while((n = read(fd, buf, sizeof(buf))) > 0){
f90: 83 ec 04 sub $0x4,%esp
f93: 89 55 d4 mov %edx,-0x2c(%ebp)
f96: 6a 0a push $0xa
f98: 56 push %esi
f99: ff 75 d0 pushl -0x30(%ebp)
f9c: e8 02 2a 00 00 call 39a3 <read>
fa1: 83 c4 10 add $0x10,%esp
fa4: 85 c0 test %eax,%eax
fa6: 7e 28 jle fd0 <sharedfd+0x120>
for(i = 0; i < sizeof(buf); i++){
fa8: 8b 55 d4 mov -0x2c(%ebp),%edx
fab: 89 f0 mov %esi,%eax
fad: eb 13 jmp fc2 <sharedfd+0x112>
faf: 90 nop
np++;
fb0: 80 f9 70 cmp $0x70,%cl
fb3: 0f 94 c1 sete %cl
fb6: 0f b6 c9 movzbl %cl,%ecx
fb9: 01 cb add %ecx,%ebx
for(i = 0; i < sizeof(buf); i++){
fbb: 83 c0 01 add $0x1,%eax
fbe: 39 c7 cmp %eax,%edi
fc0: 74 ce je f90 <sharedfd+0xe0>
if(buf[i] == 'c')
fc2: 0f b6 08 movzbl (%eax),%ecx
fc5: 80 f9 63 cmp $0x63,%cl
fc8: 75 e6 jne fb0 <sharedfd+0x100>
nc++;
fca: 83 c2 01 add $0x1,%edx
if(buf[i] == 'p')
fcd: eb ec jmp fbb <sharedfd+0x10b>
fcf: 90 nop
close(fd);
fd0: 83 ec 0c sub $0xc,%esp
fd3: ff 75 d0 pushl -0x30(%ebp)
fd6: e8 d8 29 00 00 call 39b3 <close>
unlink("sharedfd");
fdb: c7 04 24 93 42 00 00 movl $0x4293,(%esp)
fe2: e8 f4 29 00 00 call 39db <unlink>
if(nc == 10000 && np == 10000){
fe7: 8b 55 d4 mov -0x2c(%ebp),%edx
fea: 83 c4 10 add $0x10,%esp
fed: 81 fa 10 27 00 00 cmp $0x2710,%edx
ff3: 75 5b jne 1050 <sharedfd+0x1a0>
ff5: 81 fb 10 27 00 00 cmp $0x2710,%ebx
ffb: 75 53 jne 1050 <sharedfd+0x1a0>
printf(1, "sharedfd ok\n");
ffd: 83 ec 08 sub $0x8,%esp
1000: 68 9c 42 00 00 push $0x429c
1005: 6a 01 push $0x1
1007: e8 e4 2a 00 00 call 3af0 <printf>
100c: 83 c4 10 add $0x10,%esp
}
100f: 8d 65 f4 lea -0xc(%ebp),%esp
1012: 5b pop %ebx
1013: 5e pop %esi
1014: 5f pop %edi
1015: 5d pop %ebp
1016: c3 ret
printf(1, "fstests: cannot open sharedfd for writing");
1017: 83 ec 08 sub $0x8,%esp
101a: 68 58 4f 00 00 push $0x4f58
101f: 6a 01 push $0x1
1021: e8 ca 2a 00 00 call 3af0 <printf>
return;
1026: 83 c4 10 add $0x10,%esp
}
1029: 8d 65 f4 lea -0xc(%ebp),%esp
102c: 5b pop %ebx
102d: 5e pop %esi
102e: 5f pop %edi
102f: 5d pop %ebp
1030: c3 ret
printf(1, "fstests: cannot open sharedfd for reading\n");
1031: 83 ec 08 sub $0x8,%esp
1034: 68 a4 4f 00 00 push $0x4fa4
1039: 6a 01 push $0x1
103b: e8 b0 2a 00 00 call 3af0 <printf>
return;
1040: 83 c4 10 add $0x10,%esp
}
1043: 8d 65 f4 lea -0xc(%ebp),%esp
1046: 5b pop %ebx
1047: 5e pop %esi
1048: 5f pop %edi
1049: 5d pop %ebp
104a: c3 ret
exit();
104b: e8 33 29 00 00 call 3983 <exit>
printf(1, "sharedfd oops %d %d\n", nc, np);
1050: 53 push %ebx
1051: 52 push %edx
1052: 68 a9 42 00 00 push $0x42a9
1057: 6a 01 push $0x1
1059: e8 92 2a 00 00 call 3af0 <printf>
exit();
105e: e8 20 29 00 00 call 3983 <exit>
1063: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
106a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
00001070 <fourfiles>:
{
1070: f3 0f 1e fb endbr32
1074: 55 push %ebp
1075: 89 e5 mov %esp,%ebp
1077: 57 push %edi
1078: 56 push %esi
printf(1, "fourfiles test\n");
1079: be be 42 00 00 mov $0x42be,%esi
{
107e: 53 push %ebx
for(pi = 0; pi < 4; pi++){
107f: 31 db xor %ebx,%ebx
{
1081: 83 ec 34 sub $0x34,%esp
char *names[] = { "f0", "f1", "f2", "f3" };
1084: c7 45 d8 be 42 00 00 movl $0x42be,-0x28(%ebp)
printf(1, "fourfiles test\n");
108b: 68 c4 42 00 00 push $0x42c4
1090: 6a 01 push $0x1
char *names[] = { "f0", "f1", "f2", "f3" };
1092: c7 45 dc 07 44 00 00 movl $0x4407,-0x24(%ebp)
1099: c7 45 e0 0b 44 00 00 movl $0x440b,-0x20(%ebp)
10a0: c7 45 e4 c1 42 00 00 movl $0x42c1,-0x1c(%ebp)
printf(1, "fourfiles test\n");
10a7: e8 44 2a 00 00 call 3af0 <printf>
10ac: 83 c4 10 add $0x10,%esp
unlink(fname);
10af: 83 ec 0c sub $0xc,%esp
10b2: 56 push %esi
10b3: e8 23 29 00 00 call 39db <unlink>
pid = fork();
10b8: e8 be 28 00 00 call 397b <fork>
if(pid < 0){
10bd: 83 c4 10 add $0x10,%esp
10c0: 85 c0 test %eax,%eax
10c2: 0f 88 60 01 00 00 js 1228 <fourfiles+0x1b8>
if(pid == 0){
10c8: 0f 84 e5 00 00 00 je 11b3 <fourfiles+0x143>
for(pi = 0; pi < 4; pi++){
10ce: 83 c3 01 add $0x1,%ebx
10d1: 83 fb 04 cmp $0x4,%ebx
10d4: 74 06 je 10dc <fourfiles+0x6c>
10d6: 8b 74 9d d8 mov -0x28(%ebp,%ebx,4),%esi
10da: eb d3 jmp 10af <fourfiles+0x3f>
wait();
10dc: e8 aa 28 00 00 call 398b <wait>
for(i = 0; i < 2; i++){
10e1: 31 f6 xor %esi,%esi
wait();
10e3: e8 a3 28 00 00 call 398b <wait>
10e8: e8 9e 28 00 00 call 398b <wait>
10ed: e8 99 28 00 00 call 398b <wait>
fname = names[i];
10f2: 8b 44 b5 d8 mov -0x28(%ebp,%esi,4),%eax
fd = open(fname, 0);
10f6: 83 ec 08 sub $0x8,%esp
total = 0;
10f9: 31 db xor %ebx,%ebx
fd = open(fname, 0);
10fb: 6a 00 push $0x0
10fd: 50 push %eax
fname = names[i];
10fe: 89 45 d0 mov %eax,-0x30(%ebp)
fd = open(fname, 0);
1101: e8 c5 28 00 00 call 39cb <open>
while((n = read(fd, buf, sizeof(buf))) > 0){
1106: 83 c4 10 add $0x10,%esp
fd = open(fname, 0);
1109: 89 45 d4 mov %eax,-0x2c(%ebp)
while((n = read(fd, buf, sizeof(buf))) > 0){
110c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
1110: 83 ec 04 sub $0x4,%esp
1113: 68 00 20 00 00 push $0x2000
1118: 68 e0 86 00 00 push $0x86e0
111d: ff 75 d4 pushl -0x2c(%ebp)
1120: e8 7e 28 00 00 call 39a3 <read>
1125: 83 c4 10 add $0x10,%esp
1128: 85 c0 test %eax,%eax
112a: 7e 22 jle 114e <fourfiles+0xde>
for(j = 0; j < n; j++){
112c: 31 d2 xor %edx,%edx
112e: 66 90 xchg %ax,%ax
if(buf[j] != '0'+i){
1130: 83 fe 01 cmp $0x1,%esi
1133: 0f be ba e0 86 00 00 movsbl 0x86e0(%edx),%edi
113a: 19 c9 sbb %ecx,%ecx
113c: 83 c1 31 add $0x31,%ecx
113f: 39 cf cmp %ecx,%edi
1141: 75 5c jne 119f <fourfiles+0x12f>
for(j = 0; j < n; j++){
1143: 83 c2 01 add $0x1,%edx
1146: 39 d0 cmp %edx,%eax
1148: 75 e6 jne 1130 <fourfiles+0xc0>
total += n;
114a: 01 c3 add %eax,%ebx
114c: eb c2 jmp 1110 <fourfiles+0xa0>
close(fd);
114e: 83 ec 0c sub $0xc,%esp
1151: ff 75 d4 pushl -0x2c(%ebp)
1154: e8 5a 28 00 00 call 39b3 <close>
if(total != 12*500){
1159: 83 c4 10 add $0x10,%esp
115c: 81 fb 70 17 00 00 cmp $0x1770,%ebx
1162: 0f 85 d4 00 00 00 jne 123c <fourfiles+0x1cc>
unlink(fname);
1168: 83 ec 0c sub $0xc,%esp
116b: ff 75 d0 pushl -0x30(%ebp)
116e: e8 68 28 00 00 call 39db <unlink>
for(i = 0; i < 2; i++){
1173: 83 c4 10 add $0x10,%esp
1176: 83 fe 01 cmp $0x1,%esi
1179: 75 1a jne 1195 <fourfiles+0x125>
printf(1, "fourfiles ok\n");
117b: 83 ec 08 sub $0x8,%esp
117e: 68 02 43 00 00 push $0x4302
1183: 6a 01 push $0x1
1185: e8 66 29 00 00 call 3af0 <printf>
}
118a: 83 c4 10 add $0x10,%esp
118d: 8d 65 f4 lea -0xc(%ebp),%esp
1190: 5b pop %ebx
1191: 5e pop %esi
1192: 5f pop %edi
1193: 5d pop %ebp
1194: c3 ret
1195: be 01 00 00 00 mov $0x1,%esi
119a: e9 53 ff ff ff jmp 10f2 <fourfiles+0x82>
printf(1, "wrong char\n");
119f: 83 ec 08 sub $0x8,%esp
11a2: 68 e5 42 00 00 push $0x42e5
11a7: 6a 01 push $0x1
11a9: e8 42 29 00 00 call 3af0 <printf>
exit();
11ae: e8 d0 27 00 00 call 3983 <exit>
fd = open(fname, O_CREATE | O_RDWR);
11b3: 83 ec 08 sub $0x8,%esp
11b6: 68 02 02 00 00 push $0x202
11bb: 56 push %esi
11bc: e8 0a 28 00 00 call 39cb <open>
if(fd < 0){
11c1: 83 c4 10 add $0x10,%esp
fd = open(fname, O_CREATE | O_RDWR);
11c4: 89 c6 mov %eax,%esi
if(fd < 0){
11c6: 85 c0 test %eax,%eax
11c8: 78 45 js 120f <fourfiles+0x19f>
memset(buf, '0'+pi, 512);
11ca: 83 ec 04 sub $0x4,%esp
11cd: 83 c3 30 add $0x30,%ebx
11d0: 68 00 02 00 00 push $0x200
11d5: 53 push %ebx
11d6: bb 0c 00 00 00 mov $0xc,%ebx
11db: 68 e0 86 00 00 push $0x86e0
11e0: e8 fb 25 00 00 call 37e0 <memset>
11e5: 83 c4 10 add $0x10,%esp
if((n = write(fd, buf, 500)) != 500){
11e8: 83 ec 04 sub $0x4,%esp
11eb: 68 f4 01 00 00 push $0x1f4
11f0: 68 e0 86 00 00 push $0x86e0
11f5: 56 push %esi
11f6: e8 b0 27 00 00 call 39ab <write>
11fb: 83 c4 10 add $0x10,%esp
11fe: 3d f4 01 00 00 cmp $0x1f4,%eax
1203: 75 4a jne 124f <fourfiles+0x1df>
for(i = 0; i < 12; i++){
1205: 83 eb 01 sub $0x1,%ebx
1208: 75 de jne 11e8 <fourfiles+0x178>
exit();
120a: e8 74 27 00 00 call 3983 <exit>
printf(1, "create failed\n");
120f: 51 push %ecx
1210: 51 push %ecx
1211: 68 5f 45 00 00 push $0x455f
1216: 6a 01 push $0x1
1218: e8 d3 28 00 00 call 3af0 <printf>
exit();
121d: e8 61 27 00 00 call 3983 <exit>
1222: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
printf(1, "fork failed\n");
1228: 83 ec 08 sub $0x8,%esp
122b: 68 99 4d 00 00 push $0x4d99
1230: 6a 01 push $0x1
1232: e8 b9 28 00 00 call 3af0 <printf>
exit();
1237: e8 47 27 00 00 call 3983 <exit>
printf(1, "wrong length %d\n", total);
123c: 50 push %eax
123d: 53 push %ebx
123e: 68 f1 42 00 00 push $0x42f1
1243: 6a 01 push $0x1
1245: e8 a6 28 00 00 call 3af0 <printf>
exit();
124a: e8 34 27 00 00 call 3983 <exit>
printf(1, "write failed %d\n", n);
124f: 52 push %edx
1250: 50 push %eax
1251: 68 d4 42 00 00 push $0x42d4
1256: 6a 01 push $0x1
1258: e8 93 28 00 00 call 3af0 <printf>
exit();
125d: e8 21 27 00 00 call 3983 <exit>
1262: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1269: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
00001270 <createdelete>:
{
1270: f3 0f 1e fb endbr32
1274: 55 push %ebp
1275: 89 e5 mov %esp,%ebp
1277: 57 push %edi
1278: 56 push %esi
1279: 53 push %ebx
for(pi = 0; pi < 4; pi++){
127a: 31 db xor %ebx,%ebx
{
127c: 83 ec 44 sub $0x44,%esp
printf(1, "createdelete test\n");
127f: 68 10 43 00 00 push $0x4310
1284: 6a 01 push $0x1
1286: e8 65 28 00 00 call 3af0 <printf>
128b: 83 c4 10 add $0x10,%esp
pid = fork();
128e: e8 e8 26 00 00 call 397b <fork>
if(pid < 0){
1293: 85 c0 test %eax,%eax
1295: 0f 88 ce 01 00 00 js 1469 <createdelete+0x1f9>
if(pid == 0){
129b: 0f 84 17 01 00 00 je 13b8 <createdelete+0x148>
for(pi = 0; pi < 4; pi++){
12a1: 83 c3 01 add $0x1,%ebx
12a4: 83 fb 04 cmp $0x4,%ebx
12a7: 75 e5 jne 128e <createdelete+0x1e>
wait();
12a9: e8 dd 26 00 00 call 398b <wait>
12ae: 8d 7d c8 lea -0x38(%ebp),%edi
name[0] = name[1] = name[2] = 0;
12b1: be ff ff ff ff mov $0xffffffff,%esi
wait();
12b6: e8 d0 26 00 00 call 398b <wait>
12bb: e8 cb 26 00 00 call 398b <wait>
12c0: e8 c6 26 00 00 call 398b <wait>
name[0] = name[1] = name[2] = 0;
12c5: c6 45 ca 00 movb $0x0,-0x36(%ebp)
for(i = 0; i < N; i++){
12c9: 89 7d c0 mov %edi,-0x40(%ebp)
12cc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
for(pi = 0; pi < 4; pi++){
12d0: 8d 46 31 lea 0x31(%esi),%eax
12d3: 89 f7 mov %esi,%edi
12d5: 83 c6 01 add $0x1,%esi
12d8: 83 fe 09 cmp $0x9,%esi
12db: 88 45 c7 mov %al,-0x39(%ebp)
12de: 0f 9f c3 setg %bl
12e1: 85 f6 test %esi,%esi
12e3: 0f 94 c0 sete %al
12e6: 09 c3 or %eax,%ebx
12e8: 88 5d c6 mov %bl,-0x3a(%ebp)
name[2] = '\0';
12eb: bb 70 00 00 00 mov $0x70,%ebx
fd = open(name, 0);
12f0: 83 ec 08 sub $0x8,%esp
name[1] = '0' + i;
12f3: 0f b6 45 c7 movzbl -0x39(%ebp),%eax
name[0] = 'p' + pi;
12f7: 88 5d c8 mov %bl,-0x38(%ebp)
fd = open(name, 0);
12fa: 6a 00 push $0x0
12fc: ff 75 c0 pushl -0x40(%ebp)
name[1] = '0' + i;
12ff: 88 45 c9 mov %al,-0x37(%ebp)
fd = open(name, 0);
1302: e8 c4 26 00 00 call 39cb <open>
if((i == 0 || i >= N/2) && fd < 0){
1307: 83 c4 10 add $0x10,%esp
130a: 80 7d c6 00 cmpb $0x0,-0x3a(%ebp)
130e: 0f 84 8c 00 00 00 je 13a0 <createdelete+0x130>
1314: 85 c0 test %eax,%eax
1316: 0f 88 21 01 00 00 js 143d <createdelete+0x1cd>
} else if((i >= 1 && i < N/2) && fd >= 0){
131c: 83 ff 08 cmp $0x8,%edi
131f: 0f 86 60 01 00 00 jbe 1485 <createdelete+0x215>
close(fd);
1325: 83 ec 0c sub $0xc,%esp
1328: 50 push %eax
1329: e8 85 26 00 00 call 39b3 <close>
132e: 83 c4 10 add $0x10,%esp
for(pi = 0; pi < 4; pi++){
1331: 83 c3 01 add $0x1,%ebx
1334: 80 fb 74 cmp $0x74,%bl
1337: 75 b7 jne 12f0 <createdelete+0x80>
for(i = 0; i < N; i++){
1339: 83 fe 13 cmp $0x13,%esi
133c: 75 92 jne 12d0 <createdelete+0x60>
133e: 8b 7d c0 mov -0x40(%ebp),%edi
1341: be 70 00 00 00 mov $0x70,%esi
1346: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
134d: 8d 76 00 lea 0x0(%esi),%esi
for(pi = 0; pi < 4; pi++){
1350: 8d 46 c0 lea -0x40(%esi),%eax
name[0] = name[1] = name[2] = 0;
1353: bb 04 00 00 00 mov $0x4,%ebx
1358: 88 45 c7 mov %al,-0x39(%ebp)
unlink(name);
135b: 83 ec 0c sub $0xc,%esp
name[0] = 'p' + i;
135e: 89 f0 mov %esi,%eax
unlink(name);
1360: 57 push %edi
name[0] = 'p' + i;
1361: 88 45 c8 mov %al,-0x38(%ebp)
name[1] = '0' + i;
1364: 0f b6 45 c7 movzbl -0x39(%ebp),%eax
1368: 88 45 c9 mov %al,-0x37(%ebp)
unlink(name);
136b: e8 6b 26 00 00 call 39db <unlink>
for(pi = 0; pi < 4; pi++){
1370: 83 c4 10 add $0x10,%esp
1373: 83 eb 01 sub $0x1,%ebx
1376: 75 e3 jne 135b <createdelete+0xeb>
for(i = 0; i < N; i++){
1378: 83 c6 01 add $0x1,%esi
137b: 89 f0 mov %esi,%eax
137d: 3c 84 cmp $0x84,%al
137f: 75 cf jne 1350 <createdelete+0xe0>
printf(1, "createdelete ok\n");
1381: 83 ec 08 sub $0x8,%esp
1384: 68 23 43 00 00 push $0x4323
1389: 6a 01 push $0x1
138b: e8 60 27 00 00 call 3af0 <printf>
}
1390: 8d 65 f4 lea -0xc(%ebp),%esp
1393: 5b pop %ebx
1394: 5e pop %esi
1395: 5f pop %edi
1396: 5d pop %ebp
1397: c3 ret
1398: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
139f: 90 nop
} else if((i >= 1 && i < N/2) && fd >= 0){
13a0: 83 ff 08 cmp $0x8,%edi
13a3: 0f 86 d4 00 00 00 jbe 147d <createdelete+0x20d>
if(fd >= 0)
13a9: 85 c0 test %eax,%eax
13ab: 78 84 js 1331 <createdelete+0xc1>
13ad: e9 73 ff ff ff jmp 1325 <createdelete+0xb5>
13b2: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
name[0] = 'p' + pi;
13b8: 83 c3 70 add $0x70,%ebx
name[2] = '\0';
13bb: c6 45 ca 00 movb $0x0,-0x36(%ebp)
13bf: 8d 7d c8 lea -0x38(%ebp),%edi
name[0] = 'p' + pi;
13c2: 88 5d c8 mov %bl,-0x38(%ebp)
name[2] = '\0';
13c5: 31 db xor %ebx,%ebx
13c7: eb 0f jmp 13d8 <createdelete+0x168>
13c9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
for(i = 0; i < N; i++){
13d0: 83 fb 13 cmp $0x13,%ebx
13d3: 74 63 je 1438 <createdelete+0x1c8>
13d5: 83 c3 01 add $0x1,%ebx
fd = open(name, O_CREATE | O_RDWR);
13d8: 83 ec 08 sub $0x8,%esp
name[1] = '0' + i;
13db: 8d 43 30 lea 0x30(%ebx),%eax
fd = open(name, O_CREATE | O_RDWR);
13de: 68 02 02 00 00 push $0x202
13e3: 57 push %edi
name[1] = '0' + i;
13e4: 88 45 c9 mov %al,-0x37(%ebp)
fd = open(name, O_CREATE | O_RDWR);
13e7: e8 df 25 00 00 call 39cb <open>
if(fd < 0){
13ec: 83 c4 10 add $0x10,%esp
13ef: 85 c0 test %eax,%eax
13f1: 78 62 js 1455 <createdelete+0x1e5>
close(fd);
13f3: 83 ec 0c sub $0xc,%esp
13f6: 50 push %eax
13f7: e8 b7 25 00 00 call 39b3 <close>
if(i > 0 && (i % 2 ) == 0){
13fc: 83 c4 10 add $0x10,%esp
13ff: 85 db test %ebx,%ebx
1401: 74 d2 je 13d5 <createdelete+0x165>
1403: f6 c3 01 test $0x1,%bl
1406: 75 c8 jne 13d0 <createdelete+0x160>
if(unlink(name) < 0){
1408: 83 ec 0c sub $0xc,%esp
name[1] = '0' + (i / 2);
140b: 89 d8 mov %ebx,%eax
if(unlink(name) < 0){
140d: 57 push %edi
name[1] = '0' + (i / 2);
140e: d1 f8 sar %eax
1410: 83 c0 30 add $0x30,%eax
1413: 88 45 c9 mov %al,-0x37(%ebp)
if(unlink(name) < 0){
1416: e8 c0 25 00 00 call 39db <unlink>
141b: 83 c4 10 add $0x10,%esp
141e: 85 c0 test %eax,%eax
1420: 79 ae jns 13d0 <createdelete+0x160>
printf(1, "unlink failed\n");
1422: 52 push %edx
1423: 52 push %edx
1424: 68 11 3f 00 00 push $0x3f11
1429: 6a 01 push $0x1
142b: e8 c0 26 00 00 call 3af0 <printf>
exit();
1430: e8 4e 25 00 00 call 3983 <exit>
1435: 8d 76 00 lea 0x0(%esi),%esi
exit();
1438: e8 46 25 00 00 call 3983 <exit>
143d: 8b 7d c0 mov -0x40(%ebp),%edi
printf(1, "oops createdelete %s didn't exist\n", name);
1440: 83 ec 04 sub $0x4,%esp
1443: 57 push %edi
1444: 68 d0 4f 00 00 push $0x4fd0
1449: 6a 01 push $0x1
144b: e8 a0 26 00 00 call 3af0 <printf>
exit();
1450: e8 2e 25 00 00 call 3983 <exit>
printf(1, "create failed\n");
1455: 83 ec 08 sub $0x8,%esp
1458: 68 5f 45 00 00 push $0x455f
145d: 6a 01 push $0x1
145f: e8 8c 26 00 00 call 3af0 <printf>
exit();
1464: e8 1a 25 00 00 call 3983 <exit>
printf(1, "fork failed\n");
1469: 83 ec 08 sub $0x8,%esp
146c: 68 99 4d 00 00 push $0x4d99
1471: 6a 01 push $0x1
1473: e8 78 26 00 00 call 3af0 <printf>
exit();
1478: e8 06 25 00 00 call 3983 <exit>
} else if((i >= 1 && i < N/2) && fd >= 0){
147d: 85 c0 test %eax,%eax
147f: 0f 88 ac fe ff ff js 1331 <createdelete+0xc1>
1485: 8b 7d c0 mov -0x40(%ebp),%edi
printf(1, "oops createdelete %s did exist\n", name);
1488: 50 push %eax
1489: 57 push %edi
148a: 68 f4 4f 00 00 push $0x4ff4
148f: 6a 01 push $0x1
1491: e8 5a 26 00 00 call 3af0 <printf>
exit();
1496: e8 e8 24 00 00 call 3983 <exit>
149b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
149f: 90 nop
000014a0 <unlinkread>:
{
14a0: f3 0f 1e fb endbr32
14a4: 55 push %ebp
14a5: 89 e5 mov %esp,%ebp
14a7: 56 push %esi
14a8: 53 push %ebx
printf(1, "unlinkread test\n");
14a9: 83 ec 08 sub $0x8,%esp
14ac: 68 34 43 00 00 push $0x4334
14b1: 6a 01 push $0x1
14b3: e8 38 26 00 00 call 3af0 <printf>
fd = open("unlinkread", O_CREATE | O_RDWR);
14b8: 5b pop %ebx
14b9: 5e pop %esi
14ba: 68 02 02 00 00 push $0x202
14bf: 68 45 43 00 00 push $0x4345
14c4: e8 02 25 00 00 call 39cb <open>
if(fd < 0){
14c9: 83 c4 10 add $0x10,%esp
14cc: 85 c0 test %eax,%eax
14ce: 0f 88 e6 00 00 00 js 15ba <unlinkread+0x11a>
write(fd, "hello", 5);
14d4: 83 ec 04 sub $0x4,%esp
14d7: 89 c3 mov %eax,%ebx
14d9: 6a 05 push $0x5
14db: 68 6a 43 00 00 push $0x436a
14e0: 50 push %eax
14e1: e8 c5 24 00 00 call 39ab <write>
close(fd);
14e6: 89 1c 24 mov %ebx,(%esp)
14e9: e8 c5 24 00 00 call 39b3 <close>
fd = open("unlinkread", O_RDWR);
14ee: 58 pop %eax
14ef: 5a pop %edx
14f0: 6a 02 push $0x2
14f2: 68 45 43 00 00 push $0x4345
14f7: e8 cf 24 00 00 call 39cb <open>
if(fd < 0){
14fc: 83 c4 10 add $0x10,%esp
fd = open("unlinkread", O_RDWR);
14ff: 89 c3 mov %eax,%ebx
if(fd < 0){
1501: 85 c0 test %eax,%eax
1503: 0f 88 10 01 00 00 js 1619 <unlinkread+0x179>
if(unlink("unlinkread") != 0){
1509: 83 ec 0c sub $0xc,%esp
150c: 68 45 43 00 00 push $0x4345
1511: e8 c5 24 00 00 call 39db <unlink>
1516: 83 c4 10 add $0x10,%esp
1519: 85 c0 test %eax,%eax
151b: 0f 85 e5 00 00 00 jne 1606 <unlinkread+0x166>
fd1 = open("unlinkread", O_CREATE | O_RDWR);
1521: 83 ec 08 sub $0x8,%esp
1524: 68 02 02 00 00 push $0x202
1529: 68 45 43 00 00 push $0x4345
152e: e8 98 24 00 00 call 39cb <open>
write(fd1, "yyy", 3);
1533: 83 c4 0c add $0xc,%esp
1536: 6a 03 push $0x3
fd1 = open("unlinkread", O_CREATE | O_RDWR);
1538: 89 c6 mov %eax,%esi
write(fd1, "yyy", 3);
153a: 68 a2 43 00 00 push $0x43a2
153f: 50 push %eax
1540: e8 66 24 00 00 call 39ab <write>
close(fd1);
1545: 89 34 24 mov %esi,(%esp)
1548: e8 66 24 00 00 call 39b3 <close>
if(read(fd, buf, sizeof(buf)) != 5){
154d: 83 c4 0c add $0xc,%esp
1550: 68 00 20 00 00 push $0x2000
1555: 68 e0 86 00 00 push $0x86e0
155a: 53 push %ebx
155b: e8 43 24 00 00 call 39a3 <read>
1560: 83 c4 10 add $0x10,%esp
1563: 83 f8 05 cmp $0x5,%eax
1566: 0f 85 87 00 00 00 jne 15f3 <unlinkread+0x153>
if(buf[0] != 'h'){
156c: 80 3d e0 86 00 00 68 cmpb $0x68,0x86e0
1573: 75 6b jne 15e0 <unlinkread+0x140>
if(write(fd, buf, 10) != 10){
1575: 83 ec 04 sub $0x4,%esp
1578: 6a 0a push $0xa
157a: 68 e0 86 00 00 push $0x86e0
157f: 53 push %ebx
1580: e8 26 24 00 00 call 39ab <write>
1585: 83 c4 10 add $0x10,%esp
1588: 83 f8 0a cmp $0xa,%eax
158b: 75 40 jne 15cd <unlinkread+0x12d>
close(fd);
158d: 83 ec 0c sub $0xc,%esp
1590: 53 push %ebx
1591: e8 1d 24 00 00 call 39b3 <close>
unlink("unlinkread");
1596: c7 04 24 45 43 00 00 movl $0x4345,(%esp)
159d: e8 39 24 00 00 call 39db <unlink>
printf(1, "unlinkread ok\n");
15a2: 58 pop %eax
15a3: 5a pop %edx
15a4: 68 ed 43 00 00 push $0x43ed
15a9: 6a 01 push $0x1
15ab: e8 40 25 00 00 call 3af0 <printf>
}
15b0: 83 c4 10 add $0x10,%esp
15b3: 8d 65 f8 lea -0x8(%ebp),%esp
15b6: 5b pop %ebx
15b7: 5e pop %esi
15b8: 5d pop %ebp
15b9: c3 ret
printf(1, "create unlinkread failed\n");
15ba: 51 push %ecx
15bb: 51 push %ecx
15bc: 68 50 43 00 00 push $0x4350
15c1: 6a 01 push $0x1
15c3: e8 28 25 00 00 call 3af0 <printf>
exit();
15c8: e8 b6 23 00 00 call 3983 <exit>
printf(1, "unlinkread write failed\n");
15cd: 51 push %ecx
15ce: 51 push %ecx
15cf: 68 d4 43 00 00 push $0x43d4
15d4: 6a 01 push $0x1
15d6: e8 15 25 00 00 call 3af0 <printf>
exit();
15db: e8 a3 23 00 00 call 3983 <exit>
printf(1, "unlinkread wrong data\n");
15e0: 53 push %ebx
15e1: 53 push %ebx
15e2: 68 bd 43 00 00 push $0x43bd
15e7: 6a 01 push $0x1
15e9: e8 02 25 00 00 call 3af0 <printf>
exit();
15ee: e8 90 23 00 00 call 3983 <exit>
printf(1, "unlinkread read failed");
15f3: 56 push %esi
15f4: 56 push %esi
15f5: 68 a6 43 00 00 push $0x43a6
15fa: 6a 01 push $0x1
15fc: e8 ef 24 00 00 call 3af0 <printf>
exit();
1601: e8 7d 23 00 00 call 3983 <exit>
printf(1, "unlink unlinkread failed\n");
1606: 50 push %eax
1607: 50 push %eax
1608: 68 88 43 00 00 push $0x4388
160d: 6a 01 push $0x1
160f: e8 dc 24 00 00 call 3af0 <printf>
exit();
1614: e8 6a 23 00 00 call 3983 <exit>
printf(1, "open unlinkread failed\n");
1619: 50 push %eax
161a: 50 push %eax
161b: 68 70 43 00 00 push $0x4370
1620: 6a 01 push $0x1
1622: e8 c9 24 00 00 call 3af0 <printf>
exit();
1627: e8 57 23 00 00 call 3983 <exit>
162c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
00001630 <linktest>:
{
1630: f3 0f 1e fb endbr32
1634: 55 push %ebp
1635: 89 e5 mov %esp,%ebp
1637: 53 push %ebx
1638: 83 ec 0c sub $0xc,%esp
printf(1, "linktest\n");
163b: 68 fc 43 00 00 push $0x43fc
1640: 6a 01 push $0x1
1642: e8 a9 24 00 00 call 3af0 <printf>
unlink("lf1");
1647: c7 04 24 06 44 00 00 movl $0x4406,(%esp)
164e: e8 88 23 00 00 call 39db <unlink>
unlink("lf2");
1653: c7 04 24 0a 44 00 00 movl $0x440a,(%esp)
165a: e8 7c 23 00 00 call 39db <unlink>
fd = open("lf1", O_CREATE|O_RDWR);
165f: 58 pop %eax
1660: 5a pop %edx
1661: 68 02 02 00 00 push $0x202
1666: 68 06 44 00 00 push $0x4406
166b: e8 5b 23 00 00 call 39cb <open>
if(fd < 0){
1670: 83 c4 10 add $0x10,%esp
1673: 85 c0 test %eax,%eax
1675: 0f 88 1e 01 00 00 js 1799 <linktest+0x169>
if(write(fd, "hello", 5) != 5){
167b: 83 ec 04 sub $0x4,%esp
167e: 89 c3 mov %eax,%ebx
1680: 6a 05 push $0x5
1682: 68 6a 43 00 00 push $0x436a
1687: 50 push %eax
1688: e8 1e 23 00 00 call 39ab <write>
168d: 83 c4 10 add $0x10,%esp
1690: 83 f8 05 cmp $0x5,%eax
1693: 0f 85 98 01 00 00 jne 1831 <linktest+0x201>
close(fd);
1699: 83 ec 0c sub $0xc,%esp
169c: 53 push %ebx
169d: e8 11 23 00 00 call 39b3 <close>
if(link("lf1", "lf2") < 0){
16a2: 5b pop %ebx
16a3: 58 pop %eax
16a4: 68 0a 44 00 00 push $0x440a
16a9: 68 06 44 00 00 push $0x4406
16ae: e8 38 23 00 00 call 39eb <link>
16b3: 83 c4 10 add $0x10,%esp
16b6: 85 c0 test %eax,%eax
16b8: 0f 88 60 01 00 00 js 181e <linktest+0x1ee>
unlink("lf1");
16be: 83 ec 0c sub $0xc,%esp
16c1: 68 06 44 00 00 push $0x4406
16c6: e8 10 23 00 00 call 39db <unlink>
if(open("lf1", 0) >= 0){
16cb: 58 pop %eax
16cc: 5a pop %edx
16cd: 6a 00 push $0x0
16cf: 68 06 44 00 00 push $0x4406
16d4: e8 f2 22 00 00 call 39cb <open>
16d9: 83 c4 10 add $0x10,%esp
16dc: 85 c0 test %eax,%eax
16de: 0f 89 27 01 00 00 jns 180b <linktest+0x1db>
fd = open("lf2", 0);
16e4: 83 ec 08 sub $0x8,%esp
16e7: 6a 00 push $0x0
16e9: 68 0a 44 00 00 push $0x440a
16ee: e8 d8 22 00 00 call 39cb <open>
if(fd < 0){
16f3: 83 c4 10 add $0x10,%esp
fd = open("lf2", 0);
16f6: 89 c3 mov %eax,%ebx
if(fd < 0){
16f8: 85 c0 test %eax,%eax
16fa: 0f 88 f8 00 00 00 js 17f8 <linktest+0x1c8>
if(read(fd, buf, sizeof(buf)) != 5){
1700: 83 ec 04 sub $0x4,%esp
1703: 68 00 20 00 00 push $0x2000
1708: 68 e0 86 00 00 push $0x86e0
170d: 50 push %eax
170e: e8 90 22 00 00 call 39a3 <read>
1713: 83 c4 10 add $0x10,%esp
1716: 83 f8 05 cmp $0x5,%eax
1719: 0f 85 c6 00 00 00 jne 17e5 <linktest+0x1b5>
close(fd);
171f: 83 ec 0c sub $0xc,%esp
1722: 53 push %ebx
1723: e8 8b 22 00 00 call 39b3 <close>
if(link("lf2", "lf2") >= 0){
1728: 58 pop %eax
1729: 5a pop %edx
172a: 68 0a 44 00 00 push $0x440a
172f: 68 0a 44 00 00 push $0x440a
1734: e8 b2 22 00 00 call 39eb <link>
1739: 83 c4 10 add $0x10,%esp
173c: 85 c0 test %eax,%eax
173e: 0f 89 8e 00 00 00 jns 17d2 <linktest+0x1a2>
unlink("lf2");
1744: 83 ec 0c sub $0xc,%esp
1747: 68 0a 44 00 00 push $0x440a
174c: e8 8a 22 00 00 call 39db <unlink>
if(link("lf2", "lf1") >= 0){
1751: 59 pop %ecx
1752: 5b pop %ebx
1753: 68 06 44 00 00 push $0x4406
1758: 68 0a 44 00 00 push $0x440a
175d: e8 89 22 00 00 call 39eb <link>
1762: 83 c4 10 add $0x10,%esp
1765: 85 c0 test %eax,%eax
1767: 79 56 jns 17bf <linktest+0x18f>
if(link(".", "lf1") >= 0){
1769: 83 ec 08 sub $0x8,%esp
176c: 68 06 44 00 00 push $0x4406
1771: 68 ce 46 00 00 push $0x46ce
1776: e8 70 22 00 00 call 39eb <link>
177b: 83 c4 10 add $0x10,%esp
177e: 85 c0 test %eax,%eax
1780: 79 2a jns 17ac <linktest+0x17c>
printf(1, "linktest ok\n");
1782: 83 ec 08 sub $0x8,%esp
1785: 68 a4 44 00 00 push $0x44a4
178a: 6a 01 push $0x1
178c: e8 5f 23 00 00 call 3af0 <printf>
}
1791: 8b 5d fc mov -0x4(%ebp),%ebx
1794: 83 c4 10 add $0x10,%esp
1797: c9 leave
1798: c3 ret
printf(1, "create lf1 failed\n");
1799: 50 push %eax
179a: 50 push %eax
179b: 68 0e 44 00 00 push $0x440e
17a0: 6a 01 push $0x1
17a2: e8 49 23 00 00 call 3af0 <printf>
exit();
17a7: e8 d7 21 00 00 call 3983 <exit>
printf(1, "link . lf1 succeeded! oops\n");
17ac: 50 push %eax
17ad: 50 push %eax
17ae: 68 88 44 00 00 push $0x4488
17b3: 6a 01 push $0x1
17b5: e8 36 23 00 00 call 3af0 <printf>
exit();
17ba: e8 c4 21 00 00 call 3983 <exit>
printf(1, "link non-existant succeeded! oops\n");
17bf: 52 push %edx
17c0: 52 push %edx
17c1: 68 3c 50 00 00 push $0x503c
17c6: 6a 01 push $0x1
17c8: e8 23 23 00 00 call 3af0 <printf>
exit();
17cd: e8 b1 21 00 00 call 3983 <exit>
printf(1, "link lf2 lf2 succeeded! oops\n");
17d2: 50 push %eax
17d3: 50 push %eax
17d4: 68 6a 44 00 00 push $0x446a
17d9: 6a 01 push $0x1
17db: e8 10 23 00 00 call 3af0 <printf>
exit();
17e0: e8 9e 21 00 00 call 3983 <exit>
printf(1, "read lf2 failed\n");
17e5: 51 push %ecx
17e6: 51 push %ecx
17e7: 68 59 44 00 00 push $0x4459
17ec: 6a 01 push $0x1
17ee: e8 fd 22 00 00 call 3af0 <printf>
exit();
17f3: e8 8b 21 00 00 call 3983 <exit>
printf(1, "open lf2 failed\n");
17f8: 53 push %ebx
17f9: 53 push %ebx
17fa: 68 48 44 00 00 push $0x4448
17ff: 6a 01 push $0x1
1801: e8 ea 22 00 00 call 3af0 <printf>
exit();
1806: e8 78 21 00 00 call 3983 <exit>
printf(1, "unlinked lf1 but it is still there!\n");
180b: 50 push %eax
180c: 50 push %eax
180d: 68 14 50 00 00 push $0x5014
1812: 6a 01 push $0x1
1814: e8 d7 22 00 00 call 3af0 <printf>
exit();
1819: e8 65 21 00 00 call 3983 <exit>
printf(1, "link lf1 lf2 failed\n");
181e: 51 push %ecx
181f: 51 push %ecx
1820: 68 33 44 00 00 push $0x4433
1825: 6a 01 push $0x1
1827: e8 c4 22 00 00 call 3af0 <printf>
exit();
182c: e8 52 21 00 00 call 3983 <exit>
printf(1, "write lf1 failed\n");
1831: 50 push %eax
1832: 50 push %eax
1833: 68 21 44 00 00 push $0x4421
1838: 6a 01 push $0x1
183a: e8 b1 22 00 00 call 3af0 <printf>
exit();
183f: e8 3f 21 00 00 call 3983 <exit>
1844: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
184b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
184f: 90 nop
00001850 <concreate>:
{
1850: f3 0f 1e fb endbr32
1854: 55 push %ebp
1855: 89 e5 mov %esp,%ebp
1857: 57 push %edi
1858: 56 push %esi
for(i = 0; i < 40; i++){
1859: 31 f6 xor %esi,%esi
{
185b: 53 push %ebx
185c: 8d 5d ad lea -0x53(%ebp),%ebx
185f: 83 ec 64 sub $0x64,%esp
printf(1, "concreate test\n");
1862: 68 b1 44 00 00 push $0x44b1
1867: 6a 01 push $0x1
1869: e8 82 22 00 00 call 3af0 <printf>
file[0] = 'C';
186e: c6 45 ad 43 movb $0x43,-0x53(%ebp)
file[2] = '\0';
1872: 83 c4 10 add $0x10,%esp
1875: c6 45 af 00 movb $0x0,-0x51(%ebp)
for(i = 0; i < 40; i++){
1879: eb 48 jmp 18c3 <concreate+0x73>
187b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
187f: 90 nop
1880: 69 c6 ab aa aa aa imul $0xaaaaaaab,%esi,%eax
if(pid && (i % 3) == 1){
1886: 3d ab aa aa aa cmp $0xaaaaaaab,%eax
188b: 0f 83 af 00 00 00 jae 1940 <concreate+0xf0>
fd = open(file, O_CREATE | O_RDWR);
1891: 83 ec 08 sub $0x8,%esp
1894: 68 02 02 00 00 push $0x202
1899: 53 push %ebx
189a: e8 2c 21 00 00 call 39cb <open>
if(fd < 0){
189f: 83 c4 10 add $0x10,%esp
18a2: 85 c0 test %eax,%eax
18a4: 78 5f js 1905 <concreate+0xb5>
close(fd);
18a6: 83 ec 0c sub $0xc,%esp
for(i = 0; i < 40; i++){
18a9: 83 c6 01 add $0x1,%esi
close(fd);
18ac: 50 push %eax
18ad: e8 01 21 00 00 call 39b3 <close>
18b2: 83 c4 10 add $0x10,%esp
wait();
18b5: e8 d1 20 00 00 call 398b <wait>
for(i = 0; i < 40; i++){
18ba: 83 fe 28 cmp $0x28,%esi
18bd: 0f 84 9f 00 00 00 je 1962 <concreate+0x112>
unlink(file);
18c3: 83 ec 0c sub $0xc,%esp
file[1] = '0' + i;
18c6: 8d 46 30 lea 0x30(%esi),%eax
unlink(file);
18c9: 53 push %ebx
file[1] = '0' + i;
18ca: 88 45 ae mov %al,-0x52(%ebp)
unlink(file);
18cd: e8 09 21 00 00 call 39db <unlink>
pid = fork();
18d2: e8 a4 20 00 00 call 397b <fork>
if(pid && (i % 3) == 1){
18d7: 83 c4 10 add $0x10,%esp
18da: 85 c0 test %eax,%eax
18dc: 75 a2 jne 1880 <concreate+0x30>
link("C0", file);
18de: 69 f6 cd cc cc cc imul $0xcccccccd,%esi,%esi
} else if(pid == 0 && (i % 5) == 1){
18e4: 81 fe cd cc cc cc cmp $0xcccccccd,%esi
18ea: 73 34 jae 1920 <concreate+0xd0>
fd = open(file, O_CREATE | O_RDWR);
18ec: 83 ec 08 sub $0x8,%esp
18ef: 68 02 02 00 00 push $0x202
18f4: 53 push %ebx
18f5: e8 d1 20 00 00 call 39cb <open>
if(fd < 0){
18fa: 83 c4 10 add $0x10,%esp
18fd: 85 c0 test %eax,%eax
18ff: 0f 89 39 02 00 00 jns 1b3e <concreate+0x2ee>
printf(1, "concreate create %s failed\n", file);
1905: 83 ec 04 sub $0x4,%esp
1908: 53 push %ebx
1909: 68 c4 44 00 00 push $0x44c4
190e: 6a 01 push $0x1
1910: e8 db 21 00 00 call 3af0 <printf>
exit();
1915: e8 69 20 00 00 call 3983 <exit>
191a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
link("C0", file);
1920: 83 ec 08 sub $0x8,%esp
1923: 53 push %ebx
1924: 68 c1 44 00 00 push $0x44c1
1929: e8 bd 20 00 00 call 39eb <link>
192e: 83 c4 10 add $0x10,%esp
exit();
1931: e8 4d 20 00 00 call 3983 <exit>
1936: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
193d: 8d 76 00 lea 0x0(%esi),%esi
link("C0", file);
1940: 83 ec 08 sub $0x8,%esp
for(i = 0; i < 40; i++){
1943: 83 c6 01 add $0x1,%esi
link("C0", file);
1946: 53 push %ebx
1947: 68 c1 44 00 00 push $0x44c1
194c: e8 9a 20 00 00 call 39eb <link>
1951: 83 c4 10 add $0x10,%esp
wait();
1954: e8 32 20 00 00 call 398b <wait>
for(i = 0; i < 40; i++){
1959: 83 fe 28 cmp $0x28,%esi
195c: 0f 85 61 ff ff ff jne 18c3 <concreate+0x73>
memset(fa, 0, sizeof(fa));
1962: 83 ec 04 sub $0x4,%esp
1965: 8d 45 c0 lea -0x40(%ebp),%eax
1968: 6a 28 push $0x28
196a: 6a 00 push $0x0
196c: 50 push %eax
196d: e8 6e 1e 00 00 call 37e0 <memset>
fd = open(".", 0);
1972: 5e pop %esi
1973: 5f pop %edi
1974: 6a 00 push $0x0
1976: 68 ce 46 00 00 push $0x46ce
197b: 8d 7d b0 lea -0x50(%ebp),%edi
197e: e8 48 20 00 00 call 39cb <open>
n = 0;
1983: c7 45 a4 00 00 00 00 movl $0x0,-0x5c(%ebp)
while(read(fd, &de, sizeof(de)) > 0){
198a: 83 c4 10 add $0x10,%esp
fd = open(".", 0);
198d: 89 c6 mov %eax,%esi
while(read(fd, &de, sizeof(de)) > 0){
198f: 90 nop
1990: 83 ec 04 sub $0x4,%esp
1993: 6a 10 push $0x10
1995: 57 push %edi
1996: 56 push %esi
1997: e8 07 20 00 00 call 39a3 <read>
199c: 83 c4 10 add $0x10,%esp
199f: 85 c0 test %eax,%eax
19a1: 7e 3d jle 19e0 <concreate+0x190>
if(de.inum == 0)
19a3: 66 83 7d b0 00 cmpw $0x0,-0x50(%ebp)
19a8: 74 e6 je 1990 <concreate+0x140>
if(de.name[0] == 'C' && de.name[2] == '\0'){
19aa: 80 7d b2 43 cmpb $0x43,-0x4e(%ebp)
19ae: 75 e0 jne 1990 <concreate+0x140>
19b0: 80 7d b4 00 cmpb $0x0,-0x4c(%ebp)
19b4: 75 da jne 1990 <concreate+0x140>
i = de.name[1] - '0';
19b6: 0f be 45 b3 movsbl -0x4d(%ebp),%eax
19ba: 83 e8 30 sub $0x30,%eax
if(i < 0 || i >= sizeof(fa)){
19bd: 83 f8 27 cmp $0x27,%eax
19c0: 0f 87 60 01 00 00 ja 1b26 <concreate+0x2d6>
if(fa[i]){
19c6: 80 7c 05 c0 00 cmpb $0x0,-0x40(%ebp,%eax,1)
19cb: 0f 85 3d 01 00 00 jne 1b0e <concreate+0x2be>
n++;
19d1: 83 45 a4 01 addl $0x1,-0x5c(%ebp)
fa[i] = 1;
19d5: c6 44 05 c0 01 movb $0x1,-0x40(%ebp,%eax,1)
n++;
19da: eb b4 jmp 1990 <concreate+0x140>
19dc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
close(fd);
19e0: 83 ec 0c sub $0xc,%esp
19e3: 56 push %esi
19e4: e8 ca 1f 00 00 call 39b3 <close>
if(n != 40){
19e9: 83 c4 10 add $0x10,%esp
19ec: 83 7d a4 28 cmpl $0x28,-0x5c(%ebp)
19f0: 0f 85 05 01 00 00 jne 1afb <concreate+0x2ab>
for(i = 0; i < 40; i++){
19f6: 31 f6 xor %esi,%esi
19f8: eb 4c jmp 1a46 <concreate+0x1f6>
19fa: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
((i % 3) == 1 && pid != 0)){
1a00: 85 ff test %edi,%edi
1a02: 74 05 je 1a09 <concreate+0x1b9>
1a04: 83 f8 01 cmp $0x1,%eax
1a07: 74 6c je 1a75 <concreate+0x225>
unlink(file);
1a09: 83 ec 0c sub $0xc,%esp
1a0c: 53 push %ebx
1a0d: e8 c9 1f 00 00 call 39db <unlink>
unlink(file);
1a12: 89 1c 24 mov %ebx,(%esp)
1a15: e8 c1 1f 00 00 call 39db <unlink>
unlink(file);
1a1a: 89 1c 24 mov %ebx,(%esp)
1a1d: e8 b9 1f 00 00 call 39db <unlink>
unlink(file);
1a22: 89 1c 24 mov %ebx,(%esp)
1a25: e8 b1 1f 00 00 call 39db <unlink>
1a2a: 83 c4 10 add $0x10,%esp
if(pid == 0)
1a2d: 85 ff test %edi,%edi
1a2f: 0f 84 fc fe ff ff je 1931 <concreate+0xe1>
wait();
1a35: e8 51 1f 00 00 call 398b <wait>
for(i = 0; i < 40; i++){
1a3a: 83 c6 01 add $0x1,%esi
1a3d: 83 fe 28 cmp $0x28,%esi
1a40: 0f 84 8a 00 00 00 je 1ad0 <concreate+0x280>
file[1] = '0' + i;
1a46: 8d 46 30 lea 0x30(%esi),%eax
1a49: 88 45 ae mov %al,-0x52(%ebp)
pid = fork();
1a4c: e8 2a 1f 00 00 call 397b <fork>
1a51: 89 c7 mov %eax,%edi
if(pid < 0){
1a53: 85 c0 test %eax,%eax
1a55: 0f 88 8c 00 00 00 js 1ae7 <concreate+0x297>
if(((i % 3) == 0 && pid == 0) ||
1a5b: b8 ab aa aa aa mov $0xaaaaaaab,%eax
1a60: f7 e6 mul %esi
1a62: 89 d0 mov %edx,%eax
1a64: 83 e2 fe and $0xfffffffe,%edx
1a67: d1 e8 shr %eax
1a69: 01 c2 add %eax,%edx
1a6b: 89 f0 mov %esi,%eax
1a6d: 29 d0 sub %edx,%eax
1a6f: 89 c1 mov %eax,%ecx
1a71: 09 f9 or %edi,%ecx
1a73: 75 8b jne 1a00 <concreate+0x1b0>
close(open(file, 0));
1a75: 83 ec 08 sub $0x8,%esp
1a78: 6a 00 push $0x0
1a7a: 53 push %ebx
1a7b: e8 4b 1f 00 00 call 39cb <open>
1a80: 89 04 24 mov %eax,(%esp)
1a83: e8 2b 1f 00 00 call 39b3 <close>
close(open(file, 0));
1a88: 58 pop %eax
1a89: 5a pop %edx
1a8a: 6a 00 push $0x0
1a8c: 53 push %ebx
1a8d: e8 39 1f 00 00 call 39cb <open>
1a92: 89 04 24 mov %eax,(%esp)
1a95: e8 19 1f 00 00 call 39b3 <close>
close(open(file, 0));
1a9a: 59 pop %ecx
1a9b: 58 pop %eax
1a9c: 6a 00 push $0x0
1a9e: 53 push %ebx
1a9f: e8 27 1f 00 00 call 39cb <open>
1aa4: 89 04 24 mov %eax,(%esp)
1aa7: e8 07 1f 00 00 call 39b3 <close>
close(open(file, 0));
1aac: 58 pop %eax
1aad: 5a pop %edx
1aae: 6a 00 push $0x0
1ab0: 53 push %ebx
1ab1: e8 15 1f 00 00 call 39cb <open>
1ab6: 89 04 24 mov %eax,(%esp)
1ab9: e8 f5 1e 00 00 call 39b3 <close>
1abe: 83 c4 10 add $0x10,%esp
1ac1: e9 67 ff ff ff jmp 1a2d <concreate+0x1dd>
1ac6: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1acd: 8d 76 00 lea 0x0(%esi),%esi
printf(1, "concreate ok\n");
1ad0: 83 ec 08 sub $0x8,%esp
1ad3: 68 16 45 00 00 push $0x4516
1ad8: 6a 01 push $0x1
1ada: e8 11 20 00 00 call 3af0 <printf>
}
1adf: 8d 65 f4 lea -0xc(%ebp),%esp
1ae2: 5b pop %ebx
1ae3: 5e pop %esi
1ae4: 5f pop %edi
1ae5: 5d pop %ebp
1ae6: c3 ret
printf(1, "fork failed\n");
1ae7: 83 ec 08 sub $0x8,%esp
1aea: 68 99 4d 00 00 push $0x4d99
1aef: 6a 01 push $0x1
1af1: e8 fa 1f 00 00 call 3af0 <printf>
exit();
1af6: e8 88 1e 00 00 call 3983 <exit>
printf(1, "concreate not enough files in directory listing\n");
1afb: 51 push %ecx
1afc: 51 push %ecx
1afd: 68 60 50 00 00 push $0x5060
1b02: 6a 01 push $0x1
1b04: e8 e7 1f 00 00 call 3af0 <printf>
exit();
1b09: e8 75 1e 00 00 call 3983 <exit>
printf(1, "concreate duplicate file %s\n", de.name);
1b0e: 83 ec 04 sub $0x4,%esp
1b11: 8d 45 b2 lea -0x4e(%ebp),%eax
1b14: 50 push %eax
1b15: 68 f9 44 00 00 push $0x44f9
1b1a: 6a 01 push $0x1
1b1c: e8 cf 1f 00 00 call 3af0 <printf>
exit();
1b21: e8 5d 1e 00 00 call 3983 <exit>
printf(1, "concreate weird file %s\n", de.name);
1b26: 83 ec 04 sub $0x4,%esp
1b29: 8d 45 b2 lea -0x4e(%ebp),%eax
1b2c: 50 push %eax
1b2d: 68 e0 44 00 00 push $0x44e0
1b32: 6a 01 push $0x1
1b34: e8 b7 1f 00 00 call 3af0 <printf>
exit();
1b39: e8 45 1e 00 00 call 3983 <exit>
close(fd);
1b3e: 83 ec 0c sub $0xc,%esp
1b41: 50 push %eax
1b42: e8 6c 1e 00 00 call 39b3 <close>
1b47: 83 c4 10 add $0x10,%esp
1b4a: e9 e2 fd ff ff jmp 1931 <concreate+0xe1>
1b4f: 90 nop
00001b50 <linkunlink>:
{
1b50: f3 0f 1e fb endbr32
1b54: 55 push %ebp
1b55: 89 e5 mov %esp,%ebp
1b57: 57 push %edi
1b58: 56 push %esi
1b59: 53 push %ebx
1b5a: 83 ec 24 sub $0x24,%esp
printf(1, "linkunlink test\n");
1b5d: 68 24 45 00 00 push $0x4524
1b62: 6a 01 push $0x1
1b64: e8 87 1f 00 00 call 3af0 <printf>
unlink("x");
1b69: c7 04 24 b1 47 00 00 movl $0x47b1,(%esp)
1b70: e8 66 1e 00 00 call 39db <unlink>
pid = fork();
1b75: e8 01 1e 00 00 call 397b <fork>
if(pid < 0){
1b7a: 83 c4 10 add $0x10,%esp
pid = fork();
1b7d: 89 45 e4 mov %eax,-0x1c(%ebp)
if(pid < 0){
1b80: 85 c0 test %eax,%eax
1b82: 0f 88 b2 00 00 00 js 1c3a <linkunlink+0xea>
unsigned int x = (pid ? 1 : 97);
1b88: 83 7d e4 01 cmpl $0x1,-0x1c(%ebp)
1b8c: bb 64 00 00 00 mov $0x64,%ebx
if((x % 3) == 0){
1b91: be ab aa aa aa mov $0xaaaaaaab,%esi
unsigned int x = (pid ? 1 : 97);
1b96: 19 ff sbb %edi,%edi
1b98: 83 e7 60 and $0x60,%edi
1b9b: 83 c7 01 add $0x1,%edi
1b9e: eb 1a jmp 1bba <linkunlink+0x6a>
} else if((x % 3) == 1){
1ba0: 83 f8 01 cmp $0x1,%eax
1ba3: 74 7b je 1c20 <linkunlink+0xd0>
unlink("x");
1ba5: 83 ec 0c sub $0xc,%esp
1ba8: 68 b1 47 00 00 push $0x47b1
1bad: e8 29 1e 00 00 call 39db <unlink>
1bb2: 83 c4 10 add $0x10,%esp
for(i = 0; i < 100; i++){
1bb5: 83 eb 01 sub $0x1,%ebx
1bb8: 74 41 je 1bfb <linkunlink+0xab>
x = x * 1103515245 + 12345;
1bba: 69 cf 6d 4e c6 41 imul $0x41c64e6d,%edi,%ecx
1bc0: 8d b9 39 30 00 00 lea 0x3039(%ecx),%edi
if((x % 3) == 0){
1bc6: 89 f8 mov %edi,%eax
1bc8: f7 e6 mul %esi
1bca: 89 d0 mov %edx,%eax
1bcc: 83 e2 fe and $0xfffffffe,%edx
1bcf: d1 e8 shr %eax
1bd1: 01 c2 add %eax,%edx
1bd3: 89 f8 mov %edi,%eax
1bd5: 29 d0 sub %edx,%eax
1bd7: 75 c7 jne 1ba0 <linkunlink+0x50>
close(open("x", O_RDWR | O_CREATE));
1bd9: 83 ec 08 sub $0x8,%esp
1bdc: 68 02 02 00 00 push $0x202
1be1: 68 b1 47 00 00 push $0x47b1
1be6: e8 e0 1d 00 00 call 39cb <open>
1beb: 89 04 24 mov %eax,(%esp)
1bee: e8 c0 1d 00 00 call 39b3 <close>
1bf3: 83 c4 10 add $0x10,%esp
for(i = 0; i < 100; i++){
1bf6: 83 eb 01 sub $0x1,%ebx
1bf9: 75 bf jne 1bba <linkunlink+0x6a>
if(pid)
1bfb: 8b 45 e4 mov -0x1c(%ebp),%eax
1bfe: 85 c0 test %eax,%eax
1c00: 74 4b je 1c4d <linkunlink+0xfd>
wait();
1c02: e8 84 1d 00 00 call 398b <wait>
printf(1, "linkunlink ok\n");
1c07: 83 ec 08 sub $0x8,%esp
1c0a: 68 39 45 00 00 push $0x4539
1c0f: 6a 01 push $0x1
1c11: e8 da 1e 00 00 call 3af0 <printf>
}
1c16: 8d 65 f4 lea -0xc(%ebp),%esp
1c19: 5b pop %ebx
1c1a: 5e pop %esi
1c1b: 5f pop %edi
1c1c: 5d pop %ebp
1c1d: c3 ret
1c1e: 66 90 xchg %ax,%ax
link("cat", "x");
1c20: 83 ec 08 sub $0x8,%esp
1c23: 68 b1 47 00 00 push $0x47b1
1c28: 68 35 45 00 00 push $0x4535
1c2d: e8 b9 1d 00 00 call 39eb <link>
1c32: 83 c4 10 add $0x10,%esp
1c35: e9 7b ff ff ff jmp 1bb5 <linkunlink+0x65>
printf(1, "fork failed\n");
1c3a: 52 push %edx
1c3b: 52 push %edx
1c3c: 68 99 4d 00 00 push $0x4d99
1c41: 6a 01 push $0x1
1c43: e8 a8 1e 00 00 call 3af0 <printf>
exit();
1c48: e8 36 1d 00 00 call 3983 <exit>
exit();
1c4d: e8 31 1d 00 00 call 3983 <exit>
1c52: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1c59: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
00001c60 <bigdir>:
{
1c60: f3 0f 1e fb endbr32
1c64: 55 push %ebp
1c65: 89 e5 mov %esp,%ebp
1c67: 57 push %edi
1c68: 56 push %esi
1c69: 53 push %ebx
1c6a: 83 ec 24 sub $0x24,%esp
printf(1, "bigdir test\n");
1c6d: 68 48 45 00 00 push $0x4548
1c72: 6a 01 push $0x1
1c74: e8 77 1e 00 00 call 3af0 <printf>
unlink("bd");
1c79: c7 04 24 55 45 00 00 movl $0x4555,(%esp)
1c80: e8 56 1d 00 00 call 39db <unlink>
fd = open("bd", O_CREATE);
1c85: 5a pop %edx
1c86: 59 pop %ecx
1c87: 68 00 02 00 00 push $0x200
1c8c: 68 55 45 00 00 push $0x4555
1c91: e8 35 1d 00 00 call 39cb <open>
if(fd < 0){
1c96: 83 c4 10 add $0x10,%esp
1c99: 85 c0 test %eax,%eax
1c9b: 0f 88 ea 00 00 00 js 1d8b <bigdir+0x12b>
close(fd);
1ca1: 83 ec 0c sub $0xc,%esp
for(i = 0; i < 500; i++){
1ca4: 31 f6 xor %esi,%esi
1ca6: 8d 7d de lea -0x22(%ebp),%edi
close(fd);
1ca9: 50 push %eax
1caa: e8 04 1d 00 00 call 39b3 <close>
1caf: 83 c4 10 add $0x10,%esp
1cb2: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
name[1] = '0' + (i / 64);
1cb8: 89 f0 mov %esi,%eax
if(link("bd", name) != 0){
1cba: 83 ec 08 sub $0x8,%esp
name[0] = 'x';
1cbd: c6 45 de 78 movb $0x78,-0x22(%ebp)
name[1] = '0' + (i / 64);
1cc1: c1 f8 06 sar $0x6,%eax
if(link("bd", name) != 0){
1cc4: 57 push %edi
name[1] = '0' + (i / 64);
1cc5: 83 c0 30 add $0x30,%eax
if(link("bd", name) != 0){
1cc8: 68 55 45 00 00 push $0x4555
name[1] = '0' + (i / 64);
1ccd: 88 45 df mov %al,-0x21(%ebp)
name[2] = '0' + (i % 64);
1cd0: 89 f0 mov %esi,%eax
1cd2: 83 e0 3f and $0x3f,%eax
name[3] = '\0';
1cd5: c6 45 e1 00 movb $0x0,-0x1f(%ebp)
name[2] = '0' + (i % 64);
1cd9: 83 c0 30 add $0x30,%eax
1cdc: 88 45 e0 mov %al,-0x20(%ebp)
if(link("bd", name) != 0){
1cdf: e8 07 1d 00 00 call 39eb <link>
1ce4: 83 c4 10 add $0x10,%esp
1ce7: 89 c3 mov %eax,%ebx
1ce9: 85 c0 test %eax,%eax
1ceb: 75 76 jne 1d63 <bigdir+0x103>
for(i = 0; i < 500; i++){
1ced: 83 c6 01 add $0x1,%esi
1cf0: 81 fe f4 01 00 00 cmp $0x1f4,%esi
1cf6: 75 c0 jne 1cb8 <bigdir+0x58>
unlink("bd");
1cf8: 83 ec 0c sub $0xc,%esp
1cfb: 68 55 45 00 00 push $0x4555
1d00: e8 d6 1c 00 00 call 39db <unlink>
1d05: 83 c4 10 add $0x10,%esp
1d08: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1d0f: 90 nop
name[1] = '0' + (i / 64);
1d10: 89 d8 mov %ebx,%eax
if(unlink(name) != 0){
1d12: 83 ec 0c sub $0xc,%esp
name[0] = 'x';
1d15: c6 45 de 78 movb $0x78,-0x22(%ebp)
name[1] = '0' + (i / 64);
1d19: c1 f8 06 sar $0x6,%eax
if(unlink(name) != 0){
1d1c: 57 push %edi
name[1] = '0' + (i / 64);
1d1d: 83 c0 30 add $0x30,%eax
name[3] = '\0';
1d20: c6 45 e1 00 movb $0x0,-0x1f(%ebp)
name[1] = '0' + (i / 64);
1d24: 88 45 df mov %al,-0x21(%ebp)
name[2] = '0' + (i % 64);
1d27: 89 d8 mov %ebx,%eax
1d29: 83 e0 3f and $0x3f,%eax
1d2c: 83 c0 30 add $0x30,%eax
1d2f: 88 45 e0 mov %al,-0x20(%ebp)
if(unlink(name) != 0){
1d32: e8 a4 1c 00 00 call 39db <unlink>
1d37: 83 c4 10 add $0x10,%esp
1d3a: 85 c0 test %eax,%eax
1d3c: 75 39 jne 1d77 <bigdir+0x117>
for(i = 0; i < 500; i++){
1d3e: 83 c3 01 add $0x1,%ebx
1d41: 81 fb f4 01 00 00 cmp $0x1f4,%ebx
1d47: 75 c7 jne 1d10 <bigdir+0xb0>
printf(1, "bigdir ok\n");
1d49: 83 ec 08 sub $0x8,%esp
1d4c: 68 97 45 00 00 push $0x4597
1d51: 6a 01 push $0x1
1d53: e8 98 1d 00 00 call 3af0 <printf>
1d58: 83 c4 10 add $0x10,%esp
}
1d5b: 8d 65 f4 lea -0xc(%ebp),%esp
1d5e: 5b pop %ebx
1d5f: 5e pop %esi
1d60: 5f pop %edi
1d61: 5d pop %ebp
1d62: c3 ret
printf(1, "bigdir link failed\n");
1d63: 83 ec 08 sub $0x8,%esp
1d66: 68 6e 45 00 00 push $0x456e
1d6b: 6a 01 push $0x1
1d6d: e8 7e 1d 00 00 call 3af0 <printf>
exit();
1d72: e8 0c 1c 00 00 call 3983 <exit>
printf(1, "bigdir unlink failed");
1d77: 83 ec 08 sub $0x8,%esp
1d7a: 68 82 45 00 00 push $0x4582
1d7f: 6a 01 push $0x1
1d81: e8 6a 1d 00 00 call 3af0 <printf>
exit();
1d86: e8 f8 1b 00 00 call 3983 <exit>
printf(1, "bigdir create failed\n");
1d8b: 50 push %eax
1d8c: 50 push %eax
1d8d: 68 58 45 00 00 push $0x4558
1d92: 6a 01 push $0x1
1d94: e8 57 1d 00 00 call 3af0 <printf>
exit();
1d99: e8 e5 1b 00 00 call 3983 <exit>
1d9e: 66 90 xchg %ax,%ax
00001da0 <subdir>:
{
1da0: f3 0f 1e fb endbr32
1da4: 55 push %ebp
1da5: 89 e5 mov %esp,%ebp
1da7: 53 push %ebx
1da8: 83 ec 0c sub $0xc,%esp
printf(1, "subdir test\n");
1dab: 68 a2 45 00 00 push $0x45a2
1db0: 6a 01 push $0x1
1db2: e8 39 1d 00 00 call 3af0 <printf>
unlink("ff");
1db7: c7 04 24 2b 46 00 00 movl $0x462b,(%esp)
1dbe: e8 18 1c 00 00 call 39db <unlink>
if(mkdir("dd") != 0){
1dc3: c7 04 24 c8 46 00 00 movl $0x46c8,(%esp)
1dca: e8 24 1c 00 00 call 39f3 <mkdir>
1dcf: 83 c4 10 add $0x10,%esp
1dd2: 85 c0 test %eax,%eax
1dd4: 0f 85 b3 05 00 00 jne 238d <subdir+0x5ed>
fd = open("dd/ff", O_CREATE | O_RDWR);
1dda: 83 ec 08 sub $0x8,%esp
1ddd: 68 02 02 00 00 push $0x202
1de2: 68 01 46 00 00 push $0x4601
1de7: e8 df 1b 00 00 call 39cb <open>
if(fd < 0){
1dec: 83 c4 10 add $0x10,%esp
fd = open("dd/ff", O_CREATE | O_RDWR);
1def: 89 c3 mov %eax,%ebx
if(fd < 0){
1df1: 85 c0 test %eax,%eax
1df3: 0f 88 81 05 00 00 js 237a <subdir+0x5da>
write(fd, "ff", 2);
1df9: 83 ec 04 sub $0x4,%esp
1dfc: 6a 02 push $0x2
1dfe: 68 2b 46 00 00 push $0x462b
1e03: 50 push %eax
1e04: e8 a2 1b 00 00 call 39ab <write>
close(fd);
1e09: 89 1c 24 mov %ebx,(%esp)
1e0c: e8 a2 1b 00 00 call 39b3 <close>
if(unlink("dd") >= 0){
1e11: c7 04 24 c8 46 00 00 movl $0x46c8,(%esp)
1e18: e8 be 1b 00 00 call 39db <unlink>
1e1d: 83 c4 10 add $0x10,%esp
1e20: 85 c0 test %eax,%eax
1e22: 0f 89 3f 05 00 00 jns 2367 <subdir+0x5c7>
if(mkdir("/dd/dd") != 0){
1e28: 83 ec 0c sub $0xc,%esp
1e2b: 68 dc 45 00 00 push $0x45dc
1e30: e8 be 1b 00 00 call 39f3 <mkdir>
1e35: 83 c4 10 add $0x10,%esp
1e38: 85 c0 test %eax,%eax
1e3a: 0f 85 14 05 00 00 jne 2354 <subdir+0x5b4>
fd = open("dd/dd/ff", O_CREATE | O_RDWR);
1e40: 83 ec 08 sub $0x8,%esp
1e43: 68 02 02 00 00 push $0x202
1e48: 68 fe 45 00 00 push $0x45fe
1e4d: e8 79 1b 00 00 call 39cb <open>
if(fd < 0){
1e52: 83 c4 10 add $0x10,%esp
fd = open("dd/dd/ff", O_CREATE | O_RDWR);
1e55: 89 c3 mov %eax,%ebx
if(fd < 0){
1e57: 85 c0 test %eax,%eax
1e59: 0f 88 24 04 00 00 js 2283 <subdir+0x4e3>
write(fd, "FF", 2);
1e5f: 83 ec 04 sub $0x4,%esp
1e62: 6a 02 push $0x2
1e64: 68 1f 46 00 00 push $0x461f
1e69: 50 push %eax
1e6a: e8 3c 1b 00 00 call 39ab <write>
close(fd);
1e6f: 89 1c 24 mov %ebx,(%esp)
1e72: e8 3c 1b 00 00 call 39b3 <close>
fd = open("dd/dd/../ff", 0);
1e77: 58 pop %eax
1e78: 5a pop %edx
1e79: 6a 00 push $0x0
1e7b: 68 22 46 00 00 push $0x4622
1e80: e8 46 1b 00 00 call 39cb <open>
if(fd < 0){
1e85: 83 c4 10 add $0x10,%esp
fd = open("dd/dd/../ff", 0);
1e88: 89 c3 mov %eax,%ebx
if(fd < 0){
1e8a: 85 c0 test %eax,%eax
1e8c: 0f 88 de 03 00 00 js 2270 <subdir+0x4d0>
cc = read(fd, buf, sizeof(buf));
1e92: 83 ec 04 sub $0x4,%esp
1e95: 68 00 20 00 00 push $0x2000
1e9a: 68 e0 86 00 00 push $0x86e0
1e9f: 50 push %eax
1ea0: e8 fe 1a 00 00 call 39a3 <read>
if(cc != 2 || buf[0] != 'f'){
1ea5: 83 c4 10 add $0x10,%esp
1ea8: 83 f8 02 cmp $0x2,%eax
1eab: 0f 85 3a 03 00 00 jne 21eb <subdir+0x44b>
1eb1: 80 3d e0 86 00 00 66 cmpb $0x66,0x86e0
1eb8: 0f 85 2d 03 00 00 jne 21eb <subdir+0x44b>
close(fd);
1ebe: 83 ec 0c sub $0xc,%esp
1ec1: 53 push %ebx
1ec2: e8 ec 1a 00 00 call 39b3 <close>
if(link("dd/dd/ff", "dd/dd/ffff") != 0){
1ec7: 59 pop %ecx
1ec8: 5b pop %ebx
1ec9: 68 62 46 00 00 push $0x4662
1ece: 68 fe 45 00 00 push $0x45fe
1ed3: e8 13 1b 00 00 call 39eb <link>
1ed8: 83 c4 10 add $0x10,%esp
1edb: 85 c0 test %eax,%eax
1edd: 0f 85 c6 03 00 00 jne 22a9 <subdir+0x509>
if(unlink("dd/dd/ff") != 0){
1ee3: 83 ec 0c sub $0xc,%esp
1ee6: 68 fe 45 00 00 push $0x45fe
1eeb: e8 eb 1a 00 00 call 39db <unlink>
1ef0: 83 c4 10 add $0x10,%esp
1ef3: 85 c0 test %eax,%eax
1ef5: 0f 85 16 03 00 00 jne 2211 <subdir+0x471>
if(open("dd/dd/ff", O_RDONLY) >= 0){
1efb: 83 ec 08 sub $0x8,%esp
1efe: 6a 00 push $0x0
1f00: 68 fe 45 00 00 push $0x45fe
1f05: e8 c1 1a 00 00 call 39cb <open>
1f0a: 83 c4 10 add $0x10,%esp
1f0d: 85 c0 test %eax,%eax
1f0f: 0f 89 2c 04 00 00 jns 2341 <subdir+0x5a1>
if(chdir("dd") != 0){
1f15: 83 ec 0c sub $0xc,%esp
1f18: 68 c8 46 00 00 push $0x46c8
1f1d: e8 d9 1a 00 00 call 39fb <chdir>
1f22: 83 c4 10 add $0x10,%esp
1f25: 85 c0 test %eax,%eax
1f27: 0f 85 01 04 00 00 jne 232e <subdir+0x58e>
if(chdir("dd/../../dd") != 0){
1f2d: 83 ec 0c sub $0xc,%esp
1f30: 68 96 46 00 00 push $0x4696
1f35: e8 c1 1a 00 00 call 39fb <chdir>
1f3a: 83 c4 10 add $0x10,%esp
1f3d: 85 c0 test %eax,%eax
1f3f: 0f 85 b9 02 00 00 jne 21fe <subdir+0x45e>
if(chdir("dd/../../../dd") != 0){
1f45: 83 ec 0c sub $0xc,%esp
1f48: 68 bc 46 00 00 push $0x46bc
1f4d: e8 a9 1a 00 00 call 39fb <chdir>
1f52: 83 c4 10 add $0x10,%esp
1f55: 85 c0 test %eax,%eax
1f57: 0f 85 a1 02 00 00 jne 21fe <subdir+0x45e>
if(chdir("./..") != 0){
1f5d: 83 ec 0c sub $0xc,%esp
1f60: 68 cb 46 00 00 push $0x46cb
1f65: e8 91 1a 00 00 call 39fb <chdir>
1f6a: 83 c4 10 add $0x10,%esp
1f6d: 85 c0 test %eax,%eax
1f6f: 0f 85 21 03 00 00 jne 2296 <subdir+0x4f6>
fd = open("dd/dd/ffff", 0);
1f75: 83 ec 08 sub $0x8,%esp
1f78: 6a 00 push $0x0
1f7a: 68 62 46 00 00 push $0x4662
1f7f: e8 47 1a 00 00 call 39cb <open>
if(fd < 0){
1f84: 83 c4 10 add $0x10,%esp
fd = open("dd/dd/ffff", 0);
1f87: 89 c3 mov %eax,%ebx
if(fd < 0){
1f89: 85 c0 test %eax,%eax
1f8b: 0f 88 e0 04 00 00 js 2471 <subdir+0x6d1>
if(read(fd, buf, sizeof(buf)) != 2){
1f91: 83 ec 04 sub $0x4,%esp
1f94: 68 00 20 00 00 push $0x2000
1f99: 68 e0 86 00 00 push $0x86e0
1f9e: 50 push %eax
1f9f: e8 ff 19 00 00 call 39a3 <read>
1fa4: 83 c4 10 add $0x10,%esp
1fa7: 83 f8 02 cmp $0x2,%eax
1faa: 0f 85 ae 04 00 00 jne 245e <subdir+0x6be>
close(fd);
1fb0: 83 ec 0c sub $0xc,%esp
1fb3: 53 push %ebx
1fb4: e8 fa 19 00 00 call 39b3 <close>
if(open("dd/dd/ff", O_RDONLY) >= 0){
1fb9: 58 pop %eax
1fba: 5a pop %edx
1fbb: 6a 00 push $0x0
1fbd: 68 fe 45 00 00 push $0x45fe
1fc2: e8 04 1a 00 00 call 39cb <open>
1fc7: 83 c4 10 add $0x10,%esp
1fca: 85 c0 test %eax,%eax
1fcc: 0f 89 65 02 00 00 jns 2237 <subdir+0x497>
if(open("dd/ff/ff", O_CREATE|O_RDWR) >= 0){
1fd2: 83 ec 08 sub $0x8,%esp
1fd5: 68 02 02 00 00 push $0x202
1fda: 68 16 47 00 00 push $0x4716
1fdf: e8 e7 19 00 00 call 39cb <open>
1fe4: 83 c4 10 add $0x10,%esp
1fe7: 85 c0 test %eax,%eax
1fe9: 0f 89 35 02 00 00 jns 2224 <subdir+0x484>
if(open("dd/xx/ff", O_CREATE|O_RDWR) >= 0){
1fef: 83 ec 08 sub $0x8,%esp
1ff2: 68 02 02 00 00 push $0x202
1ff7: 68 3b 47 00 00 push $0x473b
1ffc: e8 ca 19 00 00 call 39cb <open>
2001: 83 c4 10 add $0x10,%esp
2004: 85 c0 test %eax,%eax
2006: 0f 89 0f 03 00 00 jns 231b <subdir+0x57b>
if(open("dd", O_CREATE) >= 0){
200c: 83 ec 08 sub $0x8,%esp
200f: 68 00 02 00 00 push $0x200
2014: 68 c8 46 00 00 push $0x46c8
2019: e8 ad 19 00 00 call 39cb <open>
201e: 83 c4 10 add $0x10,%esp
2021: 85 c0 test %eax,%eax
2023: 0f 89 df 02 00 00 jns 2308 <subdir+0x568>
if(open("dd", O_RDWR) >= 0){
2029: 83 ec 08 sub $0x8,%esp
202c: 6a 02 push $0x2
202e: 68 c8 46 00 00 push $0x46c8
2033: e8 93 19 00 00 call 39cb <open>
2038: 83 c4 10 add $0x10,%esp
203b: 85 c0 test %eax,%eax
203d: 0f 89 b2 02 00 00 jns 22f5 <subdir+0x555>
if(open("dd", O_WRONLY) >= 0){
2043: 83 ec 08 sub $0x8,%esp
2046: 6a 01 push $0x1
2048: 68 c8 46 00 00 push $0x46c8
204d: e8 79 19 00 00 call 39cb <open>
2052: 83 c4 10 add $0x10,%esp
2055: 85 c0 test %eax,%eax
2057: 0f 89 85 02 00 00 jns 22e2 <subdir+0x542>
if(link("dd/ff/ff", "dd/dd/xx") == 0){
205d: 83 ec 08 sub $0x8,%esp
2060: 68 aa 47 00 00 push $0x47aa
2065: 68 16 47 00 00 push $0x4716
206a: e8 7c 19 00 00 call 39eb <link>
206f: 83 c4 10 add $0x10,%esp
2072: 85 c0 test %eax,%eax
2074: 0f 84 55 02 00 00 je 22cf <subdir+0x52f>
if(link("dd/xx/ff", "dd/dd/xx") == 0){
207a: 83 ec 08 sub $0x8,%esp
207d: 68 aa 47 00 00 push $0x47aa
2082: 68 3b 47 00 00 push $0x473b
2087: e8 5f 19 00 00 call 39eb <link>
208c: 83 c4 10 add $0x10,%esp
208f: 85 c0 test %eax,%eax
2091: 0f 84 25 02 00 00 je 22bc <subdir+0x51c>
if(link("dd/ff", "dd/dd/ffff") == 0){
2097: 83 ec 08 sub $0x8,%esp
209a: 68 62 46 00 00 push $0x4662
209f: 68 01 46 00 00 push $0x4601
20a4: e8 42 19 00 00 call 39eb <link>
20a9: 83 c4 10 add $0x10,%esp
20ac: 85 c0 test %eax,%eax
20ae: 0f 84 a9 01 00 00 je 225d <subdir+0x4bd>
if(mkdir("dd/ff/ff") == 0){
20b4: 83 ec 0c sub $0xc,%esp
20b7: 68 16 47 00 00 push $0x4716
20bc: e8 32 19 00 00 call 39f3 <mkdir>
20c1: 83 c4 10 add $0x10,%esp
20c4: 85 c0 test %eax,%eax
20c6: 0f 84 7e 01 00 00 je 224a <subdir+0x4aa>
if(mkdir("dd/xx/ff") == 0){
20cc: 83 ec 0c sub $0xc,%esp
20cf: 68 3b 47 00 00 push $0x473b
20d4: e8 1a 19 00 00 call 39f3 <mkdir>
20d9: 83 c4 10 add $0x10,%esp
20dc: 85 c0 test %eax,%eax
20de: 0f 84 67 03 00 00 je 244b <subdir+0x6ab>
if(mkdir("dd/dd/ffff") == 0){
20e4: 83 ec 0c sub $0xc,%esp
20e7: 68 62 46 00 00 push $0x4662
20ec: e8 02 19 00 00 call 39f3 <mkdir>
20f1: 83 c4 10 add $0x10,%esp
20f4: 85 c0 test %eax,%eax
20f6: 0f 84 3c 03 00 00 je 2438 <subdir+0x698>
if(unlink("dd/xx/ff") == 0){
20fc: 83 ec 0c sub $0xc,%esp
20ff: 68 3b 47 00 00 push $0x473b
2104: e8 d2 18 00 00 call 39db <unlink>
2109: 83 c4 10 add $0x10,%esp
210c: 85 c0 test %eax,%eax
210e: 0f 84 11 03 00 00 je 2425 <subdir+0x685>
if(unlink("dd/ff/ff") == 0){
2114: 83 ec 0c sub $0xc,%esp
2117: 68 16 47 00 00 push $0x4716
211c: e8 ba 18 00 00 call 39db <unlink>
2121: 83 c4 10 add $0x10,%esp
2124: 85 c0 test %eax,%eax
2126: 0f 84 e6 02 00 00 je 2412 <subdir+0x672>
if(chdir("dd/ff") == 0){
212c: 83 ec 0c sub $0xc,%esp
212f: 68 01 46 00 00 push $0x4601
2134: e8 c2 18 00 00 call 39fb <chdir>
2139: 83 c4 10 add $0x10,%esp
213c: 85 c0 test %eax,%eax
213e: 0f 84 bb 02 00 00 je 23ff <subdir+0x65f>
if(chdir("dd/xx") == 0){
2144: 83 ec 0c sub $0xc,%esp
2147: 68 ad 47 00 00 push $0x47ad
214c: e8 aa 18 00 00 call 39fb <chdir>
2151: 83 c4 10 add $0x10,%esp
2154: 85 c0 test %eax,%eax
2156: 0f 84 90 02 00 00 je 23ec <subdir+0x64c>
if(unlink("dd/dd/ffff") != 0){
215c: 83 ec 0c sub $0xc,%esp
215f: 68 62 46 00 00 push $0x4662
2164: e8 72 18 00 00 call 39db <unlink>
2169: 83 c4 10 add $0x10,%esp
216c: 85 c0 test %eax,%eax
216e: 0f 85 9d 00 00 00 jne 2211 <subdir+0x471>
if(unlink("dd/ff") != 0){
2174: 83 ec 0c sub $0xc,%esp
2177: 68 01 46 00 00 push $0x4601
217c: e8 5a 18 00 00 call 39db <unlink>
2181: 83 c4 10 add $0x10,%esp
2184: 85 c0 test %eax,%eax
2186: 0f 85 4d 02 00 00 jne 23d9 <subdir+0x639>
if(unlink("dd") == 0){
218c: 83 ec 0c sub $0xc,%esp
218f: 68 c8 46 00 00 push $0x46c8
2194: e8 42 18 00 00 call 39db <unlink>
2199: 83 c4 10 add $0x10,%esp
219c: 85 c0 test %eax,%eax
219e: 0f 84 22 02 00 00 je 23c6 <subdir+0x626>
if(unlink("dd/dd") < 0){
21a4: 83 ec 0c sub $0xc,%esp
21a7: 68 dd 45 00 00 push $0x45dd
21ac: e8 2a 18 00 00 call 39db <unlink>
21b1: 83 c4 10 add $0x10,%esp
21b4: 85 c0 test %eax,%eax
21b6: 0f 88 f7 01 00 00 js 23b3 <subdir+0x613>
if(unlink("dd") < 0){
21bc: 83 ec 0c sub $0xc,%esp
21bf: 68 c8 46 00 00 push $0x46c8
21c4: e8 12 18 00 00 call 39db <unlink>
21c9: 83 c4 10 add $0x10,%esp
21cc: 85 c0 test %eax,%eax
21ce: 0f 88 cc 01 00 00 js 23a0 <subdir+0x600>
printf(1, "subdir ok\n");
21d4: 83 ec 08 sub $0x8,%esp
21d7: 68 aa 48 00 00 push $0x48aa
21dc: 6a 01 push $0x1
21de: e8 0d 19 00 00 call 3af0 <printf>
}
21e3: 8b 5d fc mov -0x4(%ebp),%ebx
21e6: 83 c4 10 add $0x10,%esp
21e9: c9 leave
21ea: c3 ret
printf(1, "dd/dd/../ff wrong content\n");
21eb: 50 push %eax
21ec: 50 push %eax
21ed: 68 47 46 00 00 push $0x4647
21f2: 6a 01 push $0x1
21f4: e8 f7 18 00 00 call 3af0 <printf>
exit();
21f9: e8 85 17 00 00 call 3983 <exit>
printf(1, "chdir dd/../../dd failed\n");
21fe: 50 push %eax
21ff: 50 push %eax
2200: 68 a2 46 00 00 push $0x46a2
2205: 6a 01 push $0x1
2207: e8 e4 18 00 00 call 3af0 <printf>
exit();
220c: e8 72 17 00 00 call 3983 <exit>
printf(1, "unlink dd/dd/ff failed\n");
2211: 50 push %eax
2212: 50 push %eax
2213: 68 6d 46 00 00 push $0x466d
2218: 6a 01 push $0x1
221a: e8 d1 18 00 00 call 3af0 <printf>
exit();
221f: e8 5f 17 00 00 call 3983 <exit>
printf(1, "create dd/ff/ff succeeded!\n");
2224: 51 push %ecx
2225: 51 push %ecx
2226: 68 1f 47 00 00 push $0x471f
222b: 6a 01 push $0x1
222d: e8 be 18 00 00 call 3af0 <printf>
exit();
2232: e8 4c 17 00 00 call 3983 <exit>
printf(1, "open (unlinked) dd/dd/ff succeeded!\n");
2237: 53 push %ebx
2238: 53 push %ebx
2239: 68 04 51 00 00 push $0x5104
223e: 6a 01 push $0x1
2240: e8 ab 18 00 00 call 3af0 <printf>
exit();
2245: e8 39 17 00 00 call 3983 <exit>
printf(1, "mkdir dd/ff/ff succeeded!\n");
224a: 51 push %ecx
224b: 51 push %ecx
224c: 68 b3 47 00 00 push $0x47b3
2251: 6a 01 push $0x1
2253: e8 98 18 00 00 call 3af0 <printf>
exit();
2258: e8 26 17 00 00 call 3983 <exit>
printf(1, "link dd/ff dd/dd/ffff succeeded!\n");
225d: 53 push %ebx
225e: 53 push %ebx
225f: 68 74 51 00 00 push $0x5174
2264: 6a 01 push $0x1
2266: e8 85 18 00 00 call 3af0 <printf>
exit();
226b: e8 13 17 00 00 call 3983 <exit>
printf(1, "open dd/dd/../ff failed\n");
2270: 50 push %eax
2271: 50 push %eax
2272: 68 2e 46 00 00 push $0x462e
2277: 6a 01 push $0x1
2279: e8 72 18 00 00 call 3af0 <printf>
exit();
227e: e8 00 17 00 00 call 3983 <exit>
printf(1, "create dd/dd/ff failed\n");
2283: 51 push %ecx
2284: 51 push %ecx
2285: 68 07 46 00 00 push $0x4607
228a: 6a 01 push $0x1
228c: e8 5f 18 00 00 call 3af0 <printf>
exit();
2291: e8 ed 16 00 00 call 3983 <exit>
printf(1, "chdir ./.. failed\n");
2296: 50 push %eax
2297: 50 push %eax
2298: 68 d0 46 00 00 push $0x46d0
229d: 6a 01 push $0x1
229f: e8 4c 18 00 00 call 3af0 <printf>
exit();
22a4: e8 da 16 00 00 call 3983 <exit>
printf(1, "link dd/dd/ff dd/dd/ffff failed\n");
22a9: 52 push %edx
22aa: 52 push %edx
22ab: 68 bc 50 00 00 push $0x50bc
22b0: 6a 01 push $0x1
22b2: e8 39 18 00 00 call 3af0 <printf>
exit();
22b7: e8 c7 16 00 00 call 3983 <exit>
printf(1, "link dd/xx/ff dd/dd/xx succeeded!\n");
22bc: 50 push %eax
22bd: 50 push %eax
22be: 68 50 51 00 00 push $0x5150
22c3: 6a 01 push $0x1
22c5: e8 26 18 00 00 call 3af0 <printf>
exit();
22ca: e8 b4 16 00 00 call 3983 <exit>
printf(1, "link dd/ff/ff dd/dd/xx succeeded!\n");
22cf: 50 push %eax
22d0: 50 push %eax
22d1: 68 2c 51 00 00 push $0x512c
22d6: 6a 01 push $0x1
22d8: e8 13 18 00 00 call 3af0 <printf>
exit();
22dd: e8 a1 16 00 00 call 3983 <exit>
printf(1, "open dd wronly succeeded!\n");
22e2: 50 push %eax
22e3: 50 push %eax
22e4: 68 8f 47 00 00 push $0x478f
22e9: 6a 01 push $0x1
22eb: e8 00 18 00 00 call 3af0 <printf>
exit();
22f0: e8 8e 16 00 00 call 3983 <exit>
printf(1, "open dd rdwr succeeded!\n");
22f5: 50 push %eax
22f6: 50 push %eax
22f7: 68 76 47 00 00 push $0x4776
22fc: 6a 01 push $0x1
22fe: e8 ed 17 00 00 call 3af0 <printf>
exit();
2303: e8 7b 16 00 00 call 3983 <exit>
printf(1, "create dd succeeded!\n");
2308: 50 push %eax
2309: 50 push %eax
230a: 68 60 47 00 00 push $0x4760
230f: 6a 01 push $0x1
2311: e8 da 17 00 00 call 3af0 <printf>
exit();
2316: e8 68 16 00 00 call 3983 <exit>
printf(1, "create dd/xx/ff succeeded!\n");
231b: 52 push %edx
231c: 52 push %edx
231d: 68 44 47 00 00 push $0x4744
2322: 6a 01 push $0x1
2324: e8 c7 17 00 00 call 3af0 <printf>
exit();
2329: e8 55 16 00 00 call 3983 <exit>
printf(1, "chdir dd failed\n");
232e: 50 push %eax
232f: 50 push %eax
2330: 68 85 46 00 00 push $0x4685
2335: 6a 01 push $0x1
2337: e8 b4 17 00 00 call 3af0 <printf>
exit();
233c: e8 42 16 00 00 call 3983 <exit>
printf(1, "open (unlinked) dd/dd/ff succeeded\n");
2341: 50 push %eax
2342: 50 push %eax
2343: 68 e0 50 00 00 push $0x50e0
2348: 6a 01 push $0x1
234a: e8 a1 17 00 00 call 3af0 <printf>
exit();
234f: e8 2f 16 00 00 call 3983 <exit>
printf(1, "subdir mkdir dd/dd failed\n");
2354: 53 push %ebx
2355: 53 push %ebx
2356: 68 e3 45 00 00 push $0x45e3
235b: 6a 01 push $0x1
235d: e8 8e 17 00 00 call 3af0 <printf>
exit();
2362: e8 1c 16 00 00 call 3983 <exit>
printf(1, "unlink dd (non-empty dir) succeeded!\n");
2367: 50 push %eax
2368: 50 push %eax
2369: 68 94 50 00 00 push $0x5094
236e: 6a 01 push $0x1
2370: e8 7b 17 00 00 call 3af0 <printf>
exit();
2375: e8 09 16 00 00 call 3983 <exit>
printf(1, "create dd/ff failed\n");
237a: 50 push %eax
237b: 50 push %eax
237c: 68 c7 45 00 00 push $0x45c7
2381: 6a 01 push $0x1
2383: e8 68 17 00 00 call 3af0 <printf>
exit();
2388: e8 f6 15 00 00 call 3983 <exit>
printf(1, "subdir mkdir dd failed\n");
238d: 50 push %eax
238e: 50 push %eax
238f: 68 af 45 00 00 push $0x45af
2394: 6a 01 push $0x1
2396: e8 55 17 00 00 call 3af0 <printf>
exit();
239b: e8 e3 15 00 00 call 3983 <exit>
printf(1, "unlink dd failed\n");
23a0: 50 push %eax
23a1: 50 push %eax
23a2: 68 98 48 00 00 push $0x4898
23a7: 6a 01 push $0x1
23a9: e8 42 17 00 00 call 3af0 <printf>
exit();
23ae: e8 d0 15 00 00 call 3983 <exit>
printf(1, "unlink dd/dd failed\n");
23b3: 52 push %edx
23b4: 52 push %edx
23b5: 68 83 48 00 00 push $0x4883
23ba: 6a 01 push $0x1
23bc: e8 2f 17 00 00 call 3af0 <printf>
exit();
23c1: e8 bd 15 00 00 call 3983 <exit>
printf(1, "unlink non-empty dd succeeded!\n");
23c6: 51 push %ecx
23c7: 51 push %ecx
23c8: 68 98 51 00 00 push $0x5198
23cd: 6a 01 push $0x1
23cf: e8 1c 17 00 00 call 3af0 <printf>
exit();
23d4: e8 aa 15 00 00 call 3983 <exit>
printf(1, "unlink dd/ff failed\n");
23d9: 53 push %ebx
23da: 53 push %ebx
23db: 68 6e 48 00 00 push $0x486e
23e0: 6a 01 push $0x1
23e2: e8 09 17 00 00 call 3af0 <printf>
exit();
23e7: e8 97 15 00 00 call 3983 <exit>
printf(1, "chdir dd/xx succeeded!\n");
23ec: 50 push %eax
23ed: 50 push %eax
23ee: 68 56 48 00 00 push $0x4856
23f3: 6a 01 push $0x1
23f5: e8 f6 16 00 00 call 3af0 <printf>
exit();
23fa: e8 84 15 00 00 call 3983 <exit>
printf(1, "chdir dd/ff succeeded!\n");
23ff: 50 push %eax
2400: 50 push %eax
2401: 68 3e 48 00 00 push $0x483e
2406: 6a 01 push $0x1
2408: e8 e3 16 00 00 call 3af0 <printf>
exit();
240d: e8 71 15 00 00 call 3983 <exit>
printf(1, "unlink dd/ff/ff succeeded!\n");
2412: 50 push %eax
2413: 50 push %eax
2414: 68 22 48 00 00 push $0x4822
2419: 6a 01 push $0x1
241b: e8 d0 16 00 00 call 3af0 <printf>
exit();
2420: e8 5e 15 00 00 call 3983 <exit>
printf(1, "unlink dd/xx/ff succeeded!\n");
2425: 50 push %eax
2426: 50 push %eax
2427: 68 06 48 00 00 push $0x4806
242c: 6a 01 push $0x1
242e: e8 bd 16 00 00 call 3af0 <printf>
exit();
2433: e8 4b 15 00 00 call 3983 <exit>
printf(1, "mkdir dd/dd/ffff succeeded!\n");
2438: 50 push %eax
2439: 50 push %eax
243a: 68 e9 47 00 00 push $0x47e9
243f: 6a 01 push $0x1
2441: e8 aa 16 00 00 call 3af0 <printf>
exit();
2446: e8 38 15 00 00 call 3983 <exit>
printf(1, "mkdir dd/xx/ff succeeded!\n");
244b: 52 push %edx
244c: 52 push %edx
244d: 68 ce 47 00 00 push $0x47ce
2452: 6a 01 push $0x1
2454: e8 97 16 00 00 call 3af0 <printf>
exit();
2459: e8 25 15 00 00 call 3983 <exit>
printf(1, "read dd/dd/ffff wrong len\n");
245e: 51 push %ecx
245f: 51 push %ecx
2460: 68 fb 46 00 00 push $0x46fb
2465: 6a 01 push $0x1
2467: e8 84 16 00 00 call 3af0 <printf>
exit();
246c: e8 12 15 00 00 call 3983 <exit>
printf(1, "open dd/dd/ffff failed\n");
2471: 53 push %ebx
2472: 53 push %ebx
2473: 68 e3 46 00 00 push $0x46e3
2478: 6a 01 push $0x1
247a: e8 71 16 00 00 call 3af0 <printf>
exit();
247f: e8 ff 14 00 00 call 3983 <exit>
2484: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
248b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
248f: 90 nop
00002490 <bigwrite>:
{
2490: f3 0f 1e fb endbr32
2494: 55 push %ebp
2495: 89 e5 mov %esp,%ebp
2497: 56 push %esi
2498: 53 push %ebx
for(sz = 499; sz < 12*512; sz += 471){
2499: bb f3 01 00 00 mov $0x1f3,%ebx
printf(1, "bigwrite test\n");
249e: 83 ec 08 sub $0x8,%esp
24a1: 68 b5 48 00 00 push $0x48b5
24a6: 6a 01 push $0x1
24a8: e8 43 16 00 00 call 3af0 <printf>
unlink("bigwrite");
24ad: c7 04 24 c4 48 00 00 movl $0x48c4,(%esp)
24b4: e8 22 15 00 00 call 39db <unlink>
24b9: 83 c4 10 add $0x10,%esp
24bc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
fd = open("bigwrite", O_CREATE | O_RDWR);
24c0: 83 ec 08 sub $0x8,%esp
24c3: 68 02 02 00 00 push $0x202
24c8: 68 c4 48 00 00 push $0x48c4
24cd: e8 f9 14 00 00 call 39cb <open>
if(fd < 0){
24d2: 83 c4 10 add $0x10,%esp
fd = open("bigwrite", O_CREATE | O_RDWR);
24d5: 89 c6 mov %eax,%esi
if(fd < 0){
24d7: 85 c0 test %eax,%eax
24d9: 78 7e js 2559 <bigwrite+0xc9>
int cc = write(fd, buf, sz);
24db: 83 ec 04 sub $0x4,%esp
24de: 53 push %ebx
24df: 68 e0 86 00 00 push $0x86e0
24e4: 50 push %eax
24e5: e8 c1 14 00 00 call 39ab <write>
if(cc != sz){
24ea: 83 c4 10 add $0x10,%esp
24ed: 39 d8 cmp %ebx,%eax
24ef: 75 55 jne 2546 <bigwrite+0xb6>
int cc = write(fd, buf, sz);
24f1: 83 ec 04 sub $0x4,%esp
24f4: 53 push %ebx
24f5: 68 e0 86 00 00 push $0x86e0
24fa: 56 push %esi
24fb: e8 ab 14 00 00 call 39ab <write>
if(cc != sz){
2500: 83 c4 10 add $0x10,%esp
2503: 39 d8 cmp %ebx,%eax
2505: 75 3f jne 2546 <bigwrite+0xb6>
close(fd);
2507: 83 ec 0c sub $0xc,%esp
for(sz = 499; sz < 12*512; sz += 471){
250a: 81 c3 d7 01 00 00 add $0x1d7,%ebx
close(fd);
2510: 56 push %esi
2511: e8 9d 14 00 00 call 39b3 <close>
unlink("bigwrite");
2516: c7 04 24 c4 48 00 00 movl $0x48c4,(%esp)
251d: e8 b9 14 00 00 call 39db <unlink>
for(sz = 499; sz < 12*512; sz += 471){
2522: 83 c4 10 add $0x10,%esp
2525: 81 fb 07 18 00 00 cmp $0x1807,%ebx
252b: 75 93 jne 24c0 <bigwrite+0x30>
printf(1, "bigwrite ok\n");
252d: 83 ec 08 sub $0x8,%esp
2530: 68 f7 48 00 00 push $0x48f7
2535: 6a 01 push $0x1
2537: e8 b4 15 00 00 call 3af0 <printf>
}
253c: 83 c4 10 add $0x10,%esp
253f: 8d 65 f8 lea -0x8(%ebp),%esp
2542: 5b pop %ebx
2543: 5e pop %esi
2544: 5d pop %ebp
2545: c3 ret
printf(1, "write(%d) ret %d\n", sz, cc);
2546: 50 push %eax
2547: 53 push %ebx
2548: 68 e5 48 00 00 push $0x48e5
254d: 6a 01 push $0x1
254f: e8 9c 15 00 00 call 3af0 <printf>
exit();
2554: e8 2a 14 00 00 call 3983 <exit>
printf(1, "cannot create bigwrite\n");
2559: 83 ec 08 sub $0x8,%esp
255c: 68 cd 48 00 00 push $0x48cd
2561: 6a 01 push $0x1
2563: e8 88 15 00 00 call 3af0 <printf>
exit();
2568: e8 16 14 00 00 call 3983 <exit>
256d: 8d 76 00 lea 0x0(%esi),%esi
00002570 <bigfile>:
{
2570: f3 0f 1e fb endbr32
2574: 55 push %ebp
2575: 89 e5 mov %esp,%ebp
2577: 57 push %edi
2578: 56 push %esi
2579: 53 push %ebx
257a: 83 ec 14 sub $0x14,%esp
printf(1, "bigfile test\n");
257d: 68 04 49 00 00 push $0x4904
2582: 6a 01 push $0x1
2584: e8 67 15 00 00 call 3af0 <printf>
unlink("bigfile");
2589: c7 04 24 20 49 00 00 movl $0x4920,(%esp)
2590: e8 46 14 00 00 call 39db <unlink>
fd = open("bigfile", O_CREATE | O_RDWR);
2595: 58 pop %eax
2596: 5a pop %edx
2597: 68 02 02 00 00 push $0x202
259c: 68 20 49 00 00 push $0x4920
25a1: e8 25 14 00 00 call 39cb <open>
if(fd < 0){
25a6: 83 c4 10 add $0x10,%esp
25a9: 85 c0 test %eax,%eax
25ab: 0f 88 5a 01 00 00 js 270b <bigfile+0x19b>
25b1: 89 c6 mov %eax,%esi
for(i = 0; i < 20; i++){
25b3: 31 db xor %ebx,%ebx
25b5: 8d 76 00 lea 0x0(%esi),%esi
memset(buf, i, 600);
25b8: 83 ec 04 sub $0x4,%esp
25bb: 68 58 02 00 00 push $0x258
25c0: 53 push %ebx
25c1: 68 e0 86 00 00 push $0x86e0
25c6: e8 15 12 00 00 call 37e0 <memset>
if(write(fd, buf, 600) != 600){
25cb: 83 c4 0c add $0xc,%esp
25ce: 68 58 02 00 00 push $0x258
25d3: 68 e0 86 00 00 push $0x86e0
25d8: 56 push %esi
25d9: e8 cd 13 00 00 call 39ab <write>
25de: 83 c4 10 add $0x10,%esp
25e1: 3d 58 02 00 00 cmp $0x258,%eax
25e6: 0f 85 f8 00 00 00 jne 26e4 <bigfile+0x174>
for(i = 0; i < 20; i++){
25ec: 83 c3 01 add $0x1,%ebx
25ef: 83 fb 14 cmp $0x14,%ebx
25f2: 75 c4 jne 25b8 <bigfile+0x48>
close(fd);
25f4: 83 ec 0c sub $0xc,%esp
25f7: 56 push %esi
25f8: e8 b6 13 00 00 call 39b3 <close>
fd = open("bigfile", 0);
25fd: 5e pop %esi
25fe: 5f pop %edi
25ff: 6a 00 push $0x0
2601: 68 20 49 00 00 push $0x4920
2606: e8 c0 13 00 00 call 39cb <open>
if(fd < 0){
260b: 83 c4 10 add $0x10,%esp
fd = open("bigfile", 0);
260e: 89 c6 mov %eax,%esi
if(fd < 0){
2610: 85 c0 test %eax,%eax
2612: 0f 88 e0 00 00 00 js 26f8 <bigfile+0x188>
total = 0;
2618: 31 db xor %ebx,%ebx
for(i = 0; ; i++){
261a: 31 ff xor %edi,%edi
261c: eb 30 jmp 264e <bigfile+0xde>
261e: 66 90 xchg %ax,%ax
if(cc != 300){
2620: 3d 2c 01 00 00 cmp $0x12c,%eax
2625: 0f 85 91 00 00 00 jne 26bc <bigfile+0x14c>
if(buf[0] != i/2 || buf[299] != i/2){
262b: 89 fa mov %edi,%edx
262d: 0f be 05 e0 86 00 00 movsbl 0x86e0,%eax
2634: d1 fa sar %edx
2636: 39 d0 cmp %edx,%eax
2638: 75 6e jne 26a8 <bigfile+0x138>
263a: 0f be 15 0b 88 00 00 movsbl 0x880b,%edx
2641: 39 d0 cmp %edx,%eax
2643: 75 63 jne 26a8 <bigfile+0x138>
total += cc;
2645: 81 c3 2c 01 00 00 add $0x12c,%ebx
for(i = 0; ; i++){
264b: 83 c7 01 add $0x1,%edi
cc = read(fd, buf, 300);
264e: 83 ec 04 sub $0x4,%esp
2651: 68 2c 01 00 00 push $0x12c
2656: 68 e0 86 00 00 push $0x86e0
265b: 56 push %esi
265c: e8 42 13 00 00 call 39a3 <read>
if(cc < 0){
2661: 83 c4 10 add $0x10,%esp
2664: 85 c0 test %eax,%eax
2666: 78 68 js 26d0 <bigfile+0x160>
if(cc == 0)
2668: 75 b6 jne 2620 <bigfile+0xb0>
close(fd);
266a: 83 ec 0c sub $0xc,%esp
266d: 56 push %esi
266e: e8 40 13 00 00 call 39b3 <close>
if(total != 20*600){
2673: 83 c4 10 add $0x10,%esp
2676: 81 fb e0 2e 00 00 cmp $0x2ee0,%ebx
267c: 0f 85 9c 00 00 00 jne 271e <bigfile+0x1ae>
unlink("bigfile");
2682: 83 ec 0c sub $0xc,%esp
2685: 68 20 49 00 00 push $0x4920
268a: e8 4c 13 00 00 call 39db <unlink>
printf(1, "bigfile test ok\n");
268f: 58 pop %eax
2690: 5a pop %edx
2691: 68 af 49 00 00 push $0x49af
2696: 6a 01 push $0x1
2698: e8 53 14 00 00 call 3af0 <printf>
}
269d: 83 c4 10 add $0x10,%esp
26a0: 8d 65 f4 lea -0xc(%ebp),%esp
26a3: 5b pop %ebx
26a4: 5e pop %esi
26a5: 5f pop %edi
26a6: 5d pop %ebp
26a7: c3 ret
printf(1, "read bigfile wrong data\n");
26a8: 83 ec 08 sub $0x8,%esp
26ab: 68 7c 49 00 00 push $0x497c
26b0: 6a 01 push $0x1
26b2: e8 39 14 00 00 call 3af0 <printf>
exit();
26b7: e8 c7 12 00 00 call 3983 <exit>
printf(1, "short read bigfile\n");
26bc: 83 ec 08 sub $0x8,%esp
26bf: 68 68 49 00 00 push $0x4968
26c4: 6a 01 push $0x1
26c6: e8 25 14 00 00 call 3af0 <printf>
exit();
26cb: e8 b3 12 00 00 call 3983 <exit>
printf(1, "read bigfile failed\n");
26d0: 83 ec 08 sub $0x8,%esp
26d3: 68 53 49 00 00 push $0x4953
26d8: 6a 01 push $0x1
26da: e8 11 14 00 00 call 3af0 <printf>
exit();
26df: e8 9f 12 00 00 call 3983 <exit>
printf(1, "write bigfile failed\n");
26e4: 83 ec 08 sub $0x8,%esp
26e7: 68 28 49 00 00 push $0x4928
26ec: 6a 01 push $0x1
26ee: e8 fd 13 00 00 call 3af0 <printf>
exit();
26f3: e8 8b 12 00 00 call 3983 <exit>
printf(1, "cannot open bigfile\n");
26f8: 53 push %ebx
26f9: 53 push %ebx
26fa: 68 3e 49 00 00 push $0x493e
26ff: 6a 01 push $0x1
2701: e8 ea 13 00 00 call 3af0 <printf>
exit();
2706: e8 78 12 00 00 call 3983 <exit>
printf(1, "cannot create bigfile");
270b: 50 push %eax
270c: 50 push %eax
270d: 68 12 49 00 00 push $0x4912
2712: 6a 01 push $0x1
2714: e8 d7 13 00 00 call 3af0 <printf>
exit();
2719: e8 65 12 00 00 call 3983 <exit>
printf(1, "read bigfile wrong total\n");
271e: 51 push %ecx
271f: 51 push %ecx
2720: 68 95 49 00 00 push $0x4995
2725: 6a 01 push $0x1
2727: e8 c4 13 00 00 call 3af0 <printf>
exit();
272c: e8 52 12 00 00 call 3983 <exit>
2731: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
2738: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
273f: 90 nop
00002740 <fourteen>:
{
2740: f3 0f 1e fb endbr32
2744: 55 push %ebp
2745: 89 e5 mov %esp,%ebp
2747: 83 ec 10 sub $0x10,%esp
printf(1, "fourteen test\n");
274a: 68 c0 49 00 00 push $0x49c0
274f: 6a 01 push $0x1
2751: e8 9a 13 00 00 call 3af0 <printf>
if(mkdir("12345678901234") != 0){
2756: c7 04 24 fb 49 00 00 movl $0x49fb,(%esp)
275d: e8 91 12 00 00 call 39f3 <mkdir>
2762: 83 c4 10 add $0x10,%esp
2765: 85 c0 test %eax,%eax
2767: 0f 85 97 00 00 00 jne 2804 <fourteen+0xc4>
if(mkdir("12345678901234/123456789012345") != 0){
276d: 83 ec 0c sub $0xc,%esp
2770: 68 b8 51 00 00 push $0x51b8
2775: e8 79 12 00 00 call 39f3 <mkdir>
277a: 83 c4 10 add $0x10,%esp
277d: 85 c0 test %eax,%eax
277f: 0f 85 de 00 00 00 jne 2863 <fourteen+0x123>
fd = open("123456789012345/123456789012345/123456789012345", O_CREATE);
2785: 83 ec 08 sub $0x8,%esp
2788: 68 00 02 00 00 push $0x200
278d: 68 08 52 00 00 push $0x5208
2792: e8 34 12 00 00 call 39cb <open>
if(fd < 0){
2797: 83 c4 10 add $0x10,%esp
279a: 85 c0 test %eax,%eax
279c: 0f 88 ae 00 00 00 js 2850 <fourteen+0x110>
close(fd);
27a2: 83 ec 0c sub $0xc,%esp
27a5: 50 push %eax
27a6: e8 08 12 00 00 call 39b3 <close>
fd = open("12345678901234/12345678901234/12345678901234", 0);
27ab: 58 pop %eax
27ac: 5a pop %edx
27ad: 6a 00 push $0x0
27af: 68 78 52 00 00 push $0x5278
27b4: e8 12 12 00 00 call 39cb <open>
if(fd < 0){
27b9: 83 c4 10 add $0x10,%esp
27bc: 85 c0 test %eax,%eax
27be: 78 7d js 283d <fourteen+0xfd>
close(fd);
27c0: 83 ec 0c sub $0xc,%esp
27c3: 50 push %eax
27c4: e8 ea 11 00 00 call 39b3 <close>
if(mkdir("12345678901234/12345678901234") == 0){
27c9: c7 04 24 ec 49 00 00 movl $0x49ec,(%esp)
27d0: e8 1e 12 00 00 call 39f3 <mkdir>
27d5: 83 c4 10 add $0x10,%esp
27d8: 85 c0 test %eax,%eax
27da: 74 4e je 282a <fourteen+0xea>
if(mkdir("123456789012345/12345678901234") == 0){
27dc: 83 ec 0c sub $0xc,%esp
27df: 68 14 53 00 00 push $0x5314
27e4: e8 0a 12 00 00 call 39f3 <mkdir>
27e9: 83 c4 10 add $0x10,%esp
27ec: 85 c0 test %eax,%eax
27ee: 74 27 je 2817 <fourteen+0xd7>
printf(1, "fourteen ok\n");
27f0: 83 ec 08 sub $0x8,%esp
27f3: 68 0a 4a 00 00 push $0x4a0a
27f8: 6a 01 push $0x1
27fa: e8 f1 12 00 00 call 3af0 <printf>
}
27ff: 83 c4 10 add $0x10,%esp
2802: c9 leave
2803: c3 ret
printf(1, "mkdir 12345678901234 failed\n");
2804: 50 push %eax
2805: 50 push %eax
2806: 68 cf 49 00 00 push $0x49cf
280b: 6a 01 push $0x1
280d: e8 de 12 00 00 call 3af0 <printf>
exit();
2812: e8 6c 11 00 00 call 3983 <exit>
printf(1, "mkdir 12345678901234/123456789012345 succeeded!\n");
2817: 50 push %eax
2818: 50 push %eax
2819: 68 34 53 00 00 push $0x5334
281e: 6a 01 push $0x1
2820: e8 cb 12 00 00 call 3af0 <printf>
exit();
2825: e8 59 11 00 00 call 3983 <exit>
printf(1, "mkdir 12345678901234/12345678901234 succeeded!\n");
282a: 52 push %edx
282b: 52 push %edx
282c: 68 e4 52 00 00 push $0x52e4
2831: 6a 01 push $0x1
2833: e8 b8 12 00 00 call 3af0 <printf>
exit();
2838: e8 46 11 00 00 call 3983 <exit>
printf(1, "open 12345678901234/12345678901234/12345678901234 failed\n");
283d: 51 push %ecx
283e: 51 push %ecx
283f: 68 a8 52 00 00 push $0x52a8
2844: 6a 01 push $0x1
2846: e8 a5 12 00 00 call 3af0 <printf>
exit();
284b: e8 33 11 00 00 call 3983 <exit>
printf(1, "create 123456789012345/123456789012345/123456789012345 failed\n");
2850: 51 push %ecx
2851: 51 push %ecx
2852: 68 38 52 00 00 push $0x5238
2857: 6a 01 push $0x1
2859: e8 92 12 00 00 call 3af0 <printf>
exit();
285e: e8 20 11 00 00 call 3983 <exit>
printf(1, "mkdir 12345678901234/123456789012345 failed\n");
2863: 50 push %eax
2864: 50 push %eax
2865: 68 d8 51 00 00 push $0x51d8
286a: 6a 01 push $0x1
286c: e8 7f 12 00 00 call 3af0 <printf>
exit();
2871: e8 0d 11 00 00 call 3983 <exit>
2876: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
287d: 8d 76 00 lea 0x0(%esi),%esi
00002880 <rmdot>:
{
2880: f3 0f 1e fb endbr32
2884: 55 push %ebp
2885: 89 e5 mov %esp,%ebp
2887: 83 ec 10 sub $0x10,%esp
printf(1, "rmdot test\n");
288a: 68 17 4a 00 00 push $0x4a17
288f: 6a 01 push $0x1
2891: e8 5a 12 00 00 call 3af0 <printf>
if(mkdir("dots") != 0){
2896: c7 04 24 23 4a 00 00 movl $0x4a23,(%esp)
289d: e8 51 11 00 00 call 39f3 <mkdir>
28a2: 83 c4 10 add $0x10,%esp
28a5: 85 c0 test %eax,%eax
28a7: 0f 85 b0 00 00 00 jne 295d <rmdot+0xdd>
if(chdir("dots") != 0){
28ad: 83 ec 0c sub $0xc,%esp
28b0: 68 23 4a 00 00 push $0x4a23
28b5: e8 41 11 00 00 call 39fb <chdir>
28ba: 83 c4 10 add $0x10,%esp
28bd: 85 c0 test %eax,%eax
28bf: 0f 85 1d 01 00 00 jne 29e2 <rmdot+0x162>
if(unlink(".") == 0){
28c5: 83 ec 0c sub $0xc,%esp
28c8: 68 ce 46 00 00 push $0x46ce
28cd: e8 09 11 00 00 call 39db <unlink>
28d2: 83 c4 10 add $0x10,%esp
28d5: 85 c0 test %eax,%eax
28d7: 0f 84 f2 00 00 00 je 29cf <rmdot+0x14f>
if(unlink("..") == 0){
28dd: 83 ec 0c sub $0xc,%esp
28e0: 68 cd 46 00 00 push $0x46cd
28e5: e8 f1 10 00 00 call 39db <unlink>
28ea: 83 c4 10 add $0x10,%esp
28ed: 85 c0 test %eax,%eax
28ef: 0f 84 c7 00 00 00 je 29bc <rmdot+0x13c>
if(chdir("/") != 0){
28f5: 83 ec 0c sub $0xc,%esp
28f8: 68 a1 3e 00 00 push $0x3ea1
28fd: e8 f9 10 00 00 call 39fb <chdir>
2902: 83 c4 10 add $0x10,%esp
2905: 85 c0 test %eax,%eax
2907: 0f 85 9c 00 00 00 jne 29a9 <rmdot+0x129>
if(unlink("dots/.") == 0){
290d: 83 ec 0c sub $0xc,%esp
2910: 68 6b 4a 00 00 push $0x4a6b
2915: e8 c1 10 00 00 call 39db <unlink>
291a: 83 c4 10 add $0x10,%esp
291d: 85 c0 test %eax,%eax
291f: 74 75 je 2996 <rmdot+0x116>
if(unlink("dots/..") == 0){
2921: 83 ec 0c sub $0xc,%esp
2924: 68 89 4a 00 00 push $0x4a89
2929: e8 ad 10 00 00 call 39db <unlink>
292e: 83 c4 10 add $0x10,%esp
2931: 85 c0 test %eax,%eax
2933: 74 4e je 2983 <rmdot+0x103>
if(unlink("dots") != 0){
2935: 83 ec 0c sub $0xc,%esp
2938: 68 23 4a 00 00 push $0x4a23
293d: e8 99 10 00 00 call 39db <unlink>
2942: 83 c4 10 add $0x10,%esp
2945: 85 c0 test %eax,%eax
2947: 75 27 jne 2970 <rmdot+0xf0>
printf(1, "rmdot ok\n");
2949: 83 ec 08 sub $0x8,%esp
294c: 68 be 4a 00 00 push $0x4abe
2951: 6a 01 push $0x1
2953: e8 98 11 00 00 call 3af0 <printf>
}
2958: 83 c4 10 add $0x10,%esp
295b: c9 leave
295c: c3 ret
printf(1, "mkdir dots failed\n");
295d: 50 push %eax
295e: 50 push %eax
295f: 68 28 4a 00 00 push $0x4a28
2964: 6a 01 push $0x1
2966: e8 85 11 00 00 call 3af0 <printf>
exit();
296b: e8 13 10 00 00 call 3983 <exit>
printf(1, "unlink dots failed!\n");
2970: 50 push %eax
2971: 50 push %eax
2972: 68 a9 4a 00 00 push $0x4aa9
2977: 6a 01 push $0x1
2979: e8 72 11 00 00 call 3af0 <printf>
exit();
297e: e8 00 10 00 00 call 3983 <exit>
printf(1, "unlink dots/.. worked!\n");
2983: 52 push %edx
2984: 52 push %edx
2985: 68 91 4a 00 00 push $0x4a91
298a: 6a 01 push $0x1
298c: e8 5f 11 00 00 call 3af0 <printf>
exit();
2991: e8 ed 0f 00 00 call 3983 <exit>
printf(1, "unlink dots/. worked!\n");
2996: 51 push %ecx
2997: 51 push %ecx
2998: 68 72 4a 00 00 push $0x4a72
299d: 6a 01 push $0x1
299f: e8 4c 11 00 00 call 3af0 <printf>
exit();
29a4: e8 da 0f 00 00 call 3983 <exit>
printf(1, "chdir / failed\n");
29a9: 50 push %eax
29aa: 50 push %eax
29ab: 68 a3 3e 00 00 push $0x3ea3
29b0: 6a 01 push $0x1
29b2: e8 39 11 00 00 call 3af0 <printf>
exit();
29b7: e8 c7 0f 00 00 call 3983 <exit>
printf(1, "rm .. worked!\n");
29bc: 50 push %eax
29bd: 50 push %eax
29be: 68 5c 4a 00 00 push $0x4a5c
29c3: 6a 01 push $0x1
29c5: e8 26 11 00 00 call 3af0 <printf>
exit();
29ca: e8 b4 0f 00 00 call 3983 <exit>
printf(1, "rm . worked!\n");
29cf: 50 push %eax
29d0: 50 push %eax
29d1: 68 4e 4a 00 00 push $0x4a4e
29d6: 6a 01 push $0x1
29d8: e8 13 11 00 00 call 3af0 <printf>
exit();
29dd: e8 a1 0f 00 00 call 3983 <exit>
printf(1, "chdir dots failed\n");
29e2: 50 push %eax
29e3: 50 push %eax
29e4: 68 3b 4a 00 00 push $0x4a3b
29e9: 6a 01 push $0x1
29eb: e8 00 11 00 00 call 3af0 <printf>
exit();
29f0: e8 8e 0f 00 00 call 3983 <exit>
29f5: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
29fc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
00002a00 <dirfile>:
{
2a00: f3 0f 1e fb endbr32
2a04: 55 push %ebp
2a05: 89 e5 mov %esp,%ebp
2a07: 53 push %ebx
2a08: 83 ec 0c sub $0xc,%esp
printf(1, "dir vs file\n");
2a0b: 68 c8 4a 00 00 push $0x4ac8
2a10: 6a 01 push $0x1
2a12: e8 d9 10 00 00 call 3af0 <printf>
fd = open("dirfile", O_CREATE);
2a17: 5b pop %ebx
2a18: 58 pop %eax
2a19: 68 00 02 00 00 push $0x200
2a1e: 68 d5 4a 00 00 push $0x4ad5
2a23: e8 a3 0f 00 00 call 39cb <open>
if(fd < 0){
2a28: 83 c4 10 add $0x10,%esp
2a2b: 85 c0 test %eax,%eax
2a2d: 0f 88 43 01 00 00 js 2b76 <dirfile+0x176>
close(fd);
2a33: 83 ec 0c sub $0xc,%esp
2a36: 50 push %eax
2a37: e8 77 0f 00 00 call 39b3 <close>
if(chdir("dirfile") == 0){
2a3c: c7 04 24 d5 4a 00 00 movl $0x4ad5,(%esp)
2a43: e8 b3 0f 00 00 call 39fb <chdir>
2a48: 83 c4 10 add $0x10,%esp
2a4b: 85 c0 test %eax,%eax
2a4d: 0f 84 10 01 00 00 je 2b63 <dirfile+0x163>
fd = open("dirfile/xx", 0);
2a53: 83 ec 08 sub $0x8,%esp
2a56: 6a 00 push $0x0
2a58: 68 0e 4b 00 00 push $0x4b0e
2a5d: e8 69 0f 00 00 call 39cb <open>
if(fd >= 0){
2a62: 83 c4 10 add $0x10,%esp
2a65: 85 c0 test %eax,%eax
2a67: 0f 89 e3 00 00 00 jns 2b50 <dirfile+0x150>
fd = open("dirfile/xx", O_CREATE);
2a6d: 83 ec 08 sub $0x8,%esp
2a70: 68 00 02 00 00 push $0x200
2a75: 68 0e 4b 00 00 push $0x4b0e
2a7a: e8 4c 0f 00 00 call 39cb <open>
if(fd >= 0){
2a7f: 83 c4 10 add $0x10,%esp
2a82: 85 c0 test %eax,%eax
2a84: 0f 89 c6 00 00 00 jns 2b50 <dirfile+0x150>
if(mkdir("dirfile/xx") == 0){
2a8a: 83 ec 0c sub $0xc,%esp
2a8d: 68 0e 4b 00 00 push $0x4b0e
2a92: e8 5c 0f 00 00 call 39f3 <mkdir>
2a97: 83 c4 10 add $0x10,%esp
2a9a: 85 c0 test %eax,%eax
2a9c: 0f 84 46 01 00 00 je 2be8 <dirfile+0x1e8>
if(unlink("dirfile/xx") == 0){
2aa2: 83 ec 0c sub $0xc,%esp
2aa5: 68 0e 4b 00 00 push $0x4b0e
2aaa: e8 2c 0f 00 00 call 39db <unlink>
2aaf: 83 c4 10 add $0x10,%esp
2ab2: 85 c0 test %eax,%eax
2ab4: 0f 84 1b 01 00 00 je 2bd5 <dirfile+0x1d5>
if(link("README", "dirfile/xx") == 0){
2aba: 83 ec 08 sub $0x8,%esp
2abd: 68 0e 4b 00 00 push $0x4b0e
2ac2: 68 72 4b 00 00 push $0x4b72
2ac7: e8 1f 0f 00 00 call 39eb <link>
2acc: 83 c4 10 add $0x10,%esp
2acf: 85 c0 test %eax,%eax
2ad1: 0f 84 eb 00 00 00 je 2bc2 <dirfile+0x1c2>
if(unlink("dirfile") != 0){
2ad7: 83 ec 0c sub $0xc,%esp
2ada: 68 d5 4a 00 00 push $0x4ad5
2adf: e8 f7 0e 00 00 call 39db <unlink>
2ae4: 83 c4 10 add $0x10,%esp
2ae7: 85 c0 test %eax,%eax
2ae9: 0f 85 c0 00 00 00 jne 2baf <dirfile+0x1af>
fd = open(".", O_RDWR);
2aef: 83 ec 08 sub $0x8,%esp
2af2: 6a 02 push $0x2
2af4: 68 ce 46 00 00 push $0x46ce
2af9: e8 cd 0e 00 00 call 39cb <open>
if(fd >= 0){
2afe: 83 c4 10 add $0x10,%esp
2b01: 85 c0 test %eax,%eax
2b03: 0f 89 93 00 00 00 jns 2b9c <dirfile+0x19c>
fd = open(".", 0);
2b09: 83 ec 08 sub $0x8,%esp
2b0c: 6a 00 push $0x0
2b0e: 68 ce 46 00 00 push $0x46ce
2b13: e8 b3 0e 00 00 call 39cb <open>
if(write(fd, "x", 1) > 0){
2b18: 83 c4 0c add $0xc,%esp
2b1b: 6a 01 push $0x1
fd = open(".", 0);
2b1d: 89 c3 mov %eax,%ebx
if(write(fd, "x", 1) > 0){
2b1f: 68 b1 47 00 00 push $0x47b1
2b24: 50 push %eax
2b25: e8 81 0e 00 00 call 39ab <write>
2b2a: 83 c4 10 add $0x10,%esp
2b2d: 85 c0 test %eax,%eax
2b2f: 7f 58 jg 2b89 <dirfile+0x189>
close(fd);
2b31: 83 ec 0c sub $0xc,%esp
2b34: 53 push %ebx
2b35: e8 79 0e 00 00 call 39b3 <close>
printf(1, "dir vs file OK\n");
2b3a: 58 pop %eax
2b3b: 5a pop %edx
2b3c: 68 a5 4b 00 00 push $0x4ba5
2b41: 6a 01 push $0x1
2b43: e8 a8 0f 00 00 call 3af0 <printf>
}
2b48: 8b 5d fc mov -0x4(%ebp),%ebx
2b4b: 83 c4 10 add $0x10,%esp
2b4e: c9 leave
2b4f: c3 ret
printf(1, "create dirfile/xx succeeded!\n");
2b50: 50 push %eax
2b51: 50 push %eax
2b52: 68 19 4b 00 00 push $0x4b19
2b57: 6a 01 push $0x1
2b59: e8 92 0f 00 00 call 3af0 <printf>
exit();
2b5e: e8 20 0e 00 00 call 3983 <exit>
printf(1, "chdir dirfile succeeded!\n");
2b63: 52 push %edx
2b64: 52 push %edx
2b65: 68 f4 4a 00 00 push $0x4af4
2b6a: 6a 01 push $0x1
2b6c: e8 7f 0f 00 00 call 3af0 <printf>
exit();
2b71: e8 0d 0e 00 00 call 3983 <exit>
printf(1, "create dirfile failed\n");
2b76: 51 push %ecx
2b77: 51 push %ecx
2b78: 68 dd 4a 00 00 push $0x4add
2b7d: 6a 01 push $0x1
2b7f: e8 6c 0f 00 00 call 3af0 <printf>
exit();
2b84: e8 fa 0d 00 00 call 3983 <exit>
printf(1, "write . succeeded!\n");
2b89: 51 push %ecx
2b8a: 51 push %ecx
2b8b: 68 91 4b 00 00 push $0x4b91
2b90: 6a 01 push $0x1
2b92: e8 59 0f 00 00 call 3af0 <printf>
exit();
2b97: e8 e7 0d 00 00 call 3983 <exit>
printf(1, "open . for writing succeeded!\n");
2b9c: 53 push %ebx
2b9d: 53 push %ebx
2b9e: 68 88 53 00 00 push $0x5388
2ba3: 6a 01 push $0x1
2ba5: e8 46 0f 00 00 call 3af0 <printf>
exit();
2baa: e8 d4 0d 00 00 call 3983 <exit>
printf(1, "unlink dirfile failed!\n");
2baf: 50 push %eax
2bb0: 50 push %eax
2bb1: 68 79 4b 00 00 push $0x4b79
2bb6: 6a 01 push $0x1
2bb8: e8 33 0f 00 00 call 3af0 <printf>
exit();
2bbd: e8 c1 0d 00 00 call 3983 <exit>
printf(1, "link to dirfile/xx succeeded!\n");
2bc2: 50 push %eax
2bc3: 50 push %eax
2bc4: 68 68 53 00 00 push $0x5368
2bc9: 6a 01 push $0x1
2bcb: e8 20 0f 00 00 call 3af0 <printf>
exit();
2bd0: e8 ae 0d 00 00 call 3983 <exit>
printf(1, "unlink dirfile/xx succeeded!\n");
2bd5: 50 push %eax
2bd6: 50 push %eax
2bd7: 68 54 4b 00 00 push $0x4b54
2bdc: 6a 01 push $0x1
2bde: e8 0d 0f 00 00 call 3af0 <printf>
exit();
2be3: e8 9b 0d 00 00 call 3983 <exit>
printf(1, "mkdir dirfile/xx succeeded!\n");
2be8: 50 push %eax
2be9: 50 push %eax
2bea: 68 37 4b 00 00 push $0x4b37
2bef: 6a 01 push $0x1
2bf1: e8 fa 0e 00 00 call 3af0 <printf>
exit();
2bf6: e8 88 0d 00 00 call 3983 <exit>
2bfb: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
2bff: 90 nop
00002c00 <iref>:
{
2c00: f3 0f 1e fb endbr32
2c04: 55 push %ebp
2c05: 89 e5 mov %esp,%ebp
2c07: 53 push %ebx
printf(1, "empty file name\n");
2c08: bb 33 00 00 00 mov $0x33,%ebx
{
2c0d: 83 ec 0c sub $0xc,%esp
printf(1, "empty file name\n");
2c10: 68 b5 4b 00 00 push $0x4bb5
2c15: 6a 01 push $0x1
2c17: e8 d4 0e 00 00 call 3af0 <printf>
2c1c: 83 c4 10 add $0x10,%esp
2c1f: 90 nop
if(mkdir("irefd") != 0){
2c20: 83 ec 0c sub $0xc,%esp
2c23: 68 c6 4b 00 00 push $0x4bc6
2c28: e8 c6 0d 00 00 call 39f3 <mkdir>
2c2d: 83 c4 10 add $0x10,%esp
2c30: 85 c0 test %eax,%eax
2c32: 0f 85 bb 00 00 00 jne 2cf3 <iref+0xf3>
if(chdir("irefd") != 0){
2c38: 83 ec 0c sub $0xc,%esp
2c3b: 68 c6 4b 00 00 push $0x4bc6
2c40: e8 b6 0d 00 00 call 39fb <chdir>
2c45: 83 c4 10 add $0x10,%esp
2c48: 85 c0 test %eax,%eax
2c4a: 0f 85 b7 00 00 00 jne 2d07 <iref+0x107>
mkdir("");
2c50: 83 ec 0c sub $0xc,%esp
2c53: 68 7b 42 00 00 push $0x427b
2c58: e8 96 0d 00 00 call 39f3 <mkdir>
link("README", "");
2c5d: 59 pop %ecx
2c5e: 58 pop %eax
2c5f: 68 7b 42 00 00 push $0x427b
2c64: 68 72 4b 00 00 push $0x4b72
2c69: e8 7d 0d 00 00 call 39eb <link>
fd = open("", O_CREATE);
2c6e: 58 pop %eax
2c6f: 5a pop %edx
2c70: 68 00 02 00 00 push $0x200
2c75: 68 7b 42 00 00 push $0x427b
2c7a: e8 4c 0d 00 00 call 39cb <open>
if(fd >= 0)
2c7f: 83 c4 10 add $0x10,%esp
2c82: 85 c0 test %eax,%eax
2c84: 78 0c js 2c92 <iref+0x92>
close(fd);
2c86: 83 ec 0c sub $0xc,%esp
2c89: 50 push %eax
2c8a: e8 24 0d 00 00 call 39b3 <close>
2c8f: 83 c4 10 add $0x10,%esp
fd = open("xx", O_CREATE);
2c92: 83 ec 08 sub $0x8,%esp
2c95: 68 00 02 00 00 push $0x200
2c9a: 68 b0 47 00 00 push $0x47b0
2c9f: e8 27 0d 00 00 call 39cb <open>
if(fd >= 0)
2ca4: 83 c4 10 add $0x10,%esp
2ca7: 85 c0 test %eax,%eax
2ca9: 78 0c js 2cb7 <iref+0xb7>
close(fd);
2cab: 83 ec 0c sub $0xc,%esp
2cae: 50 push %eax
2caf: e8 ff 0c 00 00 call 39b3 <close>
2cb4: 83 c4 10 add $0x10,%esp
unlink("xx");
2cb7: 83 ec 0c sub $0xc,%esp
2cba: 68 b0 47 00 00 push $0x47b0
2cbf: e8 17 0d 00 00 call 39db <unlink>
for(i = 0; i < 50 + 1; i++){
2cc4: 83 c4 10 add $0x10,%esp
2cc7: 83 eb 01 sub $0x1,%ebx
2cca: 0f 85 50 ff ff ff jne 2c20 <iref+0x20>
chdir("/");
2cd0: 83 ec 0c sub $0xc,%esp
2cd3: 68 a1 3e 00 00 push $0x3ea1
2cd8: e8 1e 0d 00 00 call 39fb <chdir>
printf(1, "empty file name OK\n");
2cdd: 58 pop %eax
2cde: 5a pop %edx
2cdf: 68 f4 4b 00 00 push $0x4bf4
2ce4: 6a 01 push $0x1
2ce6: e8 05 0e 00 00 call 3af0 <printf>
}
2ceb: 8b 5d fc mov -0x4(%ebp),%ebx
2cee: 83 c4 10 add $0x10,%esp
2cf1: c9 leave
2cf2: c3 ret
printf(1, "mkdir irefd failed\n");
2cf3: 83 ec 08 sub $0x8,%esp
2cf6: 68 cc 4b 00 00 push $0x4bcc
2cfb: 6a 01 push $0x1
2cfd: e8 ee 0d 00 00 call 3af0 <printf>
exit();
2d02: e8 7c 0c 00 00 call 3983 <exit>
printf(1, "chdir irefd failed\n");
2d07: 83 ec 08 sub $0x8,%esp
2d0a: 68 e0 4b 00 00 push $0x4be0
2d0f: 6a 01 push $0x1
2d11: e8 da 0d 00 00 call 3af0 <printf>
exit();
2d16: e8 68 0c 00 00 call 3983 <exit>
2d1b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
2d1f: 90 nop
00002d20 <forktest>:
{
2d20: f3 0f 1e fb endbr32
2d24: 55 push %ebp
2d25: 89 e5 mov %esp,%ebp
2d27: 53 push %ebx
for(n=0; n<1000; n++){
2d28: 31 db xor %ebx,%ebx
{
2d2a: 83 ec 0c sub $0xc,%esp
printf(1, "fork test\n");
2d2d: 68 08 4c 00 00 push $0x4c08
2d32: 6a 01 push $0x1
2d34: e8 b7 0d 00 00 call 3af0 <printf>
2d39: 83 c4 10 add $0x10,%esp
2d3c: eb 0f jmp 2d4d <forktest+0x2d>
2d3e: 66 90 xchg %ax,%ax
if(pid == 0)
2d40: 74 4a je 2d8c <forktest+0x6c>
for(n=0; n<1000; n++){
2d42: 83 c3 01 add $0x1,%ebx
2d45: 81 fb e8 03 00 00 cmp $0x3e8,%ebx
2d4b: 74 6b je 2db8 <forktest+0x98>
pid = fork();
2d4d: e8 29 0c 00 00 call 397b <fork>
if(pid < 0)
2d52: 85 c0 test %eax,%eax
2d54: 79 ea jns 2d40 <forktest+0x20>
for(; n > 0; n--){
2d56: 85 db test %ebx,%ebx
2d58: 74 14 je 2d6e <forktest+0x4e>
2d5a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
if(wait() < 0){
2d60: e8 26 0c 00 00 call 398b <wait>
2d65: 85 c0 test %eax,%eax
2d67: 78 28 js 2d91 <forktest+0x71>
for(; n > 0; n--){
2d69: 83 eb 01 sub $0x1,%ebx
2d6c: 75 f2 jne 2d60 <forktest+0x40>
if(wait() != -1){
2d6e: e8 18 0c 00 00 call 398b <wait>
2d73: 83 f8 ff cmp $0xffffffff,%eax
2d76: 75 2d jne 2da5 <forktest+0x85>
printf(1, "fork test OK\n");
2d78: 83 ec 08 sub $0x8,%esp
2d7b: 68 3a 4c 00 00 push $0x4c3a
2d80: 6a 01 push $0x1
2d82: e8 69 0d 00 00 call 3af0 <printf>
}
2d87: 8b 5d fc mov -0x4(%ebp),%ebx
2d8a: c9 leave
2d8b: c3 ret
exit();
2d8c: e8 f2 0b 00 00 call 3983 <exit>
printf(1, "wait stopped early\n");
2d91: 83 ec 08 sub $0x8,%esp
2d94: 68 13 4c 00 00 push $0x4c13
2d99: 6a 01 push $0x1
2d9b: e8 50 0d 00 00 call 3af0 <printf>
exit();
2da0: e8 de 0b 00 00 call 3983 <exit>
printf(1, "wait got too many\n");
2da5: 52 push %edx
2da6: 52 push %edx
2da7: 68 27 4c 00 00 push $0x4c27
2dac: 6a 01 push $0x1
2dae: e8 3d 0d 00 00 call 3af0 <printf>
exit();
2db3: e8 cb 0b 00 00 call 3983 <exit>
printf(1, "fork claimed to work 1000 times!\n");
2db8: 50 push %eax
2db9: 50 push %eax
2dba: 68 a8 53 00 00 push $0x53a8
2dbf: 6a 01 push $0x1
2dc1: e8 2a 0d 00 00 call 3af0 <printf>
exit();
2dc6: e8 b8 0b 00 00 call 3983 <exit>
2dcb: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
2dcf: 90 nop
00002dd0 <sbrktest>:
{
2dd0: f3 0f 1e fb endbr32
2dd4: 55 push %ebp
2dd5: 89 e5 mov %esp,%ebp
2dd7: 57 push %edi
for(i = 0; i < 5000; i++){
2dd8: 31 ff xor %edi,%edi
{
2dda: 56 push %esi
2ddb: 53 push %ebx
2ddc: 83 ec 54 sub $0x54,%esp
printf(stdout, "sbrk test\n");
2ddf: 68 48 4c 00 00 push $0x4c48
2de4: ff 35 f0 5e 00 00 pushl 0x5ef0
2dea: e8 01 0d 00 00 call 3af0 <printf>
oldbrk = sbrk(0);
2def: c7 04 24 00 00 00 00 movl $0x0,(%esp)
2df6: e8 18 0c 00 00 call 3a13 <sbrk>
a = sbrk(0);
2dfb: c7 04 24 00 00 00 00 movl $0x0,(%esp)
oldbrk = sbrk(0);
2e02: 89 c3 mov %eax,%ebx
a = sbrk(0);
2e04: e8 0a 0c 00 00 call 3a13 <sbrk>
2e09: 83 c4 10 add $0x10,%esp
2e0c: 89 c6 mov %eax,%esi
for(i = 0; i < 5000; i++){
2e0e: eb 02 jmp 2e12 <sbrktest+0x42>
a = b + 1;
2e10: 89 c6 mov %eax,%esi
b = sbrk(1);
2e12: 83 ec 0c sub $0xc,%esp
2e15: 6a 01 push $0x1
2e17: e8 f7 0b 00 00 call 3a13 <sbrk>
if(b != a){
2e1c: 83 c4 10 add $0x10,%esp
2e1f: 39 f0 cmp %esi,%eax
2e21: 0f 85 84 02 00 00 jne 30ab <sbrktest+0x2db>
for(i = 0; i < 5000; i++){
2e27: 83 c7 01 add $0x1,%edi
*b = 1;
2e2a: c6 06 01 movb $0x1,(%esi)
a = b + 1;
2e2d: 8d 46 01 lea 0x1(%esi),%eax
for(i = 0; i < 5000; i++){
2e30: 81 ff 88 13 00 00 cmp $0x1388,%edi
2e36: 75 d8 jne 2e10 <sbrktest+0x40>
pid = fork();
2e38: e8 3e 0b 00 00 call 397b <fork>
2e3d: 89 c7 mov %eax,%edi
if(pid < 0){
2e3f: 85 c0 test %eax,%eax
2e41: 0f 88 91 03 00 00 js 31d8 <sbrktest+0x408>
c = sbrk(1);
2e47: 83 ec 0c sub $0xc,%esp
if(c != a + 1){
2e4a: 83 c6 02 add $0x2,%esi
c = sbrk(1);
2e4d: 6a 01 push $0x1
2e4f: e8 bf 0b 00 00 call 3a13 <sbrk>
c = sbrk(1);
2e54: c7 04 24 01 00 00 00 movl $0x1,(%esp)
2e5b: e8 b3 0b 00 00 call 3a13 <sbrk>
if(c != a + 1){
2e60: 83 c4 10 add $0x10,%esp
2e63: 39 c6 cmp %eax,%esi
2e65: 0f 85 56 03 00 00 jne 31c1 <sbrktest+0x3f1>
if(pid == 0)
2e6b: 85 ff test %edi,%edi
2e6d: 0f 84 49 03 00 00 je 31bc <sbrktest+0x3ec>
wait();
2e73: e8 13 0b 00 00 call 398b <wait>
a = sbrk(0);
2e78: 83 ec 0c sub $0xc,%esp
2e7b: 6a 00 push $0x0
2e7d: e8 91 0b 00 00 call 3a13 <sbrk>
2e82: 89 c6 mov %eax,%esi
amt = (BIG) - (uint)a;
2e84: b8 00 00 40 06 mov $0x6400000,%eax
2e89: 29 f0 sub %esi,%eax
p = sbrk(amt);
2e8b: 89 04 24 mov %eax,(%esp)
2e8e: e8 80 0b 00 00 call 3a13 <sbrk>
if (p != a) {
2e93: 83 c4 10 add $0x10,%esp
2e96: 39 c6 cmp %eax,%esi
2e98: 0f 85 07 03 00 00 jne 31a5 <sbrktest+0x3d5>
a = sbrk(0);
2e9e: 83 ec 0c sub $0xc,%esp
*lastaddr = 99;
2ea1: c6 05 ff ff 3f 06 63 movb $0x63,0x63fffff
a = sbrk(0);
2ea8: 6a 00 push $0x0
2eaa: e8 64 0b 00 00 call 3a13 <sbrk>
c = sbrk(-4096);
2eaf: c7 04 24 00 f0 ff ff movl $0xfffff000,(%esp)
a = sbrk(0);
2eb6: 89 c6 mov %eax,%esi
c = sbrk(-4096);
2eb8: e8 56 0b 00 00 call 3a13 <sbrk>
if(c == (char*)0xffffffff){
2ebd: 83 c4 10 add $0x10,%esp
2ec0: 83 f8 ff cmp $0xffffffff,%eax
2ec3: 0f 84 c5 02 00 00 je 318e <sbrktest+0x3be>
c = sbrk(0);
2ec9: 83 ec 0c sub $0xc,%esp
2ecc: 6a 00 push $0x0
2ece: e8 40 0b 00 00 call 3a13 <sbrk>
if(c != a - 4096){
2ed3: 8d 96 00 f0 ff ff lea -0x1000(%esi),%edx
2ed9: 83 c4 10 add $0x10,%esp
2edc: 39 d0 cmp %edx,%eax
2ede: 0f 85 93 02 00 00 jne 3177 <sbrktest+0x3a7>
a = sbrk(0);
2ee4: 83 ec 0c sub $0xc,%esp
2ee7: 6a 00 push $0x0
2ee9: e8 25 0b 00 00 call 3a13 <sbrk>
c = sbrk(4096);
2eee: c7 04 24 00 10 00 00 movl $0x1000,(%esp)
a = sbrk(0);
2ef5: 89 c6 mov %eax,%esi
c = sbrk(4096);
2ef7: e8 17 0b 00 00 call 3a13 <sbrk>
if(c != a || sbrk(0) != a + 4096){
2efc: 83 c4 10 add $0x10,%esp
c = sbrk(4096);
2eff: 89 c7 mov %eax,%edi
if(c != a || sbrk(0) != a + 4096){
2f01: 39 c6 cmp %eax,%esi
2f03: 0f 85 57 02 00 00 jne 3160 <sbrktest+0x390>
2f09: 83 ec 0c sub $0xc,%esp
2f0c: 6a 00 push $0x0
2f0e: e8 00 0b 00 00 call 3a13 <sbrk>
2f13: 8d 96 00 10 00 00 lea 0x1000(%esi),%edx
2f19: 83 c4 10 add $0x10,%esp
2f1c: 39 c2 cmp %eax,%edx
2f1e: 0f 85 3c 02 00 00 jne 3160 <sbrktest+0x390>
if(*lastaddr == 99){
2f24: 80 3d ff ff 3f 06 63 cmpb $0x63,0x63fffff
2f2b: 0f 84 18 02 00 00 je 3149 <sbrktest+0x379>
a = sbrk(0);
2f31: 83 ec 0c sub $0xc,%esp
2f34: 6a 00 push $0x0
2f36: e8 d8 0a 00 00 call 3a13 <sbrk>
c = sbrk(-(sbrk(0) - oldbrk));
2f3b: c7 04 24 00 00 00 00 movl $0x0,(%esp)
a = sbrk(0);
2f42: 89 c6 mov %eax,%esi
c = sbrk(-(sbrk(0) - oldbrk));
2f44: e8 ca 0a 00 00 call 3a13 <sbrk>
2f49: 89 d9 mov %ebx,%ecx
2f4b: 29 c1 sub %eax,%ecx
2f4d: 89 0c 24 mov %ecx,(%esp)
2f50: e8 be 0a 00 00 call 3a13 <sbrk>
if(c != a){
2f55: 83 c4 10 add $0x10,%esp
2f58: 39 c6 cmp %eax,%esi
2f5a: 0f 85 d2 01 00 00 jne 3132 <sbrktest+0x362>
for(a = (char*)(KERNBASE); a < (char*) (KERNBASE+2000000); a += 50000){
2f60: be 00 00 00 80 mov $0x80000000,%esi
2f65: 8d 76 00 lea 0x0(%esi),%esi
ppid = getpid();
2f68: e8 9e 0a 00 00 call 3a0b <getpid>
2f6d: 89 c7 mov %eax,%edi
pid = fork();
2f6f: e8 07 0a 00 00 call 397b <fork>
if(pid < 0){
2f74: 85 c0 test %eax,%eax
2f76: 0f 88 9e 01 00 00 js 311a <sbrktest+0x34a>
if(pid == 0){
2f7c: 0f 84 76 01 00 00 je 30f8 <sbrktest+0x328>
wait();
2f82: e8 04 0a 00 00 call 398b <wait>
for(a = (char*)(KERNBASE); a < (char*) (KERNBASE+2000000); a += 50000){
2f87: 81 c6 50 c3 00 00 add $0xc350,%esi
2f8d: 81 fe 80 84 1e 80 cmp $0x801e8480,%esi
2f93: 75 d3 jne 2f68 <sbrktest+0x198>
if(pipe(fds) != 0){
2f95: 83 ec 0c sub $0xc,%esp
2f98: 8d 45 b8 lea -0x48(%ebp),%eax
2f9b: 50 push %eax
2f9c: e8 fa 09 00 00 call 399b <pipe>
2fa1: 83 c4 10 add $0x10,%esp
2fa4: 85 c0 test %eax,%eax
2fa6: 0f 85 34 01 00 00 jne 30e0 <sbrktest+0x310>
2fac: 8d 75 c0 lea -0x40(%ebp),%esi
2faf: 89 f7 mov %esi,%edi
if((pids[i] = fork()) == 0){
2fb1: e8 c5 09 00 00 call 397b <fork>
2fb6: 89 07 mov %eax,(%edi)
2fb8: 85 c0 test %eax,%eax
2fba: 0f 84 8f 00 00 00 je 304f <sbrktest+0x27f>
if(pids[i] != -1)
2fc0: 83 f8 ff cmp $0xffffffff,%eax
2fc3: 74 14 je 2fd9 <sbrktest+0x209>
read(fds[0], &scratch, 1);
2fc5: 83 ec 04 sub $0x4,%esp
2fc8: 8d 45 b7 lea -0x49(%ebp),%eax
2fcb: 6a 01 push $0x1
2fcd: 50 push %eax
2fce: ff 75 b8 pushl -0x48(%ebp)
2fd1: e8 cd 09 00 00 call 39a3 <read>
2fd6: 83 c4 10 add $0x10,%esp
for(i = 0; i < sizeof(pids)/sizeof(pids[0]); i++){
2fd9: 83 c7 04 add $0x4,%edi
2fdc: 8d 45 e8 lea -0x18(%ebp),%eax
2fdf: 39 c7 cmp %eax,%edi
2fe1: 75 ce jne 2fb1 <sbrktest+0x1e1>
c = sbrk(4096);
2fe3: 83 ec 0c sub $0xc,%esp
2fe6: 68 00 10 00 00 push $0x1000
2feb: e8 23 0a 00 00 call 3a13 <sbrk>
2ff0: 83 c4 10 add $0x10,%esp
2ff3: 89 c7 mov %eax,%edi
if(pids[i] == -1)
2ff5: 8b 06 mov (%esi),%eax
2ff7: 83 f8 ff cmp $0xffffffff,%eax
2ffa: 74 11 je 300d <sbrktest+0x23d>
kill(pids[i]);
2ffc: 83 ec 0c sub $0xc,%esp
2fff: 50 push %eax
3000: e8 b6 09 00 00 call 39bb <kill>
wait();
3005: e8 81 09 00 00 call 398b <wait>
300a: 83 c4 10 add $0x10,%esp
for(i = 0; i < sizeof(pids)/sizeof(pids[0]); i++){
300d: 83 c6 04 add $0x4,%esi
3010: 8d 45 e8 lea -0x18(%ebp),%eax
3013: 39 f0 cmp %esi,%eax
3015: 75 de jne 2ff5 <sbrktest+0x225>
if(c == (char*)0xffffffff){
3017: 83 ff ff cmp $0xffffffff,%edi
301a: 0f 84 a9 00 00 00 je 30c9 <sbrktest+0x2f9>
if(sbrk(0) > oldbrk)
3020: 83 ec 0c sub $0xc,%esp
3023: 6a 00 push $0x0
3025: e8 e9 09 00 00 call 3a13 <sbrk>
302a: 83 c4 10 add $0x10,%esp
302d: 39 c3 cmp %eax,%ebx
302f: 72 61 jb 3092 <sbrktest+0x2c2>
printf(stdout, "sbrk test OK\n");
3031: 83 ec 08 sub $0x8,%esp
3034: 68 f0 4c 00 00 push $0x4cf0
3039: ff 35 f0 5e 00 00 pushl 0x5ef0
303f: e8 ac 0a 00 00 call 3af0 <printf>
}
3044: 83 c4 10 add $0x10,%esp
3047: 8d 65 f4 lea -0xc(%ebp),%esp
304a: 5b pop %ebx
304b: 5e pop %esi
304c: 5f pop %edi
304d: 5d pop %ebp
304e: c3 ret
sbrk(BIG - (uint)sbrk(0));
304f: 83 ec 0c sub $0xc,%esp
3052: 6a 00 push $0x0
3054: e8 ba 09 00 00 call 3a13 <sbrk>
3059: 89 c2 mov %eax,%edx
305b: b8 00 00 40 06 mov $0x6400000,%eax
3060: 29 d0 sub %edx,%eax
3062: 89 04 24 mov %eax,(%esp)
3065: e8 a9 09 00 00 call 3a13 <sbrk>
write(fds[1], "x", 1);
306a: 83 c4 0c add $0xc,%esp
306d: 6a 01 push $0x1
306f: 68 b1 47 00 00 push $0x47b1
3074: ff 75 bc pushl -0x44(%ebp)
3077: e8 2f 09 00 00 call 39ab <write>
307c: 83 c4 10 add $0x10,%esp
307f: 90 nop
for(;;) sleep(1000);
3080: 83 ec 0c sub $0xc,%esp
3083: 68 e8 03 00 00 push $0x3e8
3088: e8 8e 09 00 00 call 3a1b <sleep>
308d: 83 c4 10 add $0x10,%esp
3090: eb ee jmp 3080 <sbrktest+0x2b0>
sbrk(-(sbrk(0) - oldbrk));
3092: 83 ec 0c sub $0xc,%esp
3095: 6a 00 push $0x0
3097: e8 77 09 00 00 call 3a13 <sbrk>
309c: 29 c3 sub %eax,%ebx
309e: 89 1c 24 mov %ebx,(%esp)
30a1: e8 6d 09 00 00 call 3a13 <sbrk>
30a6: 83 c4 10 add $0x10,%esp
30a9: eb 86 jmp 3031 <sbrktest+0x261>
printf(stdout, "sbrk test failed %d %x %x\n", i, a, b);
30ab: 83 ec 0c sub $0xc,%esp
30ae: 50 push %eax
30af: 56 push %esi
30b0: 57 push %edi
30b1: 68 53 4c 00 00 push $0x4c53
30b6: ff 35 f0 5e 00 00 pushl 0x5ef0
30bc: e8 2f 0a 00 00 call 3af0 <printf>
exit();
30c1: 83 c4 20 add $0x20,%esp
30c4: e8 ba 08 00 00 call 3983 <exit>
printf(stdout, "failed sbrk leaked memory\n");
30c9: 50 push %eax
30ca: 50 push %eax
30cb: 68 d5 4c 00 00 push $0x4cd5
30d0: ff 35 f0 5e 00 00 pushl 0x5ef0
30d6: e8 15 0a 00 00 call 3af0 <printf>
exit();
30db: e8 a3 08 00 00 call 3983 <exit>
printf(1, "pipe() failed\n");
30e0: 52 push %edx
30e1: 52 push %edx
30e2: 68 91 41 00 00 push $0x4191
30e7: 6a 01 push $0x1
30e9: e8 02 0a 00 00 call 3af0 <printf>
exit();
30ee: e8 90 08 00 00 call 3983 <exit>
30f3: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
30f7: 90 nop
printf(stdout, "oops could read %x = %x\n", a, *a);
30f8: 0f be 06 movsbl (%esi),%eax
30fb: 50 push %eax
30fc: 56 push %esi
30fd: 68 bc 4c 00 00 push $0x4cbc
3102: ff 35 f0 5e 00 00 pushl 0x5ef0
3108: e8 e3 09 00 00 call 3af0 <printf>
kill(ppid);
310d: 89 3c 24 mov %edi,(%esp)
3110: e8 a6 08 00 00 call 39bb <kill>
exit();
3115: e8 69 08 00 00 call 3983 <exit>
printf(stdout, "fork failed\n");
311a: 83 ec 08 sub $0x8,%esp
311d: 68 99 4d 00 00 push $0x4d99
3122: ff 35 f0 5e 00 00 pushl 0x5ef0
3128: e8 c3 09 00 00 call 3af0 <printf>
exit();
312d: e8 51 08 00 00 call 3983 <exit>
printf(stdout, "sbrk downsize failed, a %x c %x\n", a, c);
3132: 50 push %eax
3133: 56 push %esi
3134: 68 9c 54 00 00 push $0x549c
3139: ff 35 f0 5e 00 00 pushl 0x5ef0
313f: e8 ac 09 00 00 call 3af0 <printf>
exit();
3144: e8 3a 08 00 00 call 3983 <exit>
printf(stdout, "sbrk de-allocation didn't really deallocate\n");
3149: 51 push %ecx
314a: 51 push %ecx
314b: 68 6c 54 00 00 push $0x546c
3150: ff 35 f0 5e 00 00 pushl 0x5ef0
3156: e8 95 09 00 00 call 3af0 <printf>
exit();
315b: e8 23 08 00 00 call 3983 <exit>
printf(stdout, "sbrk re-allocation failed, a %x c %x\n", a, c);
3160: 57 push %edi
3161: 56 push %esi
3162: 68 44 54 00 00 push $0x5444
3167: ff 35 f0 5e 00 00 pushl 0x5ef0
316d: e8 7e 09 00 00 call 3af0 <printf>
exit();
3172: e8 0c 08 00 00 call 3983 <exit>
printf(stdout, "sbrk deallocation produced wrong address, a %x c %x\n", a, c);
3177: 50 push %eax
3178: 56 push %esi
3179: 68 0c 54 00 00 push $0x540c
317e: ff 35 f0 5e 00 00 pushl 0x5ef0
3184: e8 67 09 00 00 call 3af0 <printf>
exit();
3189: e8 f5 07 00 00 call 3983 <exit>
printf(stdout, "sbrk could not deallocate\n");
318e: 53 push %ebx
318f: 53 push %ebx
3190: 68 a1 4c 00 00 push $0x4ca1
3195: ff 35 f0 5e 00 00 pushl 0x5ef0
319b: e8 50 09 00 00 call 3af0 <printf>
exit();
31a0: e8 de 07 00 00 call 3983 <exit>
printf(stdout, "sbrk test failed to grow big address space; enough phys mem?\n");
31a5: 56 push %esi
31a6: 56 push %esi
31a7: 68 cc 53 00 00 push $0x53cc
31ac: ff 35 f0 5e 00 00 pushl 0x5ef0
31b2: e8 39 09 00 00 call 3af0 <printf>
exit();
31b7: e8 c7 07 00 00 call 3983 <exit>
exit();
31bc: e8 c2 07 00 00 call 3983 <exit>
printf(stdout, "sbrk test failed post-fork\n");
31c1: 57 push %edi
31c2: 57 push %edi
31c3: 68 85 4c 00 00 push $0x4c85
31c8: ff 35 f0 5e 00 00 pushl 0x5ef0
31ce: e8 1d 09 00 00 call 3af0 <printf>
exit();
31d3: e8 ab 07 00 00 call 3983 <exit>
printf(stdout, "sbrk test fork failed\n");
31d8: 50 push %eax
31d9: 50 push %eax
31da: 68 6e 4c 00 00 push $0x4c6e
31df: ff 35 f0 5e 00 00 pushl 0x5ef0
31e5: e8 06 09 00 00 call 3af0 <printf>
exit();
31ea: e8 94 07 00 00 call 3983 <exit>
31ef: 90 nop
000031f0 <validateint>:
{
31f0: f3 0f 1e fb endbr32
}
31f4: c3 ret
31f5: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
31fc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
00003200 <validatetest>:
{
3200: f3 0f 1e fb endbr32
3204: 55 push %ebp
3205: 89 e5 mov %esp,%ebp
3207: 56 push %esi
for(p = 0; p <= (uint)hi; p += 4096){
3208: 31 f6 xor %esi,%esi
{
320a: 53 push %ebx
printf(stdout, "validate test\n");
320b: 83 ec 08 sub $0x8,%esp
320e: 68 fe 4c 00 00 push $0x4cfe
3213: ff 35 f0 5e 00 00 pushl 0x5ef0
3219: e8 d2 08 00 00 call 3af0 <printf>
321e: 83 c4 10 add $0x10,%esp
3221: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
if((pid = fork()) == 0){
3228: e8 4e 07 00 00 call 397b <fork>
322d: 89 c3 mov %eax,%ebx
322f: 85 c0 test %eax,%eax
3231: 74 63 je 3296 <validatetest+0x96>
sleep(0);
3233: 83 ec 0c sub $0xc,%esp
3236: 6a 00 push $0x0
3238: e8 de 07 00 00 call 3a1b <sleep>
sleep(0);
323d: c7 04 24 00 00 00 00 movl $0x0,(%esp)
3244: e8 d2 07 00 00 call 3a1b <sleep>
kill(pid);
3249: 89 1c 24 mov %ebx,(%esp)
324c: e8 6a 07 00 00 call 39bb <kill>
wait();
3251: e8 35 07 00 00 call 398b <wait>
if(link("nosuchfile", (char*)p) != -1){
3256: 58 pop %eax
3257: 5a pop %edx
3258: 56 push %esi
3259: 68 0d 4d 00 00 push $0x4d0d
325e: e8 88 07 00 00 call 39eb <link>
3263: 83 c4 10 add $0x10,%esp
3266: 83 f8 ff cmp $0xffffffff,%eax
3269: 75 30 jne 329b <validatetest+0x9b>
for(p = 0; p <= (uint)hi; p += 4096){
326b: 81 c6 00 10 00 00 add $0x1000,%esi
3271: 81 fe 00 40 11 00 cmp $0x114000,%esi
3277: 75 af jne 3228 <validatetest+0x28>
printf(stdout, "validate ok\n");
3279: 83 ec 08 sub $0x8,%esp
327c: 68 31 4d 00 00 push $0x4d31
3281: ff 35 f0 5e 00 00 pushl 0x5ef0
3287: e8 64 08 00 00 call 3af0 <printf>
}
328c: 83 c4 10 add $0x10,%esp
328f: 8d 65 f8 lea -0x8(%ebp),%esp
3292: 5b pop %ebx
3293: 5e pop %esi
3294: 5d pop %ebp
3295: c3 ret
exit();
3296: e8 e8 06 00 00 call 3983 <exit>
printf(stdout, "link should not succeed\n");
329b: 83 ec 08 sub $0x8,%esp
329e: 68 18 4d 00 00 push $0x4d18
32a3: ff 35 f0 5e 00 00 pushl 0x5ef0
32a9: e8 42 08 00 00 call 3af0 <printf>
exit();
32ae: e8 d0 06 00 00 call 3983 <exit>
32b3: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
32ba: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
000032c0 <bsstest>:
{
32c0: f3 0f 1e fb endbr32
32c4: 55 push %ebp
32c5: 89 e5 mov %esp,%ebp
32c7: 83 ec 10 sub $0x10,%esp
printf(stdout, "bss test\n");
32ca: 68 3e 4d 00 00 push $0x4d3e
32cf: ff 35 f0 5e 00 00 pushl 0x5ef0
32d5: e8 16 08 00 00 call 3af0 <printf>
32da: 83 c4 10 add $0x10,%esp
for(i = 0; i < sizeof(uninit); i++){
32dd: 31 c0 xor %eax,%eax
32df: 90 nop
if(uninit[i] != '\0'){
32e0: 80 b8 c0 5f 00 00 00 cmpb $0x0,0x5fc0(%eax)
32e7: 75 22 jne 330b <bsstest+0x4b>
for(i = 0; i < sizeof(uninit); i++){
32e9: 83 c0 01 add $0x1,%eax
32ec: 3d 10 27 00 00 cmp $0x2710,%eax
32f1: 75 ed jne 32e0 <bsstest+0x20>
printf(stdout, "bss test ok\n");
32f3: 83 ec 08 sub $0x8,%esp
32f6: 68 59 4d 00 00 push $0x4d59
32fb: ff 35 f0 5e 00 00 pushl 0x5ef0
3301: e8 ea 07 00 00 call 3af0 <printf>
}
3306: 83 c4 10 add $0x10,%esp
3309: c9 leave
330a: c3 ret
printf(stdout, "bss test failed\n");
330b: 83 ec 08 sub $0x8,%esp
330e: 68 48 4d 00 00 push $0x4d48
3313: ff 35 f0 5e 00 00 pushl 0x5ef0
3319: e8 d2 07 00 00 call 3af0 <printf>
exit();
331e: e8 60 06 00 00 call 3983 <exit>
3323: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
332a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
00003330 <bigargtest>:
{
3330: f3 0f 1e fb endbr32
3334: 55 push %ebp
3335: 89 e5 mov %esp,%ebp
3337: 83 ec 14 sub $0x14,%esp
unlink("bigarg-ok");
333a: 68 66 4d 00 00 push $0x4d66
333f: e8 97 06 00 00 call 39db <unlink>
pid = fork();
3344: e8 32 06 00 00 call 397b <fork>
if(pid == 0){
3349: 83 c4 10 add $0x10,%esp
334c: 85 c0 test %eax,%eax
334e: 74 40 je 3390 <bigargtest+0x60>
} else if(pid < 0){
3350: 0f 88 c1 00 00 00 js 3417 <bigargtest+0xe7>
wait();
3356: e8 30 06 00 00 call 398b <wait>
fd = open("bigarg-ok", 0);
335b: 83 ec 08 sub $0x8,%esp
335e: 6a 00 push $0x0
3360: 68 66 4d 00 00 push $0x4d66
3365: e8 61 06 00 00 call 39cb <open>
if(fd < 0){
336a: 83 c4 10 add $0x10,%esp
336d: 85 c0 test %eax,%eax
336f: 0f 88 8b 00 00 00 js 3400 <bigargtest+0xd0>
close(fd);
3375: 83 ec 0c sub $0xc,%esp
3378: 50 push %eax
3379: e8 35 06 00 00 call 39b3 <close>
unlink("bigarg-ok");
337e: c7 04 24 66 4d 00 00 movl $0x4d66,(%esp)
3385: e8 51 06 00 00 call 39db <unlink>
}
338a: 83 c4 10 add $0x10,%esp
338d: c9 leave
338e: c3 ret
338f: 90 nop
args[i] = "bigargs test: failed\n ";
3390: c7 04 85 20 5f 00 00 movl $0x54c0,0x5f20(,%eax,4)
3397: c0 54 00 00
for(i = 0; i < MAXARG-1; i++)
339b: 83 c0 01 add $0x1,%eax
339e: 83 f8 1f cmp $0x1f,%eax
33a1: 75 ed jne 3390 <bigargtest+0x60>
printf(stdout, "bigarg test\n");
33a3: 51 push %ecx
33a4: 51 push %ecx
33a5: 68 70 4d 00 00 push $0x4d70
33aa: ff 35 f0 5e 00 00 pushl 0x5ef0
args[MAXARG-1] = 0;
33b0: c7 05 9c 5f 00 00 00 movl $0x0,0x5f9c
33b7: 00 00 00
printf(stdout, "bigarg test\n");
33ba: e8 31 07 00 00 call 3af0 <printf>
exec("echo", args);
33bf: 58 pop %eax
33c0: 5a pop %edx
33c1: 68 20 5f 00 00 push $0x5f20
33c6: 68 3d 3f 00 00 push $0x3f3d
33cb: e8 f3 05 00 00 call 39c3 <exec>
printf(stdout, "bigarg test ok\n");
33d0: 59 pop %ecx
33d1: 58 pop %eax
33d2: 68 7d 4d 00 00 push $0x4d7d
33d7: ff 35 f0 5e 00 00 pushl 0x5ef0
33dd: e8 0e 07 00 00 call 3af0 <printf>
fd = open("bigarg-ok", O_CREATE);
33e2: 58 pop %eax
33e3: 5a pop %edx
33e4: 68 00 02 00 00 push $0x200
33e9: 68 66 4d 00 00 push $0x4d66
33ee: e8 d8 05 00 00 call 39cb <open>
close(fd);
33f3: 89 04 24 mov %eax,(%esp)
33f6: e8 b8 05 00 00 call 39b3 <close>
exit();
33fb: e8 83 05 00 00 call 3983 <exit>
printf(stdout, "bigarg test failed!\n");
3400: 50 push %eax
3401: 50 push %eax
3402: 68 a6 4d 00 00 push $0x4da6
3407: ff 35 f0 5e 00 00 pushl 0x5ef0
340d: e8 de 06 00 00 call 3af0 <printf>
exit();
3412: e8 6c 05 00 00 call 3983 <exit>
printf(stdout, "bigargtest: fork failed\n");
3417: 52 push %edx
3418: 52 push %edx
3419: 68 8d 4d 00 00 push $0x4d8d
341e: ff 35 f0 5e 00 00 pushl 0x5ef0
3424: e8 c7 06 00 00 call 3af0 <printf>
exit();
3429: e8 55 05 00 00 call 3983 <exit>
342e: 66 90 xchg %ax,%ax
00003430 <fsfull>:
{
3430: f3 0f 1e fb endbr32
3434: 55 push %ebp
3435: 89 e5 mov %esp,%ebp
3437: 57 push %edi
3438: 56 push %esi
for(nfiles = 0; ; nfiles++){
3439: 31 f6 xor %esi,%esi
{
343b: 53 push %ebx
343c: 83 ec 54 sub $0x54,%esp
printf(1, "fsfull test\n");
343f: 68 bb 4d 00 00 push $0x4dbb
3444: 6a 01 push $0x1
3446: e8 a5 06 00 00 call 3af0 <printf>
344b: 83 c4 10 add $0x10,%esp
344e: 66 90 xchg %ax,%ax
name[1] = '0' + nfiles / 1000;
3450: b8 d3 4d 62 10 mov $0x10624dd3,%eax
name[3] = '0' + (nfiles % 100) / 10;
3455: b9 cd cc cc cc mov $0xcccccccd,%ecx
printf(1, "writing %s\n", name);
345a: 83 ec 04 sub $0x4,%esp
name[0] = 'f';
345d: c6 45 a8 66 movb $0x66,-0x58(%ebp)
name[1] = '0' + nfiles / 1000;
3461: f7 e6 mul %esi
name[5] = '\0';
3463: c6 45 ad 00 movb $0x0,-0x53(%ebp)
name[1] = '0' + nfiles / 1000;
3467: c1 ea 06 shr $0x6,%edx
346a: 8d 42 30 lea 0x30(%edx),%eax
name[2] = '0' + (nfiles % 1000) / 100;
346d: 69 d2 e8 03 00 00 imul $0x3e8,%edx,%edx
name[1] = '0' + nfiles / 1000;
3473: 88 45 a9 mov %al,-0x57(%ebp)
name[2] = '0' + (nfiles % 1000) / 100;
3476: 89 f0 mov %esi,%eax
3478: 29 d0 sub %edx,%eax
347a: 89 c2 mov %eax,%edx
347c: b8 1f 85 eb 51 mov $0x51eb851f,%eax
3481: f7 e2 mul %edx
name[3] = '0' + (nfiles % 100) / 10;
3483: b8 1f 85 eb 51 mov $0x51eb851f,%eax
name[2] = '0' + (nfiles % 1000) / 100;
3488: c1 ea 05 shr $0x5,%edx
348b: 83 c2 30 add $0x30,%edx
348e: 88 55 aa mov %dl,-0x56(%ebp)
name[3] = '0' + (nfiles % 100) / 10;
3491: f7 e6 mul %esi
3493: 89 f0 mov %esi,%eax
3495: c1 ea 05 shr $0x5,%edx
3498: 6b d2 64 imul $0x64,%edx,%edx
349b: 29 d0 sub %edx,%eax
349d: f7 e1 mul %ecx
name[4] = '0' + (nfiles % 10);
349f: 89 f0 mov %esi,%eax
name[3] = '0' + (nfiles % 100) / 10;
34a1: c1 ea 03 shr $0x3,%edx
34a4: 83 c2 30 add $0x30,%edx
34a7: 88 55 ab mov %dl,-0x55(%ebp)
name[4] = '0' + (nfiles % 10);
34aa: f7 e1 mul %ecx
34ac: 89 f1 mov %esi,%ecx
34ae: c1 ea 03 shr $0x3,%edx
34b1: 8d 04 92 lea (%edx,%edx,4),%eax
34b4: 01 c0 add %eax,%eax
34b6: 29 c1 sub %eax,%ecx
34b8: 89 c8 mov %ecx,%eax
34ba: 83 c0 30 add $0x30,%eax
34bd: 88 45 ac mov %al,-0x54(%ebp)
printf(1, "writing %s\n", name);
34c0: 8d 45 a8 lea -0x58(%ebp),%eax
34c3: 50 push %eax
34c4: 68 c8 4d 00 00 push $0x4dc8
34c9: 6a 01 push $0x1
34cb: e8 20 06 00 00 call 3af0 <printf>
int fd = open(name, O_CREATE|O_RDWR);
34d0: 58 pop %eax
34d1: 8d 45 a8 lea -0x58(%ebp),%eax
34d4: 5a pop %edx
34d5: 68 02 02 00 00 push $0x202
34da: 50 push %eax
34db: e8 eb 04 00 00 call 39cb <open>
if(fd < 0){
34e0: 83 c4 10 add $0x10,%esp
int fd = open(name, O_CREATE|O_RDWR);
34e3: 89 c7 mov %eax,%edi
if(fd < 0){
34e5: 85 c0 test %eax,%eax
34e7: 78 4d js 3536 <fsfull+0x106>
int total = 0;
34e9: 31 db xor %ebx,%ebx
34eb: eb 05 jmp 34f2 <fsfull+0xc2>
34ed: 8d 76 00 lea 0x0(%esi),%esi
total += cc;
34f0: 01 c3 add %eax,%ebx
int cc = write(fd, buf, 512);
34f2: 83 ec 04 sub $0x4,%esp
34f5: 68 00 02 00 00 push $0x200
34fa: 68 e0 86 00 00 push $0x86e0
34ff: 57 push %edi
3500: e8 a6 04 00 00 call 39ab <write>
if(cc < 512)
3505: 83 c4 10 add $0x10,%esp
3508: 3d ff 01 00 00 cmp $0x1ff,%eax
350d: 7f e1 jg 34f0 <fsfull+0xc0>
printf(1, "wrote %d bytes\n", total);
350f: 83 ec 04 sub $0x4,%esp
3512: 53 push %ebx
3513: 68 e4 4d 00 00 push $0x4de4
3518: 6a 01 push $0x1
351a: e8 d1 05 00 00 call 3af0 <printf>
close(fd);
351f: 89 3c 24 mov %edi,(%esp)
3522: e8 8c 04 00 00 call 39b3 <close>
if(total == 0)
3527: 83 c4 10 add $0x10,%esp
352a: 85 db test %ebx,%ebx
352c: 74 1e je 354c <fsfull+0x11c>
for(nfiles = 0; ; nfiles++){
352e: 83 c6 01 add $0x1,%esi
3531: e9 1a ff ff ff jmp 3450 <fsfull+0x20>
printf(1, "open %s failed\n", name);
3536: 83 ec 04 sub $0x4,%esp
3539: 8d 45 a8 lea -0x58(%ebp),%eax
353c: 50 push %eax
353d: 68 d4 4d 00 00 push $0x4dd4
3542: 6a 01 push $0x1
3544: e8 a7 05 00 00 call 3af0 <printf>
break;
3549: 83 c4 10 add $0x10,%esp
name[1] = '0' + nfiles / 1000;
354c: bf d3 4d 62 10 mov $0x10624dd3,%edi
name[2] = '0' + (nfiles % 1000) / 100;
3551: bb 1f 85 eb 51 mov $0x51eb851f,%ebx
3556: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
355d: 8d 76 00 lea 0x0(%esi),%esi
name[1] = '0' + nfiles / 1000;
3560: 89 f0 mov %esi,%eax
3562: 89 f1 mov %esi,%ecx
unlink(name);
3564: 83 ec 0c sub $0xc,%esp
name[0] = 'f';
3567: c6 45 a8 66 movb $0x66,-0x58(%ebp)
name[1] = '0' + nfiles / 1000;
356b: f7 ef imul %edi
356d: c1 f9 1f sar $0x1f,%ecx
name[5] = '\0';
3570: c6 45 ad 00 movb $0x0,-0x53(%ebp)
name[1] = '0' + nfiles / 1000;
3574: c1 fa 06 sar $0x6,%edx
3577: 29 ca sub %ecx,%edx
3579: 8d 42 30 lea 0x30(%edx),%eax
name[2] = '0' + (nfiles % 1000) / 100;
357c: 69 d2 e8 03 00 00 imul $0x3e8,%edx,%edx
name[1] = '0' + nfiles / 1000;
3582: 88 45 a9 mov %al,-0x57(%ebp)
name[2] = '0' + (nfiles % 1000) / 100;
3585: 89 f0 mov %esi,%eax
3587: 29 d0 sub %edx,%eax
3589: f7 e3 mul %ebx
name[3] = '0' + (nfiles % 100) / 10;
358b: 89 f0 mov %esi,%eax
name[2] = '0' + (nfiles % 1000) / 100;
358d: c1 ea 05 shr $0x5,%edx
3590: 83 c2 30 add $0x30,%edx
3593: 88 55 aa mov %dl,-0x56(%ebp)
name[3] = '0' + (nfiles % 100) / 10;
3596: f7 eb imul %ebx
3598: 89 f0 mov %esi,%eax
359a: c1 fa 05 sar $0x5,%edx
359d: 29 ca sub %ecx,%edx
359f: 6b d2 64 imul $0x64,%edx,%edx
35a2: 29 d0 sub %edx,%eax
35a4: ba cd cc cc cc mov $0xcccccccd,%edx
35a9: f7 e2 mul %edx
name[4] = '0' + (nfiles % 10);
35ab: 89 f0 mov %esi,%eax
name[3] = '0' + (nfiles % 100) / 10;
35ad: c1 ea 03 shr $0x3,%edx
35b0: 83 c2 30 add $0x30,%edx
35b3: 88 55 ab mov %dl,-0x55(%ebp)
name[4] = '0' + (nfiles % 10);
35b6: ba 67 66 66 66 mov $0x66666667,%edx
35bb: f7 ea imul %edx
35bd: c1 fa 02 sar $0x2,%edx
35c0: 29 ca sub %ecx,%edx
35c2: 89 f1 mov %esi,%ecx
nfiles--;
35c4: 83 ee 01 sub $0x1,%esi
name[4] = '0' + (nfiles % 10);
35c7: 8d 04 92 lea (%edx,%edx,4),%eax
35ca: 01 c0 add %eax,%eax
35cc: 29 c1 sub %eax,%ecx
35ce: 89 c8 mov %ecx,%eax
35d0: 83 c0 30 add $0x30,%eax
35d3: 88 45 ac mov %al,-0x54(%ebp)
unlink(name);
35d6: 8d 45 a8 lea -0x58(%ebp),%eax
35d9: 50 push %eax
35da: e8 fc 03 00 00 call 39db <unlink>
while(nfiles >= 0){
35df: 83 c4 10 add $0x10,%esp
35e2: 83 fe ff cmp $0xffffffff,%esi
35e5: 0f 85 75 ff ff ff jne 3560 <fsfull+0x130>
printf(1, "fsfull test finished\n");
35eb: 83 ec 08 sub $0x8,%esp
35ee: 68 f4 4d 00 00 push $0x4df4
35f3: 6a 01 push $0x1
35f5: e8 f6 04 00 00 call 3af0 <printf>
}
35fa: 83 c4 10 add $0x10,%esp
35fd: 8d 65 f4 lea -0xc(%ebp),%esp
3600: 5b pop %ebx
3601: 5e pop %esi
3602: 5f pop %edi
3603: 5d pop %ebp
3604: c3 ret
3605: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
360c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
00003610 <uio>:
{
3610: f3 0f 1e fb endbr32
3614: 55 push %ebp
3615: 89 e5 mov %esp,%ebp
3617: 83 ec 10 sub $0x10,%esp
printf(1, "uio test\n");
361a: 68 0a 4e 00 00 push $0x4e0a
361f: 6a 01 push $0x1
3621: e8 ca 04 00 00 call 3af0 <printf>
pid = fork();
3626: e8 50 03 00 00 call 397b <fork>
if(pid == 0){
362b: 83 c4 10 add $0x10,%esp
362e: 85 c0 test %eax,%eax
3630: 74 1b je 364d <uio+0x3d>
} else if(pid < 0){
3632: 78 3d js 3671 <uio+0x61>
wait();
3634: e8 52 03 00 00 call 398b <wait>
printf(1, "uio test done\n");
3639: 83 ec 08 sub $0x8,%esp
363c: 68 14 4e 00 00 push $0x4e14
3641: 6a 01 push $0x1
3643: e8 a8 04 00 00 call 3af0 <printf>
}
3648: 83 c4 10 add $0x10,%esp
364b: c9 leave
364c: c3 ret
asm volatile("outb %0,%1"::"a"(val), "d" (port));
364d: b8 09 00 00 00 mov $0x9,%eax
3652: ba 70 00 00 00 mov $0x70,%edx
3657: ee out %al,(%dx)
asm volatile("inb %1,%0" : "=a" (val) : "d" (port));
3658: ba 71 00 00 00 mov $0x71,%edx
365d: ec in (%dx),%al
printf(1, "uio: uio succeeded; test FAILED\n");
365e: 52 push %edx
365f: 52 push %edx
3660: 68 a0 55 00 00 push $0x55a0
3665: 6a 01 push $0x1
3667: e8 84 04 00 00 call 3af0 <printf>
exit();
366c: e8 12 03 00 00 call 3983 <exit>
printf (1, "fork failed\n");
3671: 50 push %eax
3672: 50 push %eax
3673: 68 99 4d 00 00 push $0x4d99
3678: 6a 01 push $0x1
367a: e8 71 04 00 00 call 3af0 <printf>
exit();
367f: e8 ff 02 00 00 call 3983 <exit>
3684: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
368b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
368f: 90 nop
00003690 <argptest>:
{
3690: f3 0f 1e fb endbr32
3694: 55 push %ebp
3695: 89 e5 mov %esp,%ebp
3697: 53 push %ebx
3698: 83 ec 0c sub $0xc,%esp
fd = open("init", O_RDONLY);
369b: 6a 00 push $0x0
369d: 68 23 4e 00 00 push $0x4e23
36a2: e8 24 03 00 00 call 39cb <open>
if (fd < 0) {
36a7: 83 c4 10 add $0x10,%esp
36aa: 85 c0 test %eax,%eax
36ac: 78 39 js 36e7 <argptest+0x57>
read(fd, sbrk(0) - 1, -1);
36ae: 83 ec 0c sub $0xc,%esp
36b1: 89 c3 mov %eax,%ebx
36b3: 6a 00 push $0x0
36b5: e8 59 03 00 00 call 3a13 <sbrk>
36ba: 83 c4 0c add $0xc,%esp
36bd: 83 e8 01 sub $0x1,%eax
36c0: 6a ff push $0xffffffff
36c2: 50 push %eax
36c3: 53 push %ebx
36c4: e8 da 02 00 00 call 39a3 <read>
close(fd);
36c9: 89 1c 24 mov %ebx,(%esp)
36cc: e8 e2 02 00 00 call 39b3 <close>
printf(1, "arg test passed\n");
36d1: 58 pop %eax
36d2: 5a pop %edx
36d3: 68 35 4e 00 00 push $0x4e35
36d8: 6a 01 push $0x1
36da: e8 11 04 00 00 call 3af0 <printf>
}
36df: 8b 5d fc mov -0x4(%ebp),%ebx
36e2: 83 c4 10 add $0x10,%esp
36e5: c9 leave
36e6: c3 ret
printf(2, "open failed\n");
36e7: 51 push %ecx
36e8: 51 push %ecx
36e9: 68 28 4e 00 00 push $0x4e28
36ee: 6a 02 push $0x2
36f0: e8 fb 03 00 00 call 3af0 <printf>
exit();
36f5: e8 89 02 00 00 call 3983 <exit>
36fa: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
00003700 <rand>:
{
3700: f3 0f 1e fb endbr32
randstate = randstate * 1664525 + 1013904223;
3704: 69 05 ec 5e 00 00 0d imul $0x19660d,0x5eec,%eax
370b: 66 19 00
370e: 05 5f f3 6e 3c add $0x3c6ef35f,%eax
3713: a3 ec 5e 00 00 mov %eax,0x5eec
}
3718: c3 ret
3719: 66 90 xchg %ax,%ax
371b: 66 90 xchg %ax,%ax
371d: 66 90 xchg %ax,%ax
371f: 90 nop
00003720 <strcpy>:
#include "user.h"
#include "x86.h"
char*
strcpy(char *s, const char *t)
{
3720: f3 0f 1e fb endbr32
3724: 55 push %ebp
char *os;
os = s;
while((*s++ = *t++) != 0)
3725: 31 c0 xor %eax,%eax
{
3727: 89 e5 mov %esp,%ebp
3729: 53 push %ebx
372a: 8b 4d 08 mov 0x8(%ebp),%ecx
372d: 8b 5d 0c mov 0xc(%ebp),%ebx
while((*s++ = *t++) != 0)
3730: 0f b6 14 03 movzbl (%ebx,%eax,1),%edx
3734: 88 14 01 mov %dl,(%ecx,%eax,1)
3737: 83 c0 01 add $0x1,%eax
373a: 84 d2 test %dl,%dl
373c: 75 f2 jne 3730 <strcpy+0x10>
;
return os;
}
373e: 89 c8 mov %ecx,%eax
3740: 5b pop %ebx
3741: 5d pop %ebp
3742: c3 ret
3743: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
374a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
00003750 <strcmp>:
int
strcmp(const char *p, const char *q)
{
3750: f3 0f 1e fb endbr32
3754: 55 push %ebp
3755: 89 e5 mov %esp,%ebp
3757: 53 push %ebx
3758: 8b 4d 08 mov 0x8(%ebp),%ecx
375b: 8b 55 0c mov 0xc(%ebp),%edx
while(*p && *p == *q)
375e: 0f b6 01 movzbl (%ecx),%eax
3761: 0f b6 1a movzbl (%edx),%ebx
3764: 84 c0 test %al,%al
3766: 75 19 jne 3781 <strcmp+0x31>
3768: eb 26 jmp 3790 <strcmp+0x40>
376a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
3770: 0f b6 41 01 movzbl 0x1(%ecx),%eax
p++, q++;
3774: 83 c1 01 add $0x1,%ecx
3777: 83 c2 01 add $0x1,%edx
while(*p && *p == *q)
377a: 0f b6 1a movzbl (%edx),%ebx
377d: 84 c0 test %al,%al
377f: 74 0f je 3790 <strcmp+0x40>
3781: 38 d8 cmp %bl,%al
3783: 74 eb je 3770 <strcmp+0x20>
return (uchar)*p - (uchar)*q;
3785: 29 d8 sub %ebx,%eax
}
3787: 5b pop %ebx
3788: 5d pop %ebp
3789: c3 ret
378a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
3790: 31 c0 xor %eax,%eax
return (uchar)*p - (uchar)*q;
3792: 29 d8 sub %ebx,%eax
}
3794: 5b pop %ebx
3795: 5d pop %ebp
3796: c3 ret
3797: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
379e: 66 90 xchg %ax,%ax
000037a0 <strlen>:
uint
strlen(const char *s)
{
37a0: f3 0f 1e fb endbr32
37a4: 55 push %ebp
37a5: 89 e5 mov %esp,%ebp
37a7: 8b 55 08 mov 0x8(%ebp),%edx
int n;
for(n = 0; s[n]; n++)
37aa: 80 3a 00 cmpb $0x0,(%edx)
37ad: 74 21 je 37d0 <strlen+0x30>
37af: 31 c0 xor %eax,%eax
37b1: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
37b8: 83 c0 01 add $0x1,%eax
37bb: 80 3c 02 00 cmpb $0x0,(%edx,%eax,1)
37bf: 89 c1 mov %eax,%ecx
37c1: 75 f5 jne 37b8 <strlen+0x18>
;
return n;
}
37c3: 89 c8 mov %ecx,%eax
37c5: 5d pop %ebp
37c6: c3 ret
37c7: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
37ce: 66 90 xchg %ax,%ax
for(n = 0; s[n]; n++)
37d0: 31 c9 xor %ecx,%ecx
}
37d2: 5d pop %ebp
37d3: 89 c8 mov %ecx,%eax
37d5: c3 ret
37d6: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
37dd: 8d 76 00 lea 0x0(%esi),%esi
000037e0 <memset>:
void*
memset(void *dst, int c, uint n)
{
37e0: f3 0f 1e fb endbr32
37e4: 55 push %ebp
37e5: 89 e5 mov %esp,%ebp
37e7: 57 push %edi
37e8: 8b 55 08 mov 0x8(%ebp),%edx
}
static inline void
stosb(void *addr, int data, int cnt)
{
asm volatile("cld; rep stosb" :
37eb: 8b 4d 10 mov 0x10(%ebp),%ecx
37ee: 8b 45 0c mov 0xc(%ebp),%eax
37f1: 89 d7 mov %edx,%edi
37f3: fc cld
37f4: f3 aa rep stos %al,%es:(%edi)
stosb(dst, c, n);
return dst;
}
37f6: 89 d0 mov %edx,%eax
37f8: 5f pop %edi
37f9: 5d pop %ebp
37fa: c3 ret
37fb: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
37ff: 90 nop
00003800 <strchr>:
char*
strchr(const char *s, char c)
{
3800: f3 0f 1e fb endbr32
3804: 55 push %ebp
3805: 89 e5 mov %esp,%ebp
3807: 8b 45 08 mov 0x8(%ebp),%eax
380a: 0f b6 4d 0c movzbl 0xc(%ebp),%ecx
for(; *s; s++)
380e: 0f b6 10 movzbl (%eax),%edx
3811: 84 d2 test %dl,%dl
3813: 75 16 jne 382b <strchr+0x2b>
3815: eb 21 jmp 3838 <strchr+0x38>
3817: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
381e: 66 90 xchg %ax,%ax
3820: 0f b6 50 01 movzbl 0x1(%eax),%edx
3824: 83 c0 01 add $0x1,%eax
3827: 84 d2 test %dl,%dl
3829: 74 0d je 3838 <strchr+0x38>
if(*s == c)
382b: 38 d1 cmp %dl,%cl
382d: 75 f1 jne 3820 <strchr+0x20>
return (char*)s;
return 0;
}
382f: 5d pop %ebp
3830: c3 ret
3831: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
return 0;
3838: 31 c0 xor %eax,%eax
}
383a: 5d pop %ebp
383b: c3 ret
383c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
00003840 <gets>:
char*
gets(char *buf, int max)
{
3840: f3 0f 1e fb endbr32
3844: 55 push %ebp
3845: 89 e5 mov %esp,%ebp
3847: 57 push %edi
3848: 56 push %esi
int i, cc;
char c;
for(i=0; i+1 < max; ){
3849: 31 f6 xor %esi,%esi
{
384b: 53 push %ebx
384c: 89 f3 mov %esi,%ebx
384e: 83 ec 1c sub $0x1c,%esp
3851: 8b 7d 08 mov 0x8(%ebp),%edi
for(i=0; i+1 < max; ){
3854: eb 33 jmp 3889 <gets+0x49>
3856: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
385d: 8d 76 00 lea 0x0(%esi),%esi
cc = read(0, &c, 1);
3860: 83 ec 04 sub $0x4,%esp
3863: 8d 45 e7 lea -0x19(%ebp),%eax
3866: 6a 01 push $0x1
3868: 50 push %eax
3869: 6a 00 push $0x0
386b: e8 33 01 00 00 call 39a3 <read>
if(cc < 1)
3870: 83 c4 10 add $0x10,%esp
3873: 85 c0 test %eax,%eax
3875: 7e 1c jle 3893 <gets+0x53>
break;
buf[i++] = c;
3877: 0f b6 45 e7 movzbl -0x19(%ebp),%eax
387b: 83 c7 01 add $0x1,%edi
387e: 88 47 ff mov %al,-0x1(%edi)
if(c == '\n' || c == '\r')
3881: 3c 0a cmp $0xa,%al
3883: 74 23 je 38a8 <gets+0x68>
3885: 3c 0d cmp $0xd,%al
3887: 74 1f je 38a8 <gets+0x68>
for(i=0; i+1 < max; ){
3889: 83 c3 01 add $0x1,%ebx
388c: 89 fe mov %edi,%esi
388e: 3b 5d 0c cmp 0xc(%ebp),%ebx
3891: 7c cd jl 3860 <gets+0x20>
3893: 89 f3 mov %esi,%ebx
break;
}
buf[i] = '\0';
return buf;
}
3895: 8b 45 08 mov 0x8(%ebp),%eax
buf[i] = '\0';
3898: c6 03 00 movb $0x0,(%ebx)
}
389b: 8d 65 f4 lea -0xc(%ebp),%esp
389e: 5b pop %ebx
389f: 5e pop %esi
38a0: 5f pop %edi
38a1: 5d pop %ebp
38a2: c3 ret
38a3: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
38a7: 90 nop
38a8: 8b 75 08 mov 0x8(%ebp),%esi
38ab: 8b 45 08 mov 0x8(%ebp),%eax
38ae: 01 de add %ebx,%esi
38b0: 89 f3 mov %esi,%ebx
buf[i] = '\0';
38b2: c6 03 00 movb $0x0,(%ebx)
}
38b5: 8d 65 f4 lea -0xc(%ebp),%esp
38b8: 5b pop %ebx
38b9: 5e pop %esi
38ba: 5f pop %edi
38bb: 5d pop %ebp
38bc: c3 ret
38bd: 8d 76 00 lea 0x0(%esi),%esi
000038c0 <stat>:
int
stat(const char *n, struct stat *st)
{
38c0: f3 0f 1e fb endbr32
38c4: 55 push %ebp
38c5: 89 e5 mov %esp,%ebp
38c7: 56 push %esi
38c8: 53 push %ebx
int fd;
int r;
fd = open(n, O_RDONLY);
38c9: 83 ec 08 sub $0x8,%esp
38cc: 6a 00 push $0x0
38ce: ff 75 08 pushl 0x8(%ebp)
38d1: e8 f5 00 00 00 call 39cb <open>
if(fd < 0)
38d6: 83 c4 10 add $0x10,%esp
38d9: 85 c0 test %eax,%eax
38db: 78 2b js 3908 <stat+0x48>
return -1;
r = fstat(fd, st);
38dd: 83 ec 08 sub $0x8,%esp
38e0: ff 75 0c pushl 0xc(%ebp)
38e3: 89 c3 mov %eax,%ebx
38e5: 50 push %eax
38e6: e8 f8 00 00 00 call 39e3 <fstat>
close(fd);
38eb: 89 1c 24 mov %ebx,(%esp)
r = fstat(fd, st);
38ee: 89 c6 mov %eax,%esi
close(fd);
38f0: e8 be 00 00 00 call 39b3 <close>
return r;
38f5: 83 c4 10 add $0x10,%esp
}
38f8: 8d 65 f8 lea -0x8(%ebp),%esp
38fb: 89 f0 mov %esi,%eax
38fd: 5b pop %ebx
38fe: 5e pop %esi
38ff: 5d pop %ebp
3900: c3 ret
3901: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
return -1;
3908: be ff ff ff ff mov $0xffffffff,%esi
390d: eb e9 jmp 38f8 <stat+0x38>
390f: 90 nop
00003910 <atoi>:
int
atoi(const char *s)
{
3910: f3 0f 1e fb endbr32
3914: 55 push %ebp
3915: 89 e5 mov %esp,%ebp
3917: 53 push %ebx
3918: 8b 55 08 mov 0x8(%ebp),%edx
int n;
n = 0;
while('0' <= *s && *s <= '9')
391b: 0f be 02 movsbl (%edx),%eax
391e: 8d 48 d0 lea -0x30(%eax),%ecx
3921: 80 f9 09 cmp $0x9,%cl
n = 0;
3924: b9 00 00 00 00 mov $0x0,%ecx
while('0' <= *s && *s <= '9')
3929: 77 1a ja 3945 <atoi+0x35>
392b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
392f: 90 nop
n = n*10 + *s++ - '0';
3930: 83 c2 01 add $0x1,%edx
3933: 8d 0c 89 lea (%ecx,%ecx,4),%ecx
3936: 8d 4c 48 d0 lea -0x30(%eax,%ecx,2),%ecx
while('0' <= *s && *s <= '9')
393a: 0f be 02 movsbl (%edx),%eax
393d: 8d 58 d0 lea -0x30(%eax),%ebx
3940: 80 fb 09 cmp $0x9,%bl
3943: 76 eb jbe 3930 <atoi+0x20>
return n;
}
3945: 89 c8 mov %ecx,%eax
3947: 5b pop %ebx
3948: 5d pop %ebp
3949: c3 ret
394a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
00003950 <memmove>:
void*
memmove(void *vdst, const void *vsrc, int n)
{
3950: f3 0f 1e fb endbr32
3954: 55 push %ebp
3955: 89 e5 mov %esp,%ebp
3957: 57 push %edi
3958: 8b 45 10 mov 0x10(%ebp),%eax
395b: 8b 55 08 mov 0x8(%ebp),%edx
395e: 56 push %esi
395f: 8b 75 0c mov 0xc(%ebp),%esi
char *dst;
const char *src;
dst = vdst;
src = vsrc;
while(n-- > 0)
3962: 85 c0 test %eax,%eax
3964: 7e 0f jle 3975 <memmove+0x25>
3966: 01 d0 add %edx,%eax
dst = vdst;
3968: 89 d7 mov %edx,%edi
396a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
*dst++ = *src++;
3970: a4 movsb %ds:(%esi),%es:(%edi)
while(n-- > 0)
3971: 39 f8 cmp %edi,%eax
3973: 75 fb jne 3970 <memmove+0x20>
return vdst;
}
3975: 5e pop %esi
3976: 89 d0 mov %edx,%eax
3978: 5f pop %edi
3979: 5d pop %ebp
397a: c3 ret
0000397b <fork>:
name: \
movl $SYS_ ## name, %eax; \
int $T_SYSCALL; \
ret
SYSCALL(fork)
397b: b8 01 00 00 00 mov $0x1,%eax
3980: cd 40 int $0x40
3982: c3 ret
00003983 <exit>:
SYSCALL(exit)
3983: b8 02 00 00 00 mov $0x2,%eax
3988: cd 40 int $0x40
398a: c3 ret
0000398b <wait>:
SYSCALL(wait)
398b: b8 03 00 00 00 mov $0x3,%eax
3990: cd 40 int $0x40
3992: c3 ret
00003993 <waitx>:
SYSCALL(waitx) //changed
3993: b8 16 00 00 00 mov $0x16,%eax
3998: cd 40 int $0x40
399a: c3 ret
0000399b <pipe>:
SYSCALL(pipe)
399b: b8 04 00 00 00 mov $0x4,%eax
39a0: cd 40 int $0x40
39a2: c3 ret
000039a3 <read>:
SYSCALL(read)
39a3: b8 05 00 00 00 mov $0x5,%eax
39a8: cd 40 int $0x40
39aa: c3 ret
000039ab <write>:
SYSCALL(write)
39ab: b8 10 00 00 00 mov $0x10,%eax
39b0: cd 40 int $0x40
39b2: c3 ret
000039b3 <close>:
SYSCALL(close)
39b3: b8 15 00 00 00 mov $0x15,%eax
39b8: cd 40 int $0x40
39ba: c3 ret
000039bb <kill>:
SYSCALL(kill)
39bb: b8 06 00 00 00 mov $0x6,%eax
39c0: cd 40 int $0x40
39c2: c3 ret
000039c3 <exec>:
SYSCALL(exec)
39c3: b8 07 00 00 00 mov $0x7,%eax
39c8: cd 40 int $0x40
39ca: c3 ret
000039cb <open>:
SYSCALL(open)
39cb: b8 0f 00 00 00 mov $0xf,%eax
39d0: cd 40 int $0x40
39d2: c3 ret
000039d3 <mknod>:
SYSCALL(mknod)
39d3: b8 11 00 00 00 mov $0x11,%eax
39d8: cd 40 int $0x40
39da: c3 ret
000039db <unlink>:
SYSCALL(unlink)
39db: b8 12 00 00 00 mov $0x12,%eax
39e0: cd 40 int $0x40
39e2: c3 ret
000039e3 <fstat>:
SYSCALL(fstat)
39e3: b8 08 00 00 00 mov $0x8,%eax
39e8: cd 40 int $0x40
39ea: c3 ret
000039eb <link>:
SYSCALL(link)
39eb: b8 13 00 00 00 mov $0x13,%eax
39f0: cd 40 int $0x40
39f2: c3 ret
000039f3 <mkdir>:
SYSCALL(mkdir)
39f3: b8 14 00 00 00 mov $0x14,%eax
39f8: cd 40 int $0x40
39fa: c3 ret
000039fb <chdir>:
SYSCALL(chdir)
39fb: b8 09 00 00 00 mov $0x9,%eax
3a00: cd 40 int $0x40
3a02: c3 ret
00003a03 <dup>:
SYSCALL(dup)
3a03: b8 0a 00 00 00 mov $0xa,%eax
3a08: cd 40 int $0x40
3a0a: c3 ret
00003a0b <getpid>:
SYSCALL(getpid)
3a0b: b8 0b 00 00 00 mov $0xb,%eax
3a10: cd 40 int $0x40
3a12: c3 ret
00003a13 <sbrk>:
SYSCALL(sbrk)
3a13: b8 0c 00 00 00 mov $0xc,%eax
3a18: cd 40 int $0x40
3a1a: c3 ret
00003a1b <sleep>:
SYSCALL(sleep)
3a1b: b8 0d 00 00 00 mov $0xd,%eax
3a20: cd 40 int $0x40
3a22: c3 ret
00003a23 <uptime>:
SYSCALL(uptime)
3a23: b8 0e 00 00 00 mov $0xe,%eax
3a28: cd 40 int $0x40
3a2a: c3 ret
00003a2b <ps>:
SYSCALL(ps)
3a2b: b8 17 00 00 00 mov $0x17,%eax
3a30: cd 40 int $0x40
3a32: c3 ret
00003a33 <set_priority>:
3a33: b8 18 00 00 00 mov $0x18,%eax
3a38: cd 40 int $0x40
3a3a: c3 ret
3a3b: 66 90 xchg %ax,%ax
3a3d: 66 90 xchg %ax,%ax
3a3f: 90 nop
00003a40 <printint>:
write(fd, &c, 1);
}
static void
printint(int fd, int xx, int base, int sgn)
{
3a40: 55 push %ebp
3a41: 89 e5 mov %esp,%ebp
3a43: 57 push %edi
3a44: 56 push %esi
3a45: 53 push %ebx
3a46: 83 ec 3c sub $0x3c,%esp
3a49: 89 4d c4 mov %ecx,-0x3c(%ebp)
uint x;
neg = 0;
if(sgn && xx < 0){
neg = 1;
x = -xx;
3a4c: 89 d1 mov %edx,%ecx
{
3a4e: 89 45 b8 mov %eax,-0x48(%ebp)
if(sgn && xx < 0){
3a51: 85 d2 test %edx,%edx
3a53: 0f 89 7f 00 00 00 jns 3ad8 <printint+0x98>
3a59: f6 45 08 01 testb $0x1,0x8(%ebp)
3a5d: 74 79 je 3ad8 <printint+0x98>
neg = 1;
3a5f: c7 45 bc 01 00 00 00 movl $0x1,-0x44(%ebp)
x = -xx;
3a66: f7 d9 neg %ecx
} else {
x = xx;
}
i = 0;
3a68: 31 db xor %ebx,%ebx
3a6a: 8d 75 d7 lea -0x29(%ebp),%esi
3a6d: 8d 76 00 lea 0x0(%esi),%esi
do{
buf[i++] = digits[x % base];
3a70: 89 c8 mov %ecx,%eax
3a72: 31 d2 xor %edx,%edx
3a74: 89 cf mov %ecx,%edi
3a76: f7 75 c4 divl -0x3c(%ebp)
3a79: 0f b6 92 f8 55 00 00 movzbl 0x55f8(%edx),%edx
3a80: 89 45 c0 mov %eax,-0x40(%ebp)
3a83: 89 d8 mov %ebx,%eax
3a85: 8d 5b 01 lea 0x1(%ebx),%ebx
}while((x /= base) != 0);
3a88: 8b 4d c0 mov -0x40(%ebp),%ecx
buf[i++] = digits[x % base];
3a8b: 88 14 1e mov %dl,(%esi,%ebx,1)
}while((x /= base) != 0);
3a8e: 39 7d c4 cmp %edi,-0x3c(%ebp)
3a91: 76 dd jbe 3a70 <printint+0x30>
if(neg)
3a93: 8b 4d bc mov -0x44(%ebp),%ecx
3a96: 85 c9 test %ecx,%ecx
3a98: 74 0c je 3aa6 <printint+0x66>
buf[i++] = '-';
3a9a: c6 44 1d d8 2d movb $0x2d,-0x28(%ebp,%ebx,1)
buf[i++] = digits[x % base];
3a9f: 89 d8 mov %ebx,%eax
buf[i++] = '-';
3aa1: ba 2d 00 00 00 mov $0x2d,%edx
while(--i >= 0)
3aa6: 8b 7d b8 mov -0x48(%ebp),%edi
3aa9: 8d 5c 05 d7 lea -0x29(%ebp,%eax,1),%ebx
3aad: eb 07 jmp 3ab6 <printint+0x76>
3aaf: 90 nop
3ab0: 0f b6 13 movzbl (%ebx),%edx
3ab3: 83 eb 01 sub $0x1,%ebx
write(fd, &c, 1);
3ab6: 83 ec 04 sub $0x4,%esp
3ab9: 88 55 d7 mov %dl,-0x29(%ebp)
3abc: 6a 01 push $0x1
3abe: 56 push %esi
3abf: 57 push %edi
3ac0: e8 e6 fe ff ff call 39ab <write>
while(--i >= 0)
3ac5: 83 c4 10 add $0x10,%esp
3ac8: 39 de cmp %ebx,%esi
3aca: 75 e4 jne 3ab0 <printint+0x70>
putc(fd, buf[i]);
}
3acc: 8d 65 f4 lea -0xc(%ebp),%esp
3acf: 5b pop %ebx
3ad0: 5e pop %esi
3ad1: 5f pop %edi
3ad2: 5d pop %ebp
3ad3: c3 ret
3ad4: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
neg = 0;
3ad8: c7 45 bc 00 00 00 00 movl $0x0,-0x44(%ebp)
3adf: eb 87 jmp 3a68 <printint+0x28>
3ae1: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
3ae8: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
3aef: 90 nop
00003af0 <printf>:
// Print to the given fd. Only understands %d, %x, %p, %s.
void
printf(int fd, const char *fmt, ...)
{
3af0: f3 0f 1e fb endbr32
3af4: 55 push %ebp
3af5: 89 e5 mov %esp,%ebp
3af7: 57 push %edi
3af8: 56 push %esi
3af9: 53 push %ebx
3afa: 83 ec 2c sub $0x2c,%esp
int c, i, state;
uint *ap;
state = 0;
ap = (uint*)(void*)&fmt + 1;
for(i = 0; fmt[i]; i++){
3afd: 8b 75 0c mov 0xc(%ebp),%esi
3b00: 0f b6 1e movzbl (%esi),%ebx
3b03: 84 db test %bl,%bl
3b05: 0f 84 b4 00 00 00 je 3bbf <printf+0xcf>
ap = (uint*)(void*)&fmt + 1;
3b0b: 8d 45 10 lea 0x10(%ebp),%eax
3b0e: 83 c6 01 add $0x1,%esi
write(fd, &c, 1);
3b11: 8d 7d e7 lea -0x19(%ebp),%edi
state = 0;
3b14: 31 d2 xor %edx,%edx
ap = (uint*)(void*)&fmt + 1;
3b16: 89 45 d0 mov %eax,-0x30(%ebp)
3b19: eb 33 jmp 3b4e <printf+0x5e>
3b1b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
3b1f: 90 nop
3b20: 89 55 d4 mov %edx,-0x2c(%ebp)
c = fmt[i] & 0xff;
if(state == 0){
if(c == '%'){
state = '%';
3b23: ba 25 00 00 00 mov $0x25,%edx
if(c == '%'){
3b28: 83 f8 25 cmp $0x25,%eax
3b2b: 74 17 je 3b44 <printf+0x54>
write(fd, &c, 1);
3b2d: 83 ec 04 sub $0x4,%esp
3b30: 88 5d e7 mov %bl,-0x19(%ebp)
3b33: 6a 01 push $0x1
3b35: 57 push %edi
3b36: ff 75 08 pushl 0x8(%ebp)
3b39: e8 6d fe ff ff call 39ab <write>
3b3e: 8b 55 d4 mov -0x2c(%ebp),%edx
} else {
putc(fd, c);
3b41: 83 c4 10 add $0x10,%esp
for(i = 0; fmt[i]; i++){
3b44: 0f b6 1e movzbl (%esi),%ebx
3b47: 83 c6 01 add $0x1,%esi
3b4a: 84 db test %bl,%bl
3b4c: 74 71 je 3bbf <printf+0xcf>
c = fmt[i] & 0xff;
3b4e: 0f be cb movsbl %bl,%ecx
3b51: 0f b6 c3 movzbl %bl,%eax
if(state == 0){
3b54: 85 d2 test %edx,%edx
3b56: 74 c8 je 3b20 <printf+0x30>
}
} else if(state == '%'){
3b58: 83 fa 25 cmp $0x25,%edx
3b5b: 75 e7 jne 3b44 <printf+0x54>
if(c == 'd'){
3b5d: 83 f8 64 cmp $0x64,%eax
3b60: 0f 84 9a 00 00 00 je 3c00 <printf+0x110>
printint(fd, *ap, 10, 1);
ap++;
} else if(c == 'x' || c == 'p'){
3b66: 81 e1 f7 00 00 00 and $0xf7,%ecx
3b6c: 83 f9 70 cmp $0x70,%ecx
3b6f: 74 5f je 3bd0 <printf+0xe0>
printint(fd, *ap, 16, 0);
ap++;
} else if(c == 's'){
3b71: 83 f8 73 cmp $0x73,%eax
3b74: 0f 84 d6 00 00 00 je 3c50 <printf+0x160>
s = "(null)";
while(*s != 0){
putc(fd, *s);
s++;
}
} else if(c == 'c'){
3b7a: 83 f8 63 cmp $0x63,%eax
3b7d: 0f 84 8d 00 00 00 je 3c10 <printf+0x120>
putc(fd, *ap);
ap++;
} else if(c == '%'){
3b83: 83 f8 25 cmp $0x25,%eax
3b86: 0f 84 b4 00 00 00 je 3c40 <printf+0x150>
write(fd, &c, 1);
3b8c: 83 ec 04 sub $0x4,%esp
3b8f: c6 45 e7 25 movb $0x25,-0x19(%ebp)
3b93: 6a 01 push $0x1
3b95: 57 push %edi
3b96: ff 75 08 pushl 0x8(%ebp)
3b99: e8 0d fe ff ff call 39ab <write>
putc(fd, c);
} else {
// Unknown % sequence. Print it to draw attention.
putc(fd, '%');
putc(fd, c);
3b9e: 88 5d e7 mov %bl,-0x19(%ebp)
write(fd, &c, 1);
3ba1: 83 c4 0c add $0xc,%esp
3ba4: 6a 01 push $0x1
3ba6: 83 c6 01 add $0x1,%esi
3ba9: 57 push %edi
3baa: ff 75 08 pushl 0x8(%ebp)
3bad: e8 f9 fd ff ff call 39ab <write>
for(i = 0; fmt[i]; i++){
3bb2: 0f b6 5e ff movzbl -0x1(%esi),%ebx
putc(fd, c);
3bb6: 83 c4 10 add $0x10,%esp
}
state = 0;
3bb9: 31 d2 xor %edx,%edx
for(i = 0; fmt[i]; i++){
3bbb: 84 db test %bl,%bl
3bbd: 75 8f jne 3b4e <printf+0x5e>
}
}
}
3bbf: 8d 65 f4 lea -0xc(%ebp),%esp
3bc2: 5b pop %ebx
3bc3: 5e pop %esi
3bc4: 5f pop %edi
3bc5: 5d pop %ebp
3bc6: c3 ret
3bc7: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
3bce: 66 90 xchg %ax,%ax
printint(fd, *ap, 16, 0);
3bd0: 83 ec 0c sub $0xc,%esp
3bd3: b9 10 00 00 00 mov $0x10,%ecx
3bd8: 6a 00 push $0x0
3bda: 8b 5d d0 mov -0x30(%ebp),%ebx
3bdd: 8b 45 08 mov 0x8(%ebp),%eax
3be0: 8b 13 mov (%ebx),%edx
3be2: e8 59 fe ff ff call 3a40 <printint>
ap++;
3be7: 89 d8 mov %ebx,%eax
3be9: 83 c4 10 add $0x10,%esp
state = 0;
3bec: 31 d2 xor %edx,%edx
ap++;
3bee: 83 c0 04 add $0x4,%eax
3bf1: 89 45 d0 mov %eax,-0x30(%ebp)
3bf4: e9 4b ff ff ff jmp 3b44 <printf+0x54>
3bf9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
printint(fd, *ap, 10, 1);
3c00: 83 ec 0c sub $0xc,%esp
3c03: b9 0a 00 00 00 mov $0xa,%ecx
3c08: 6a 01 push $0x1
3c0a: eb ce jmp 3bda <printf+0xea>
3c0c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
putc(fd, *ap);
3c10: 8b 5d d0 mov -0x30(%ebp),%ebx
write(fd, &c, 1);
3c13: 83 ec 04 sub $0x4,%esp
putc(fd, *ap);
3c16: 8b 03 mov (%ebx),%eax
write(fd, &c, 1);
3c18: 6a 01 push $0x1
ap++;
3c1a: 83 c3 04 add $0x4,%ebx
write(fd, &c, 1);
3c1d: 57 push %edi
3c1e: ff 75 08 pushl 0x8(%ebp)
putc(fd, *ap);
3c21: 88 45 e7 mov %al,-0x19(%ebp)
write(fd, &c, 1);
3c24: e8 82 fd ff ff call 39ab <write>
ap++;
3c29: 89 5d d0 mov %ebx,-0x30(%ebp)
3c2c: 83 c4 10 add $0x10,%esp
state = 0;
3c2f: 31 d2 xor %edx,%edx
3c31: e9 0e ff ff ff jmp 3b44 <printf+0x54>
3c36: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
3c3d: 8d 76 00 lea 0x0(%esi),%esi
putc(fd, c);
3c40: 88 5d e7 mov %bl,-0x19(%ebp)
write(fd, &c, 1);
3c43: 83 ec 04 sub $0x4,%esp
3c46: e9 59 ff ff ff jmp 3ba4 <printf+0xb4>
3c4b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
3c4f: 90 nop
s = (char*)*ap;
3c50: 8b 45 d0 mov -0x30(%ebp),%eax
3c53: 8b 18 mov (%eax),%ebx
ap++;
3c55: 83 c0 04 add $0x4,%eax
3c58: 89 45 d0 mov %eax,-0x30(%ebp)
if(s == 0)
3c5b: 85 db test %ebx,%ebx
3c5d: 74 17 je 3c76 <printf+0x186>
while(*s != 0){
3c5f: 0f b6 03 movzbl (%ebx),%eax
state = 0;
3c62: 31 d2 xor %edx,%edx
while(*s != 0){
3c64: 84 c0 test %al,%al
3c66: 0f 84 d8 fe ff ff je 3b44 <printf+0x54>
3c6c: 89 75 d4 mov %esi,-0x2c(%ebp)
3c6f: 89 de mov %ebx,%esi
3c71: 8b 5d 08 mov 0x8(%ebp),%ebx
3c74: eb 1a jmp 3c90 <printf+0x1a0>
s = "(null)";
3c76: bb ee 55 00 00 mov $0x55ee,%ebx
while(*s != 0){
3c7b: 89 75 d4 mov %esi,-0x2c(%ebp)
3c7e: b8 28 00 00 00 mov $0x28,%eax
3c83: 89 de mov %ebx,%esi
3c85: 8b 5d 08 mov 0x8(%ebp),%ebx
3c88: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
3c8f: 90 nop
write(fd, &c, 1);
3c90: 83 ec 04 sub $0x4,%esp
s++;
3c93: 83 c6 01 add $0x1,%esi
3c96: 88 45 e7 mov %al,-0x19(%ebp)
write(fd, &c, 1);
3c99: 6a 01 push $0x1
3c9b: 57 push %edi
3c9c: 53 push %ebx
3c9d: e8 09 fd ff ff call 39ab <write>
while(*s != 0){
3ca2: 0f b6 06 movzbl (%esi),%eax
3ca5: 83 c4 10 add $0x10,%esp
3ca8: 84 c0 test %al,%al
3caa: 75 e4 jne 3c90 <printf+0x1a0>
3cac: 8b 75 d4 mov -0x2c(%ebp),%esi
state = 0;
3caf: 31 d2 xor %edx,%edx
3cb1: e9 8e fe ff ff jmp 3b44 <printf+0x54>
3cb6: 66 90 xchg %ax,%ax
3cb8: 66 90 xchg %ax,%ax
3cba: 66 90 xchg %ax,%ax
3cbc: 66 90 xchg %ax,%ax
3cbe: 66 90 xchg %ax,%ax
00003cc0 <free>:
static Header base;
static Header *freep;
void
free(void *ap)
{
3cc0: f3 0f 1e fb endbr32
3cc4: 55 push %ebp
Header *bp, *p;
bp = (Header*)ap - 1;
for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
3cc5: a1 a0 5f 00 00 mov 0x5fa0,%eax
{
3cca: 89 e5 mov %esp,%ebp
3ccc: 57 push %edi
3ccd: 56 push %esi
3cce: 53 push %ebx
3ccf: 8b 5d 08 mov 0x8(%ebp),%ebx
3cd2: 8b 10 mov (%eax),%edx
bp = (Header*)ap - 1;
3cd4: 8d 4b f8 lea -0x8(%ebx),%ecx
for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
3cd7: 39 c8 cmp %ecx,%eax
3cd9: 73 15 jae 3cf0 <free+0x30>
3cdb: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
3cdf: 90 nop
3ce0: 39 d1 cmp %edx,%ecx
3ce2: 72 14 jb 3cf8 <free+0x38>
if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
3ce4: 39 d0 cmp %edx,%eax
3ce6: 73 10 jae 3cf8 <free+0x38>
{
3ce8: 89 d0 mov %edx,%eax
for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
3cea: 8b 10 mov (%eax),%edx
3cec: 39 c8 cmp %ecx,%eax
3cee: 72 f0 jb 3ce0 <free+0x20>
if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
3cf0: 39 d0 cmp %edx,%eax
3cf2: 72 f4 jb 3ce8 <free+0x28>
3cf4: 39 d1 cmp %edx,%ecx
3cf6: 73 f0 jae 3ce8 <free+0x28>
break;
if(bp + bp->s.size == p->s.ptr){
3cf8: 8b 73 fc mov -0x4(%ebx),%esi
3cfb: 8d 3c f1 lea (%ecx,%esi,8),%edi
3cfe: 39 fa cmp %edi,%edx
3d00: 74 1e je 3d20 <free+0x60>
bp->s.size += p->s.ptr->s.size;
bp->s.ptr = p->s.ptr->s.ptr;
} else
bp->s.ptr = p->s.ptr;
3d02: 89 53 f8 mov %edx,-0x8(%ebx)
if(p + p->s.size == bp){
3d05: 8b 50 04 mov 0x4(%eax),%edx
3d08: 8d 34 d0 lea (%eax,%edx,8),%esi
3d0b: 39 f1 cmp %esi,%ecx
3d0d: 74 28 je 3d37 <free+0x77>
p->s.size += bp->s.size;
p->s.ptr = bp->s.ptr;
} else
p->s.ptr = bp;
3d0f: 89 08 mov %ecx,(%eax)
freep = p;
}
3d11: 5b pop %ebx
freep = p;
3d12: a3 a0 5f 00 00 mov %eax,0x5fa0
}
3d17: 5e pop %esi
3d18: 5f pop %edi
3d19: 5d pop %ebp
3d1a: c3 ret
3d1b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
3d1f: 90 nop
bp->s.size += p->s.ptr->s.size;
3d20: 03 72 04 add 0x4(%edx),%esi
3d23: 89 73 fc mov %esi,-0x4(%ebx)
bp->s.ptr = p->s.ptr->s.ptr;
3d26: 8b 10 mov (%eax),%edx
3d28: 8b 12 mov (%edx),%edx
3d2a: 89 53 f8 mov %edx,-0x8(%ebx)
if(p + p->s.size == bp){
3d2d: 8b 50 04 mov 0x4(%eax),%edx
3d30: 8d 34 d0 lea (%eax,%edx,8),%esi
3d33: 39 f1 cmp %esi,%ecx
3d35: 75 d8 jne 3d0f <free+0x4f>
p->s.size += bp->s.size;
3d37: 03 53 fc add -0x4(%ebx),%edx
freep = p;
3d3a: a3 a0 5f 00 00 mov %eax,0x5fa0
p->s.size += bp->s.size;
3d3f: 89 50 04 mov %edx,0x4(%eax)
p->s.ptr = bp->s.ptr;
3d42: 8b 53 f8 mov -0x8(%ebx),%edx
3d45: 89 10 mov %edx,(%eax)
}
3d47: 5b pop %ebx
3d48: 5e pop %esi
3d49: 5f pop %edi
3d4a: 5d pop %ebp
3d4b: c3 ret
3d4c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
00003d50 <malloc>:
return freep;
}
void*
malloc(uint nbytes)
{
3d50: f3 0f 1e fb endbr32
3d54: 55 push %ebp
3d55: 89 e5 mov %esp,%ebp
3d57: 57 push %edi
3d58: 56 push %esi
3d59: 53 push %ebx
3d5a: 83 ec 1c sub $0x1c,%esp
Header *p, *prevp;
uint nunits;
nunits = (nbytes + sizeof(Header) - 1)/sizeof(Header) + 1;
3d5d: 8b 45 08 mov 0x8(%ebp),%eax
if((prevp = freep) == 0){
3d60: 8b 3d a0 5f 00 00 mov 0x5fa0,%edi
nunits = (nbytes + sizeof(Header) - 1)/sizeof(Header) + 1;
3d66: 8d 70 07 lea 0x7(%eax),%esi
3d69: c1 ee 03 shr $0x3,%esi
3d6c: 83 c6 01 add $0x1,%esi
if((prevp = freep) == 0){
3d6f: 85 ff test %edi,%edi
3d71: 0f 84 a9 00 00 00 je 3e20 <malloc+0xd0>
base.s.ptr = freep = prevp = &base;
base.s.size = 0;
}
for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
3d77: 8b 07 mov (%edi),%eax
if(p->s.size >= nunits){
3d79: 8b 48 04 mov 0x4(%eax),%ecx
3d7c: 39 f1 cmp %esi,%ecx
3d7e: 73 6d jae 3ded <malloc+0x9d>
3d80: 81 fe 00 10 00 00 cmp $0x1000,%esi
3d86: bb 00 10 00 00 mov $0x1000,%ebx
3d8b: 0f 43 de cmovae %esi,%ebx
p = sbrk(nu * sizeof(Header));
3d8e: 8d 0c dd 00 00 00 00 lea 0x0(,%ebx,8),%ecx
3d95: 89 4d e4 mov %ecx,-0x1c(%ebp)
3d98: eb 17 jmp 3db1 <malloc+0x61>
3d9a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
3da0: 8b 10 mov (%eax),%edx
if(p->s.size >= nunits){
3da2: 8b 4a 04 mov 0x4(%edx),%ecx
3da5: 39 f1 cmp %esi,%ecx
3da7: 73 4f jae 3df8 <malloc+0xa8>
3da9: 8b 3d a0 5f 00 00 mov 0x5fa0,%edi
3daf: 89 d0 mov %edx,%eax
p->s.size = nunits;
}
freep = prevp;
return (void*)(p + 1);
}
if(p == freep)
3db1: 39 c7 cmp %eax,%edi
3db3: 75 eb jne 3da0 <malloc+0x50>
p = sbrk(nu * sizeof(Header));
3db5: 83 ec 0c sub $0xc,%esp
3db8: ff 75 e4 pushl -0x1c(%ebp)
3dbb: e8 53 fc ff ff call 3a13 <sbrk>
if(p == (char*)-1)
3dc0: 83 c4 10 add $0x10,%esp
3dc3: 83 f8 ff cmp $0xffffffff,%eax
3dc6: 74 1b je 3de3 <malloc+0x93>
hp->s.size = nu;
3dc8: 89 58 04 mov %ebx,0x4(%eax)
free((void*)(hp + 1));
3dcb: 83 ec 0c sub $0xc,%esp
3dce: 83 c0 08 add $0x8,%eax
3dd1: 50 push %eax
3dd2: e8 e9 fe ff ff call 3cc0 <free>
return freep;
3dd7: a1 a0 5f 00 00 mov 0x5fa0,%eax
if((p = morecore(nunits)) == 0)
3ddc: 83 c4 10 add $0x10,%esp
3ddf: 85 c0 test %eax,%eax
3de1: 75 bd jne 3da0 <malloc+0x50>
return 0;
}
}
3de3: 8d 65 f4 lea -0xc(%ebp),%esp
return 0;
3de6: 31 c0 xor %eax,%eax
}
3de8: 5b pop %ebx
3de9: 5e pop %esi
3dea: 5f pop %edi
3deb: 5d pop %ebp
3dec: c3 ret
if(p->s.size >= nunits){
3ded: 89 c2 mov %eax,%edx
3def: 89 f8 mov %edi,%eax
3df1: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
if(p->s.size == nunits)
3df8: 39 ce cmp %ecx,%esi
3dfa: 74 54 je 3e50 <malloc+0x100>
p->s.size -= nunits;
3dfc: 29 f1 sub %esi,%ecx
3dfe: 89 4a 04 mov %ecx,0x4(%edx)
p += p->s.size;
3e01: 8d 14 ca lea (%edx,%ecx,8),%edx
p->s.size = nunits;
3e04: 89 72 04 mov %esi,0x4(%edx)
freep = prevp;
3e07: a3 a0 5f 00 00 mov %eax,0x5fa0
}
3e0c: 8d 65 f4 lea -0xc(%ebp),%esp
return (void*)(p + 1);
3e0f: 8d 42 08 lea 0x8(%edx),%eax
}
3e12: 5b pop %ebx
3e13: 5e pop %esi
3e14: 5f pop %edi
3e15: 5d pop %ebp
3e16: c3 ret
3e17: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
3e1e: 66 90 xchg %ax,%ax
base.s.ptr = freep = prevp = &base;
3e20: c7 05 a0 5f 00 00 a4 movl $0x5fa4,0x5fa0
3e27: 5f 00 00
base.s.size = 0;
3e2a: bf a4 5f 00 00 mov $0x5fa4,%edi
base.s.ptr = freep = prevp = &base;
3e2f: c7 05 a4 5f 00 00 a4 movl $0x5fa4,0x5fa4
3e36: 5f 00 00
for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
3e39: 89 f8 mov %edi,%eax
base.s.size = 0;
3e3b: c7 05 a8 5f 00 00 00 movl $0x0,0x5fa8
3e42: 00 00 00
if(p->s.size >= nunits){
3e45: e9 36 ff ff ff jmp 3d80 <malloc+0x30>
3e4a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
prevp->s.ptr = p->s.ptr;
3e50: 8b 0a mov (%edx),%ecx
3e52: 89 08 mov %ecx,(%eax)
3e54: eb b1 jmp 3e07 <malloc+0xb7>
|
li t0, 3
mul s6, t0 ,t0 |
; A122619: n_{2n}.
; 1,2,3,4,5,6,7,8,9,20,23,26,29,32,35,38,41,44,47,80,85,90,95,100,105,110,115,120,125,180,187,194,201,208,215,222,229,236,243,320,329,338,347,356,365,374,383,392,401,500,511,522,533,544,555,566,577,588,599,720,733,746
mov $2,$0
add $2,1
mov $8,$0
lpb $2
mov $0,$8
sub $2,1
sub $0,$2
mov $9,$0
mov $11,2
lpb $11
sub $11,1
add $0,$11
sub $0,1
mod $3,5
mov $6,$0
add $6,1
add $3,$6
add $3,$0
sub $3,$0
sub $3,5
mov $7,$6
div $7,10
mov $5,$7
mul $5,3
mul $5,$3
mov $3,5
mov $4,$11
mov $6,$5
lpb $4
sub $4,1
mov $10,$6
lpe
lpe
lpb $9
mov $9,0
sub $10,$6
lpe
mov $6,$10
div $6,3
mul $6,2
add $6,1
add $1,$6
lpe
|
SECTION code_clib
PUBLIC printc_MODE2
PUBLIC generic_console_xypos_graphics
EXTERN __multi8_ink
EXTERN __multi8_paper
EXTERN generic_console_font32
EXTERN generic_console_udg32
EXTERN generic_console_flags
EXTERN __vram_in
EXTERN l_push_di
EXTERN l_pop_ei
defc DISPLAY = 0x8000
INCLUDE "target/pc88/def/pc88.def"
printc_MODE2:
ld a,d
call generic_console_xypos_graphics
ex de,hl
ld bc,(generic_console_font32)
ld l,a
ld h,0
bit 7,l
jr z,not_udg
res 7,l
ld bc,(generic_console_udg32)
inc b
not_udg:
add hl,hl
add hl,hl
add hl,hl
add hl,bc
dec h ;-32 characters
ld a,(generic_console_flags)
ld b,a
rlca ;get bit 7 out
sbc a
ld c,a ; c = 0/ c = 255
exx
;de' = screen
;hl' = font
;b' = flags
;c' = inverse xor
call l_push_di
printc_skip_v2_setup:
ld b,8
loop:
push bc
ld a,b
exx
cp 1
jr nz,not_last_row
; It's not the last row, check for bold
bit 3,b
jr z,not_last_row
ld a,255 ;Underline
jr no_bold
not_last_row:
bit 4,b
ld a,(hl) ;pick up font form main memory
jr z,no_bold
rrca
or (hl)
no_bold:
xor c
inc hl ;Move to next row in font
exx
ld h,a ;save ink version
cpl
ld l,a ;save paper version
ld de,(__multi8_ink)
ld a,(__vram_in)
ld b,a
;Consider the blue plane
rrc e ;Ink
ld a,e
sbc a,a ;= 255 if it was set
and h
ld c,a ;Contains ink blue to be set
rrc d ;paper
ld a,d
sbc a,a ;255 if set, 0 = if not set
and l
or c ;So now we have the blue byte
ex af,af
ld a,b
or @00000110
out ($2a),a
ex af,af
exx
ld (de),a ;And write it
exx
;Consider the green plane
rrc e ;Ink
ld a,e
sbc a,a ;= 255 if it was set
and h
ld c,a ;Contains ink blue to be set
rrc d ;paper
ld a,d
sbc a,a ;255 if set, 0 = if not set
and l
or c ;So now we have the blue byte
ex af,af
ld a,b
or @00000011
out ($2a),a
ex af,af
exx
ld (de),a ;And write it
exx
;Consider the red plane
rrc e ;Ink
ld a,e
sbc a,a ;= 255 if it was set
and h
ld c,a ;Contains ink blue to be set
rrc d ;paper
ld a,d
sbc a,a ;255 if set, 0 = if not set
and l
or c ;So now we have the blue byte
ex af,af
ld a,b
or @00000101
out ($2a),a
ex af,af
exx
ld (de),a ;And write it
exx
; Back to main memory
ex af,af
ld a,b
out ($2a),a
ex af,af
printc_next_row:
exx
ex de,hl
push bc
ld bc,80 ;Next row
add hl,bc
ex de,hl
pop bc
exx
pop bc
djnz loop
call l_pop_ei
ret
generic_console_xypos_graphics:
ld hl, DISPLAY - 80 * 8
ld de, 80 * 8
inc b
generic_console_xypos_graphics_1:
add hl,de
djnz generic_console_xypos_graphics_1
add hl,bc
ret
|
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <set>
// class multiset
// template<typename K>
// pair<iterator,iterator> equal_range(const K& x); //
// C++14
// template<typename K>
// pair<const_iterator,const_iterator> equal_range(const K& x) const; //
// C++14
#include <cassert>
#include <set>
#include <utility>
#include "min_allocator.h"
#include "private_constructor.hpp"
#include "test_macros.h"
struct Comp {
using is_transparent = void;
bool operator()(const std::pair<int, int> &lhs,
const std::pair<int, int> &rhs) const {
return lhs < rhs;
}
bool operator()(const std::pair<int, int> &lhs, int rhs) const {
return lhs.first < rhs;
}
bool operator()(int lhs, const std::pair<int, int> &rhs) const {
return lhs < rhs.first;
}
};
int main() {
std::multiset<std::pair<int, int>, Comp> s{{2, 1}, {1, 1}, {1, 1}, {1, 1}, {2, 2}};
auto er = s.equal_range(1);
long nels = 0;
for (auto it = er.first; it != er.second; it++) {
assert(it->first == 1);
nels++;
}
assert(nels == 3);
}
|
; A118185: Triangle T(n,k) = 4^(k*(n-k)) for n>=k>=0, read by rows.
; 1,1,1,1,4,1,1,16,16,1,1,64,256,64,1,1,256,4096,4096,256,1,1,1024,65536,262144,65536,1024,1,1,4096,1048576,16777216,16777216,1048576,4096,1,1,16384,16777216,1073741824,4294967296,1073741824,16777216,16384,1
seq $0,4247 ; Multiplication table read by antidiagonals: T(i,j) = ij (i>=0, j>=0).
mov $1,4
pow $1,$0
mov $0,$1
|
; -----------------------------------------------------------------------------
; Test for fmath functions under py65mon.
; Martin Heermance <mheermance@gmail.com>
; -----------------------------------------------------------------------------
.outfile "tests/itrig16Test.rom"
.alias RamSize $7EFF ; default $8000 for 32 kb x 8 bit RAM
.require "../../Common/data.asm"
.text
.org $c000
.require "../itrig16.asm"
; Main entry point for the test
main:
ldx #SP0 ; Reset stack pointer
`pushzero
jsr mockConioInit
jsr sinTest
jsr cosTest
jsr tanTest
jsr asinTest
jsr acosTest
jsr atanTest
brk
_anglesToTest:
.word [[$ffff^[FULL_ROTATION+ACUTE_ANGLE]]+1] ; -$480
.word [[$ffff^ACUTE_ANGLE]+1] ; -$80
.word $0000, ACUTE_ANGLE, RIGHT_ANGLE, RIGHT_ANGLE+ACUTE_ANGLE
.word STRAIGHT_ANGLE, RIGHT_ANGLE+STRAIGHT_ANGLE
.word RIGHT_ANGLE+STRAIGHT_ANGLE+ACUTE_ANGLE, FULL_ROTATION
.word FULL_ROTATION+ACUTE_ANGLE, 2*FULL_ROTATION+ACUTE_ANGLE
.scope
_name: .byte "*** sin16 test ***",0
_msg1: .byte "sin of ",0
_msg2: .byte " = ",0
sinTest:
`println _name
ldy #$00
_loop: lda _anglesToTest,y
`pusha
iny
lda _anglesToTest,y
sta TOS_MSB,x
jsr _test
iny
cpy #22
bmi _loop
`printcr
rts
_test: `print _msg1
jsr printTosSigned
`print _msg2
jsr sin16
jsr printTosSignedln
`drop
rts
.scend
.scope
_name: .byte "*** cos16 test ***",0
_msg1: .byte "cos of ",0
_msg2: .byte " = ",0
cosTest:
`println _name
ldy #$00
_loop: lda _anglesToTest,y
`pusha
iny
lda _anglesToTest,y
sta TOS_MSB,x
jsr _test
iny
cpy #22
bmi _loop
`printcr
rts
_test: `print _msg1
jsr printTosSigned
`print _msg2
jsr cos16
jsr printTosSignedln
`drop
rts
.scend
.scope
_name: .byte "*** tan16 test ***",0
_msg1: .byte "tan of ",0
_msg2: .byte " = ",0
tanTest:
`println _name
`pushi [[$ffff^[ACUTE_ANGLE]]+1]
_loop: `dup
`pushi STRAIGHT_ANGLE
`if_less16
`dup
jsr _test
`pushi [10*DEGREE_ANGLE]
jsr add16
bra _loop
_else: `printcr
`drop
rts
_test: `print _msg1
jsr printTosSigned
`print _msg2
jsr tan16
jsr printTosSignedln
`drop
rts
.scend
.scope
_name: .byte "*** asin16 test ***",0
_msg1: .byte "asin of ",0
_msg2: .byte " = ",0
_sineValuesToTest:
.word $A57E, $0000, $0295, $257E, $5A82, $7fff, $8001
asinTest:
`println _name
ldy #$00
_loop: lda _sineValuesToTest,y
`pusha
iny
lda _sineValuesToTest,y
sta TOS_MSB,x
jsr _test
iny
cpy #14
bmi _loop
`printcr
rts
_test: `print _msg1
jsr printTosSigned
`print _msg2
jsr asin16
jsr printTosSignedln
`drop
rts
.scend
.scope
_name: .byte "*** acos16 test ***",0
_msg1: .byte "asin of ",0
_msg2: .byte " = ",0
_cosineValuesToTest:
.word $A57E, $0000, $0295, $257E, $5A82, $7fff, $8001
acosTest:
`println _name
ldy #$00
_loop: lda _cosineValuesToTest,y
`pusha
iny
lda _cosineValuesToTest,y
sta TOS_MSB,x
jsr _test
iny
cpy #14
bmi _loop
`printcr
rts
_test: `print _msg1
jsr printTosSigned
`print _msg2
jsr acos16
jsr printTosSignedln
`drop
rts
.scend
.scope
_name: .byte "*** atan test ***",0
_msg1: .byte "atan2 of [X = ",0
_msg2: .byte ", Y = ",0
_msg3: .byte "] = ",0
_xVals: .byte 3, 3, 4, 0, 4, $fb, $fb, 0, 4
_yVals: .byte 0, 4, 4, 4, $fc, 0, $fb, $fb, $fb
_yValsEnd:
.alias _yValsCount [_yValsEnd - _yVals]
atanTest:
`println _name
ldy #$00
_loop: `pushZero
lda _yVals,y
sta TOS_MSB,x
`pushZero
lda _xVals,y
sta TOS_MSB,x
jsr _test
iny
cpy #_yValsCount
bmi _loop
_exit: jsr printstack
rts
_test: `print _msg1
jsr printTosSigned
`print _msg2
`swap
jsr printTosSigned
`print _msg3
`swap
jsr atan216
jsr printTosSignedln
`drop
rts
.scend
.require "../../Common/tests/mockConio.asm"
.require "../../Common/conio.asm"
.require "../../Common/math16.asm"
.require "../../Common/print.asm"
.require "../../Common/stack.asm"
.require "../../Common/vectors.asm"
|
; *****************************************************************************
; *****************************************************************************
;
; Name: spriteaccess.asm
; Purpose: Sprite Modifier Code
; Created: 26th March 2020
; Reviewed: TODO
; Author: Paul Robson (paul@robsons.org.uk)
;
; *****************************************************************************
; *****************************************************************************
; *****************************************************************************
;
; Select sprite R0. Return 0 if okay
;
; *****************************************************************************
.OSXSpriteSelect
push r1,r2
mov r2,r0,#0 ; put number in R2
ldm r1,#spriteCount ; check it is < sprite count
sub r0,r1,#0 ; clear R0 in cases.
mov r0,#1 ; return error if so.
sklt
jmp #_OSXSSExit
stm r15,#spritesEnabled ; sprites are enabled
mult r2,#spriteRecordSize ; now an offset
ldm r0,#spriteAddress ; add base address
add r0,r2,#0
stm r0,#spriteSelect ; saves exit
clr r0 ; return 0
._OSXSSExit
pop r1,r2
ret
; *****************************************************************************
;
; Move current sprite to X,Y
;
; *****************************************************************************
.OSXSpriteMove
push r2 ; save temp register
;
mov r2,r0,#0 ; -32 ... width + 32
add r2,#32
sub r2,#pixelWidth+64
sklt
jmp #_OSXSMFail
mov r2,r1,#0 ; -32 ... height + 32
add r2,#32
sub r2,#pixelHeight+64
sklt
jmp #_OSXSMFail
;
ldm r2,#spriteSelect ; update value
stm r0,r2,#spNewX
stm r1,r2,#spNewY
clr r0 ; return zero
skz r0
._OSXSMFail
mov r0,#1
pop r2
ret
; *****************************************************************************
;
; Set image to R0
;
; *****************************************************************************
.OSXSpriteSetImage
push r1,r2,link
mov r1,r0,#0 ; image -> R1
ldm r2,#spriteImageCount ; check image# < count
sub r0,r2,#0
sklt
jmp #_OSXSSIFail
mov r0,#$FF00 ; mask
jsr #OSIUpdateStatus
clr r0 ; exit with zero.
skz r0
._OSXSSIFail
mov r0,#1
pop r1,r2,link
ret
; *****************************************************************************
;
; Set orientation to 0-3
;
; *****************************************************************************
.OSXSpriteSetOrientation
push r1,link
mov r1,r0,#0 ; colour -> R1
sub r0,#4 ; check 0-3
sklt
jmp #_OSXSSOFail
;
ror r1,#3 ; put into correct place in word
mov r0,#$9FFF ; mask
jsr #OSIUpdateStatus
clr r0 ; exit with zero.
skz r0
._OSXSSOFail
mov r0,#1
pop r1,link
ret
; *****************************************************************************
;
; Set size to 1-2
;
; *****************************************************************************
.OSXSpriteSetSize
push r1,link
dec r0 ; now 0-1
mov r1,r0,#0 ; size-1 -> R1
and r0,#$FFFE ; exit if 0 or 1
skz r0
jmp #_OSXSSSFail ; set size fail.
ror r1,#4 ; put into bit 12
mov r0,#$EFFF ; mask
jsr #OSIUpdateStatus
clr r0 ; exit with zero.
skz r0
._OSXSSSFail
mov r0,#1
pop r1,link
ret
; *****************************************************************************
;
; Update sprite colour to R0
;
; *****************************************************************************
.OSXSpriteSetColour
push r1,link
mov r1,r0,#0 ; colour -> R1
sub r0,#16 ; check 0-15
sklt
jmp #_OSXSSCFail
;
ror r1,#8 ; put into correct place in word
mov r0,#$F0FF ; mask
jsr #OSIUpdateStatus
clr r0 ; exit with zero.
skz r0
._OSXSSCFail
mov r0,#1
pop r1,link
ret
; *****************************************************************************
;
; Kill off a sprite
;
; *****************************************************************************
.OSXSpriteKill
push r1,link
clr r0 ; 0 value and mask
clr r1
jsr #OSIUpdateStatus ; update status
ldm r1,#spriteSelect ; get currently selected sprite
stm r14,#spScriptPtr ; zero the script pointer so no more script runs.
stm r14,#spCycleDelay ; zero the delay counter so it won't try to move it.
pop r1,link
ret
; *****************************************************************************
;
; Update status with value R1 mask R0
;
; Required because the new Status may already have changed from the no
; change value.
;
; *****************************************************************************
.OSIUpdateStatus
push r2,r3
ldm r2,#spriteSelect ; currently selected sprite
ldm r3,r2,#spNewStatus ; has the new status changed, e.g. new value set.
xor r3,#spNoChange
skz r3 ; if R3 is zero copy the old status to the new
jmp #_OSIUSChanged ; one as a basis.
ldm r3,r2,#spStatus
stm r3,r2,#spNewStatus
._OSIUSChanged
ldm r3,r2,#spNewStatus ; get the new status
and r3,r0,#0 ; and with mask
add r3,r1,#0 ; add in data
stm r3,r2,#spNewStatus ; write back
pop r2,r3
ret
; *****************************************************************************
;
; Get sprite Element R1 from Sprite # R0
;
; *****************************************************************************
.OSXGetSpriteInfo
push r1,r2
mult r0,#spriteRecordSize ; make point to record
ldm r2,#spriteAddress
add r2,r0,#0 ; element in record -> R1
add r2,r1,#0
;
ldm r1,r2,#spNewX-spX ; read the updated value.
mov r0,r1,#0 ; put in R0.
xor r1,#spNoChange ; if it is no change,
sknz r1
ldm r0,r2,#0 ; read current value
pop r1,r2
ret |
; A021091: Decimal expansion of 1/87.
; 0,1,1,4,9,4,2,5,2,8,7,3,5,6,3,2,1,8,3,9,0,8,0,4,5,9,7,7,0,1,1,4,9,4,2,5,2,8,7,3,5,6,3,2,1,8,3,9,0,8,0,4,5,9,7,7,0,1,1,4,9,4,2,5,2,8,7,3,5,6,3,2,1,8,3,9,0,8,0,4,5,9,7,7,0,1,1,4,9,4,2,5,2,8,7,3,5,6,3
add $0,2
mov $1,10
pow $1,$0
mul $1,4
div $1,3480
mod $1,10
mov $0,$1
|
//===-test_sce_sum_expanded_popart.cc-----------------------------------------------------------===//
//
// Copyright (C) 2019-2020 Alibaba Group Holding Limited.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// =============================================================================
// clang-format off
// Testing CXX Code Gen using ODLA API on popart
// RUN: %halo_compiler -target cxx -o %data_path/test_sce_sum_expanded/test_data_set_0/input_0.cc -x onnx -emit-data-as-c %data_path/test_sce_sum_expanded/test_data_set_0/input_0.pb
// RUN: %halo_compiler -target cxx -o %data_path/test_sce_sum_expanded/test_data_set_0/output_0.cc -x onnx -emit-data-as-c %data_path/test_sce_sum_expanded/test_data_set_0/output_0.pb
// RUN: %halo_compiler -target cxx -o %data_path/test_sce_sum_expanded/test_data_set_0/input_1.cc -x onnx -emit-data-as-c %data_path/test_sce_sum_expanded/test_data_set_0/input_1.pb
// RUN: %halo_compiler -target cxx -batch-size 1 %halo_compile_flags %data_path/test_sce_sum_expanded/model.onnx -o %t.cc
// RUN: %cxx -c -fPIC -o %t.o %t.cc -I%odla_path/include
// RUN: %cxx -g %s %t.o %t.bin -I%T -I%odla_path/include -I%unittests_path -I%data_path/test_sce_sum_expanded/test_data_set_0 %odla_link %device_link -lodla_popart -o %t_popart.exe -Wno-deprecated-declarations
// RUN: %t_popart.exe 0.0001 0 popart %data_path/test_sce_sum_expanded | FileCheck %s
// CHECK: Result Pass
// clang-format on
// XFAIL: *
#include "test_sce_sum_expanded_popart.cc.tmp.main.cc.in"
|
#include "drape_frontend/render_group.hpp"
#include "drape_frontend/visual_params.hpp"
#include "drape/debug_rect_renderer.hpp"
#include "drape/shader_def.hpp"
#include "drape/vertex_array_buffer.hpp"
#include "geometry/screenbase.hpp"
#include "base/stl_add.hpp"
#include "std/bind.hpp"
namespace df
{
void BaseRenderGroup::SetRenderParams(ref_ptr<dp::GpuProgram> shader, ref_ptr<dp::GpuProgram> shader3d,
ref_ptr<dp::UniformValuesStorage> generalUniforms)
{
m_shader = shader;
m_shader3d = shader3d;
m_generalUniforms = generalUniforms;
}
void BaseRenderGroup::UpdateAnimation()
{
m_uniforms.SetFloatValue("u_opacity", 1.0);
}
void BaseRenderGroup::Render(const ScreenBase & screen)
{
ref_ptr<dp::GpuProgram> shader = screen.isPerspective() ? m_shader3d : m_shader;
ASSERT(shader != nullptr, ());
ASSERT(m_generalUniforms != nullptr, ());
shader->Bind();
dp::ApplyState(m_state, shader);
dp::ApplyUniforms(*(m_generalUniforms.get()), shader);
}
bool BaseRenderGroup::IsOverlay() const
{
return m_state.GetDepthLayer() == dp::GLState::OverlayLayer;
}
RenderGroup::RenderGroup(dp::GLState const & state, df::TileKey const & tileKey)
: TBase(state, tileKey)
, m_pendingOnDelete(false)
, m_canBeDeleted(false)
{
}
RenderGroup::~RenderGroup()
{
m_renderBuckets.clear();
}
void RenderGroup::Update(ScreenBase const & modelView)
{
ASSERT(m_shader != nullptr, ());
ASSERT(m_generalUniforms != nullptr, ());
for(drape_ptr<dp::RenderBucket> & renderBucket : m_renderBuckets)
renderBucket->Update(modelView);
}
void RenderGroup::CollectOverlay(ref_ptr<dp::OverlayTree> tree)
{
if (CanBeDeleted())
return;
ASSERT(m_shader != nullptr, ());
ASSERT(m_generalUniforms != nullptr, ());
for (auto & renderBucket : m_renderBuckets)
renderBucket->CollectOverlayHandles(tree);
}
void RenderGroup::RemoveOverlay(ref_ptr<dp::OverlayTree> tree)
{
for (auto & renderBucket : m_renderBuckets)
renderBucket->RemoveOverlayHandles(tree);
}
void RenderGroup::Render(ScreenBase const & screen)
{
BaseRenderGroup::Render(screen);
ref_ptr<dp::GpuProgram> shader = screen.isPerspective() ? m_shader3d : m_shader;
for(auto & renderBucket : m_renderBuckets)
renderBucket->GetBuffer()->Build(shader);
auto const & params = df::VisualParams::Instance().GetGlyphVisualParams();
int programIndex = m_state.GetProgramIndex();
int program3dIndex = m_state.GetProgram3dIndex();
if (programIndex == gpu::TEXT_OUTLINED_PROGRAM ||
program3dIndex == gpu::TEXT_OUTLINED_BILLBOARD_PROGRAM)
{
m_uniforms.SetFloatValue("u_contrastGamma", params.m_outlineContrast, params.m_outlineGamma);
m_uniforms.SetFloatValue("u_isOutlinePass", 1.0f);
dp::ApplyUniforms(m_uniforms, shader);
for(auto & renderBucket : m_renderBuckets)
renderBucket->Render();
m_uniforms.SetFloatValue("u_contrastGamma", params.m_contrast, params.m_gamma);
m_uniforms.SetFloatValue("u_isOutlinePass", 0.0f);
dp::ApplyUniforms(m_uniforms, shader);
for(auto & renderBucket : m_renderBuckets)
renderBucket->Render();
}
else if (programIndex == gpu::TEXT_PROGRAM ||
program3dIndex == gpu::TEXT_BILLBOARD_PROGRAM)
{
m_uniforms.SetFloatValue("u_contrastGamma", params.m_contrast, params.m_gamma);
dp::ApplyUniforms(m_uniforms, shader);
for(auto & renderBucket : m_renderBuckets)
renderBucket->Render();
}
else
{
dp::ApplyUniforms(m_uniforms, shader);
for(drape_ptr<dp::RenderBucket> & renderBucket : m_renderBuckets)
renderBucket->Render();
}
#ifdef RENDER_DEBUG_RECTS
for(auto const & renderBucket : m_renderBuckets)
renderBucket->RenderDebug(screen);
#endif
}
void RenderGroup::AddBucket(drape_ptr<dp::RenderBucket> && bucket)
{
m_renderBuckets.push_back(move(bucket));
}
bool RenderGroup::IsLess(RenderGroup const & other) const
{
return m_state < other.m_state;
}
bool RenderGroup::UpdateCanBeDeletedStatus(bool canBeDeleted, int currentZoom, ref_ptr<dp::OverlayTree> tree)
{
if (!IsPendingOnDelete())
return false;
for (size_t i = 0; i < m_renderBuckets.size(); )
{
bool visibleBucket = !canBeDeleted && (m_renderBuckets[i]->GetMinZoom() <= currentZoom);
if (!visibleBucket)
{
m_renderBuckets[i]->RemoveOverlayHandles(tree);
swap(m_renderBuckets[i], m_renderBuckets.back());
m_renderBuckets.pop_back();
}
else
{
++i;
}
}
m_canBeDeleted = m_renderBuckets.empty();
return m_canBeDeleted;
}
bool RenderGroupComparator::operator()(drape_ptr<RenderGroup> const & l, drape_ptr<RenderGroup> const & r)
{
m_pendingOnDeleteFound |= (l->IsPendingOnDelete() || r->IsPendingOnDelete());
bool const lCanBeDeleted = l->CanBeDeleted();
bool const rCanBeDeleted = r->CanBeDeleted();
if (rCanBeDeleted == lCanBeDeleted)
{
dp::GLState const & lState = l->GetState();
dp::GLState const & rState = r->GetState();
dp::GLState::DepthLayer lDepth = lState.GetDepthLayer();
dp::GLState::DepthLayer rDepth = rState.GetDepthLayer();
if (lDepth != rDepth)
return lDepth < rDepth;
return lState < rState;
}
if (rCanBeDeleted)
return true;
return false;
}
UserMarkRenderGroup::UserMarkRenderGroup(dp::GLState const & state,
TileKey const & tileKey,
drape_ptr<dp::RenderBucket> && bucket)
: TBase(state, tileKey)
, m_renderBucket(move(bucket))
, m_animation(new OpacityAnimation(0.25 /*duration*/, 0.0 /* minValue */, 1.0 /* maxValue*/))
{
m_mapping.AddRangePoint(0.6, 1.3);
m_mapping.AddRangePoint(0.85, 0.8);
m_mapping.AddRangePoint(1.0, 1.0);
}
UserMarkRenderGroup::~UserMarkRenderGroup()
{
}
void UserMarkRenderGroup::UpdateAnimation()
{
BaseRenderGroup::UpdateAnimation();
float t = 1.0;
if (m_animation)
t = m_animation->GetOpacity();
m_uniforms.SetFloatValue("u_interpolationT", m_mapping.GetValue(t));
}
void UserMarkRenderGroup::Render(ScreenBase const & screen)
{
BaseRenderGroup::Render(screen);
ref_ptr<dp::GpuProgram> shader = screen.isPerspective() ? m_shader3d : m_shader;
dp::ApplyUniforms(m_uniforms, shader);
if (m_renderBucket != nullptr)
{
m_renderBucket->GetBuffer()->Build(shader);
m_renderBucket->Render();
}
}
string DebugPrint(RenderGroup const & group)
{
ostringstream out;
out << DebugPrint(group.GetTileKey());
return out.str();
}
} // namespace df
|
; A234017: Inverse function for injection A055938.
; 0,0,1,0,0,2,3,0,0,4,0,0,5,6,7,0,0,8,0,0,9,10,0,0,11,0,0,12,13,14,15,0,0,16,0,0,17,18,0,0,19,0,0,20,21,22,0,0,23,0,0,24,25,0,0,26,0,0,27,28,29,30,31,0,0,32,0,0,33,34,0,0,35,0,0,36,37,38,0,0,39,0,0,40,41,0,0,42,0,0,43,44,45,46,0,0,47,0,0,48,49,0,0,50,0,0,51,52,53,0,0,54,0,0,55,56,0,0,57,0,0,58,59,60,61,62,63,0,0,64,0,0,65,66,0,0,67,0,0,68,69,70,0,0,71,0,0,72,73,0,0,74,0,0,75,76,77,78,0,0,79,0,0,80,81,0,0,82,0,0,83,84,85,0,0,86,0,0,87,88,0,0,89,0,0,90,91,92,93,94,0,0,95,0,0,96,97,0,0,98,0,0,99,100,101,0,0,102,0,0,103,104,0,0,105,0,0,106,107,108,109,0,0,110,0,0,111,112,0,0,113,0,0,114,115,116,0,0,117,0,0,118,119,0,0,120,0,0,121,122
mov $5,$0
mov $7,2
lpb $7,1
clr $0,5
mov $0,$5
sub $7,1
add $0,$7
sub $0,1
cal $0,234016 ; Partial sums of the characteristic function of A055938.
mov $1,$0
add $2,$0
pow $2,2
add $3,$2
add $1,$3
mov $8,$7
lpb $8,1
mov $6,$1
sub $8,1
lpe
lpe
lpb $5,1
mov $5,0
sub $6,$1
lpe
mov $1,$6
div $1,2
|
#ifdef MSU1_CPP
void MSU1::serialize(serializer &s) {
Processor::serialize(s);
s.integer(mmio.data_offset);
s.integer(mmio.audio_offset);
s.integer(mmio.audio_loop_offset);
s.integer(mmio.audio_track);
s.integer(mmio.audio_volume);
s.integer(mmio.data_busy);
s.integer(mmio.audio_busy);
s.integer(mmio.audio_repeat);
s.integer(mmio.audio_play);
if(datafile.open()) datafile.close();
if(datafile.open(interface()->path(Cartridge::Slot::Base, "msu1.rom"), file::mode::read)) {
datafile.seek(mmio.data_offset);
}
if(audiofile.open()) audiofile.close();
if(audiofile.open(interface()->path(Cartridge::Slot::Base, { "track-", (unsigned)mmio.audio_track, ".pcm" }), file::mode::read)) {
audiofile.seek(mmio.audio_offset);
}
}
#endif
|
;======================================================================================================================
; FAMISTUDIO SOUND ENGINE (3.1.0)
; Copyright (c) 2019-2021 Mathieu Gauthier
;
; Copying and distribution of this file, with or without
; modification, are permitted in any medium without royalty provided
; the copyright notice and this notice are preserved in all source
; code copies. This file is offered as-is, without any warranty.
;======================================================================================================================
;======================================================================================================================
; This is the FamiStudio sound engine. It is used by the NSF and ROM exporter of FamiStudio and can be used to make
; games. It supports every feature from FamiStudio, some of them are toggeable to save CPU/memory.
;
; This is essentially a heavily modified version of FamiTone2 by Shiru. A lot of his code and comments are still
; present here, so massive thanks to him!! I am not trying to steal his work or anything, i renamed a lot of functions
; and variables because at some point it was becoming a mess of coding standards and getting hard to maintain.
;
; Moderately advanced users can probably figure out how to use the sound engine simply by reading these comments.
; For more in-depth documentation, please go to:
;
; https://famistudio.org/doc/soundengine/
;======================================================================================================================
;======================================================================================================================
; INTERFACE
;
; The interface is pretty much the same as FamiTone2, with a slightly different naming convention. The subroutines you
; can call from your game are:
;
; - famistudio_init : Initialize the engine with some music data.
; - famistudio_music_play : Start music playback with a specific song.
; - famistudio_music_pause : Pause/unpause music playback.
; - famistudio_music_stop : Stops music playback.
; - famistudio_sfx_init : Initialize SFX engine with SFX data.
; - famistudio_sfx_play : Play a SFX.
; - famistudio_sfx_sample_play : Play a DPCM SFX.
; - famistudio_update : Updates the music/SFX engine, call once per frame, ideally from NMI.
;
; You can check the demo ROM to see how they are used or check out the online documentation for more info.
;======================================================================================================================
;======================================================================================================================
; CONFIGURATION
;
; There are 2 main ways of configuring the engine.
;
; 1) The simplest way is right here, in the section below. Simply comment/uncomment these defines, and move on
; with your life.
;
; 2) The second way is "externally", using definitions coming from elsewhere in your app or the command line. If you
; wish do so, simply define FAMISTUDIO_CFG_EXTERNAL=1 and this whole section will be ignored. You are then
; responsible for providing all configuration. This is useful if you have multiple projects that needs
; different configurations, while pointing to the same code file. This is how the provided demos and FamiStudio
; uses it.
;
; Note that unless specified, the engine uses "if" and not "ifdef" for all boolean values so you need to define these
; to non-zero values. Undefined values will be assumed to be zero.
;
; There are 4 main things to configure, each of them will be detailed below.
;
; 1) Segments (ZP/RAM/PRG)
; 2) Audio expansion
; 3) Global engine parameters
; 4) Supported features
;======================================================================================================================
.ifndef FAMISTUDIO_CFG_EXTERNAL
FAMISTUDIO_CFG_EXTERNAL = 0
.endif
; Set this to configure the sound engine from outside (in your app, or from the command line)
.if !FAMISTUDIO_CFG_EXTERNAL
;======================================================================================================================
; 1) SEGMENT CONFIGURATION
;
; You need to tell where you want to allocate the zeropage, RAM and code. This section will be slightly different for
; each assembler.
;
; For NESASM, you can specify the .rsset location for zeroage and RAM/BSS as well as the .bank/.org for the engine
; code. The .zp/.bss/.code section directives can also be emitted. ALl these values are optional and will be tested
; as .ifdef.
;======================================================================================================================
; Define this to emit the ".zp" directive before the zeropage variables.
; FAMISTUDIO_NESASM_ZP_SECTION = 1
; Address where to allocate the zeropage variables that the engine use.
FAMISTUDIO_NESASM_ZP_RSSET = $00a0
; Define this to emit the ".bss" directive before the RAM/BSS variables.
; FAMISTUDIO_NESASM_BSS_SECTION = 1
; Address where to allocate the RAN/BSS variables that the engine use.
FAMISTUDIO_NESASM_BSS_RSSET = $0400
; Define this to emit the ".code" directive before the code section.
; FAMISTUDIO_NESASM_CODE_SECTION = 1
; Define this to emit the ".bank" directive before the code section.
; FAMISTUDIO_NESASM_CODE_BANK = 0
; Address where to place the engine code.
FAMISTUDIO_NESASM_CODE_ORG = $8000
;======================================================================================================================
; 2) AUDIO EXPANSION CONFIGURATION
;
; You can enable up to one audio expansion (FAMISTUDIO_EXP_XXX). Enabling more than one expansion will lead to
; undefined behavior. Memory usage goes up as more complex expansions are used. The audio expansion you choose
; **MUST MATCH** with the data you will load in the engine. Loading a FDS song while enabling VRC6 will lead to
; undefined behavior.
;======================================================================================================================
; Konami VRC6 (2 extra square + saw)
; FAMISTUDIO_EXP_VRC6 = 1
; Konami VRC7 (6 FM channels)
; FAMISTUDIO_EXP_VRC7 = 1
; Nintendo MMC5 (2 extra squares, extra DPCM not supported)
; FAMISTUDIO_EXP_MMC5 = 1
; Sunsoft S5B (2 extra squares, advanced features not supported.)
; FAMISTUDIO_EXP_S5B = 1
; Famicom Disk System (extra wavetable channel)
; FAMISTUDIO_EXP_FDS = 1
; Namco 163 (between 1 and 8 extra wavetable channels) + number of channels.
; FAMISTUDIO_EXP_N163 = 1
; FAMISTUDIO_EXP_N163_CHN_CNT = 4
;======================================================================================================================
; 3) GLOBAL ENGINE CONFIGURATION
;
; These are parameters that configures the engine, but are independent of the data you will be importing, such as
; which platform (PAL/NTSC) you want to support playback for, whether SFX are enabled or not, etc. They all have the
; form FAMISTUDIO_CFG_XXX.
;======================================================================================================================
; One of these MUST be defined (PAL or NTSC playback). Note that only NTSC support is supported when using any of the audio expansions.
; FAMISTUDIO_CFG_PAL_SUPPORT = 1
FAMISTUDIO_CFG_NTSC_SUPPORT = 1
; Support for sound effects playback + number of SFX that can play at once.
; FAMISTUDIO_CFG_SFX_SUPPORT = 1
; FAMISTUDIO_CFG_SFX_STREAMS = 2
; Blaarg's smooth vibrato technique. Eliminates phase resets ("pops") on square channels.
; FAMISTUDIO_CFG_SMOOTH_VIBRATO = 1
; Enables DPCM playback support.
FAMISTUDIO_CFG_DPCM_SUPPORT = 1
; Must be enabled if you are calling sound effects from a different thread than the sound engine update.
; FAMISTUDIO_CFG_THREAD = 1
;======================================================================================================================
; 4) SUPPORTED FEATURES CONFIGURATION
;
; Every feature supported in FamiStudio is supported by this sound engine. If you know for sure that you are not using
; specific features in your music, you can disable them to save memory/processing time. Using a feature in your song
; and failing to enable it will likely lead to crashes (BRK), or undefined behavior. They all have the form
; FAMISTUDIO_USE_XXX.
;======================================================================================================================
; Must be enabled if the songs you will be importing have been created using FamiTracker tempo mode. If you are using
; FamiStudio tempo mode, this must be undefined. You cannot mix and match tempo modes, the engine can only run in one
; mode or the other.
; More information at: https://famistudio.org/doc/song/#tempo-modes
; FAMISTUDIO_USE_FAMITRACKER_TEMPO = 1
; Must be enabled if the songs uses delayed notes or delayed cuts. This is obviously only available when using
; FamiTracker tempo mode as FamiStudio tempo mode does not need this.
; FAMISTUDIO_USE_FAMITRACKER_DELAYED_NOTES_OR_CUTS = 1
; Must be enabled if any song uses the volume track. The volume track allows manipulating the volume at the track level
; independently from instruments.
; More information at: https://famistudio.org/doc/pianoroll/#editing-volume-tracks-effects
FAMISTUDIO_USE_VOLUME_TRACK = 1
; Must be enabled if any song uses slides on the volume track. Volume track must be enabled too.
; More information at: https://famistudio.org/doc/pianoroll/#editing-volume-tracks-effects
; FAMISTUDIO_USE_VOLUME_SLIDES = 1
; Must be enabled if any song uses the pitch track. The pitch track allows manipulating the pitch at the track level
; independently from instruments.
; More information at: https://famistudio.org/doc/pianoroll/#pitch
FAMISTUDIO_USE_PITCH_TRACK = 1
; Must be enabled if any song uses slide notes. Slide notes allows portamento and slide effects.
; More information at: https://famistudio.org/doc/pianoroll/#slide-notes
FAMISTUDIO_USE_SLIDE_NOTES = 1
; Must be enabled if any song uses slide notes on the noise channel too.
; More information at: https://famistudio.org/doc/pianoroll/#slide-notes
; FAMISTUDIO_USE_NOISE_SLIDE_NOTES = 1
; Must be enabled if any song uses the vibrato speed/depth effect track.
; More information at: https://famistudio.org/doc/pianoroll/#vibrato-depth-speed
FAMISTUDIO_USE_VIBRATO = 1
; Must be enabled if any song uses arpeggios (not to be confused with instrument arpeggio envelopes, those are always
; supported).
; More information at: (TODO)
FAMISTUDIO_USE_ARPEGGIO = 1
; Must be enabled if any song uses the "Duty Cycle" effect (equivalent of FamiTracker Vxx, also called "Timbre").
; FAMISTUDIO_USE_DUTYCYCLE_EFFECT = 1
.endif
; Memory location of the DPCM samples. Must be between $c000 and $ffc0, and a multiple of 64.
.ifndef FAMISTUDIO_DPCM_OFF
FAMISTUDIO_DPCM_OFF = $c000
.endif
;======================================================================================================================
; END OF CONFIGURATION
;
; Ideally, you should not have to change anything below this line.
;======================================================================================================================
;======================================================================================================================
; INTERNAL DEFINES (Do not touch)
;======================================================================================================================
.ifndef FAMISTUDIO_EXP_VRC6
FAMISTUDIO_EXP_VRC6 = 0
.endif
.ifndef FAMISTUDIO_EXP_VRC7
FAMISTUDIO_EXP_VRC7 = 0
.endif
.ifndef FAMISTUDIO_EXP_MMC5
FAMISTUDIO_EXP_MMC5 = 0
.endif
.ifndef FAMISTUDIO_EXP_S5B
FAMISTUDIO_EXP_S5B = 0
.endif
.ifndef FAMISTUDIO_EXP_FDS
FAMISTUDIO_EXP_FDS = 0
.endif
.ifndef FAMISTUDIO_EXP_N163
FAMISTUDIO_EXP_N163 = 0
.endif
.ifndef FAMISTUDIO_EXP_N163_CHN_CNT
FAMISTUDIO_EXP_N163_CHN_CNT = 1
.endif
.ifndef FAMISTUDIO_CFG_PAL_SUPPORT
FAMISTUDIO_CFG_PAL_SUPPORT = 0
.endif
.ifndef FAMISTUDIO_CFG_NTSC_SUPPORT
.if FAMISTUDIO_CFG_PAL_SUPPORT
FAMISTUDIO_CFG_NTSC_SUPPORT = 0
.else
FAMISTUDIO_CFG_NTSC_SUPPORT = 1
.endif
.endif
.if (FAMISTUDIO_CFG_NTSC_SUPPORT != 0) & (FAMISTUDIO_CFG_PAL_SUPPORT != 0)
FAMISTUDIO_DUAL_SUPPORT = 1
.else
FAMISTUDIO_DUAL_SUPPORT = 0
.endif
.ifndef FAMISTUDIO_CFG_SFX_SUPPORT
FAMISTUDIO_CFG_SFX_SUPPORT = 0
FAMISTUDIO_CFG_SFX_STREAMS = 0
.endif
.ifndef FAMISTUDIO_CFG_SFX_STREAMS
FAMISTUDIO_CFG_SFX_STREAMS = 1
.endif
.ifndef FAMISTUDIO_CFG_SMOOTH_VIBRATO
FAMISTUDIO_CFG_SMOOTH_VIBRATO = 0
.endif
.ifndef FAMISTUDIO_CFG_DPCM_SUPPORT
FAMISTUDIO_CFG_DPCM_SUPPORT = 0
.endif
.ifndef FAMISTUDIO_CFG_EQUALIZER
FAMISTUDIO_CFG_EQUALIZER = 0
.endif
.ifndef FAMISTUDIO_USE_FAMITRACKER_TEMPO
FAMISTUDIO_USE_FAMITRACKER_TEMPO = 0
.endif
.ifndef FAMISTUDIO_USE_FAMITRACKER_DELAYED_NOTES_OR_CUTS
FAMISTUDIO_USE_FAMITRACKER_DELAYED_NOTES_OR_CUTS = 0
.endif
.ifndef FAMISTUDIO_USE_VOLUME_TRACK
FAMISTUDIO_USE_VOLUME_TRACK = 0
.endif
.ifndef FAMISTUDIO_USE_VOLUME_SLIDES
FAMISTUDIO_USE_VOLUME_SLIDES = 0
.endif
.ifndef FAMISTUDIO_USE_PITCH_TRACK
FAMISTUDIO_USE_PITCH_TRACK = 0
.endif
.ifndef FAMISTUDIO_USE_SLIDE_NOTES
FAMISTUDIO_USE_SLIDE_NOTES = 0
.endif
.ifndef FAMISTUDIO_USE_NOISE_SLIDE_NOTES
FAMISTUDIO_USE_NOISE_SLIDE_NOTES = 0
.endif
.ifndef FAMISTUDIO_USE_VIBRATO
FAMISTUDIO_USE_VIBRATO = 0
.endif
.ifndef FAMISTUDIO_USE_ARPEGGIO
FAMISTUDIO_USE_ARPEGGIO = 0
.endif
.ifndef FAMISTUDIO_USE_DUTYCYCLE_EFFECT
FAMISTUDIO_USE_DUTYCYCLE_EFFECT = 0
.endif
.ifndef FAMISTUDIO_CFG_THREAD
FAMISTUDIO_CFG_THREAD = 0
.endif
.if (FAMISTUDIO_EXP_VRC6 + FAMISTUDIO_EXP_VRC7 + FAMISTUDIO_EXP_MMC5 + FAMISTUDIO_EXP_S5B + FAMISTUDIO_EXP_FDS + FAMISTUDIO_EXP_N163) = 0
FAMISTUDIO_EXP_NONE = 1
.else
FAMISTUDIO_EXP_NONE = 0
.endif
.if (FAMISTUDIO_EXP_VRC7 + FAMISTUDIO_EXP_N163 + FAMISTUDIO_EXP_FDS) != 0
FAMISTUDIO_EXP_NOTE_START = 5
.endif
.if (FAMISTUDIO_EXP_VRC6) != 0
FAMISTUDIO_EXP_NOTE_START = 7
.endif
.if (FAMISTUDIO_USE_NOISE_SLIDE_NOTES != 0) & (FAMISTUDIO_USE_SLIDE_NOTES = 0)
.error "Noise slide notes can only be used when regular slide notes are enabled too."
.endif
.if (FAMISTUDIO_USE_VOLUME_SLIDES != 0) & (FAMISTUDIO_USE_VOLUME_TRACK = 0)
.error "Volume slides can only be used when the volume track is enabled too."
.endif
.if (FAMISTUDIO_USE_FAMITRACKER_DELAYED_NOTES_OR_CUTS != 0) & (FAMISTUDIO_USE_FAMITRACKER_TEMPO = 0)
.error "Delayed notes or cuts only make sense when using FamiTracker tempo."
.endif
.if (FAMISTUDIO_EXP_VRC6 + FAMISTUDIO_EXP_VRC7 + FAMISTUDIO_EXP_MMC5 + FAMISTUDIO_EXP_S5B + FAMISTUDIO_EXP_FDS + FAMISTUDIO_EXP_N163) > 1
.error "Only one audio expansion can be enabled."
.endif
.if (FAMISTUDIO_EXP_N163 != 0) & ((FAMISTUDIO_EXP_N163_CHN_CNT < 1) | (FAMISTUDIO_EXP_N163_CHN_CNT > 8))
.error "N163 only supports between 1 and 8 channels."
.endif
FAMISTUDIO_DPCM_PTR = (FAMISTUDIO_DPCM_OFF & $3fff) >> 6
.if FAMISTUDIO_EXP_VRC7
FAMISTUDIO_NUM_ENVELOPES = 3+3+2+3+2+2+2+2+2+2
FAMISTUDIO_NUM_PITCH_ENVELOPES = 9
FAMISTUDIO_NUM_CHANNELS = 11
FAMISTUDIO_NUM_DUTY_CYCLES = 3
.endif
.if FAMISTUDIO_EXP_VRC6
FAMISTUDIO_NUM_ENVELOPES = 3+3+2+3+3+3+3
FAMISTUDIO_NUM_PITCH_ENVELOPES = 6
FAMISTUDIO_NUM_CHANNELS = 8
FAMISTUDIO_NUM_DUTY_CYCLES = 6
.endif
.if FAMISTUDIO_EXP_S5B
FAMISTUDIO_NUM_ENVELOPES = 3+3+2+3+2+2+2
FAMISTUDIO_NUM_PITCH_ENVELOPES = 6
FAMISTUDIO_NUM_CHANNELS = 8
FAMISTUDIO_NUM_DUTY_CYCLES = 3
.endif
.if FAMISTUDIO_EXP_N163
FAMISTUDIO_NUM_ENVELOPES = 3+3+2+3+(FAMISTUDIO_EXP_N163_CHN_CNT*2)
FAMISTUDIO_NUM_PITCH_ENVELOPES = 3+FAMISTUDIO_EXP_N163_CHN_CNT
FAMISTUDIO_NUM_CHANNELS = 5+FAMISTUDIO_EXP_N163_CHN_CNT
FAMISTUDIO_NUM_DUTY_CYCLES = 3
.endif
.if FAMISTUDIO_EXP_MMC5
FAMISTUDIO_NUM_ENVELOPES = 3+3+2+3+3+3
FAMISTUDIO_NUM_PITCH_ENVELOPES = 5
FAMISTUDIO_NUM_CHANNELS = 7
FAMISTUDIO_NUM_DUTY_CYCLES = 5
.endif
.if FAMISTUDIO_EXP_FDS
FAMISTUDIO_NUM_ENVELOPES = 3+3+2+3+2
FAMISTUDIO_NUM_PITCH_ENVELOPES = 4
FAMISTUDIO_NUM_CHANNELS = 6
FAMISTUDIO_NUM_DUTY_CYCLES = 3
.endif
.if FAMISTUDIO_EXP_NONE
FAMISTUDIO_NUM_ENVELOPES = 3+3+2+3
FAMISTUDIO_NUM_PITCH_ENVELOPES = 3
FAMISTUDIO_NUM_CHANNELS = 5
FAMISTUDIO_NUM_DUTY_CYCLES = 3
.endif
.if FAMISTUDIO_EXP_NONE
FAMISTUDIO_NUM_VOLUME_SLIDES = 4
.else
FAMISTUDIO_NUM_VOLUME_SLIDES = FAMISTUDIO_NUM_CHANNELS ; DPCM volume is unused.
.endif
.if FAMISTUDIO_USE_NOISE_SLIDE_NOTES
FAMISTUDIO_NUM_SLIDES = FAMISTUDIO_NUM_PITCH_ENVELOPES + 1
.else
FAMISTUDIO_NUM_SLIDES = FAMISTUDIO_NUM_PITCH_ENVELOPES
.endif
; Keep the noise slide at the end so the pitch envelopes/slides are in sync.
FAMISTUDIO_NOISE_SLIDE_INDEX = FAMISTUDIO_NUM_SLIDES - 1
FAMISTUDIO_CH0_ENVS = 0
FAMISTUDIO_CH1_ENVS = 3
FAMISTUDIO_CH2_ENVS = 6
FAMISTUDIO_CH3_ENVS = 8
.if FAMISTUDIO_EXP_VRC6
FAMISTUDIO_CH5_ENVS = 11
FAMISTUDIO_CH6_ENVS = 14
FAMISTUDIO_CH7_ENVS = 17
.endif
.if FAMISTUDIO_EXP_VRC7
FAMISTUDIO_CH5_ENVS = 11
FAMISTUDIO_CH6_ENVS = 13
FAMISTUDIO_CH7_ENVS = 15
FAMISTUDIO_CH8_ENVS = 17
FAMISTUDIO_CH9_ENVS = 19
FAMISTUDIO_CH10_ENVS = 21
.endif
.if FAMISTUDIO_EXP_N163
FAMISTUDIO_CH5_ENVS = 11
FAMISTUDIO_CH6_ENVS = 13
FAMISTUDIO_CH7_ENVS = 15
FAMISTUDIO_CH8_ENVS = 17
FAMISTUDIO_CH9_ENVS = 19
FAMISTUDIO_CH10_ENVS = 21
FAMISTUDIO_CH11_ENVS = 23
FAMISTUDIO_CH12_ENVS = 25
.endif
.if FAMISTUDIO_EXP_FDS
FAMISTUDIO_CH5_ENVS = 11
.endif
.if FAMISTUDIO_EXP_MMC5
FAMISTUDIO_CH5_ENVS = 11
FAMISTUDIO_CH6_ENVS = 14
.endif
.if FAMISTUDIO_EXP_S5B
FAMISTUDIO_CH5_ENVS = 11
FAMISTUDIO_CH6_ENVS = 13
FAMISTUDIO_CH7_ENVS = 15
.endif
FAMISTUDIO_ENV_VOLUME_OFF = 0
FAMISTUDIO_ENV_NOTE_OFF = 1
FAMISTUDIO_ENV_DUTY_OFF = 2
.if FAMISTUDIO_EXP_VRC7
FAMISTUDIO_PITCH_SHIFT = 3
.else
.if FAMISTUDIO_EXP_N163
.if (FAMISTUDIO_EXP_N163_CHN_CNT > 4)
FAMISTUDIO_PITCH_SHIFT = 5
.endif
.if (FAMISTUDIO_EXP_N163_CHN_CNT > 2) & (FAMISTUDIO_EXP_N163_CHN_CNT <= 4)
FAMISTUDIO_PITCH_SHIFT = 4
.endif
.if (FAMISTUDIO_EXP_N163_CHN_CNT > 1) & (FAMISTUDIO_EXP_N163_CHN_CNT <= 2)
FAMISTUDIO_PITCH_SHIFT = 3
.endif
.if (FAMISTUDIO_EXP_N163_CHN_CNT = 1)
FAMISTUDIO_PITCH_SHIFT = 2
.endif
.else
FAMISTUDIO_PITCH_SHIFT = 0
.endif
.endif
.if FAMISTUDIO_EXP_N163
FAMISTUDIO_N163_CHN_MASK = (FAMISTUDIO_EXP_N163_CHN_CNT - 1) << 4
.endif
.if FAMISTUDIO_CFG_SFX_SUPPORT
FAMISTUDIO_SFX_STRUCT_SIZE = 15
FAMISTUDIO_SFX_CH0 = FAMISTUDIO_SFX_STRUCT_SIZE * 0
FAMISTUDIO_SFX_CH1 = FAMISTUDIO_SFX_STRUCT_SIZE * 1
FAMISTUDIO_SFX_CH2 = FAMISTUDIO_SFX_STRUCT_SIZE * 2
FAMISTUDIO_SFX_CH3 = FAMISTUDIO_SFX_STRUCT_SIZE * 3
.endif
;======================================================================================================================
; RAM VARIABLES (You should not have to play with these)
;======================================================================================================================
.ifdef FAMISTUDIO_NESASM_BSS_SECTION
.bss
.endif
.ifdef FAMISTUDIO_NESASM_BSS_RSSET
.rsset FAMISTUDIO_NESASM_BSS_RSSET
.endif
famistudio_env_value: .rs FAMISTUDIO_NUM_ENVELOPES
famistudio_env_repeat: .rs FAMISTUDIO_NUM_ENVELOPES
famistudio_env_addr_lo: .rs FAMISTUDIO_NUM_ENVELOPES
famistudio_env_addr_hi: .rs FAMISTUDIO_NUM_ENVELOPES
famistudio_env_ptr: .rs FAMISTUDIO_NUM_ENVELOPES
famistudio_pitch_env_value_lo: .rs FAMISTUDIO_NUM_PITCH_ENVELOPES
famistudio_pitch_env_value_hi: .rs FAMISTUDIO_NUM_PITCH_ENVELOPES
famistudio_pitch_env_repeat: .rs FAMISTUDIO_NUM_PITCH_ENVELOPES
famistudio_pitch_env_addr_lo: .rs FAMISTUDIO_NUM_PITCH_ENVELOPES
famistudio_pitch_env_addr_hi: .rs FAMISTUDIO_NUM_PITCH_ENVELOPES
famistudio_pitch_env_ptr: .rs FAMISTUDIO_NUM_PITCH_ENVELOPES
.if FAMISTUDIO_USE_PITCH_TRACK
famistudio_pitch_env_fine_value: .rs FAMISTUDIO_NUM_PITCH_ENVELOPES
.endif
.if FAMISTUDIO_USE_SLIDE_NOTES
famistudio_slide_step: .rs FAMISTUDIO_NUM_SLIDES
famistudio_slide_pitch_lo: .rs FAMISTUDIO_NUM_SLIDES
famistudio_slide_pitch_hi: .rs FAMISTUDIO_NUM_SLIDES
.endif
famistudio_chn_ptr_lo: .rs FAMISTUDIO_NUM_CHANNELS
famistudio_chn_ptr_hi: .rs FAMISTUDIO_NUM_CHANNELS
famistudio_chn_note: .rs FAMISTUDIO_NUM_CHANNELS
famistudio_chn_instrument: .rs FAMISTUDIO_NUM_CHANNELS
famistudio_chn_repeat: .rs FAMISTUDIO_NUM_CHANNELS
famistudio_chn_return_lo: .rs FAMISTUDIO_NUM_CHANNELS
famistudio_chn_return_hi: .rs FAMISTUDIO_NUM_CHANNELS
famistudio_chn_ref_len: .rs FAMISTUDIO_NUM_CHANNELS
.if FAMISTUDIO_USE_VOLUME_TRACK
famistudio_chn_volume_track: .rs FAMISTUDIO_NUM_CHANNELS
.if FAMISTUDIO_USE_VOLUME_SLIDES
famistudio_chn_volume_slide_step: .rs FAMISTUDIO_NUM_VOLUME_SLIDES
famistudio_chn_volume_slide_target: .rs FAMISTUDIO_NUM_VOLUME_SLIDES
.endif
.endif
.if (FAMISTUDIO_USE_VIBRATO != 0) | (FAMISTUDIO_USE_ARPEGGIO != 0)
famistudio_chn_env_override: .rs FAMISTUDIO_NUM_CHANNELS ; bit 7 = pitch, bit 0 = arpeggio.
.endif
.if FAMISTUDIO_USE_FAMITRACKER_DELAYED_NOTES_OR_CUTS
famistudio_chn_note_delay: .rs FAMISTUDIO_NUM_CHANNELS
famistudio_chn_cut_delay: .rs FAMISTUDIO_NUM_CHANNELS
.endif
.if (FAMISTUDIO_EXP_N163 != 0) | (FAMISTUDIO_EXP_VRC7 != 0) | (FAMISTUDIO_EXP_FDS != 0)
famistudio_chn_inst_changed: .rs FAMISTUDIO_NUM_CHANNELS-5
.endif
.if FAMISTUDIO_CFG_EQUALIZER
famistudio_chn_note_counter: .rs FAMISTUDIO_NUM_CHANNELS
.endif
.if FAMISTUDIO_EXP_VRC6
famistudio_vrc6_saw_volume: .rs 1 ; -1 = 1/4, 0 = 1/2, 1 = Full
.endif
.if FAMISTUDIO_EXP_VRC7
famistudio_chn_vrc7_prev_hi: .rs 6
famistudio_chn_vrc7_patch: .rs 6
famistudio_chn_vrc7_trigger: .rs 6 ; bit 0 = new note triggered, bit 7 = note released.
.endif
.if FAMISTUDIO_EXP_N163
famistudio_chn_n163_wave_len: .rs FAMISTUDIO_EXP_N163_CHN_CNT
.endif
.if FAMISTUDIO_USE_DUTYCYCLE_EFFECT
famistudio_duty_cycle: .rs FAMISTUDIO_NUM_DUTY_CYCLES
.endif
.if FAMISTUDIO_USE_FAMITRACKER_TEMPO
famistudio_tempo_step_lo: .rs 1
famistudio_tempo_step_hi: .rs 1
famistudio_tempo_acc_lo: .rs 1
famistudio_tempo_acc_hi: .rs 1
.if FAMISTUDIO_USE_FAMITRACKER_DELAYED_NOTES_OR_CUTS
famistudio_tempo_advance_row: .rs 1
.endif
.else
famistudio_tempo_env_ptr_lo: .rs 1
famistudio_tempo_env_ptr_hi: .rs 1
famistudio_tempo_env_counter: .rs 1
famistudio_tempo_env_idx: .rs 1
famistudio_tempo_frame_num: .rs 1
famistudio_tempo_frame_cnt: .rs 1
.endif
famistudio_pal_adjust: .rs 1
famistudio_song_list_lo: .rs 1
famistudio_song_list_hi: .rs 1
famistudio_instrument_lo: .rs 1
famistudio_instrument_hi: .rs 1
famistudio_dpcm_list_lo: .rs 1 ; TODO: Not needed if DPCM support is disabled.
famistudio_dpcm_list_hi: .rs 1 ; TODO: Not needed if DPCM support is disabled.
famistudio_dpcm_effect: .rs 1 ; TODO: Not needed if DPCM support is disabled.
famistudio_pulse1_prev: .rs 1
famistudio_pulse2_prev: .rs 1
famistudio_song_speed = famistudio_chn_instrument+4
.if FAMISTUDIO_EXP_MMC5
famistudio_mmc5_pulse1_prev: .rs 1
famistudio_mmc5_pulse2_prev: .rs 1
.endif
.if FAMISTUDIO_EXP_FDS
famistudio_fds_mod_speed: .rs 2
famistudio_fds_mod_depth: .rs 1
famistudio_fds_mod_delay: .rs 1
famistudio_fds_override_flags: .rs 1 ; Bit 7 = mod speed overriden, bit 6 mod depth overriden
.endif
.if FAMISTUDIO_EXP_VRC7
famistudio_vrc7_dummy: .rs 1 ; TODO: Find a dummy address i can simply write to without side effects.
.endif
; FDS, N163 and VRC7 have very different instrument layout and are 16-bytes, so we keep them seperate.
.if (FAMISTUDIO_EXP_FDS != 0) | (FAMISTUDIO_EXP_N163 != 0) | (FAMISTUDIO_EXP_VRC7 != 0)
famistudio_exp_instrument_lo: .rs 1
famistudio_exp_instrument_hi: .rs 1
.endif
.if FAMISTUDIO_CFG_SFX_SUPPORT
famistudio_output_buf: .rs 11
famistudio_sfx_addr_lo: .rs 1
famistudio_sfx_addr_hi: .rs 1
famistudio_sfx_base_addr: .rs (FAMISTUDIO_CFG_SFX_STREAMS * FAMISTUDIO_SFX_STRUCT_SIZE)
; TODO: Refactor SFX memory layout. These uses a AoS approach, not fan.
famistudio_sfx_repeat = famistudio_sfx_base_addr + 0
famistudio_sfx_ptr_lo = famistudio_sfx_base_addr + 1
famistudio_sfx_ptr_hi = famistudio_sfx_base_addr + 2
famistudio_sfx_offset = famistudio_sfx_base_addr + 3
famistudio_sfx_buffer = famistudio_sfx_base_addr + 4
.endif
;======================================================================================================================
; ZEROPAGE VARIABLES
;
; These are only used as temporary variable during the famistudio_xxx calls.
; Feel free to alias those with other ZP values in your programs to save a few bytes.
;======================================================================================================================
.ifdef FAMISTUDIO_NESASM_ZP_SECTION
.zp
.endif
.ifdef FAMISTUDIO_NESASM_ZP_RSSET
.rsset FAMISTUDIO_NESASM_ZP_RSSET
.endif
famistudio_r0: .rs 1
famistudio_r1: .rs 1
famistudio_r2: .rs 1
famistudio_ptr0: .rs 2
famistudio_ptr1: .rs 2
famistudio_ptr0_lo = famistudio_ptr0+0
famistudio_ptr0_hi = famistudio_ptr0+1
famistudio_ptr1_lo = famistudio_ptr1+0
famistudio_ptr1_hi = famistudio_ptr1+1
;======================================================================================================================
; CODE
;======================================================================================================================
.ifdef FAMISTUDIO_NESASM_CODE_SECTION
.code
.endif
.ifdef FAMISTUDIO_NESASM_CODE_BANK
.bank FAMISTUDIO_NESASM_CODE_BANK
.endif
.ifdef FAMISTUDIO_NESASM_CODE_ORG
.org FAMISTUDIO_NESASM_CODE_ORG
.endif
FAMISTUDIO_APU_PL1_VOL = $4000
FAMISTUDIO_APU_PL1_SWEEP = $4001
FAMISTUDIO_APU_PL1_LO = $4002
FAMISTUDIO_APU_PL1_HI = $4003
FAMISTUDIO_APU_PL2_VOL = $4004
FAMISTUDIO_APU_PL2_SWEEP = $4005
FAMISTUDIO_APU_PL2_LO = $4006
FAMISTUDIO_APU_PL2_HI = $4007
FAMISTUDIO_APU_TRI_LINEAR = $4008
FAMISTUDIO_APU_TRI_LO = $400a
FAMISTUDIO_APU_TRI_HI = $400b
FAMISTUDIO_APU_NOISE_VOL = $400c
FAMISTUDIO_APU_NOISE_LO = $400e
FAMISTUDIO_APU_NOISE_HI = $400f
FAMISTUDIO_APU_DMC_FREQ = $4010
FAMISTUDIO_APU_DMC_RAW = $4011
FAMISTUDIO_APU_DMC_START = $4012
FAMISTUDIO_APU_DMC_LEN = $4013
FAMISTUDIO_APU_SND_CHN = $4015
FAMISTUDIO_APU_FRAME_CNT = $4017
.if FAMISTUDIO_EXP_VRC6
FAMISTUDIO_VRC6_PL1_VOL = $9000
FAMISTUDIO_VRC6_PL1_LO = $9001
FAMISTUDIO_VRC6_PL1_HI = $9002
FAMISTUDIO_VRC6_PL2_VOL = $a000
FAMISTUDIO_VRC6_PL2_LO = $a001
FAMISTUDIO_VRC6_PL2_HI = $a002
FAMISTUDIO_VRC6_SAW_VOL = $b000
FAMISTUDIO_VRC6_SAW_LO = $b001
FAMISTUDIO_VRC6_SAW_HI = $b002
.endif
.if FAMISTUDIO_EXP_VRC7
FAMISTUDIO_VRC7_SILENCE = $e000
FAMISTUDIO_VRC7_REG_SEL = $9010
FAMISTUDIO_VRC7_REG_WRITE = $9030
FAMISTUDIO_VRC7_REG_LO_1 = $10
FAMISTUDIO_VRC7_REG_LO_2 = $11
FAMISTUDIO_VRC7_REG_LO_3 = $12
FAMISTUDIO_VRC7_REG_LO_4 = $13
FAMISTUDIO_VRC7_REG_LO_5 = $14
FAMISTUDIO_VRC7_REG_LO_6 = $15
FAMISTUDIO_VRC7_REG_HI_1 = $20
FAMISTUDIO_VRC7_REG_HI_2 = $21
FAMISTUDIO_VRC7_REG_HI_3 = $22
FAMISTUDIO_VRC7_REG_HI_4 = $23
FAMISTUDIO_VRC7_REG_HI_5 = $24
FAMISTUDIO_VRC7_REG_HI_6 = $25
FAMISTUDIO_VRC7_REG_VOL_1 = $30
FAMISTUDIO_VRC7_REG_VOL_2 = $31
FAMISTUDIO_VRC7_REG_VOL_3 = $32
FAMISTUDIO_VRC7_REG_VOL_4 = $33
FAMISTUDIO_VRC7_REG_VOL_5 = $34
FAMISTUDIO_VRC7_REG_VOL_6 = $35
.endif
.if FAMISTUDIO_EXP_MMC5
FAMISTUDIO_MMC5_PL1_VOL = $5000
FAMISTUDIO_MMC5_PL1_SWEEP = $5001
FAMISTUDIO_MMC5_PL1_LO = $5002
FAMISTUDIO_MMC5_PL1_HI = $5003
FAMISTUDIO_MMC5_PL2_VOL = $5004
FAMISTUDIO_MMC5_PL2_SWEEP = $5005
FAMISTUDIO_MMC5_PL2_LO = $5006
FAMISTUDIO_MMC5_PL2_HI = $5007
FAMISTUDIO_MMC5_PCM_MODE = $5010
FAMISTUDIO_MMC5_SND_CHN = $5015
.endif
.if FAMISTUDIO_EXP_N163
FAMISTUDIO_N163_SILENCE = $e000
FAMISTUDIO_N163_ADDR = $f800
FAMISTUDIO_N163_DATA = $4800
FAMISTUDIO_N163_REG_FREQ_LO = $78
FAMISTUDIO_N163_REG_PHASE_LO = $79
FAMISTUDIO_N163_REG_FREQ_MID = $7a
FAMISTUDIO_N163_REG_PHASE_MID = $7b
FAMISTUDIO_N163_REG_FREQ_HI = $7c
FAMISTUDIO_N163_REG_PHASE_HI = $7d
FAMISTUDIO_N163_REG_WAVE = $7e
FAMISTUDIO_N163_REG_VOLUME = $7f
.endif
.if FAMISTUDIO_EXP_S5B
FAMISTUDIO_S5B_ADDR = $c000
FAMISTUDIO_S5B_DATA = $e000
FAMISTUDIO_S5B_REG_LO_A = $00
FAMISTUDIO_S5B_REG_HI_A = $01
FAMISTUDIO_S5B_REG_LO_B = $02
FAMISTUDIO_S5B_REG_HI_B = $03
FAMISTUDIO_S5B_REG_LO_C = $04
FAMISTUDIO_S5B_REG_HI_C = $05
FAMISTUDIO_S5B_REG_NOISE = $06
FAMISTUDIO_S5B_REG_TONE = $07
FAMISTUDIO_S5B_REG_VOL_A = $08
FAMISTUDIO_S5B_REG_VOL_B = $09
FAMISTUDIO_S5B_REG_VOL_C = $0a
FAMISTUDIO_S5B_REG_ENV_LO = $0b
FAMISTUDIO_S5B_REG_ENV_HI = $0c
FAMISTUDIO_S5B_REG_SHAPE = $0d
FAMISTUDIO_S5B_REG_IO_A = $0e
FAMISTUDIO_S5B_REG_IO_B = $0f
.endif
.if FAMISTUDIO_EXP_FDS
FAMISTUDIO_FDS_WAV_START = $4040
FAMISTUDIO_FDS_VOL_ENV = $4080
FAMISTUDIO_FDS_FREQ_LO = $4082
FAMISTUDIO_FDS_FREQ_HI = $4083
FAMISTUDIO_FDS_SWEEP_ENV = $4084
FAMISTUDIO_FDS_SWEEP_BIAS = $4085
FAMISTUDIO_FDS_MOD_LO = $4086
FAMISTUDIO_FDS_MOD_HI = $4087
FAMISTUDIO_FDS_MOD_TABLE = $4088
FAMISTUDIO_FDS_VOL = $4089
FAMISTUDIO_FDS_ENV_SPEED = $408A
.endif
.if !FAMISTUDIO_CFG_SFX_SUPPORT
; Output directly to APU
FAMISTUDIO_ALIAS_PL1_VOL = FAMISTUDIO_APU_PL1_VOL
FAMISTUDIO_ALIAS_PL1_LO = FAMISTUDIO_APU_PL1_LO
FAMISTUDIO_ALIAS_PL1_HI = FAMISTUDIO_APU_PL1_HI
FAMISTUDIO_ALIAS_PL2_VOL = FAMISTUDIO_APU_PL2_VOL
FAMISTUDIO_ALIAS_PL2_LO = FAMISTUDIO_APU_PL2_LO
FAMISTUDIO_ALIAS_PL2_HI = FAMISTUDIO_APU_PL2_HI
FAMISTUDIO_ALIAS_TRI_LINEAR = FAMISTUDIO_APU_TRI_LINEAR
FAMISTUDIO_ALIAS_TRI_LO = FAMISTUDIO_APU_TRI_LO
FAMISTUDIO_ALIAS_TRI_HI = FAMISTUDIO_APU_TRI_HI
FAMISTUDIO_ALIAS_NOISE_VOL = FAMISTUDIO_APU_NOISE_VOL
FAMISTUDIO_ALIAS_NOISE_LO = FAMISTUDIO_APU_NOISE_LO
.else
; Otherwise write to the output buffer
FAMISTUDIO_ALIAS_PL1_VOL = famistudio_output_buf + 0
FAMISTUDIO_ALIAS_PL1_LO = famistudio_output_buf + 1
FAMISTUDIO_ALIAS_PL1_HI = famistudio_output_buf + 2
FAMISTUDIO_ALIAS_PL2_VOL = famistudio_output_buf + 3
FAMISTUDIO_ALIAS_PL2_LO = famistudio_output_buf + 4
FAMISTUDIO_ALIAS_PL2_HI = famistudio_output_buf + 5
FAMISTUDIO_ALIAS_TRI_LINEAR = famistudio_output_buf + 6
FAMISTUDIO_ALIAS_TRI_LO = famistudio_output_buf + 7
FAMISTUDIO_ALIAS_TRI_HI = famistudio_output_buf + 8
FAMISTUDIO_ALIAS_NOISE_VOL = famistudio_output_buf + 9
FAMISTUDIO_ALIAS_NOISE_LO = famistudio_output_buf + 10
.endif
;======================================================================================================================
; FAMISTUDIO_INIT (public)
;
; Reset APU, initialize the sound engine with some music data.
;
; [in] a : Playback platform, zero for PAL, non-zero for NTSC.
; [in] x : Pointer to music data (lo)
; [in] y : Pointer to music data (hi)
;======================================================================================================================
famistudio_init:
.music_data_ptr = famistudio_ptr0
stx famistudio_song_list_lo
sty famistudio_song_list_hi
stx <.music_data_ptr+0
sty <.music_data_ptr+1
.if FAMISTUDIO_DUAL_SUPPORT
tax
beq .pal
lda #97
.pal:
.else
.if FAMISTUDIO_CFG_PAL_SUPPORT
lda #0
.endif
.if FAMISTUDIO_CFG_NTSC_SUPPORT
lda #97
.endif
.endif
sta famistudio_pal_adjust
jsr famistudio_music_stop
; Instrument address
ldy #1
lda [.music_data_ptr],y
sta famistudio_instrument_lo
iny
lda [.music_data_ptr],y
sta famistudio_instrument_hi
iny
; Expansions instrument address
.if (FAMISTUDIO_EXP_FDS != 0) | (FAMISTUDIO_EXP_N163 != 0) | (FAMISTUDIO_EXP_VRC7 != 0)
lda [.music_data_ptr],y
sta famistudio_exp_instrument_lo
iny
lda [.music_data_ptr],y
sta famistudio_exp_instrument_hi
iny
.endif
; Sample list address
lda [.music_data_ptr],y
sta famistudio_dpcm_list_lo
iny
lda [.music_data_ptr],y
sta famistudio_dpcm_list_hi
lda #$80 ; Previous pulse period MSB, to not write it when not changed
sta famistudio_pulse1_prev
sta famistudio_pulse2_prev
lda #$0f ; Enable channels, stop DMC
sta FAMISTUDIO_APU_SND_CHN
lda #$80 ; Disable triangle length counter
sta FAMISTUDIO_APU_TRI_LINEAR
lda #$00 ; Load noise length
sta FAMISTUDIO_APU_NOISE_HI
lda #$30 ; Volumes to 0
sta FAMISTUDIO_APU_PL1_VOL
sta FAMISTUDIO_APU_PL2_VOL
sta FAMISTUDIO_APU_NOISE_VOL
lda #$08 ; No sweep
sta FAMISTUDIO_APU_PL1_SWEEP
sta FAMISTUDIO_APU_PL2_SWEEP
.if FAMISTUDIO_EXP_VRC7
lda #0
sta FAMISTUDIO_VRC7_SILENCE ; Enable VRC7 audio.
.endif
.if FAMISTUDIO_EXP_MMC5
lda #$00
sta FAMISTUDIO_MMC5_PCM_MODE
lda #$03
sta FAMISTUDIO_MMC5_SND_CHN
.endif
.if FAMISTUDIO_EXP_S5B
lda #FAMISTUDIO_S5B_REG_TONE
sta FAMISTUDIO_S5B_ADDR
lda #$38 ; No noise, just 3 tones for now.
sta FAMISTUDIO_S5B_DATA
.endif
jmp famistudio_music_stop
;======================================================================================================================
; FAMISTUDIO_MUSIC_STOP (public)
;
; Stops any music currently playing, if any. Note that this will not update the APU, so sound might linger. Calling
; famistudio_update after this will update the APU.
;
; [in] no input params.
;======================================================================================================================
famistudio_music_stop:
lda #0
sta famistudio_song_speed
sta famistudio_dpcm_effect
ldx #0
.set_channels:
sta famistudio_chn_repeat,x
sta famistudio_chn_instrument,x
sta famistudio_chn_note,x
sta famistudio_chn_ref_len,x
.if FAMISTUDIO_USE_VOLUME_TRACK
sta famistudio_chn_volume_track,x
.endif
.if (FAMISTUDIO_USE_VIBRATO != 0) | (FAMISTUDIO_USE_ARPEGGIO != 0)
sta famistudio_chn_env_override,x
.endif
.if FAMISTUDIO_CFG_EQUALIZER
sta famistudio_chn_note_counter,x
.endif
.if FAMISTUDIO_USE_FAMITRACKER_DELAYED_NOTES_OR_CUTS
lda #$ff
sta famistudio_chn_note_delay,x
sta famistudio_chn_cut_delay,x
lda #0
.endif
inx
cpx #FAMISTUDIO_NUM_CHANNELS
bne .set_channels
.if FAMISTUDIO_USE_DUTYCYCLE_EFFECT
ldx #0
.set_duty_cycles:
sta famistudio_duty_cycle,x
inx
cpx #FAMISTUDIO_NUM_DUTY_CYCLES
bne .set_duty_cycles
.endif
.if FAMISTUDIO_USE_SLIDE_NOTES
ldx #0
.set_slides:
sta famistudio_slide_step, x
inx
cpx #FAMISTUDIO_NUM_SLIDES
bne .set_slides
.endif
.if FAMISTUDIO_USE_VOLUME_SLIDES
ldx #0
.set_volume_slides:
sta famistudio_chn_volume_slide_step, x
sta famistudio_chn_volume_slide_target, x
inx
cpx #FAMISTUDIO_NUM_VOLUME_SLIDES
bne .set_volume_slides
.endif
ldx #0
.set_envelopes:
lda #LOW(famistudio_dummy_envelope)
sta famistudio_env_addr_lo,x
lda #HIGH(famistudio_dummy_envelope)
sta famistudio_env_addr_hi,x
lda #0
sta famistudio_env_repeat,x
sta famistudio_env_value,x
sta famistudio_env_ptr,x
inx
cpx #FAMISTUDIO_NUM_ENVELOPES
bne .set_envelopes
ldx #0
.set_pitch_envelopes:
lda #LOW(famistudio_dummy_pitch_envelope)
sta famistudio_pitch_env_addr_lo,x
lda #HIGH(famistudio_dummy_pitch_envelope)
sta famistudio_pitch_env_addr_hi,x
lda #0
sta famistudio_pitch_env_repeat,x
sta famistudio_pitch_env_value_lo,x
sta famistudio_pitch_env_value_hi,x
.if FAMISTUDIO_USE_PITCH_TRACK
sta famistudio_pitch_env_fine_value,x
.endif
lda #1
sta famistudio_pitch_env_ptr,x
inx
cpx #FAMISTUDIO_NUM_PITCH_ENVELOPES
bne .set_pitch_envelopes
jmp famistudio_sample_stop
;======================================================================================================================
; FAMISTUDIO_MUSIC_PLAY (public)
;
; Plays a song from the loaded music data (from a previous call to famistudio_init).
;
; [in] a : Song index.
;======================================================================================================================
famistudio_music_play:
.tmp = famistudio_ptr0_lo
.song_list_ptr = famistudio_ptr0
.temp_env_ptr = famistudio_ptr1
ldx famistudio_song_list_lo
stx <.song_list_ptr+0
ldx famistudio_song_list_hi
stx <.song_list_ptr+1
ldy #0
cmp [.song_list_ptr],y
bcc .valid_song
rts ; Invalid song index.
.valid_song:
.if FAMISTUDIO_NUM_CHANNELS = 5
asl a
sta <.tmp
asl a
tax
asl a
adc <.tmp
stx <.tmp
adc <.tmp
.endif
.if FAMISTUDIO_NUM_CHANNELS = 6
asl a
asl a
asl a
asl a
.endif
.if FAMISTUDIO_NUM_CHANNELS = 7
asl a
sta <.tmp
asl a
asl a
asl a
adc <.tmp
.endif
.if FAMISTUDIO_NUM_CHANNELS = 8
asl a
asl a
sta <.tmp
asl a
asl a
adc <.tmp
.endif
.if FAMISTUDIO_NUM_CHANNELS = 9
asl a
sta <.tmp
asl a
tax
asl a
asl a
adc <.tmp
stx <.tmp
adc <.tmp
.endif
.if FAMISTUDIO_NUM_CHANNELS = 10
asl a
asl a
asl a
sta <.tmp
asl a
adc <.tmp
.endif
.if FAMISTUDIO_NUM_CHANNELS = 11
asl a
sta <.tmp
asl a
asl a
tax
asl a
adc <.tmp
stx <.tmp
adc <.tmp
.endif
.if FAMISTUDIO_NUM_CHANNELS = 12
asl a
asl a
sta <.tmp
asl a
tax
asl a
adc <.tmp
stx <.tmp
adc <.tmp
.endif
.if FAMISTUDIO_NUM_CHANNELS = 13
asl a
sta <.tmp
asl a
asl a
asl a
asl a
sec
sbc <.tmp
.endif
.if (FAMISTUDIO_EXP_FDS != 0) | (FAMISTUDIO_EXP_VRC7 != 0) | (FAMISTUDIO_EXP_N163 != 0)
adc #7 ; We have an extra expansion instrument pointer for these.
.else
adc #5
.endif
tay
lda famistudio_song_list_lo
sta <.song_list_ptr+0
jsr famistudio_music_stop
ldx #0
.set_channels:
; Channel data address
lda [.song_list_ptr],y
sta famistudio_chn_ptr_lo,x
iny
lda [.song_list_ptr],y
sta famistudio_chn_ptr_hi,x
iny
lda #0
sta famistudio_chn_repeat,x
sta famistudio_chn_instrument,x
sta famistudio_chn_note,x
sta famistudio_chn_ref_len,x
.if FAMISTUDIO_USE_VOLUME_TRACK
lda #$f0
sta famistudio_chn_volume_track,x
.endif
.if FAMISTUDIO_USE_FAMITRACKER_DELAYED_NOTES_OR_CUTS
lda #$ff
sta famistudio_chn_note_delay,x
sta famistudio_chn_cut_delay,x
.endif
.nextchannel:
inx
cpx #FAMISTUDIO_NUM_CHANNELS
bne .set_channels
.if FAMISTUDIO_USE_FAMITRACKER_TEMPO
lda famistudio_pal_adjust
beq .pal
iny
iny
.pal:
; Tempo increment.
lda [.song_list_ptr],y
sta famistudio_tempo_step_lo
iny
lda [.song_list_ptr],y
sta famistudio_tempo_step_hi
lda #0 ; Reset tempo accumulator
sta famistudio_tempo_acc_lo
lda #6 ; Default speed
sta famistudio_tempo_acc_hi
sta famistudio_song_speed ; Apply default speed, this also enables music
.else
lda [.song_list_ptr],y
sta famistudio_tempo_env_ptr_lo
sta <.temp_env_ptr+0
iny
lda [.song_list_ptr],y
sta famistudio_tempo_env_ptr_hi
sta <.temp_env_ptr+1
iny
lda [.song_list_ptr],y
.if FAMISTUDIO_DUAL_SUPPORT ; Dual mode
ldx famistudio_pal_adjust
bne .ntsc_target
ora #1
.ntsc_target:
.else
.if FAMISTUDIO_CFG_PAL_SUPPORT ; PAL only
ora #1
.endif
.endif
tax
lda famistudio_tempo_frame_lookup, x ; Lookup contains the number of frames to run (0,1,2) to maintain tempo
sta famistudio_tempo_frame_num
ldy #0
sty famistudio_tempo_env_idx
lda [.temp_env_ptr],y
clc
adc #1
sta famistudio_tempo_env_counter
lda #6
sta famistudio_song_speed ; Non-zero simply so the song isnt considered paused.
.endif
.if FAMISTUDIO_EXP_VRC7
lda #0
ldx #5
.clear_vrc7_loop:
sta famistudio_chn_vrc7_prev_hi, x
sta famistudio_chn_vrc7_patch, x
sta famistudio_chn_vrc7_trigger,x
dex
bpl .clear_vrc7_loop
.endif
.if FAMISTUDIO_EXP_VRC6
lda #0
sta famistudio_vrc6_saw_volume
.endif
.if FAMISTUDIO_EXP_FDS
lda #0
sta famistudio_fds_mod_speed+0
sta famistudio_fds_mod_speed+1
sta famistudio_fds_mod_depth
sta famistudio_fds_mod_delay
sta famistudio_fds_override_flags
.endif
.if (FAMISTUDIO_EXP_N163 != 0) | (FAMISTUDIO_EXP_VRC7 != 0) | (FAMISTUDIO_EXP_FDS != 0)
lda #0
ldx #(FAMISTUDIO_NUM_CHANNELS-5)
.clear_inst_changed_loop:
sta famistudio_chn_inst_changed, x
dex
bpl .clear_inst_changed_loop
.endif
.if FAMISTUDIO_EXP_N163
lda #0
ldx #FAMISTUDIO_EXP_N163_CHN_CNT
.clear_vrc7_loop:
sta famistudio_chn_n163_wave_len, x
dex
bpl .clear_vrc7_loop
.endif
.skip:
rts
;======================================================================================================================
; FAMISTUDIO_MUSIC_PAUSE (public)
;
; Pause/unpause the currently playing song. Note that this will not update the APU, so sound might linger. Calling
; famistudio_update after this will update the APU.
;
; [in] a : zero to play, non-zero to pause.
;======================================================================================================================
famistudio_music_pause:
tax
beq .unpause
.pause:
jsr famistudio_sample_stop
lda #0
sta famistudio_env_value+FAMISTUDIO_CH0_ENVS+FAMISTUDIO_ENV_VOLUME_OFF
sta famistudio_env_value+FAMISTUDIO_CH1_ENVS+FAMISTUDIO_ENV_VOLUME_OFF
sta famistudio_env_value+FAMISTUDIO_CH2_ENVS+FAMISTUDIO_ENV_VOLUME_OFF
sta famistudio_env_value+FAMISTUDIO_CH3_ENVS+FAMISTUDIO_ENV_VOLUME_OFF
.ifdef FAMISTUDIO_CH5_ENVS
sta famistudio_env_value+FAMISTUDIO_CH5_ENVS+FAMISTUDIO_ENV_VOLUME_OFF
.endif
.ifdef FAMISTUDIO_CH6_ENVS
sta famistudio_env_value+FAMISTUDIO_CH6_ENVS+FAMISTUDIO_ENV_VOLUME_OFF
.endif
.ifdef FAMISTUDIO_CH7_ENVS
sta famistudio_env_value+FAMISTUDIO_CH7_ENVS+FAMISTUDIO_ENV_VOLUME_OFF
.endif
.ifdef FAMISTUDIO_CH8_ENVS
sta famistudio_env_value+FAMISTUDIO_CH8_ENVS+FAMISTUDIO_ENV_VOLUME_OFF
.endif
.ifdef FAMISTUDIO_CH9_ENVS
sta famistudio_env_value+FAMISTUDIO_CH9_ENVS+FAMISTUDIO_ENV_VOLUME_OFF
.endif
.ifdef FAMISTUDIO_CH10_ENVS
sta famistudio_env_value+FAMISTUDIO_CH10_ENVS+FAMISTUDIO_ENV_VOLUME_OFF
.endif
.ifdef FAMISTUDIO_CH11_ENVS
sta famistudio_env_value+FAMISTUDIO_CH11_ENVS+FAMISTUDIO_ENV_VOLUME_OFF
.endif
.ifdef FAMISTUDIO_CH12_ENVS
sta famistudio_env_value+FAMISTUDIO_CH12_ENVS+FAMISTUDIO_ENV_VOLUME_OFF
.endif
lda famistudio_song_speed ; <= 0 pauses the music
ora #$80
bne .done
.unpause:
lda famistudio_song_speed ; > 0 unpause music
and #$7f
.done:
sta famistudio_song_speed
rts
;======================================================================================================================
; FAMISTUDIO_GET_NOTE_PITCH_MACRO (internal)
;
; Uber-macro used to compute the final pitch of a note, taking into account the current note, arpeggios, instrument
; pitch envelopes, slide notes and fine pitch tracks.
;
; [in] x : note index.
; [in] y : slide/pitch envelope index.
; [out] famistudio_ptr1 : Final note pitch.
;======================================================================================================================
famistudio_get_note_pitch_macro .macro ; pitch_env_offset, note_table_lsb, note_table_msb
pitch_env_offset\@ = \1
;note_table_lsb\@ = \2 ; Getting "Internal error" when trying to do this.
;note_table_msb\@ = \3 ; Getting "Internal error" when trying to do this.
.pitch = famistudio_ptr1
.tmp_ror = famistudio_r0
.if FAMISTUDIO_USE_PITCH_TRACK
; Pitch envelope + fine pitch (sign extended)
clc
lda famistudio_pitch_env_fine_value+pitch_env_offset\@, y
adc famistudio_pitch_env_value_lo+pitch_env_offset\@, y
sta <.pitch+0
lda famistudio_pitch_env_fine_value+pitch_env_offset\@, y
and #$80
beq .pos
lda #$ff
.pos:
adc famistudio_pitch_env_value_hi+pitch_env_offset\@, y
sta <.pitch+1
.else
; Pitch envelope only
lda famistudio_pitch_env_value_lo+pitch_env_offset\@, y
sta <.pitch+0
lda famistudio_pitch_env_value_hi+pitch_env_offset\@, y
sta <.pitch+1
.endif
.if FAMISTUDIO_USE_SLIDE_NOTES
; Check if there is an active slide.
lda famistudio_slide_step+pitch_env_offset\@, y
beq .no_slide
; Add slide
.if (pitch_env_offset\@ >= 3) & ((FAMISTUDIO_EXP_VRC7 != 0) | (FAMISTUDIO_EXP_N163 != 0))
; These channels dont have fractional part for slides and have the same shift for slides + pitch.
clc
lda famistudio_slide_pitch_lo+pitch_env_offset\@, y
adc <.pitch+0
sta <.pitch+0
lda famistudio_slide_pitch_hi+pitch_env_offset\@, y
adc <.pitch+1
sta <.pitch+1
.else
; Most channels have 1 bit of fraction for slides.
lda famistudio_slide_pitch_hi+pitch_env_offset\@, y
cmp #$80 ; Sign extend upcoming right shift.
ror a ; We have 1 bit of fraction for slides, shift right hi byte.
sta <.tmp_ror
lda famistudio_slide_pitch_lo+pitch_env_offset\@, y
ror a ; Shift right low byte.
clc
adc <.pitch+0
sta <.pitch+0
lda <.tmp_ror
adc <.pitch+1
sta <.pitch+1
.endif
.endif
.no_slide:
.if (pitch_env_offset\@ >= 3) & ((FAMISTUDIO_EXP_VRC7 != 0) | (FAMISTUDIO_EXP_N163 != 0))
.if FAMISTUDIO_PITCH_SHIFT >= 1
asl <.pitch+0
rol <.pitch+1
.if FAMISTUDIO_PITCH_SHIFT >= 2
asl <.pitch+0
rol <.pitch+1
.if FAMISTUDIO_PITCH_SHIFT >= 3
asl <.pitch+0
rol <.pitch+1
.if FAMISTUDIO_PITCH_SHIFT >= 4
asl <.pitch+0
rol <.pitch+1
.if FAMISTUDIO_PITCH_SHIFT >= 5
asl <.pitch+0
rol <.pitch+1
.endif
.endif
.endif
.endif
.endif
.endif
; Finally, add note pitch.
clc
lda \2,x ; \2 = note_table_lsb
adc <.pitch+0
sta <.pitch+0
lda \3,x ; \3 = note_table_msb
adc <.pitch+1
sta <.pitch+1
.endm
famistudio_get_note_pitch:
famistudio_get_note_pitch_macro 0, famistudio_note_table_lsb, famistudio_note_table_msb
rts
.if FAMISTUDIO_EXP_VRC6
famistudio_get_note_pitch_vrc6_saw:
famistudio_get_note_pitch_macro 0, famistudio_saw_note_table_lsb, famistudio_saw_note_table_msb
rts
.endif
;======================================================================================================================
; FAMISTUDIO_SMOOTH_VIBRATO (internal)
;
; Implementation of Blaarg's smooth vibrato to eliminate pops on square channels. Called either from regular channel
; updates or from SFX code.
;
; [in] a : new hi period.
;======================================================================================================================
famistudio_smooth_vibrato .macro ; pulse_lo, pulse_prev, reg_hi, reg_lo, reg_sweep, pulse_lo_is_zp
pulse_lo\@ = \1
pulse_prev\@ = \2
reg_hi\@ = \3
reg_lo\@ = \4
reg_sweep\@ = \5
pulse_lo_is_zp\@ = \6
; Blaarg's smooth vibrato technique, only used if high period delta is 1 or -1.
tax ; X = new hi-period
sec
sbc pulse_prev\@ ; A = signed hi-period delta.
beq .done\@
stx pulse_prev\@
tay
iny ; We only care about -1 ($ff) and 1. Adding one means we only check of 0 or 2, we already checked for zero (so < 3).
cpy #$03
bcs .hi_delta_too_big\@
ldx #$40
stx FAMISTUDIO_APU_FRAME_CNT ; Reset frame counter in case it was about to clock
lda famistudio_smooth_vibrato_period_lo_lookup, y ; Be sure low 8 bits of timer period are $ff (for positive delta), or $00 (for negative delta)
sta reg_lo\@
lda famistudio_smooth_vibrato_sweep_lookup, y ; Sweep enabled, shift = 7, set negative flag or delta is negative..
sta reg_sweep\@
lda #$c0
sta FAMISTUDIO_APU_FRAME_CNT ; Clock sweep immediately
lda #$08
sta reg_sweep\@ ; Disable sweep
; HACK : It seems like in NESASM, macro parameters cant sometimes be ZP and sometimes not...
.if pulse_lo_is_zp\@ != 0
lda <pulse_lo\@
.else
lda pulse_lo\@
.endif
sta reg_lo\@ ; Restore lo-period.
jmp .done\@
.hi_delta_too_big\@:
stx reg_hi\@
.done\@:
.endm
;======================================================================================================================
; FAMISTUDIO_UPDATE_CHANNEL_SOUND (internal)
;
; Uber-macro used to update the APU registers for a given 2A03/VRC6/MMC5 channel. This macro is an absolute mess, but
; it is still more maintainable than having many different functions.
;
; [in] no input params.
;======================================================================================================================
famistudio_update_channel_sound .macro ; idx, env_offset, pulse_prev, vol_ora, hi_ora, reg_hi, reg_lo, reg_vol, reg_sweep
idx\@ = \1
env_offset\@ = \2
pulse_prev\@ = \3
vol_ora\@ = \4
hi_ora\@ = \5
reg_hi\@ = \6
reg_lo\@ = \7
reg_vol\@ = \8
reg_sweep\@ = \9
.tmp\@ = famistudio_r0
.pitch\@ = famistudio_ptr1
lda famistudio_chn_note+idx\@
bne .nocut\@
jmp .set_volume\@
.nocut\@:
clc
adc famistudio_env_value+env_offset\@+FAMISTUDIO_ENV_NOTE_OFF
.if idx\@ = 3 ; Noise channel is a bit special
.if FAMISTUDIO_USE_NOISE_SLIDE_NOTES
; Check if there is an active slide on the noise channel.
ldy famistudio_slide_step+FAMISTUDIO_NOISE_SLIDE_INDEX
beq .no_noise_slide\@
; We have 4 bits of fraction for noise slides.
sta <.tmp\@
lda famistudio_slide_pitch_lo+FAMISTUDIO_NOISE_SLIDE_INDEX
sta <.pitch\@+0
lda famistudio_slide_pitch_hi+FAMISTUDIO_NOISE_SLIDE_INDEX
cmp #$80
ror a
ror <.pitch\@+0
cmp #$80
ror a
ror <.pitch\@+0
cmp #$80
ror a
ror <.pitch\@+0
cmp #$80
ror a
lda <.pitch\@+0
ror a
clc
adc <.tmp\@
.endif
.no_noise_slide\@:
and #$0f
eor #$0f
sta <.tmp\@
ldx famistudio_env_value+env_offset\@+FAMISTUDIO_ENV_DUTY_OFF
lda famistudio_duty_lookup, x
asl a
and #$80
ora <.tmp\@
.else
.if FAMISTUDIO_DUAL_SUPPORT
clc
adc famistudio_pal_adjust
.endif
tax
; This basically does same as "famistudio_channel_to_pitch_env"
.if idx\@ < 3
ldy #idx\@
.else
ldy #(idx\@ - 2)
.endif
.if (FAMISTUDIO_EXP_VRC6 != 0) & (idx\@ = 7)
jsr famistudio_get_note_pitch_vrc6_saw
.else
jsr famistudio_get_note_pitch
.endif
lda <.pitch\@+0
sta reg_lo\@
lda <.pitch\@+1
.if (pulse_prev\@ != 0) & ((FAMISTUDIO_CFG_SFX_SUPPORT = 0) | (reg_sweep\@ = 0))
.if (reg_sweep\@ != 0) & (FAMISTUDIO_CFG_SMOOTH_VIBRATO != 0)
famistudio_smooth_vibrato .pitch\@, pulse_prev\@, reg_hi\@, reg_lo\@, reg_sweep\@, 1
.else
cmp pulse_prev\@
beq .compute_volume\@
sta pulse_prev\@
.endif
.endif
.if (hi_ora\@ != 0)
ora #hi_ora\@
.endif
.endif ; idx = 3
.if (pulse_prev\@ = 0) | (reg_sweep\@ = 0) | (FAMISTUDIO_CFG_SFX_SUPPORT != 0) | (FAMISTUDIO_CFG_SMOOTH_VIBRATO = 0)
sta reg_hi\@
.endif
.compute_volume\@:
.if FAMISTUDIO_USE_VOLUME_TRACK
lda famistudio_chn_volume_track+idx\@
.if FAMISTUDIO_USE_VOLUME_SLIDES
; During a slide, the lower 4 bits are fraction.
and #$f0
.endif
ora famistudio_env_value+env_offset\@+FAMISTUDIO_ENV_VOLUME_OFF
tax
lda famistudio_volume_table, x
.else
lda famistudio_env_value+env_offset\@+FAMISTUDIO_ENV_VOLUME_OFF
.endif
.if (FAMISTUDIO_EXP_VRC6 != 0) & (idx\@ = 7)
; VRC6 saw has 6-bits
ldx famistudio_vrc6_saw_volume
bmi .set_volume\@
asl a
ldx famistudio_vrc6_saw_volume
beq .set_volume\@
asl a
.endif
.set_volume\@:
.if (idx\@ = 0) | (idx\@ = 1) | (idx\@ = 3) | ((idx\@ >= 5) & (FAMISTUDIO_EXP_MMC5 != 0))
ldx famistudio_env_value+env_offset\@+FAMISTUDIO_ENV_DUTY_OFF
ora famistudio_duty_lookup, x
.else
.if ((idx\@ = 5) | (idx\@ = 6) & (FAMISTUDIO_EXP_VRC6 != 0))
ldx famistudio_env_value+env_offset\@+FAMISTUDIO_ENV_DUTY_OFF
ora famistudio_vrc6_duty_lookup, x
.endif
.endif
.if (vol_ora\@ != 0)
ora #vol_ora\@
.endif
sta reg_vol\@
.endm
.if FAMISTUDIO_EXP_FDS
;======================================================================================================================
; FAMISTUDIO_UPDATE_FDS_CHANNEL_SOUND (internal)
;
; Updates the FDS audio registers.
;
; [in] no input params.
;======================================================================================================================
famistudio_update_fds_channel_sound:
.pitch = famistudio_ptr1
lda famistudio_chn_note+5
bne .nocut
jmp .set_volume
.nocut:
clc
adc famistudio_env_value+FAMISTUDIO_CH5_ENVS+FAMISTUDIO_ENV_NOTE_OFF
tax
ldy #0
famistudio_get_note_pitch_macro 3, famistudio_fds_note_table_lsb, famistudio_fds_note_table_msb
lda <.pitch+0
sta FAMISTUDIO_FDS_FREQ_LO
lda <.pitch+1
sta FAMISTUDIO_FDS_FREQ_HI
.check_mod_delay:
lda famistudio_fds_mod_delay
beq .zero_delay
dec famistudio_fds_mod_delay
lda #$80
sta FAMISTUDIO_FDS_MOD_HI
bne .compute_volume
.zero_delay:
lda famistudio_fds_mod_speed+1
sta FAMISTUDIO_FDS_MOD_HI
lda famistudio_fds_mod_speed+0
sta FAMISTUDIO_FDS_MOD_LO
lda famistudio_fds_mod_depth
ora #$80
sta FAMISTUDIO_FDS_SWEEP_ENV
.compute_volume:
.if FAMISTUDIO_USE_VOLUME_TRACK
lda famistudio_chn_volume_track+5
.if FAMISTUDIO_USE_VOLUME_SLIDES
; During a slide, the lower 4 bits are fraction.
and #$f0
.endif
ora famistudio_env_value+FAMISTUDIO_CH5_ENVS+FAMISTUDIO_ENV_VOLUME_OFF
tax
lda famistudio_volume_table, x
.else
lda famistudio_env_value+FAMISTUDIO_CH5_ENVS+FAMISTUDIO_ENV_VOLUME_OFF
.endif
asl a ; FDS volume is 6-bits, but clamped to 32. Just double it.
.set_volume:
ora #$80
sta FAMISTUDIO_FDS_VOL_ENV
lda #0
sta famistudio_fds_override_flags
rts
.endif
.if FAMISTUDIO_EXP_VRC7
famistudio_vrc7_reg_table_lo:
.byte FAMISTUDIO_VRC7_REG_LO_1, FAMISTUDIO_VRC7_REG_LO_2, FAMISTUDIO_VRC7_REG_LO_3, FAMISTUDIO_VRC7_REG_LO_4, FAMISTUDIO_VRC7_REG_LO_5, FAMISTUDIO_VRC7_REG_LO_6
famistudio_vrc7_reg_table_hi:
.byte FAMISTUDIO_VRC7_REG_HI_1, FAMISTUDIO_VRC7_REG_HI_2, FAMISTUDIO_VRC7_REG_HI_3, FAMISTUDIO_VRC7_REG_HI_4, FAMISTUDIO_VRC7_REG_HI_5, FAMISTUDIO_VRC7_REG_HI_6
famistudio_vrc7_vol_table:
.byte FAMISTUDIO_VRC7_REG_VOL_1, FAMISTUDIO_VRC7_REG_VOL_2, FAMISTUDIO_VRC7_REG_VOL_3, FAMISTUDIO_VRC7_REG_VOL_4, FAMISTUDIO_VRC7_REG_VOL_5, FAMISTUDIO_VRC7_REG_VOL_6
famistudio_vrc7_env_table:
.byte FAMISTUDIO_CH5_ENVS, FAMISTUDIO_CH6_ENVS, FAMISTUDIO_CH7_ENVS, FAMISTUDIO_CH8_ENVS, FAMISTUDIO_CH9_ENVS, FAMISTUDIO_CH10_ENVS
famistudio_vrc7_invert_vol_table:
.byte $0f, $0e, $0d, $0c, $0b, $0a, $09, $08, $07, $06, $05, $04, $03, $02, $01, $00
; From nesdev wiki.
famistudio_vrc7_wait_reg_write:
stx famistudio_vrc7_dummy
ldx #$08
.wait_loop:
dex
bne .wait_loop
ldx famistudio_vrc7_dummy
rts
; From nesdev wiki.
famistudio_vrc7_wait_reg_select:
rts
;======================================================================================================================
; FAMISTUDIO_UPDATE_VRC7_CHANNEL_SOUND (internal)
;
; Updates the VRC7 audio registers for a given channel.
;
; [in] y: VRC7 channel idx (0,1,2,3,4,5)
;======================================================================================================================
famistudio_update_vrc7_channel_sound:
.pitch = famistudio_ptr1
lda #0
sta famistudio_chn_inst_changed,y
lda famistudio_chn_vrc7_trigger,y
bpl .check_cut
.release:
; Untrigger note.
lda famistudio_vrc7_reg_table_hi,y
sta FAMISTUDIO_VRC7_REG_SEL
jsr famistudio_vrc7_wait_reg_select
lda famistudio_chn_vrc7_prev_hi, y
and #$ef ; remove trigger
sta famistudio_chn_vrc7_prev_hi, y
sta FAMISTUDIO_VRC7_REG_WRITE
jsr famistudio_vrc7_wait_reg_write
rts
.check_cut:
lda famistudio_chn_note+5,y
bne .nocut
.cut:
; Untrigger note.
lda famistudio_vrc7_reg_table_hi,y
sta FAMISTUDIO_VRC7_REG_SEL
jsr famistudio_vrc7_wait_reg_select
lda famistudio_chn_vrc7_prev_hi, y
and #$cf ; Remove trigger + sustain
sta famistudio_chn_vrc7_prev_hi, y
sta FAMISTUDIO_VRC7_REG_WRITE
jsr famistudio_vrc7_wait_reg_write
rts
.nocut:
; Read note, apply arpeggio
clc
ldx famistudio_vrc7_env_table,y
adc famistudio_env_value+FAMISTUDIO_ENV_NOTE_OFF,x
tax
; Apply pitch envelope, fine pitch & slides
famistudio_get_note_pitch_macro 3, famistudio_vrc7_note_table_lsb, famistudio_vrc7_note_table_msb
; Compute octave by dividing by 2 until we are <= 512 (0x100).
ldx #0
.compute_octave_loop:
lda <.pitch+1
cmp #2
bcc .octave_done
lsr a
sta <.pitch+1
ror <.pitch+0
inx
jmp .compute_octave_loop
.octave_done:
; Write pitch (lo)
lda famistudio_vrc7_reg_table_lo,y
sta FAMISTUDIO_VRC7_REG_SEL
jsr famistudio_vrc7_wait_reg_select
lda <.pitch+0
sta FAMISTUDIO_VRC7_REG_WRITE
jsr famistudio_vrc7_wait_reg_write
; Un-trigger previous note if needed.
lda famistudio_chn_vrc7_prev_hi, y
and #$10 ; set trigger.
beq .write_hi_period
lda famistudio_chn_vrc7_trigger,y
beq .write_hi_period
.untrigger_prev_note:
lda famistudio_vrc7_reg_table_hi,y
sta FAMISTUDIO_VRC7_REG_SEL
jsr famistudio_vrc7_wait_reg_select
lda famistudio_chn_vrc7_prev_hi,y
and #$ef ; remove trigger
sta FAMISTUDIO_VRC7_REG_WRITE
jsr famistudio_vrc7_wait_reg_write
.write_hi_period:
; Write pitch (hi)
lda famistudio_vrc7_reg_table_hi,y
sta FAMISTUDIO_VRC7_REG_SEL
jsr famistudio_vrc7_wait_reg_select
txa
asl a
ora #$30
ora <.pitch+1
sta famistudio_chn_vrc7_prev_hi, y
sta FAMISTUDIO_VRC7_REG_WRITE
jsr famistudio_vrc7_wait_reg_write
; Read/multiply volume
ldx famistudio_vrc7_env_table,y
.if FAMISTUDIO_USE_VOLUME_TRACK
lda famistudio_chn_volume_track+5, y
.if FAMISTUDIO_USE_VOLUME_SLIDES
; During a slide, the lower 4 bits are fraction.
and #$f0
.endif
ora famistudio_env_value+FAMISTUDIO_ENV_VOLUME_OFF,x
.else
lda famistudio_env_value+FAMISTUDIO_ENV_VOLUME_OFF,x
.endif
tax
lda #0
sta famistudio_chn_vrc7_trigger,y
.update_volume:
; Write volume
lda famistudio_vrc7_vol_table,y
sta FAMISTUDIO_VRC7_REG_SEL
jsr famistudio_vrc7_wait_reg_select
.if FAMISTUDIO_USE_VOLUME_TRACK
lda famistudio_volume_table,x
tax
.endif
lda famistudio_vrc7_invert_vol_table,x
ora famistudio_chn_vrc7_patch,y
sta FAMISTUDIO_VRC7_REG_WRITE
jsr famistudio_vrc7_wait_reg_write
rts
.endif
.if FAMISTUDIO_EXP_N163
famistudio_n163_reg_table_lo:
.byte FAMISTUDIO_N163_REG_FREQ_LO - $00
.byte FAMISTUDIO_N163_REG_FREQ_LO - $08
.byte FAMISTUDIO_N163_REG_FREQ_LO - $10
.byte FAMISTUDIO_N163_REG_FREQ_LO - $18
.byte FAMISTUDIO_N163_REG_FREQ_LO - $20
.byte FAMISTUDIO_N163_REG_FREQ_LO - $28
.byte FAMISTUDIO_N163_REG_FREQ_LO - $30
.byte FAMISTUDIO_N163_REG_FREQ_LO - $38
famistudio_n163_reg_table_mid:
.byte FAMISTUDIO_N163_REG_FREQ_MID - $00
.byte FAMISTUDIO_N163_REG_FREQ_MID - $08
.byte FAMISTUDIO_N163_REG_FREQ_MID - $10
.byte FAMISTUDIO_N163_REG_FREQ_MID - $18
.byte FAMISTUDIO_N163_REG_FREQ_MID - $20
.byte FAMISTUDIO_N163_REG_FREQ_MID - $28
.byte FAMISTUDIO_N163_REG_FREQ_MID - $30
.byte FAMISTUDIO_N163_REG_FREQ_MID - $38
famistudio_n163_reg_table_hi:
.byte FAMISTUDIO_N163_REG_FREQ_HI - $00
.byte FAMISTUDIO_N163_REG_FREQ_HI - $08
.byte FAMISTUDIO_N163_REG_FREQ_HI - $10
.byte FAMISTUDIO_N163_REG_FREQ_HI - $18
.byte FAMISTUDIO_N163_REG_FREQ_HI - $20
.byte FAMISTUDIO_N163_REG_FREQ_HI - $28
.byte FAMISTUDIO_N163_REG_FREQ_HI - $30
.byte FAMISTUDIO_N163_REG_FREQ_HI - $38
famistudio_n163_vol_table:
.byte FAMISTUDIO_N163_REG_VOLUME - $00
.byte FAMISTUDIO_N163_REG_VOLUME - $08
.byte FAMISTUDIO_N163_REG_VOLUME - $10
.byte FAMISTUDIO_N163_REG_VOLUME - $18
.byte FAMISTUDIO_N163_REG_VOLUME - $20
.byte FAMISTUDIO_N163_REG_VOLUME - $28
.byte FAMISTUDIO_N163_REG_VOLUME - $30
.byte FAMISTUDIO_N163_REG_VOLUME - $38
famistudio_n163_env_table:
.byte FAMISTUDIO_CH5_ENVS
.byte FAMISTUDIO_CH6_ENVS
.byte FAMISTUDIO_CH7_ENVS
.byte FAMISTUDIO_CH8_ENVS
.byte FAMISTUDIO_CH9_ENVS
.byte FAMISTUDIO_CH10_ENVS
.byte FAMISTUDIO_CH11_ENVS
.byte FAMISTUDIO_CH12_ENVS
;======================================================================================================================
; FAMISTUDIO_UPDATE_N163_CHANNEL_SOUND (internal)
;
; Updates the N163 audio registers for a given channel.
;
; [in] y: N163 channel idx (0,1,2,3,4,5,6,7)
;======================================================================================================================
famistudio_update_n163_channel_sound:
.pitch = famistudio_ptr1
.pitch_hi = famistudio_r2
lda famistudio_chn_note+5,y
bne .nocut
ldx #0 ; This will fetch volume 0.
bne .nocut
jmp .update_volume
.nocut:
; Read note, apply arpeggio
clc
ldx famistudio_n163_env_table,y
adc famistudio_env_value+FAMISTUDIO_ENV_NOTE_OFF,x
tax
; Apply pitch envelope, fine pitch & slides
famistudio_get_note_pitch_macro 3, famistudio_n163_note_table_lsb, famistudio_n163_note_table_msb
; Convert 16-bit -> 18-bit.
asl <.pitch+0
rol <.pitch+1
lda #0
adc #0
sta <.pitch_hi
asl <.pitch+0
rol <.pitch+1
rol <.pitch_hi
; Write pitch
lda famistudio_n163_reg_table_lo,y
sta FAMISTUDIO_N163_ADDR
lda <.pitch+0
sta FAMISTUDIO_N163_DATA
lda famistudio_n163_reg_table_mid,y
sta FAMISTUDIO_N163_ADDR
lda <.pitch+1
sta FAMISTUDIO_N163_DATA
lda famistudio_n163_reg_table_hi,y
sta FAMISTUDIO_N163_ADDR
lda famistudio_chn_n163_wave_len,y
ora <.pitch_hi
sta FAMISTUDIO_N163_DATA
; Read/multiply volume
ldx famistudio_n163_env_table,y
.if FAMISTUDIO_USE_VOLUME_TRACK
lda famistudio_chn_volume_track+5, y
.if FAMISTUDIO_USE_VOLUME_SLIDES
; During a slide, the lower 4 bits are fraction.
and #$f0
.endif
ora famistudio_env_value+FAMISTUDIO_ENV_VOLUME_OFF,x
.else
lda famistudio_env_value+FAMISTUDIO_ENV_VOLUME_OFF,x
.endif
tax
.update_volume:
; Write volume
lda famistudio_n163_vol_table,y
sta FAMISTUDIO_N163_ADDR
.if FAMISTUDIO_USE_VOLUME_TRACK
lda famistudio_volume_table,x
.else
txa
.endif
ora #FAMISTUDIO_N163_CHN_MASK
sta FAMISTUDIO_N163_DATA
lda #0
sta famistudio_chn_inst_changed,y
rts
.endif
.if FAMISTUDIO_EXP_S5B
famistudio_s5b_reg_table_lo:
.byte FAMISTUDIO_S5B_REG_LO_A, FAMISTUDIO_S5B_REG_LO_B, FAMISTUDIO_S5B_REG_LO_C
famistudio_s5b_reg_table_hi:
.byte FAMISTUDIO_S5B_REG_HI_A, FAMISTUDIO_S5B_REG_HI_B, FAMISTUDIO_S5B_REG_HI_C
famistudio_s5b_vol_table:
.byte FAMISTUDIO_S5B_REG_VOL_A, FAMISTUDIO_S5B_REG_VOL_B, FAMISTUDIO_S5B_REG_VOL_C
famistudio_s5b_env_table:
.byte FAMISTUDIO_CH5_ENVS, FAMISTUDIO_CH6_ENVS, FAMISTUDIO_CH7_ENVS
;======================================================================================================================
; FAMISTUDIO_UPDATE_S5B_CHANNEL_SOUND (internal)
;
; Updates the S5B audio registers for a given channel.
;
; [in] y: S5B channel idx (0,1,2)
;======================================================================================================================
famistudio_update_s5b_channel_sound:
.pitch = famistudio_ptr1
lda famistudio_chn_note+5,y
bne .nocut
ldx #0 ; This will fetch volume 0.
beq .update_volume
.nocut:
; Read note, apply arpeggio
clc
ldx famistudio_s5b_env_table,y
adc famistudio_env_value+FAMISTUDIO_ENV_NOTE_OFF,x
tax
; Apply pitch envelope, fine pitch & slides
famistudio_get_note_pitch_macro 3, famistudio_note_table_lsb, famistudio_note_table_msb
; Write pitch
lda famistudio_s5b_reg_table_lo,y
sta FAMISTUDIO_S5B_ADDR
lda <.pitch+0
sta FAMISTUDIO_S5B_DATA
lda famistudio_s5b_reg_table_hi,y
sta FAMISTUDIO_S5B_ADDR
lda <.pitch+1
sta FAMISTUDIO_S5B_DATA
; Read/multiply volume
ldx famistudio_s5b_env_table,y
.if FAMISTUDIO_USE_VOLUME_TRACK
lda famistudio_chn_volume_track+5, y
.if FAMISTUDIO_USE_VOLUME_SLIDES
; During a slide, the lower 4 bits are fraction.
and #$f0
.endif
ora famistudio_env_value+FAMISTUDIO_ENV_VOLUME_OFF,x
.else
lda famistudio_env_value+FAMISTUDIO_ENV_VOLUME_OFF,x
.endif
tax
.update_volume:
; Write volume
lda famistudio_s5b_vol_table,y
sta FAMISTUDIO_S5B_ADDR
.if FAMISTUDIO_USE_VOLUME_TRACK
lda famistudio_volume_table,x
sta FAMISTUDIO_S5B_DATA
.else
stx FAMISTUDIO_S5B_DATA
.endif
rts
.endif
;======================================================================================================================
; FAMISTUDIO_UPDATE_ROW (internal)
;
; Advance the song for a given channel. Will read any new note or effect (if any) and load any new
;
; [in] x: channel index (also true when leaving the function)
;======================================================================================================================
famistudio_update_row:
.if !FAMISTUDIO_CFG_DPCM_SUPPORT
cpx #4
beq .no_new_note
.endif
jsr famistudio_channel_update
bcc .no_new_note
txa
tay
ldx famistudio_channel_env,y
lda famistudio_chn_instrument,y
; TODO: If samples are disabled, there is no point in doing this test most of the time.
cpy #4
.if (FAMISTUDIO_EXP_VRC6 != 0) | (FAMISTUDIO_EXP_MMC5 != 0) | (FAMISTUDIO_EXP_S5B != 0)
bne .base_instrument
.else
bcc .base_instrument
.endif
.if (FAMISTUDIO_EXP_FDS != 0) | (FAMISTUDIO_EXP_VRC7 != 0) | (FAMISTUDIO_EXP_N163 != 0)
beq .dpcm
.if FAMISTUDIO_EXP_FDS
jsr famistudio_set_fds_instrument
jmp .new_note
.endif
.if FAMISTUDIO_EXP_VRC7
jsr famistudio_set_vrc7_instrument
jmp .new_note
.endif
.if FAMISTUDIO_EXP_N163
jsr famistudio_set_n163_instrument
jmp .new_note
.endif
.endif
.dpcm:
.if FAMISTUDIO_CFG_DPCM_SUPPORT
lda famistudio_chn_note+4
bne .play_sample
jsr famistudio_sample_stop
bne .no_new_note
.play_sample:
jsr famistudio_music_sample_play
ldx #4
jmp .new_note
.endif
.base_instrument:
jsr famistudio_set_instrument
.new_note:
.if FAMISTUDIO_CFG_EQUALIZER
lda #9
sta famistudio_chn_note_counter, x
.endif
.no_new_note:
rts
.if FAMISTUDIO_USE_FAMITRACKER_DELAYED_NOTES_OR_CUTS
;======================================================================================================================
; FAMISTUDIO_UPDATE_ROW_WITH_DELAYS (internal)
;
; Advance the song for a given channel, but while managing notes/cuts delays.
;
; [in] x: channel index (also true when leaving the function)
;======================================================================================================================
famistudio_update_row_with_delays:
; Is the tempo telling us to advance by 1 row?
lda famistudio_tempo_advance_row
beq .check_delayed_note
; Tempo says we need to advance, was there a delayed note wairing?
lda famistudio_chn_note_delay,x
bmi .advance
; Need to clear any pending delayed note before advancing (will be inaudible).
.clear_delayed_note:
lda #$ff
sta famistudio_chn_note_delay,x
jsr famistudio_update_row ; This is the update for the de delayed note.
jmp .advance
; Tempo said we didnt need to advance, see if there is delayed note with a counter that reached zero.
.check_delayed_note:
lda famistudio_chn_note_delay,x
bmi .check_delayed_cut
sec
sbc #1
sta famistudio_chn_note_delay,x
bpl .check_delayed_cut ; When wrapping from 0 -> 0xff, we play the note.
; Finally, advance by 1 row.
.advance:
jsr famistudio_update_row
; Handle delayed cuts.
.check_delayed_cut:
lda famistudio_chn_cut_delay,x
bmi .done
sec
sbc #1
sta famistudio_chn_cut_delay,x
bpl .done ; When wrapping from 0 -> 0xff, we play the note.
; Write a stop note.
lda #0
sta famistudio_chn_note,x
.done:
rts
.endif
;======================================================================================================================
; FAMISTUDIO_UPDATE (public)
;
; Main update function, should be called once per frame, ideally at the end of NMI. Will update the tempo, advance
; the song if needed, update instrument and apply any change to the APU registers.
;
; [in] no input params.
;======================================================================================================================
famistudio_update:
.pitch_env_type = famistudio_r0
.temp_pitch = famistudio_r1
.tempo_env_ptr = famistudio_ptr0
.env_ptr = famistudio_ptr0
.pitch_env_ptr = famistudio_ptr0
.if FAMISTUDIO_CFG_THREAD
lda <famistudio_ptr0_lo
pha
lda <famistudio_ptr0_hi
pha
.endif
lda famistudio_song_speed ; Speed 0 means that no music is playing currently
bmi .pause ; Bit 7 set is the pause flag
bne .update
.pause:
.if !FAMISTUDIO_USE_FAMITRACKER_TEMPO
lda #1
sta famistudio_tempo_frame_cnt
.endif
jmp .update_sound
;----------------------------------------------------------------------------------------------------------------------
.update:
.if FAMISTUDIO_USE_FAMITRACKER_TEMPO
lda famistudio_tempo_acc_hi
cmp famistudio_song_speed
.if FAMISTUDIO_USE_FAMITRACKER_DELAYED_NOTES_OR_CUTS
ldx #0
stx famistudio_tempo_advance_row
bcc .update_row
.else
bcc .update_envelopes
.endif
sbc famistudio_song_speed ; Carry is set.
sta famistudio_tempo_acc_hi
.if FAMISTUDIO_USE_FAMITRACKER_DELAYED_NOTES_OR_CUTS
ldx #1
stx famistudio_tempo_advance_row
.endif
.else ; FamiStudio tempo
; Decrement envelope counter, see if we need to advance.
dec famistudio_tempo_env_counter
beq .advance_tempo_envelope
lda #1
jmp .store_frame_count
.advance_tempo_envelope:
; Advance the envelope by one step.
lda famistudio_tempo_env_ptr_lo
sta <.tempo_env_ptr+0
lda famistudio_tempo_env_ptr_hi
sta <.tempo_env_ptr+1
inc famistudio_tempo_env_idx
ldy famistudio_tempo_env_idx
lda [.tempo_env_ptr],y
bpl .store_counter ; Negative value means we loop back to to index 1.
.tempo_envelope_end:
ldy #1
sty famistudio_tempo_env_idx
lda [.tempo_env_ptr],y
.store_counter:
; Reset the counter
sta famistudio_tempo_env_counter
lda famistudio_tempo_frame_num
bne .store_frame_count
jmp .skip_frame
.store_frame_count:
sta famistudio_tempo_frame_cnt
.endif
;----------------------------------------------------------------------------------------------------------------------
.update_row:
ldx #0
.channel_loop:
.if FAMISTUDIO_USE_FAMITRACKER_DELAYED_NOTES_OR_CUTS
jsr famistudio_update_row_with_delays
.else
jsr famistudio_update_row
.endif
inx
cpx #FAMISTUDIO_NUM_CHANNELS
bne .channel_loop
;----------------------------------------------------------------------------------------------------------------------
.update_envelopes:
ldx #0
.env_process:
lda famistudio_env_repeat,x
beq .env_read
dec famistudio_env_repeat,x
bne .env_next
.env_read:
lda famistudio_env_addr_lo,x
sta <.env_ptr+0
lda famistudio_env_addr_hi,x
sta <.env_ptr+1
ldy famistudio_env_ptr,x
.env_read_value:
lda [.env_ptr],y
bpl .env_special ; Values below 128 used as a special code, loop or repeat
clc ; Values above 128 are output value+192 (output values are signed -63..64)
adc #256-192
sta famistudio_env_value,x
iny
bne .env_next_store_ptr
.env_special:
bne .env_set_repeat ; Zero is the loop point, non-zero values used for the repeat counter
iny
lda [.env_ptr],y ; Read loop position
tay
jmp .env_read_value
.env_set_repeat:
iny
sta famistudio_env_repeat,x ; Store the repeat counter value
.env_next_store_ptr:
tya
sta famistudio_env_ptr,x
.env_next:
inx
cpx #FAMISTUDIO_NUM_ENVELOPES
bne .env_process
;----------------------------------------------------------------------------------------------------------------------
.update_pitch_envelopes:
ldx #0
jmp .pitch_env_process
.pitch_relate_update_with_last_value:
lda famistudio_pitch_env_repeat,x
sec
sbc #1
sta famistudio_pitch_env_repeat,x
and #$7f
beq .pitch_env_read
lda famistudio_pitch_env_addr_lo,x
sta <.pitch_env_ptr+0
lda famistudio_pitch_env_addr_hi,x
sta <.pitch_env_ptr+1
ldy famistudio_pitch_env_ptr,x
dey
dey
lda [.pitch_env_ptr],y
clc
adc #256-192
sta <.temp_pitch
clc
adc famistudio_pitch_env_value_lo,x
sta famistudio_pitch_env_value_lo,x
lda <.temp_pitch
bpl .pitch_relative_last_pos
lda #$ff
.pitch_relative_last_pos:
adc famistudio_pitch_env_value_hi,x
sta famistudio_pitch_env_value_hi,x
jmp .pitch_env_next
.pitch_env_process:
lda famistudio_pitch_env_repeat,x
cmp #$81
bcs .pitch_relate_update_with_last_value
and #$7f
beq .pitch_env_read
dec famistudio_pitch_env_repeat,x
bne .pitch_env_next
.pitch_env_read:
lda famistudio_pitch_env_addr_lo,x
sta <.pitch_env_ptr+0
lda famistudio_pitch_env_addr_hi,x
sta <.pitch_env_ptr+1
ldy #0
lda [.pitch_env_ptr],y
sta <.pitch_env_type ; First value is 0 for absolute envelope, 0x80 for relative.
ldy famistudio_pitch_env_ptr,x
.pitch_env_read_value:
lda [.pitch_env_ptr],y
bpl .pitch_env_special
clc
adc #256-192
bit <.pitch_env_type
bmi .pitch_relative
.pitch_absolute:
sta famistudio_pitch_env_value_lo,x
ora #0
bmi .pitch_absolute_neg
lda #0
jmp .pitch_absolute_set_value_hi
.pitch_absolute_neg:
lda #$ff
.pitch_absolute_set_value_hi:
sta famistudio_pitch_env_value_hi,x
iny
jmp .pitch_env_next_store_ptr
.pitch_relative:
sta <.temp_pitch
clc
adc famistudio_pitch_env_value_lo,x
sta famistudio_pitch_env_value_lo,x
lda <.temp_pitch
and #$80
bpl .pitch_relative_pos
lda #$ff
.pitch_relative_pos:
adc famistudio_pitch_env_value_hi,x
sta famistudio_pitch_env_value_hi,x
iny
jmp .pitch_env_next_store_ptr
.pitch_env_special:
bne .pitch_env_set_repeat
iny
lda [.pitch_env_ptr],y
tay
jmp .pitch_env_read_value
.pitch_env_set_repeat:
iny
ora <.pitch_env_type ; This is going to set the relative flag in the hi-bit.
sta famistudio_pitch_env_repeat,x
.pitch_env_next_store_ptr:
tya
sta famistudio_pitch_env_ptr,x
.pitch_env_next:
inx
cpx #FAMISTUDIO_NUM_PITCH_ENVELOPES
bne .pitch_env_process
.if FAMISTUDIO_USE_SLIDE_NOTES
;----------------------------------------------------------------------------------------------------------------------
.update_slides:
ldx #0
.slide_process:
lda famistudio_slide_step,x ; Zero repeat means no active slide.
beq .slide_next
clc ; Add step to slide pitch (16bit + 8bit signed).
lda famistudio_slide_step,x
adc famistudio_slide_pitch_lo,x
sta famistudio_slide_pitch_lo,x
lda famistudio_slide_step,x
and #$80
beq .positive_slide
.negative_slide:
lda #$ff
adc famistudio_slide_pitch_hi,x
sta famistudio_slide_pitch_hi,x
bpl .slide_next
jmp .clear_slide
.positive_slide:
adc famistudio_slide_pitch_hi,x
sta famistudio_slide_pitch_hi,x
bmi .slide_next
.clear_slide:
lda #0
sta famistudio_slide_step,x
.slide_next:
inx
cpx #FAMISTUDIO_NUM_SLIDES
bne .slide_process
.endif
.if FAMISTUDIO_USE_VOLUME_SLIDES
; FIXME : This seem wayyyy more complicated than it should.
; - The track volume has 4 bits of fraction : VVVVFFFF
; - The slide step is signed : SVVVFFFF
; - The slide target (end volume) is simply : VVVV0000
;
; foreach slides
; if step != 0
; volume += step
; if step > 0 && volume >= target || step < 0 && volume <= target
; volume = target
; step = 0
.update_volume_slides:
ldx #0
.volume_side_process:
lda famistudio_chn_volume_slide_step,x
beq .volume_slide_next
clc
bmi .negative_volume_slide
.positive_volume_slide:
; If the slide goes up, stop if we hit the target or go over it, over 15 (carry will be set)
adc famistudio_chn_volume_track,x
bcs .clear_volume_slide
sta famistudio_chn_volume_track,x
cmp famistudio_chn_volume_slide_target,x
bcc .volume_slide_next
bcs .clear_volume_slide
.negative_volume_slide:
; If the slide goes do, stop if we hit the target or go below it, or below zero.
; This is a bit trickier since we cant rely on the carry or any flag to
; tell us if we wrapped around.
adc famistudio_chn_volume_track,x
ldy famistudio_chn_volume_track,x
bmi .slide_upper_half
.slide_lower_half:
sta famistudio_chn_volume_track,x
cmp famistudio_chn_volume_slide_target,x
beq .clear_volume_slide
bmi .clear_volume_slide
bcc .volume_slide_next
.slide_upper_half:
sta famistudio_chn_volume_track,x
cmp famistudio_chn_volume_slide_target,x
beq .clear_volume_slide
bcs .volume_slide_next
.clear_volume_slide:
lda famistudio_chn_volume_slide_target,x
sta famistudio_chn_volume_track,x
lda #0
sta famistudio_chn_volume_slide_step,x
.volume_slide_next:
inx
cpx #FAMISTUDIO_NUM_VOLUME_SLIDES
bne .volume_side_process
.endif
.if FAMISTUDIO_CFG_EQUALIZER
.update_equalizer:
ldx #0
.eq_channel_loop:
lda famistudio_chn_note_counter, x
beq .no_note
dec famistudio_chn_note_counter, x
.no_note:
inx
cpx #FAMISTUDIO_NUM_CHANNELS
bne .eq_channel_loop
.endif
;----------------------------------------------------------------------------------------------------------------------
.update_sound:
famistudio_update_channel_sound 0, FAMISTUDIO_CH0_ENVS, famistudio_pulse1_prev, 0, 0, FAMISTUDIO_ALIAS_PL1_HI, FAMISTUDIO_ALIAS_PL1_LO, FAMISTUDIO_ALIAS_PL1_VOL, FAMISTUDIO_APU_PL1_SWEEP
famistudio_update_channel_sound 1, FAMISTUDIO_CH1_ENVS, famistudio_pulse2_prev, 0, 0, FAMISTUDIO_ALIAS_PL2_HI, FAMISTUDIO_ALIAS_PL2_LO, FAMISTUDIO_ALIAS_PL2_VOL, FAMISTUDIO_APU_PL2_SWEEP
famistudio_update_channel_sound 2, FAMISTUDIO_CH2_ENVS, 0, #$80, 0, FAMISTUDIO_ALIAS_TRI_HI, FAMISTUDIO_ALIAS_TRI_LO, FAMISTUDIO_ALIAS_TRI_LINEAR, 0
famistudio_update_channel_sound 3, FAMISTUDIO_CH3_ENVS, 0, #$f0, 0, FAMISTUDIO_ALIAS_NOISE_LO, 0, FAMISTUDIO_ALIAS_NOISE_VOL, 0
.if FAMISTUDIO_EXP_VRC6
famistudio_update_channel_sound 5, FAMISTUDIO_CH5_ENVS, 0, 0, #$80, FAMISTUDIO_VRC6_PL1_HI, FAMISTUDIO_VRC6_PL1_LO, FAMISTUDIO_VRC6_PL1_VOL, 0
famistudio_update_channel_sound 6, FAMISTUDIO_CH6_ENVS, 0, 0, #$80, FAMISTUDIO_VRC6_PL2_HI, FAMISTUDIO_VRC6_PL2_LO, FAMISTUDIO_VRC6_PL2_VOL, 0
famistudio_update_channel_sound 7, FAMISTUDIO_CH7_ENVS, 0, 0, #$80, FAMISTUDIO_VRC6_SAW_HI, FAMISTUDIO_VRC6_SAW_LO, FAMISTUDIO_VRC6_SAW_VOL, 0
.endif
.if FAMISTUDIO_EXP_MMC5
famistudio_update_channel_sound 5, FAMISTUDIO_CH5_ENVS, famistudio_mmc5_pulse1_prev, 0, 0, FAMISTUDIO_MMC5_PL1_HI, FAMISTUDIO_MMC5_PL1_LO, FAMISTUDIO_MMC5_PL1_VOL, 0
famistudio_update_channel_sound 6, FAMISTUDIO_CH6_ENVS, famistudio_mmc5_pulse2_prev, 0, 0, FAMISTUDIO_MMC5_PL2_HI, FAMISTUDIO_MMC5_PL2_LO, FAMISTUDIO_MMC5_PL2_VOL, 0
.endif
.if FAMISTUDIO_EXP_FDS
jsr famistudio_update_fds_channel_sound
.endif
.if FAMISTUDIO_EXP_VRC7
ldy #0
.vrc7_channel_loop:
jsr famistudio_update_vrc7_channel_sound
iny
cpy #6
bne .vrc7_channel_loop
.endif
.if FAMISTUDIO_EXP_N163
ldy #0
.n163_channel_loop:
jsr famistudio_update_n163_channel_sound
iny
cpy #FAMISTUDIO_EXP_N163_CHN_CNT
bne .n163_channel_loop
.endif
.if FAMISTUDIO_EXP_S5B
ldy #0
.s5b_channel_loop:
jsr famistudio_update_s5b_channel_sound
iny
cpy #3
bne .s5b_channel_loop
.endif
.if FAMISTUDIO_USE_FAMITRACKER_TEMPO
lda famistudio_song_speed
bmi .skip_famitracker_tempo_update ; bit 7 = paused
clc ; Update frame counter that considers speed, tempo, and PAL/NTSC
lda famistudio_tempo_acc_lo
adc famistudio_tempo_step_lo
sta famistudio_tempo_acc_lo
lda famistudio_tempo_acc_hi
adc famistudio_tempo_step_hi
sta famistudio_tempo_acc_hi
.skip_famitracker_tempo_update:
.else
; See if we need to run a double frame (playing NTSC song on PAL)
dec famistudio_tempo_frame_cnt
beq .skip_frame
jmp .update_row
.endif
.skip_frame:
;----------------------------------------------------------------------------------------------------------------------
.if FAMISTUDIO_CFG_SFX_SUPPORT
; Process all sound effect streams
.if FAMISTUDIO_CFG_SFX_STREAMS > 0
ldx #FAMISTUDIO_SFX_CH0
jsr famistudio_sfx_update
.endif
.if FAMISTUDIO_CFG_SFX_STREAMS > 1
ldx #FAMISTUDIO_SFX_CH1
jsr famistudio_sfx_update
.endif
.if FAMISTUDIO_CFG_SFX_STREAMS > 2
ldx #FAMISTUDIO_SFX_CH2
jsr famistudio_sfx_update
.endif
.if FAMISTUDIO_CFG_SFX_STREAMS > 3
ldx #FAMISTUDIO_SFX_CH3
jsr famistudio_sfx_update
.endif
; Send data from the output buffer to the APU
lda famistudio_output_buf ; Pulse 1 volume
sta FAMISTUDIO_APU_PL1_VOL
lda famistudio_output_buf+1 ; Pulse 1 period LSB
sta FAMISTUDIO_APU_PL1_LO
lda famistudio_output_buf+2 ; Pulse 1 period MSB, only applied when changed
.if FAMISTUDIO_CFG_SMOOTH_VIBRATO
famistudio_smooth_vibrato famistudio_output_buf+1, famistudio_pulse1_prev, FAMISTUDIO_APU_PL1_HI, FAMISTUDIO_APU_PL1_LO, FAMISTUDIO_APU_PL1_SWEEP, 0
.else
cmp famistudio_pulse1_prev
beq .no_pulse1_upd
sta famistudio_pulse1_prev
sta FAMISTUDIO_APU_PL1_HI
.endif
.no_pulse1_upd:
lda famistudio_output_buf+3 ; Pulse 2 volume
sta FAMISTUDIO_APU_PL2_VOL
lda famistudio_output_buf+4 ; Pulse 2 period LSB
sta FAMISTUDIO_APU_PL2_LO
lda famistudio_output_buf+5 ; Pulse 2 period MSB, only applied when changed
.if FAMISTUDIO_CFG_SMOOTH_VIBRATO
famistudio_smooth_vibrato famistudio_output_buf+4, famistudio_pulse2_prev, FAMISTUDIO_APU_PL2_HI, FAMISTUDIO_APU_PL2_LO, FAMISTUDIO_APU_PL2_SWEEP, 0
.else
cmp famistudio_pulse2_prev
beq .no_pulse2_upd
sta famistudio_pulse2_prev
sta FAMISTUDIO_APU_PL2_HI
.endif
.no_pulse2_upd:
lda famistudio_output_buf+6 ; Triangle volume (plays or not)
sta FAMISTUDIO_APU_TRI_LINEAR
lda famistudio_output_buf+7 ; Triangle period LSB
sta FAMISTUDIO_APU_TRI_LO
lda famistudio_output_buf+8 ; Triangle period MSB
sta FAMISTUDIO_APU_TRI_HI
lda famistudio_output_buf+9 ; Noise volume
sta FAMISTUDIO_APU_NOISE_VOL
lda famistudio_output_buf+10 ; Noise period
sta FAMISTUDIO_APU_NOISE_LO
.endif
.if FAMISTUDIO_CFG_THREAD
pla
sta <famistudio_ptr0_hi
pla
sta <famistudio_ptr0_lo
.endif
rts
;======================================================================================================================
; FAMISTUDIO_SET_INSTRUMENT (internal)
;
; Internal function to set an instrument for a given channel. Will initialize all instrument envelopes.
;
; [in] x: first envelope index for this channel.
; [in] y: channel index
; [in] a: instrument index.
;======================================================================================================================
famistudio_set_instrument:
.intrument_ptr = famistudio_ptr0
.chan_idx = famistudio_r1
.tmp_x = famistudio_r2
sty <.chan_idx
asl a ; Instrument number is pre multiplied by 4
tay
lda famistudio_instrument_hi
adc #0 ; Use carry to extend range for 64 instruments
sta <.intrument_ptr+1
lda famistudio_instrument_lo
sta <.intrument_ptr+0
; Volume envelope
lda [.intrument_ptr],y
sta famistudio_env_addr_lo,x
iny
lda [.intrument_ptr],y
iny
sta famistudio_env_addr_hi,x
inx
; Arpeggio envelope
.if FAMISTUDIO_USE_ARPEGGIO
stx <.tmp_x
ldx <.chan_idx
lda famistudio_chn_env_override,x ; Check if its overriden by arpeggio.
lsr a
ldx <.tmp_x
bcc .read_arpeggio_ptr
iny ; Instrument arpeggio is overriden by arpeggio, dont touch!
jmp .init_envelopes
.endif
.read_arpeggio_ptr:
lda [.intrument_ptr],y
sta famistudio_env_addr_lo,x
iny
lda [.intrument_ptr],y
sta famistudio_env_addr_hi,x
.init_envelopes:
; Initialize volume + arpeggio envelopes.
lda #1
sta famistudio_env_ptr-1,x ; Reset volume envelope pointer to 1 (volume have releases point in index 0)
lda #0
sta famistudio_env_repeat-1,x
sta famistudio_env_repeat,x
sta famistudio_env_ptr,x
; Duty cycle envelope
lda <.chan_idx
cmp #2 ; Triangle has no duty.
.if !FAMISTUDIO_EXP_S5B
bne .duty
.else
beq .no_duty
cmp #5 ; S5B has no duty.
bcc .duty
.endif
.no_duty:
iny
iny
bne .pitch_env
.duty:
inx
iny
lda [.intrument_ptr],y
sta famistudio_env_addr_lo,x
iny
lda [.intrument_ptr],y
sta famistudio_env_addr_hi,x
lda #0
sta famistudio_env_repeat,x
sta famistudio_env_ptr,x
.if FAMISTUDIO_USE_DUTYCYCLE_EFFECT
stx <.tmp_x
ldx <.chan_idx
lda famistudio_channel_to_dutycycle,x
tax
lda famistudio_duty_cycle,x
ldx <.tmp_x
.endif
sta famistudio_env_value,x
.pitch_env:
; Pitch envelopes.
ldx <.chan_idx
.if FAMISTUDIO_USE_VIBRATO
lda famistudio_chn_env_override,x ; Instrument pitch is overriden by vibrato, dont touch!
bmi .no_pitch
.endif
lda famistudio_channel_to_pitch_env, x
bmi .no_pitch
tax
lda #1
sta famistudio_pitch_env_ptr,x ; Reset pitch envelope pointert to 1 (pitch envelope have relative/absolute flag in the first byte)
lda #0
sta famistudio_pitch_env_repeat,x
sta famistudio_pitch_env_value_lo,x
sta famistudio_pitch_env_value_hi,x
iny
lda [.intrument_ptr],y
sta famistudio_pitch_env_addr_lo,x
iny
lda [.intrument_ptr],y
sta famistudio_pitch_env_addr_hi,x
.no_pitch:
ldx <.chan_idx
rts
.if (FAMISTUDIO_EXP_FDS != 0) | (FAMISTUDIO_EXP_N163 != 0) | (FAMISTUDIO_EXP_VRC7 != 0)
;======================================================================================================================
; FAMISTUDIO_SET_EXP_INSTRUMENT_BASE (internal)
;
; Internal macro to set an expansion instrument for a given channel. Will initialize all instrument envelopes.
;
; [in] x: first envelope index for this channel.
; [in] y: channel index
; [in] a: instrument index.
;======================================================================================================================
famistudio_set_exp_instrument .macro
.chan_idx = famistudio_r1
.tmp_x = famistudio_r2
.ptr = famistudio_ptr0
sty <.chan_idx
asl a ; Instrument number is pre multiplied by 4
asl a
tay
lda famistudio_exp_instrument_hi
adc #0 ; Use carry to extend range for 64 instruments
sta <.ptr+1
lda famistudio_exp_instrument_lo
sta <.ptr+0
; Volume envelope
lda [.ptr],y
sta famistudio_env_addr_lo,x
iny
lda [.ptr],y
iny
sta famistudio_env_addr_hi,x
inx
; Arpeggio envelope
.if FAMISTUDIO_USE_ARPEGGIO
stx <.tmp_x
ldx <.chan_idx
lda famistudio_chn_env_override,x ; Check if its overriden by arpeggio.
lsr a
ldx <.tmp_x
bcc .read_arpeggio_ptr
iny ; Instrument arpeggio is overriden by arpeggio, dont touch!
jmp .init_envelopes
.endif
.read_arpeggio_ptr:
lda [.ptr],y
sta famistudio_env_addr_lo,x
iny
lda [.ptr],y
sta famistudio_env_addr_hi,x
jmp .init_envelopes
.init_envelopes:
iny
; Initialize volume + arpeggio envelopes.
lda #1
sta famistudio_env_ptr-1,x ; Reset volume envelope pointer to 1 (volume have releases point in index 0)
lda #0
sta famistudio_env_repeat-1,x
sta famistudio_env_repeat,x
sta famistudio_env_ptr,x
; Pitch envelopes.
ldx <.chan_idx
.if FAMISTUDIO_USE_VIBRATO
lda famistudio_chn_env_override,x ; Instrument pitch is overriden by vibrato, dont touch!
bpl .pitch_env
iny
iny
bne .pitch_overriden
.endif
.pitch_env:
dex
dex ; Noise + DPCM dont have pitch envelopes
lda #1
sta famistudio_pitch_env_ptr,x ; Reset pitch envelope pointert to 1 (pitch envelope have relative/absolute flag in the first byte)
lda #0
sta famistudio_pitch_env_repeat,x
sta famistudio_pitch_env_value_lo,x
sta famistudio_pitch_env_value_hi,x
lda [.ptr],y
sta famistudio_pitch_env_addr_lo,x
iny
lda [.ptr],y
sta famistudio_pitch_env_addr_hi,x
iny
.pitch_overriden:
ldx <.chan_idx
.endm
.endif
.if FAMISTUDIO_EXP_VRC7
;======================================================================================================================
; FAMISTUDIO_SET_VRC7_INSTRUMENT (internal)
;
; Internal function to set a VRC7 instrument for a given channel. Will load custom patch if needed.
;
; [in] x: first envelope index for this channel.
; [in] y: channel index
; [in] a: instrument index.
;======================================================================================================================
famistudio_set_vrc7_instrument:
.ptr = famistudio_ptr0
.chan_idx = famistudio_r1
famistudio_set_exp_instrument #0
lda <.chan_idx
sec
sbc #5
tax
lda famistudio_chn_inst_changed,x
beq .done
lda [.ptr],y
sta famistudio_chn_vrc7_patch, x
bne .done
.read_custom_patch:
ldx #0
iny
iny
.read_patch_loop:
stx FAMISTUDIO_VRC7_REG_SEL
jsr famistudio_vrc7_wait_reg_select
lda [.ptr],y
iny
sta FAMISTUDIO_VRC7_REG_WRITE
jsr famistudio_vrc7_wait_reg_write
inx
cpx #8
bne .read_patch_loop
.done:
ldx <.chan_idx
rts
.endif
.if FAMISTUDIO_EXP_FDS
;======================================================================================================================
; FAMISTUDIO_SET_FDS_INSTRUMENT (internal)
;
; Internal function to set a FDS instrument. Will upload the wave and modulation envelope if needed.
;
; [in] x: first envelope index for this channel.
; [in] y: channel index
; [in] a: instrument index.
;======================================================================================================================
famistudio_set_fds_instrument:
.ptr = famistudio_ptr0
.wave_ptr = famistudio_ptr1
.master_vol = famistudio_r1
.tmp_y = famistudio_r2
famistudio_set_exp_instrument
lda #0
sta FAMISTUDIO_FDS_SWEEP_BIAS
lda famistudio_chn_inst_changed
bne .write_fds_wave
iny ; Skip master volume + wave + mod envelope.
iny
iny
iny
iny
jmp .load_mod_param
.write_fds_wave:
lda [.ptr],y
sta <.master_vol
iny
ora #$80
sta FAMISTUDIO_FDS_VOL ; Enable wave RAM write
; FDS Waveform
lda [.ptr],y
sta <.wave_ptr+0
iny
lda [.ptr],y
sta <.wave_ptr+1
iny
sty <.tmp_y
ldy #0
.wave_loop:
lda [.wave_ptr],y
sta FAMISTUDIO_FDS_WAV_START,y
iny
cpy #64
bne .wave_loop
lda #$80
sta FAMISTUDIO_FDS_MOD_HI ; Need to disable modulation before writing.
lda <.master_vol
sta FAMISTUDIO_FDS_VOL ; Disable RAM write.
lda #0
sta FAMISTUDIO_FDS_SWEEP_BIAS
; FDS Modulation
ldy <.tmp_y
lda [.ptr],y
sta <.wave_ptr+0
iny
lda [.ptr],y
sta <.wave_ptr+1
iny
sty <.tmp_y
ldy #0
.mod_loop:
lda [.wave_ptr],y
sta FAMISTUDIO_FDS_MOD_TABLE
iny
cpy #32
bne .mod_loop
lda #0
sta famistudio_chn_inst_changed
ldy <.tmp_y
.load_mod_param:
.check_mod_speed:
bit famistudio_fds_override_flags
bmi .mod_speed_overriden
.load_mod_speed:
lda [.ptr],y
sta famistudio_fds_mod_speed+0
iny
lda [.ptr],y
sta famistudio_fds_mod_speed+1
jmp .check_mod_depth
.mod_speed_overriden:
iny
.check_mod_depth:
iny
bit famistudio_fds_override_flags
bvs .mod_depth_overriden
.load_mod_depth:
lda [.ptr],y
sta famistudio_fds_mod_depth
.mod_depth_overriden:
iny
lda [.ptr],y
sta famistudio_fds_mod_delay
ldx #5
rts
.endif
.if FAMISTUDIO_EXP_N163
famistudio_n163_wave_table:
.byte FAMISTUDIO_N163_REG_WAVE - $00
.byte FAMISTUDIO_N163_REG_WAVE - $08
.byte FAMISTUDIO_N163_REG_WAVE - $10
.byte FAMISTUDIO_N163_REG_WAVE - $18
.byte FAMISTUDIO_N163_REG_WAVE - $20
.byte FAMISTUDIO_N163_REG_WAVE - $28
.byte FAMISTUDIO_N163_REG_WAVE - $30
.byte FAMISTUDIO_N163_REG_WAVE - $38
;======================================================================================================================
; FAMISTUDIO_SET_FDS_INSTRUMENT (internal)
;
; Internal function to set a N163 instrument. Will upload the waveform if needed.
;
; [in] x: first envelope index for this channel.
; [in] y: channel index
; [in] a: instrument index.
;======================================================================================================================
famistudio_set_n163_instrument:
.ptr = famistudio_ptr0
.wave_ptr = famistudio_ptr1
.wave_len = famistudio_r0
.chan_idx = famistudio_r1
.wave_pos = famistudio_r2
famistudio_set_exp_instrument
; Wave position
lda <.chan_idx
sec
sbc #5
tax
lda famistudio_chn_inst_changed,x
beq .done
lda famistudio_n163_wave_table, x
sta FAMISTUDIO_N163_ADDR
lda [.ptr],y
sta <.wave_pos
sta FAMISTUDIO_N163_DATA
iny
; Wave length
lda [.ptr],y
sta <.wave_len
lda #$00 ; 256 - wave length
sec
sbc <.wave_len
sec
sbc <.wave_len
sta famistudio_chn_n163_wave_len, x
iny
; N163 wave pointer.
lda [.ptr],y
sta <.wave_ptr+0
iny
lda [.ptr],y
sta <.wave_ptr+1
; N163 wave
lda <.wave_pos
ora #$80
sta FAMISTUDIO_N163_ADDR
ldy #0
.wave_loop:
lda [.wave_ptr],y
sta FAMISTUDIO_N163_DATA
iny
cpy <.wave_len
bne .wave_loop
.done:
ldx <.chan_idx
rts
.endif
; Increments 16-bit. (internal)
famistudio_inc_16 .macro ; addr
addr\@ = \1
inc <addr\@+0
bne .ok\@
inc <addr\@+1
.ok\@:
.endm
; Add 8-bit to a 16-bit (unsigned). (internal)
famistudio_add_16_8 .macro ; addr, val
addr\@ = \1
val\@ = \2
clc
lda #val\@
adc <addr\@+0
sta <addr\@+0
bcc .ok\@
inc <addr\@+1
.ok\@:
.endm
;======================================================================================================================
; FAMISTUDIO_CHANNEL_UPDATE (internal)
;
; Advances the song by one frame for a given channel. If a new note or effect(s) are found, they will be processed.
;
; [in] x: channel index
;======================================================================================================================
famistudio_channel_update:
; TODO : This function is an absolute mess:
; - Change all increments of the ptr to "iny" and increment the real pointer once.
; - See if we can unify the old FT2 "special_code" with our "special_code_6x".
.tmp_ptr_lo = famistudio_r0
.tmp_chan_idx = famistudio_r0
.tmp_slide_from = famistudio_r1
.tmp_slide_idx = famistudio_r1
.tmp_duty_cycle = famistudio_r1
.update_flags = famistudio_r2 ; bit 7 = no attack, bit 6 = has set delayed cut.
.slide_delta_lo = famistudio_ptr1_hi
.channel_data_ptr = famistudio_ptr0
.special_code_jmp_ptr = famistudio_ptr1
.tempo_env_ptr = famistudio_ptr1
.volume_env_ptr = famistudio_ptr1
lda famistudio_chn_repeat,x
beq .no_repeat
dec famistudio_chn_repeat,x
clc
rts
.no_repeat:
lda #0
sta <.update_flags
lda famistudio_chn_ptr_lo,x
sta <.channel_data_ptr+0
lda famistudio_chn_ptr_hi,x
sta <.channel_data_ptr+1
ldy #0
.read_byte:
lda [.channel_data_ptr],y
famistudio_inc_16 .channel_data_ptr
.check_regular_note:
cmp #$61
bcs .check_special_code ; $00 to $60 are regular notes, most common case.
jmp .regular_note
.check_special_code:
ora #0
bpl .check_volume_track
jmp .special_code ; Bit 7: 0=note 1=special code
.check_volume_track:
cmp #$70
bcc .special_code_6x
.if FAMISTUDIO_USE_VOLUME_TRACK
.volume_track:
and #$0f
asl a
asl a
asl a
asl a
sta famistudio_chn_volume_track,x
jmp .read_byte
.else
brk ; If you hit this, this mean you use the volume track in your songs, but did not enable the "FAMISTUDIO_USE_VOLUME_TRACK" feature.
.endif
.special_code_6x:
stx <.tmp_chan_idx
and #$0f
tax
lda .famistudio_special_code_jmp_lo-1,x
sta <.special_code_jmp_ptr+0
lda .famistudio_special_code_jmp_hi-1,x
sta <.special_code_jmp_ptr+1
ldx <.tmp_chan_idx
jmp [.special_code_jmp_ptr]
.if FAMISTUDIO_EXP_FDS
.special_code_fds_mod_depth:
lda [.channel_data_ptr],y
famistudio_inc_16 .channel_data_ptr
sta famistudio_fds_mod_depth
lda #$40
ora famistudio_fds_override_flags
sta famistudio_fds_override_flags
jmp .read_byte
.special_code_fds_mod_speed:
lda [.channel_data_ptr],y
sta famistudio_fds_mod_speed+0
iny
lda [.channel_data_ptr],y
sta famistudio_fds_mod_speed+1
famistudio_add_16_8 .channel_data_ptr, #2
lda #$80
ora famistudio_fds_override_flags
sta famistudio_fds_override_flags
dey
jmp .read_byte
.endif
.if FAMISTUDIO_EXP_VRC6
.special_code_vrc6_saw_volume:
lda [.channel_data_ptr],y
famistudio_inc_16 .channel_data_ptr
sta famistudio_vrc6_saw_volume
jmp .read_byte
.endif
.if FAMISTUDIO_USE_VOLUME_SLIDES
.special_code_volume_slide:
lda [.channel_data_ptr],y
iny
sta famistudio_chn_volume_slide_step, x
lda [.channel_data_ptr],y
sta famistudio_chn_volume_slide_target, x
famistudio_add_16_8 .channel_data_ptr, #2
dey
jmp .read_byte
.endif
.if FAMISTUDIO_USE_PITCH_TRACK
.special_code_fine_pitch:
stx <.tmp_chan_idx
lda famistudio_channel_to_pitch_env,x
tax
lda [.channel_data_ptr],y
famistudio_inc_16 .channel_data_ptr
sta famistudio_pitch_env_fine_value,x
ldx <.tmp_chan_idx
jmp .read_byte
.endif
.if FAMISTUDIO_USE_VIBRATO
.special_code_clear_pitch_override_flag:
lda #$7f
and famistudio_chn_env_override,x
sta famistudio_chn_env_override,x
jmp .read_byte
.special_code_override_pitch_envelope:
lda #$80
ora famistudio_chn_env_override,x
sta famistudio_chn_env_override,x
stx <.tmp_chan_idx
lda famistudio_channel_to_pitch_env,x
tax
lda [.channel_data_ptr],y
sta famistudio_pitch_env_addr_lo,x
iny
lda [.channel_data_ptr],y
sta famistudio_pitch_env_addr_hi,x
lda #0
tay
sta famistudio_pitch_env_repeat,x
lda #1
sta famistudio_pitch_env_ptr,x
ldx <.tmp_chan_idx
famistudio_add_16_8 .channel_data_ptr, #2
jmp .read_byte
.endif
.if FAMISTUDIO_USE_ARPEGGIO
.special_code_clear_arpeggio_override_flag:
lda #$fe
and famistudio_chn_env_override,x
sta famistudio_chn_env_override,x
jmp .read_byte
.special_code_override_arpeggio_envelope:
lda #$01
ora famistudio_chn_env_override,x
sta famistudio_chn_env_override,x
stx <.tmp_chan_idx
lda famistudio_channel_to_arpeggio_env,x
tax
lda [.channel_data_ptr],y
sta famistudio_env_addr_lo,x
iny
lda [.channel_data_ptr],y
sta famistudio_env_addr_hi,x
lda #0
tay
sta famistudio_env_repeat,x ; Reset the envelope since this might be a no-attack note.
sta famistudio_env_value,x
sta famistudio_env_ptr,x
ldx <.tmp_chan_idx
famistudio_add_16_8 .channel_data_ptr, #2
jmp .read_byte
.special_code_reset_arpeggio:
stx <.tmp_chan_idx
lda famistudio_channel_to_arpeggio_env,x
tax
lda #0
sta famistudio_env_repeat,x
sta famistudio_env_value,x
sta famistudio_env_ptr,x
ldx <.tmp_chan_idx
jmp .read_byte
.endif
.if FAMISTUDIO_USE_DUTYCYCLE_EFFECT
.special_code_duty_cycle_effect:
stx <.tmp_chan_idx
lda famistudio_channel_to_dutycycle,x
tax
lda [.channel_data_ptr],y
sta famistudio_duty_cycle,x
sta <.tmp_duty_cycle
ldx <.tmp_chan_idx
lda famistudio_channel_to_duty,x
tax
lda <.tmp_duty_cycle
sta famistudio_env_value,x
ldx <.tmp_chan_idx
famistudio_inc_16 .channel_data_ptr
jmp .read_byte
.endif
.if FAMISTUDIO_USE_FAMITRACKER_DELAYED_NOTES_OR_CUTS
.special_code_note_delay:
lda [.channel_data_ptr],y
sta famistudio_chn_note_delay,x
famistudio_inc_16 .channel_data_ptr
jmp .no_ref
.special_code_cut_delay:
lda #$40
sta <.update_flags
lda [.channel_data_ptr],y
sta famistudio_chn_cut_delay,x
famistudio_inc_16 .channel_data_ptr
jmp .read_byte
.endif
.if !FAMISTUDIO_USE_FAMITRACKER_TEMPO
.special_code_set_tempo_envelope:
; Load and reset the new tempo envelope.
lda [.channel_data_ptr],y
sta famistudio_tempo_env_ptr_lo
sta <.tempo_env_ptr+0
iny
lda [.channel_data_ptr],y
sta famistudio_tempo_env_ptr_hi
sta <.tempo_env_ptr+1
famistudio_add_16_8 .channel_data_ptr, #2
jmp .reset_tempo_env
.special_code_reset_tempo_envelope:
lda famistudio_tempo_env_ptr_lo
sta <.tempo_env_ptr+0
lda famistudio_tempo_env_ptr_hi
sta <.tempo_env_ptr+1
.reset_tempo_env:
ldy #0
sty famistudio_tempo_env_idx
lda [.tempo_env_ptr],y
sta famistudio_tempo_env_counter
jmp .read_byte
.endif
.special_code_disable_attack:
lda #$80
ora <.update_flags
sta <.update_flags
jmp .read_byte
.if FAMISTUDIO_USE_SLIDE_NOTES
.if FAMISTUDIO_USE_NOISE_SLIDE_NOTES
.noise_slide:
lda [.channel_data_ptr],y ; Read slide step size
iny
sta famistudio_slide_step+FAMISTUDIO_NOISE_SLIDE_INDEX
lda [.channel_data_ptr],y ; Read slide note from
iny
sec
sbc [.channel_data_ptr],y ; Read slide note to
sta famistudio_slide_pitch_lo+FAMISTUDIO_NOISE_SLIDE_INDEX
bpl .positive_noise_slide
.negative_noise_slide:
; Sign extend.
lda #$ff
bmi .noise_shift
.positive_noise_slide:
lda #$00
.noise_shift:
; Noise slides have 4-bits of fraction.
asl famistudio_slide_pitch_lo+FAMISTUDIO_NOISE_SLIDE_INDEX
rol a
asl famistudio_slide_pitch_lo+FAMISTUDIO_NOISE_SLIDE_INDEX
rol a
asl famistudio_slide_pitch_lo+FAMISTUDIO_NOISE_SLIDE_INDEX
rol a
asl famistudio_slide_pitch_lo+FAMISTUDIO_NOISE_SLIDE_INDEX
rol a
sta famistudio_slide_pitch_hi+FAMISTUDIO_NOISE_SLIDE_INDEX
jmp .slide_done_pos
.endif
.special_code_slide:
.if FAMISTUDIO_USE_NOISE_SLIDE_NOTES
cpx #3
beq .noise_slide
.endif
stx <.tmp_chan_idx
lda famistudio_channel_to_slide,x
tax
lda [.channel_data_ptr],y ; Read slide step size
iny
sta famistudio_slide_step,x
lda [.channel_data_ptr],y ; Read slide note from
.if FAMISTUDIO_DUAL_SUPPORT
clc
adc famistudio_pal_adjust
.endif
sta <.tmp_slide_from
iny
lda [.channel_data_ptr],y ; Read slide note to
ldy <.tmp_slide_from ; reload note from
.if FAMISTUDIO_DUAL_SUPPORT
adc famistudio_pal_adjust
.endif
stx <.tmp_slide_idx ; X contained the slide index.
tax
.ifdef FAMISTUDIO_EXP_NOTE_START
lda <.tmp_chan_idx
cmp #FAMISTUDIO_EXP_NOTE_START
bcs .note_table_expansion
.endif
sec ; Subtract the pitch of both notes.
lda famistudio_note_table_lsb,y
sbc famistudio_note_table_lsb,x
sta <.slide_delta_lo
lda famistudio_note_table_msb,y
sbc famistudio_note_table_msb,x
.ifdef FAMISTUDIO_EXP_NOTE_START
jmp .note_table_done
.note_table_expansion:
sec
lda famistudio_exp_note_table_lsb,y
sbc famistudio_exp_note_table_lsb,x
sta <.slide_delta_lo
lda famistudio_exp_note_table_msb,y
sbc famistudio_exp_note_table_msb,x
.note_table_done:
.endif
ldx <.tmp_slide_idx ; slide index.
sta famistudio_slide_pitch_hi,x
.if (FAMISTUDIO_EXP_N163 != 0) | (FAMISTUDIO_EXP_VRC7 != 0)
cpx #3 ; Slide #3 is the first of expansion slides.
bcs .positive_shift
.endif
.negative_shift:
lda <.slide_delta_lo
asl a ; Shift-left, we have 1 bit of fractional slide.
sta famistudio_slide_pitch_lo,x
rol famistudio_slide_pitch_hi,x ; Shift-left, we have 1 bit of fractional slide.
.if (FAMISTUDIO_EXP_N163 != 0) | (FAMISTUDIO_EXP_VRC7 != 0)
jmp .shift_done
.positive_shift:
lda <.slide_delta_lo
sta famistudio_slide_pitch_lo,x
.if FAMISTUDIO_PITCH_SHIFT >= 1
lda famistudio_slide_pitch_hi,x
cmp #$80
ror famistudio_slide_pitch_hi,x
ror famistudio_slide_pitch_lo,x
.if FAMISTUDIO_PITCH_SHIFT >= 2
lda famistudio_slide_pitch_hi,x
cmp #$80
ror famistudio_slide_pitch_hi,x
ror famistudio_slide_pitch_lo,x
.if FAMISTUDIO_PITCH_SHIFT >= 3
lda famistudio_slide_pitch_hi,x
cmp #$80
ror famistudio_slide_pitch_hi,x
ror famistudio_slide_pitch_lo,x
.if FAMISTUDIO_PITCH_SHIFT >= 4
lda famistudio_slide_pitch_hi,x
cmp #$80
ror famistudio_slide_pitch_hi,x
ror famistudio_slide_pitch_lo,x
.if FAMISTUDIO_PITCH_SHIFT >= 5
lda famistudio_slide_pitch_hi,x
cmp #$80
ror famistudio_slide_pitch_hi,x
ror famistudio_slide_pitch_lo,x
.endif
.endif
.endif
.endif
.endif
.shift_done:
.endif
ldx <.tmp_chan_idx
ldy #2
.slide_done_pos:
lda [.channel_data_ptr],y ; Re-read the target note (ugly...)
sta famistudio_chn_note,x ; Store note code
famistudio_add_16_8 .channel_data_ptr, #3
ldy #0
jmp .check_no_attack
.endif
.regular_note:
sta famistudio_chn_note,x ; Store note code
.if FAMISTUDIO_USE_SLIDE_NOTES
ldy famistudio_channel_to_slide,x ; Clear any previous slide on new node.
bmi .check_no_attack
lda #0
sta famistudio_slide_step,y
.endif
.check_no_attack:
bit <.update_flags
bmi .no_attack
.if FAMISTUDIO_USE_FAMITRACKER_DELAYED_NOTES_OR_CUTS
; Any note with an attack clears any pending delayed cut, unless it was set during this update (flags bit 6).
bvs .check_stop_note
lda #$ff
sta famistudio_chn_cut_delay,x
.endif
.check_stop_note:
lda famistudio_chn_note,x ; Dont trigger attack on stop notes.
beq .no_attack
.if FAMISTUDIO_EXP_VRC7
cpx #5
bcs .vrc7_channel
sec ; New note flag is set
jmp .done
.vrc7_channel:
lda #1
sta famistudio_chn_vrc7_trigger-5,x ; Set trigger flag for VRC7
.endif
.sec_and_done:
sec ; New note flag is set
jmp .done
.no_attack:
.if FAMISTUDIO_CFG_DPCM_SUPPORT
cpx #4
beq .sec_and_done
.endif
clc ; Pretend there is no new note.
jmp .done
.special_code:
and #$7f
lsr a
bcs .set_empty_rows
asl a
asl a
sta famistudio_chn_instrument,x ; Store instrument number*4
.if (FAMISTUDIO_EXP_N163 != 0) | (FAMISTUDIO_EXP_VRC7 != 0) | (FAMISTUDIO_EXP_FDS != 0)
cpx #5
bcc .regular_channel
lda #1
sta famistudio_chn_inst_changed-5, x
.regular_channel:
.endif
jmp .read_byte
.set_speed:
.if !FAMISTUDIO_USE_FAMITRACKER_TEMPO
jmp .invalid_opcode
.else
lda [.channel_data_ptr],y
sta famistudio_song_speed
famistudio_inc_16 .channel_data_ptr
jmp .read_byte
.endif
.set_loop:
lda [.channel_data_ptr],y
sta <.tmp_ptr_lo
iny
lda [.channel_data_ptr],y
sta <.channel_data_ptr+1
lda <.tmp_ptr_lo
sta <.channel_data_ptr+0
dey
jmp .read_byte
.set_empty_rows:
cmp #$3d
beq .set_speed
cmp #$3c
beq .release_note
bcc .set_repeat
cmp #$3e
beq .set_loop
.set_reference:
clc ; Remember return address+3
lda <.channel_data_ptr+0
adc #3
sta famistudio_chn_return_lo,x
lda <.channel_data_ptr+1
adc #0
sta famistudio_chn_return_hi,x
lda [.channel_data_ptr],y ; Read length of the reference (how many rows)
sta famistudio_chn_ref_len,x
iny
lda [.channel_data_ptr],y ; Read 16-bit absolute address of the reference
sta <.tmp_ptr_lo
iny
lda [.channel_data_ptr],y
sta <.channel_data_ptr+1
lda <.tmp_ptr_lo
sta <.channel_data_ptr+0
ldy #0
jmp .read_byte
.release_note:
.if FAMISTUDIO_EXP_VRC7
cpx #5
bcc .apu_channel
lda #$80
sta famistudio_chn_vrc7_trigger-5,x ; Set release flag for VRC7
.apu_channel:
.endif
stx <.tmp_chan_idx
lda famistudio_channel_to_volume_env,x ; DPCM(5) will never have releases.
tax
lda famistudio_env_addr_lo,x ; Load envelope data address into temp
sta <.volume_env_ptr+0
lda famistudio_env_addr_hi,x
sta <.volume_env_ptr+1
ldy #0
lda [.volume_env_ptr],y ; Read first byte of the envelope data, this contains the release index.
beq .env_has_no_release
sta famistudio_env_ptr,x
lda #0
sta famistudio_env_repeat,x ; Need to reset envelope repeat to force update.
.env_has_no_release:
ldx <.tmp_chan_idx
clc
jmp .done
.set_repeat:
sta famistudio_chn_repeat,x ; Set up repeat counter, carry is clear, no new note
.done:
lda famistudio_chn_ref_len,x ; Check reference row counter
beq .no_ref ; If it is zero, there is no reference
dec famistudio_chn_ref_len,x ; Decrease row counter
bne .no_ref
lda famistudio_chn_return_lo,x ; End of a reference, return to previous pointer
sta famistudio_chn_ptr_lo,x
lda famistudio_chn_return_hi,x
sta famistudio_chn_ptr_hi,x
rts
.no_ref:
lda <.channel_data_ptr+0
sta famistudio_chn_ptr_lo,x
lda <.channel_data_ptr+1
sta famistudio_chn_ptr_hi,x
rts
.invalid_opcode:
; If you hit this, this mean you either:
; - have fine pitches in your songs, but didnt enable "FAMISTUDIO_USE_PITCH_TRACK"
; - have vibrato effect in your songs, but didnt enable "FAMISTUDIO_USE_VIBRATO"
; - have arpeggiated chords in your songs, but didnt enable "FAMISTUDIO_USE_ARPEGGIO"
; - have slide notes in your songs, but didnt enable "FAMISTUDIO_USE_SLIDE_NOTES"
; - have a duty cycle effect in your songs, but didnt enable "FAMISTUDIO_USE_DUTYCYCLE_EFFECT"
; - have delayed notes/cuts in your songs, but didnt enable "FAMISTUDIO_USE_FAMITRACKER_DELAYED_NOTES_OR_CUTS"
; - have exported a song that uses FamiStudio tempo but have defined "FAMISTUDIO_USE_FAMITRACKER_TEMPO"
; - have exported VRC6 data but didnt define "FAMISTUDIO_EXP_VRC6"
brk
.famistudio_special_code_jmp_lo:
.if FAMISTUDIO_USE_SLIDE_NOTES
.byte LOW(.special_code_slide) ; $61
.else
.byte LOW(.invalid_opcode) ; $61
.endif
.byte LOW(.special_code_disable_attack) ; $62
.if FAMISTUDIO_USE_VIBRATO
.byte LOW(.special_code_override_pitch_envelope) ; $63
.byte LOW(.special_code_clear_pitch_override_flag) ; $64
.else
.byte LOW(.invalid_opcode) ; $63
.byte LOW(.invalid_opcode) ; $64
.endif
.if FAMISTUDIO_USE_ARPEGGIO
.byte LOW(.special_code_override_arpeggio_envelope) ; $65
.byte LOW(.special_code_clear_arpeggio_override_flag) ; $66
.byte LOW(.special_code_reset_arpeggio) ; $67
.else
.byte LOW(.invalid_opcode) ; $65
.byte LOW(.invalid_opcode) ; $66
.byte LOW(.invalid_opcode) ; $67
.endif
.if FAMISTUDIO_USE_PITCH_TRACK
.byte LOW(.special_code_fine_pitch) ; $68
.else
.byte LOW(.invalid_opcode) ; $68
.endif
.if FAMISTUDIO_USE_DUTYCYCLE_EFFECT
.byte LOW(.special_code_duty_cycle_effect) ; $69
.else
.byte LOW(.invalid_opcode) ; $69
.endif
.if FAMISTUDIO_USE_FAMITRACKER_DELAYED_NOTES_OR_CUTS
.byte LOW(.special_code_note_delay) ; $6a
.byte LOW(.special_code_cut_delay) ; $6b
.endif
.if !FAMISTUDIO_USE_FAMITRACKER_TEMPO
.byte LOW(.special_code_set_tempo_envelope) ; $6a
.byte LOW(.special_code_reset_tempo_envelope) ; $6b
.endif
.if (FAMISTUDIO_USE_FAMITRACKER_TEMPO != 0) & (FAMISTUDIO_USE_FAMITRACKER_DELAYED_NOTES_OR_CUTS = 0)
.byte LOW(.invalid_opcode) ; $6a
.byte LOW(.invalid_opcode) ; $6b
.endif
.if FAMISTUDIO_EXP_FDS
.byte LOW(.special_code_fds_mod_speed) ; $6c
.byte LOW(.special_code_fds_mod_depth) ; $6d
.endif
.if FAMISTUDIO_EXP_VRC6
.byte LOW(.special_code_vrc6_saw_volume) ; $6c
.byte LOW(.invalid_opcode) ; $6d
.endif
.if (FAMISTUDIO_EXP_FDS + FAMISTUDIO_EXP_VRC6) = 0
.byte LOW(.invalid_opcode) ; $6c
.byte LOW(.invalid_opcode) ; $6d
.endif
.if FAMISTUDIO_USE_VOLUME_SLIDES
.byte LOW(.special_code_volume_slide) ; $6e
.else
.byte LOW(.invalid_opcode) ; $6e
.endif
.famistudio_special_code_jmp_hi:
.if FAMISTUDIO_USE_SLIDE_NOTES
.byte HIGH(.special_code_slide) ; $61
.else
.byte HIGH(.invalid_opcode) ; $61
.endif
.byte HIGH(.special_code_disable_attack) ; $62
.if FAMISTUDIO_USE_VIBRATO
.byte HIGH(.special_code_override_pitch_envelope) ; $63
.byte HIGH(.special_code_clear_pitch_override_flag) ; $64
.else
.byte HIGH(.invalid_opcode) ; $63
.byte HIGH(.invalid_opcode) ; $64
.endif
.if FAMISTUDIO_USE_ARPEGGIO
.byte HIGH(.special_code_override_arpeggio_envelope) ; $64
.byte HIGH(.special_code_clear_arpeggio_override_flag); $66
.byte HIGH(.special_code_reset_arpeggio) ; $67
.else
.byte HIGH(.invalid_opcode) ; $65
.byte HIGH(.invalid_opcode) ; $66
.byte HIGH(.invalid_opcode) ; $67
.endif
.if FAMISTUDIO_USE_PITCH_TRACK
.byte HIGH(.special_code_fine_pitch) ; $68
.else
.byte HIGH(.invalid_opcode) ; $68
.endif
.if FAMISTUDIO_USE_DUTYCYCLE_EFFECT
.byte HIGH(.special_code_duty_cycle_effect) ; $69
.else
.byte HIGH(.invalid_opcode) ; $69
.endif
.if FAMISTUDIO_USE_FAMITRACKER_DELAYED_NOTES_OR_CUTS
.byte HIGH(.special_code_note_delay) ; $6a
.byte HIGH(.special_code_cut_delay) ; $6b
.endif
.if !FAMISTUDIO_USE_FAMITRACKER_TEMPO
.byte HIGH(.special_code_set_tempo_envelope) ; $6a
.byte HIGH(.special_code_reset_tempo_envelope) ; $6b
.endif
.if (FAMISTUDIO_USE_FAMITRACKER_TEMPO != 0) & (FAMISTUDIO_USE_FAMITRACKER_DELAYED_NOTES_OR_CUTS = 0)
.byte HIGH(.invalid_opcode) ; $6a
.byte HIGH(.invalid_opcode) ; $6b
.endif
.if FAMISTUDIO_EXP_FDS
.byte HIGH(.special_code_fds_mod_speed) ; $6c
.byte HIGH(.special_code_fds_mod_depth) ; $6d
.endif
.if FAMISTUDIO_EXP_VRC6
.byte HIGH(.special_code_vrc6_saw_volume) ; $6c
.byte HIGH(.invalid_opcode) ; $6d
.endif
.if (FAMISTUDIO_EXP_FDS + FAMISTUDIO_EXP_VRC6) = 0
.byte HIGH(.invalid_opcode) ; $6c
.byte HIGH(.invalid_opcode) ; $6d
.endif
.if FAMISTUDIO_USE_VOLUME_SLIDES
.byte HIGH(.special_code_volume_slide) ; $6e
.else
.byte HIGH(.invalid_opcode) ; $6e
.endif
;======================================================================================================================
; FAMISTUDIO_SAMPLE_STOP (internal)
;
; Stop DPCM sample if it plays
;
; [in] no input params.
;======================================================================================================================
famistudio_sample_stop:
lda #%00001111
sta FAMISTUDIO_APU_SND_CHN
rts
.if FAMISTUDIO_CFG_DPCM_SUPPORT
;======================================================================================================================
; FAMISTUDIO_SAMPLE_PLAY_SFX (public)
;
; Play DPCM sample with higher priority, for sound effects
;
; [in] a: Sample index, 1...63.
;======================================================================================================================
famistudio_sfx_sample_play:
ldx #1
stx famistudio_dpcm_effect
sample_play:
.tmp = famistudio_r0
.sample_data_ptr = famistudio_ptr0
asl a ; Sample number * 4, offset in the sample table
asl a
clc
adc famistudio_dpcm_list_lo
sta <.sample_data_ptr+0
lda #0
adc famistudio_dpcm_list_hi
sta <.sample_data_ptr+1
lda #%00001111 ; Stop DPCM
sta FAMISTUDIO_APU_SND_CHN
ldy #0
lda [.sample_data_ptr],y ; Sample offset
sta FAMISTUDIO_APU_DMC_START
iny
lda [.sample_data_ptr],y ; Sample length
sta FAMISTUDIO_APU_DMC_LEN
iny
lda [.sample_data_ptr],y ; Pitch and loop
sta FAMISTUDIO_APU_DMC_FREQ
iny
lda [.sample_data_ptr],y ; Initial DMC counter
sta FAMISTUDIO_APU_DMC_RAW
lda #%00011111 ; Start DMC
sta FAMISTUDIO_APU_SND_CHN
rts
;======================================================================================================================
; FAMISTUDIO_SAMPLE_PLAY_MUSIC (internal)
;
; Play DPCM sample, used by music player, could be used externally. Samples played for music have lower priority than
; samples played by SFX.
;
; [in] a: Sample index, 1...63.
;======================================================================================================================
famistudio_music_sample_play:
ldx famistudio_dpcm_effect
beq sample_play
tax
lda FAMISTUDIO_APU_SND_CHN
and #16
beq .not_busy
rts
.not_busy:
sta famistudio_dpcm_effect
txa
jmp sample_play
.endif
.if FAMISTUDIO_CFG_SFX_SUPPORT
;======================================================================================================================
; FAMISTUDIO_SFX_INIT (public)
;
; Initialize the sound effect player.
;
; [in] x: Sound effect data pointer (lo)
; [in] y: Sound effect data pointer (hi)
;======================================================================================================================
famistudio_sfx_init:
.effect_list_ptr = famistudio_ptr0
stx <.effect_list_ptr+0
sty <.effect_list_ptr+1
ldy #0
.if FAMISTUDIO_DUAL_SUPPORT
lda famistudio_pal_adjust ; Add 2 to the sound list pointer for PAL
bne .ntsc
iny
iny
.ntsc:
.endif
lda [.effect_list_ptr],y
sta famistudio_sfx_addr_lo
iny
lda [.effect_list_ptr],y
sta famistudio_sfx_addr_hi
ldx #FAMISTUDIO_SFX_CH0
.set_channels:
jsr famistudio_sfx_clear_channel
txa
clc
adc #FAMISTUDIO_SFX_STRUCT_SIZE
tax
cpx #FAMISTUDIO_SFX_STRUCT_SIZE*FAMISTUDIO_CFG_SFX_STREAMS
bne .set_channels
rts
;======================================================================================================================
; FAMISTUDIO_SFX_CLEAR_CHANNEL (internal)
;
; Clears output buffer of a sound effect.
;
; [in] x: Offset of the sound effect stream.
;======================================================================================================================
famistudio_sfx_clear_channel:
lda #0
sta famistudio_sfx_ptr_hi,x ; This stops the effect
sta famistudio_sfx_repeat,x
sta famistudio_sfx_offset,x
sta famistudio_sfx_buffer+6,x ; Mute triangle
lda #$30
sta famistudio_sfx_buffer+0,x ; Mute pulse1
sta famistudio_sfx_buffer+3,x ; Mute pulse2
sta famistudio_sfx_buffer+9,x ; Mute noise
rts
;======================================================================================================================
; FAMISTUDIO_SFX_PLAY (public)
;
; Plays a sound effect.
;
; [in] a: Sound effect index (0...127)
; [in] x: Offset of sound effect channel, should be FAMISTUDIO_SFX_CH0..FAMISTUDIO_SFX_CH3
;======================================================================================================================
famistudio_sfx_play:
.effect_data_ptr = famistudio_ptr0
asl a
tay
jsr famistudio_sfx_clear_channel ; Stops the effect if it plays
lda famistudio_sfx_addr_lo
sta <.effect_data_ptr+0
lda famistudio_sfx_addr_hi
sta <.effect_data_ptr+1
lda [.effect_data_ptr],y
sta famistudio_sfx_ptr_lo,x
iny
lda [.effect_data_ptr],y
sta famistudio_sfx_ptr_hi,x ; This write enables the effect
rts
;======================================================================================================================
; FAMISTUDIO_SFX_UPDATE (internal)
;
; Updates a single sound effect stream.
;
; [in] x: Offset of sound effect channel, should be FAMISTUDIO_SFX_CH0..FAMISTUDIO_SFX_CH3
;======================================================================================================================
famistudio_sfx_update:
.tmp = famistudio_r0
.tmpx = famistudio_r1
.effect_data_ptr = famistudio_ptr0
lda famistudio_sfx_repeat,x ; Check if repeat counter is not zero
beq .no_repeat
dec famistudio_sfx_repeat,x ; Decrement and return
bne .update_buf ; Just mix with output buffer
.no_repeat:
lda famistudio_sfx_ptr_hi,x ; Check if MSB of the pointer is not zero
bne .sfx_active
rts ; Return otherwise, no active effect
.sfx_active:
sta <.effect_data_ptr+1 ;load effect pointer into temp
lda famistudio_sfx_ptr_lo,x
sta <.effect_data_ptr+0
ldy famistudio_sfx_offset,x
clc
.read_byte:
lda [.effect_data_ptr],y ; Read byte of effect
bmi .get_data ; If bit 7 is set, it is a register write
beq .eof
iny
bne .store_repeat
jsr .inc_sfx
.store_repeat:
sta famistudio_sfx_repeat,x ; If bit 7 is reset, it is number of repeats
tya
sta famistudio_sfx_offset,x
jmp .update_buf
.get_data:
iny
bne .get_data2
jsr .inc_sfx
.get_data2:
stx <.tmp ; It is a register write
adc <.tmp ; Get offset in the effect output buffer
tax
lda [.effect_data_ptr],y
iny
bne .write_buffer
stx <.tmpx
ldx <.tmp
jsr .inc_sfx
ldx <.tmpx
.write_buffer:
sta famistudio_sfx_buffer-128,x
ldx <.tmp
jmp .read_byte
.eof:
sta famistudio_sfx_ptr_hi,x ; Mark channel as inactive
.update_buf:
lda famistudio_output_buf ; Compare effect output buffer with main output buffer
and #$0f ; If volume of pulse 1 of effect is higher than that of the main buffer, overwrite the main buffer value with the new one
sta <.tmp
lda famistudio_sfx_buffer+0,x
and #$0f
cmp <.tmp
bcc .no_pulse1
lda famistudio_sfx_buffer+0,x
sta famistudio_output_buf+0
lda famistudio_sfx_buffer+1,x
sta famistudio_output_buf+1
lda famistudio_sfx_buffer+2,x
sta famistudio_output_buf+2
.no_pulse1:
lda famistudio_output_buf+3
and #$0f
sta <.tmp
lda famistudio_sfx_buffer+3,x
and #$0f
cmp <.tmp
bcc .no_pulse2
lda famistudio_sfx_buffer+3,x
sta famistudio_output_buf+3
lda famistudio_sfx_buffer+4,x
sta famistudio_output_buf+4
lda famistudio_sfx_buffer+5,x
sta famistudio_output_buf+5
.no_pulse2:
lda famistudio_sfx_buffer+6,x ; Overwrite triangle of main output buffer if it is active
beq .no_triangle
sta famistudio_output_buf+6
lda famistudio_sfx_buffer+7,x
sta famistudio_output_buf+7
lda famistudio_sfx_buffer+8,x
sta famistudio_output_buf+8
.no_triangle:
lda famistudio_output_buf+9
and #$0f
sta <.tmp
lda famistudio_sfx_buffer+9,x
and #$0f
cmp <.tmp
bcc .no_noise
lda famistudio_sfx_buffer+9,x
sta famistudio_output_buf+9
lda famistudio_sfx_buffer+10,x
sta famistudio_output_buf+10
.no_noise:
rts
.inc_sfx:
inc <.effect_data_ptr+1
inc famistudio_sfx_ptr_hi,x
rts
.endif
; Dummy envelope used to initialize all channels with silence
famistudio_dummy_envelope:
.byte $c0,$7f,$00,$00
famistudio_dummy_pitch_envelope:
.byte $00,$c0,$7f,$00,$01
; Note tables
famistudio_note_table_lsb:
.if FAMISTUDIO_CFG_PAL_SUPPORT
.byte $00
.byte $68, $b6, $0e, $6f, $d9, $4b, $c6, $48, $d1, $60, $f6, $92 ; Octave 0
.byte $34, $db, $86, $37, $ec, $a5, $62, $23, $e8, $b0, $7b, $49 ; Octave 1
.byte $19, $ed, $c3, $9b, $75, $52, $31, $11, $f3, $d7, $bd, $a4 ; Octave 2
.byte $8c, $76, $61, $4d, $3a, $29, $18, $08, $f9, $eb, $de, $d1 ; Octave 3
.byte $c6, $ba, $b0, $a6, $9d, $94, $8b, $84, $7c, $75, $6e, $68 ; Octave 4
.byte $62, $5d, $57, $52, $4e, $49, $45, $41, $3e, $3a, $37, $34 ; Octave 5
.byte $31, $2e, $2b, $29, $26, $24, $22, $20, $1e, $1d, $1b, $19 ; Octave 6
.byte $18, $16, $15, $14, $13, $12, $11, $10, $0f, $0e, $0d, $0c ; Octave 7
.endif
.if FAMISTUDIO_CFG_NTSC_SUPPORT
.byte $00
.byte $5b, $9c, $e6, $3b, $9a, $01, $72, $ea, $6a, $f1, $7f, $13 ; Octave 0
.byte $ad, $4d, $f3, $9d, $4c, $00, $b8, $74, $34, $f8, $bf, $89 ; Octave 1
.byte $56, $26, $f9, $ce, $a6, $80, $5c, $3a, $1a, $fb, $df, $c4 ; Octave 2
.byte $ab, $93, $7c, $67, $52, $3f, $2d, $1c, $0c, $fd, $ef, $e1 ; Octave 3
.byte $d5, $c9, $bd, $b3, $a9, $9f, $96, $8e, $86, $7e, $77, $70 ; Octave 4
.byte $6a, $64, $5e, $59, $54, $4f, $4b, $46, $42, $3f, $3b, $38 ; Octave 5
.byte $34, $31, $2f, $2c, $29, $27, $25, $23, $21, $1f, $1d, $1b ; Octave 6
.byte $1a, $18, $17, $15, $14, $13, $12, $11, $10, $0f, $0e, $0d ; Octave 7
.endif
famistudio_note_table_msb:
.if FAMISTUDIO_CFG_PAL_SUPPORT
.byte $00
.byte $0c, $0b, $0b, $0a, $09, $09, $08, $08, $07, $07, $06, $06 ; Octave 0
.byte $06, $05, $05, $05, $04, $04, $04, $04, $03, $03, $03, $03 ; Octave 1
.byte $03, $02, $02, $02, $02, $02, $02, $02, $01, $01, $01, $01 ; Octave 2
.byte $01, $01, $01, $01, $01, $01, $01, $01, $00, $00, $00, $00 ; Octave 3
.byte $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00 ; Octave 4
.byte $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00 ; Octave 5
.byte $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00 ; Octave 6
.byte $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00 ; Octave 7
.endif
.if FAMISTUDIO_CFG_NTSC_SUPPORT
.byte $00
.byte $0d, $0c, $0b, $0b, $0a, $0a, $09, $08, $08, $07, $07, $07 ; Octave 0
.byte $06, $06, $05, $05, $05, $05, $04, $04, $04, $03, $03, $03 ; Octave 1
.byte $03, $03, $02, $02, $02, $02, $02, $02, $02, $01, $01, $01 ; Octave 2
.byte $01, $01, $01, $01, $01, $01, $01, $01, $01, $00, $00, $00 ; Octave 3
.byte $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00 ; Octave 4
.byte $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00 ; Octave 5
.byte $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00 ; Octave 6
.byte $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00 ; Octave 7
.endif
.if FAMISTUDIO_EXP_VRC6
famistudio_exp_note_table_lsb:
famistudio_saw_note_table_lsb:
.byte $00
.byte $44, $69, $9a, $d6, $1e, $70, $cb, $30, $9e, $13, $91, $16 ; Octave 0
.byte $a2, $34, $cc, $6b, $0e, $b7, $65, $18, $ce, $89, $48, $0a ; Octave 1
.byte $d0, $99, $66, $35, $07, $db, $b2, $8b, $67, $44, $23, $05 ; Octave 2
.byte $e8, $cc, $b2, $9a, $83, $6d, $59, $45, $33, $22, $11, $02 ; Octave 3
.byte $f3, $e6, $d9, $cc, $c1, $b6, $ac, $a2, $99, $90, $88, $80 ; Octave 4
.byte $79, $72, $6c, $66, $60, $5b, $55, $51, $4c, $48, $44, $40 ; Octave 5
.byte $3c, $39, $35, $32, $2f, $2d, $2a, $28, $25, $23, $21, $1f ; Octave 6
.byte $1e, $1c, $1a, $19, $17, $16, $15, $13, $12, $11, $10, $0f ; Octave 7
famistudio_exp_note_table_msb:
famistudio_saw_note_table_msb:
.byte $00
.byte $0f, $0e, $0d, $0c, $0c, $0b, $0a, $0a, $09, $09, $08, $08 ; Octave 0
.byte $07, $07, $06, $06, $06, $05, $05, $05, $04, $04, $04, $04 ; Octave 1
.byte $03, $03, $03, $03, $03, $02, $02, $02, $02, $02, $02, $02 ; Octave 2
.byte $01, $01, $01, $01, $01, $01, $01, $01, $01, $01, $01, $01 ; Octave 3
.byte $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00 ; Octave 4
.byte $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00 ; Octave 5
.byte $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00 ; Octave 6
.byte $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00 ; Octave 7
.endif
.if FAMISTUDIO_EXP_VRC7
famistudio_exp_note_table_lsb:
famistudio_vrc7_note_table_lsb:
.byte $00
.byte $ac, $b7, $c2, $cd, $d9, $e6, $f4, $02, $12, $22, $33, $46 ; Octave 0
.byte $58, $6e, $84, $9a, $b2, $cc, $e8, $04, $24, $44, $66, $8c ; Octave 1
.byte $b0, $dc, $08, $34, $64, $98, $d0, $08, $48, $88, $cc, $18 ; Octave 2
.byte $60, $b8, $10, $68, $c8, $30, $a0, $10, $90, $10, $98, $30 ; Octave 3
.byte $c0, $70, $20, $d0, $90, $60, $40, $20, $20, $20, $30, $60 ; Octave 4
.byte $80, $e0, $40, $a0, $20, $c0, $80, $40, $40, $40, $60, $c0 ; Octave 5
.byte $00, $c0, $80, $40, $40, $80, $00, $80, $80, $80, $c0, $80 ; Octave 6
.byte $00, $80, $00, $80, $80, $00, $00, $00, $00, $00, $80, $00 ; Octave 7
famistudio_exp_note_table_msb:
famistudio_vrc7_note_table_msb:
.byte $00
.byte $00, $00, $00, $00, $00, $00, $00, $01, $01, $01, $01, $01 ; Octave 0
.byte $01, $01, $01, $01, $01, $01, $01, $02, $02, $02, $02, $02 ; Octave 1
.byte $02, $02, $03, $03, $03, $03, $03, $04, $04, $04, $04, $05 ; Octave 2
.byte $05, $05, $06, $06, $06, $07, $07, $08, $08, $09, $09, $0a ; Octave 3
.byte $0a, $0b, $0c, $0c, $0d, $0e, $0f, $10, $11, $12, $13, $14 ; Octave 4
.byte $15, $16, $18, $19, $1b, $1c, $1e, $20, $22, $24, $26, $28 ; Octave 5
.byte $2b, $2d, $30, $33, $36, $39, $3d, $40, $44, $48, $4c, $51 ; Octave 6
.byte $56, $5b, $61, $66, $6c, $73, $7a, $81, $89, $91, $99, $a3 ; Octave 7
.endif
.if FAMISTUDIO_EXP_FDS
famistudio_exp_note_table_lsb:
famistudio_fds_note_table_lsb:
.byte $00
.byte $13, $14, $16, $17, $18, $1a, $1b, $1d, $1e, $20, $22, $24 ; Octave 0
.byte $26, $29, $2b, $2e, $30, $33, $36, $39, $3d, $40, $44, $48 ; Octave 1
.byte $4d, $51, $56, $5b, $61, $66, $6c, $73, $7a, $81, $89, $91 ; Octave 2
.byte $99, $a2, $ac, $b6, $c1, $cd, $d9, $e6, $f3, $02, $11, $21 ; Octave 3
.byte $33, $45, $58, $6d, $82, $99, $b2, $cb, $e7, $04, $22, $43 ; Octave 4
.byte $65, $8a, $b0, $d9, $04, $32, $63, $97, $cd, $07, $44, $85 ; Octave 5
.byte $ca, $13, $60, $b2, $09, $65, $c6, $2d, $9b, $0e, $89, $0b ; Octave 6
.byte $94, $26, $c1, $64, $12, $ca, $8c, $5b, $35, $1d, $12, $16 ; Octave 7
famistudio_exp_note_table_msb:
famistudio_fds_note_table_msb:
.byte $00
.byte $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00 ; Octave 0
.byte $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00 ; Octave 1
.byte $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00 ; Octave 2
.byte $00, $00, $00, $00, $00, $00, $00, $00, $00, $01, $01, $01 ; Octave 3
.byte $01, $01, $01, $01, $01, $01, $01, $01, $01, $02, $02, $02 ; Octave 4
.byte $02, $02, $02, $02, $03, $03, $03, $03, $03, $04, $04, $04 ; Octave 5
.byte $04, $05, $05, $05, $06, $06, $06, $07, $07, $08, $08, $09 ; Octave 6
.byte $09, $0a, $0a, $0b, $0c, $0c, $0d, $0e, $0f, $10, $11, $12 ; Octave 7
.endif
.if FAMISTUDIO_EXP_N163
.if FAMISTUDIO_EXP_N163_CHN_CNT = 1
famistudio_exp_note_table_lsb:
famistudio_n163_note_table_lsb:
.byte $00
.byte $47,$4c,$50,$55,$5a,$5f,$65,$6b,$72,$78,$80,$87 ; Octave 0
.byte $8f,$98,$a1,$aa,$b5,$bf,$cb,$d7,$e4,$f1,$00,$0f ; Octave 1
.byte $1f,$30,$42,$55,$6a,$7f,$96,$ae,$c8,$e3,$00,$1e ; Octave 2
.byte $3e,$60,$85,$ab,$d4,$ff,$2c,$5d,$90,$c6,$00,$3d ; Octave 3
.byte $7d,$c1,$0a,$57,$a8,$fe,$59,$ba,$20,$8d,$00,$7a ; Octave 4
.byte $fb,$83,$14,$ae,$50,$fd,$b3,$74,$41,$1a,$00,$f4 ; Octave 5
.byte $f6,$07,$29,$5c,$a1,$fa,$67,$e9,$83,$35,$01,$e8 ; Octave 6
.byte $ec,$0f,$52,$b8,$43,$f4,$ce,$d3,$06,$6a,$02,$d1 ; Octave 7
famistudio_exp_note_table_msb:
famistudio_n163_note_table_msb:
.byte $00
.byte $00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00 ; Octave 0
.byte $00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$01,$01 ; Octave 1
.byte $01,$01,$01,$01,$01,$01,$01,$01,$01,$01,$02,$02 ; Octave 2
.byte $02,$02,$02,$02,$02,$02,$03,$03,$03,$03,$04,$04 ; Octave 3
.byte $04,$04,$05,$05,$05,$05,$06,$06,$07,$07,$08,$08 ; Octave 4
.byte $08,$09,$0a,$0a,$0b,$0b,$0c,$0d,$0e,$0f,$10,$10 ; Octave 5
.byte $11,$13,$14,$15,$16,$17,$19,$1a,$1c,$1e,$20,$21 ; Octave 6
.byte $23,$26,$28,$2a,$2d,$2f,$32,$35,$39,$3c,$40,$43 ; Octave 7
.endif
.if FAMISTUDIO_EXP_N163_CHN_CNT = 2
famistudio_exp_note_table_lsb:
famistudio_n163_note_table_lsb:
.byte $00
.byte $8f,$98,$a1,$aa,$b5,$bf,$cb,$d7,$e4,$f1,$00,$0f ; Octave 0
.byte $1f,$30,$42,$55,$6a,$7f,$96,$ae,$c8,$e3,$00,$1e ; Octave 1
.byte $3e,$60,$85,$ab,$d4,$ff,$2c,$5d,$90,$c6,$00,$3d ; Octave 2
.byte $7d,$c1,$0a,$57,$a8,$fe,$59,$ba,$20,$8d,$00,$7a ; Octave 3
.byte $fb,$83,$14,$ae,$50,$fd,$b3,$74,$41,$1a,$00,$f4 ; Octave 4
.byte $f6,$07,$29,$5c,$a1,$fa,$67,$e9,$83,$35,$01,$e8 ; Octave 5
.byte $ec,$0f,$52,$b8,$43,$f4,$ce,$d3,$06,$6a,$02,$d1 ; Octave 6
.byte $d9,$1f,$a5,$71,$86,$e8,$9c,$a7,$0d,$d5,$05,$a2 ; Octave 7
famistudio_exp_note_table_msb:
famistudio_n163_note_table_msb:
.byte $00
.byte $00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$01,$01 ; Octave 0
.byte $01,$01,$01,$01,$01,$01,$01,$01,$01,$01,$02,$02 ; Octave 1
.byte $02,$02,$02,$02,$02,$02,$03,$03,$03,$03,$04,$04 ; Octave 2
.byte $04,$04,$05,$05,$05,$05,$06,$06,$07,$07,$08,$08 ; Octave 3
.byte $08,$09,$0a,$0a,$0b,$0b,$0c,$0d,$0e,$0f,$10,$10 ; Octave 4
.byte $11,$13,$14,$15,$16,$17,$19,$1a,$1c,$1e,$20,$21 ; Octave 5
.byte $23,$26,$28,$2a,$2d,$2f,$32,$35,$39,$3c,$40,$43 ; Octave 6
.byte $47,$4c,$50,$55,$5a,$5f,$65,$6b,$72,$78,$80,$87 ; Octave 7
.endif
.if FAMISTUDIO_EXP_N163_CHN_CNT = 3
famistudio_exp_note_table_lsb:
famistudio_n163_note_table_lsb:
.byte $00
.byte $d7,$e4,$f1,$00,$0f,$1f,$30,$42,$56,$6a,$80,$96 ; Octave 0
.byte $af,$c8,$e3,$00,$1f,$3f,$61,$85,$ac,$d5,$00,$2d ; Octave 1
.byte $5e,$91,$c7,$01,$3e,$7e,$c3,$0b,$58,$aa,$00,$5b ; Octave 2
.byte $bc,$22,$8f,$02,$7c,$fd,$86,$17,$b1,$54,$00,$b7 ; Octave 3
.byte $78,$45,$1f,$05,$f9,$fb,$0d,$2f,$62,$a8,$01,$6e ; Octave 4
.byte $f1,$8b,$3e,$0a,$f2,$f7,$1a,$5e,$c5,$50,$02,$dc ; Octave 5
.byte $e3,$17,$7c,$15,$e4,$ee,$35,$bd,$8a,$a0,$04,$b9 ; Octave 6
.byte $c6,$2e,$f8,$2a,$c9,$dc,$6a,$7a,$14,$40,$08,$73 ; Octave 7
famistudio_exp_note_table_msb:
famistudio_n163_note_table_msb:
.byte $00
.byte $00,$00,$00,$01,$01,$01,$01,$01,$01,$01,$01,$01 ; Octave 0
.byte $01,$01,$01,$02,$02,$02,$02,$02,$02,$02,$03,$03 ; Octave 1
.byte $03,$03,$03,$04,$04,$04,$04,$05,$05,$05,$06,$06 ; Octave 2
.byte $06,$07,$07,$08,$08,$08,$09,$0a,$0a,$0b,$0c,$0c ; Octave 3
.byte $0d,$0e,$0f,$10,$10,$11,$13,$14,$15,$16,$18,$19 ; Octave 4
.byte $1a,$1c,$1e,$20,$21,$23,$26,$28,$2a,$2d,$30,$32 ; Octave 5
.byte $35,$39,$3c,$40,$43,$47,$4c,$50,$55,$5a,$60,$65 ; Octave 6
.byte $6b,$72,$78,$80,$87,$8f,$98,$a1,$ab,$b5,$c0,$cb ; Octave 7
.endif
.if FAMISTUDIO_EXP_N163_CHN_CNT = 4
famistudio_exp_note_table_lsb:
famistudio_n163_note_table_lsb:
.byte $00
.byte $1f,$30,$42,$55,$6a,$7f,$96,$ae,$c8,$e3,$00,$1e ; Octave 0
.byte $3e,$60,$85,$ab,$d4,$ff,$2c,$5d,$90,$c6,$00,$3d ; Octave 1
.byte $7d,$c1,$0a,$57,$a8,$fe,$59,$ba,$20,$8d,$00,$7a ; Octave 2
.byte $fb,$83,$14,$ae,$50,$fd,$b3,$74,$41,$1a,$00,$f4 ; Octave 3
.byte $f6,$07,$29,$5c,$a1,$fa,$67,$e9,$83,$35,$01,$e8 ; Octave 4
.byte $ec,$0f,$52,$b8,$43,$f4,$ce,$d3,$06,$6a,$02,$d1 ; Octave 5
.byte $d9,$1f,$a5,$71,$86,$e8,$9c,$a7,$0d,$d5,$05,$a2 ; Octave 6
.byte $b2,$3e,$4b,$e3,$0c,$d0,$38,$4e,$1b,$ab,$ff,$ff ; Octave 7
famistudio_exp_note_table_msb:
famistudio_n163_note_table_msb:
.byte $00
.byte $01,$01,$01,$01,$01,$01,$01,$01,$01,$01,$02,$02 ; Octave 0
.byte $02,$02,$02,$02,$02,$02,$03,$03,$03,$03,$04,$04 ; Octave 1
.byte $04,$04,$05,$05,$05,$05,$06,$06,$07,$07,$08,$08 ; Octave 2
.byte $08,$09,$0a,$0a,$0b,$0b,$0c,$0d,$0e,$0f,$10,$10 ; Octave 3
.byte $11,$13,$14,$15,$16,$17,$19,$1a,$1c,$1e,$20,$21 ; Octave 4
.byte $23,$26,$28,$2a,$2d,$2f,$32,$35,$39,$3c,$40,$43 ; Octave 5
.byte $47,$4c,$50,$55,$5a,$5f,$65,$6b,$72,$78,$80,$87 ; Octave 6
.byte $8f,$98,$a1,$aa,$b5,$bf,$cb,$d7,$e4,$f1,$ff,$ff ; Octave 7
.endif
.if FAMISTUDIO_EXP_N163_CHN_CNT = 5
famistudio_exp_note_table_lsb:
famistudio_n163_note_table_lsb:
.byte $00
.byte $67,$7c,$93,$ab,$c4,$df,$fc,$1a,$3a,$5c,$80,$a6 ; Octave 0
.byte $ce,$f9,$26,$56,$89,$bf,$f8,$34,$74,$b8,$00,$4c ; Octave 1
.byte $9c,$f2,$4c,$ac,$12,$7e,$f0,$69,$e9,$70,$00,$98 ; Octave 2
.byte $39,$e4,$99,$59,$24,$fc,$e0,$d2,$d2,$e1,$00,$31 ; Octave 3
.byte $73,$c9,$33,$b3,$49,$f8,$c0,$a4,$a4,$c2,$01,$62 ; Octave 4
.byte $e7,$93,$67,$67,$93,$f1,$81,$48,$48,$85,$03,$c5 ; Octave 5
.byte $cf,$26,$cf,$ce,$27,$e2,$03,$90,$91,$0b,$06,$8a ; Octave 6
.byte $9f,$4d,$9e,$9c,$4f,$c4,$06,$ff,$ff,$ff,$ff,$ff ; Octave 7
famistudio_exp_note_table_msb:
famistudio_n163_note_table_msb:
.byte $00
.byte $01,$01,$01,$01,$01,$01,$01,$02,$02,$02,$02,$02 ; Octave 0
.byte $02,$02,$03,$03,$03,$03,$03,$04,$04,$04,$05,$05 ; Octave 1
.byte $05,$05,$06,$06,$07,$07,$07,$08,$08,$09,$0a,$0a ; Octave 2
.byte $0b,$0b,$0c,$0d,$0e,$0e,$0f,$10,$11,$12,$14,$15 ; Octave 3
.byte $16,$17,$19,$1a,$1c,$1d,$1f,$21,$23,$25,$28,$2a ; Octave 4
.byte $2c,$2f,$32,$35,$38,$3b,$3f,$43,$47,$4b,$50,$54 ; Octave 5
.byte $59,$5f,$64,$6a,$71,$77,$7f,$86,$8e,$97,$a0,$a9 ; Octave 6
.byte $b3,$be,$c9,$d5,$e2,$ef,$fe,$ff,$ff,$ff,$ff,$ff ; Octave 7
.endif
.if FAMISTUDIO_EXP_N163_CHN_CNT = 6
famistudio_exp_note_table_lsb:
famistudio_n163_note_table_lsb:
.byte $00
.byte $af,$c8,$e3,$00,$1f,$3f,$61,$85,$ac,$d5,$00,$2d ; Octave 0
.byte $5e,$91,$c7,$01,$3e,$7e,$c3,$0b,$58,$aa,$00,$5b ; Octave 1
.byte $bc,$22,$8f,$02,$7c,$fd,$86,$17,$b1,$54,$00,$b7 ; Octave 2
.byte $78,$45,$1f,$05,$f9,$fb,$0d,$2f,$62,$a8,$01,$6e ; Octave 3
.byte $f1,$8b,$3e,$0a,$f2,$f7,$1a,$5e,$c5,$50,$02,$dc ; Octave 4
.byte $e3,$17,$7c,$15,$e4,$ee,$35,$bd,$8a,$a0,$04,$b9 ; Octave 5
.byte $c6,$2e,$f8,$2a,$c9,$dc,$6a,$7a,$14,$40,$08,$73 ; Octave 6
.byte $8c,$5d,$f1,$ff,$ff,$ff,$ff,$ff,$ff,$ff,$ff,$ff ; Octave 7
famistudio_exp_note_table_msb:
famistudio_n163_note_table_msb:
.byte $00
.byte $01,$01,$01,$02,$02,$02,$02,$02,$02,$02,$03,$03 ; Octave 0
.byte $03,$03,$03,$04,$04,$04,$04,$05,$05,$05,$06,$06 ; Octave 1
.byte $06,$07,$07,$08,$08,$08,$09,$0a,$0a,$0b,$0c,$0c ; Octave 2
.byte $0d,$0e,$0f,$10,$10,$11,$13,$14,$15,$16,$18,$19 ; Octave 3
.byte $1a,$1c,$1e,$20,$21,$23,$26,$28,$2a,$2d,$30,$32 ; Octave 4
.byte $35,$39,$3c,$40,$43,$47,$4c,$50,$55,$5a,$60,$65 ; Octave 5
.byte $6b,$72,$78,$80,$87,$8f,$98,$a1,$ab,$b5,$c0,$cb ; Octave 6
.byte $d7,$e4,$f1,$ff,$ff,$ff,$ff,$ff,$ff,$ff,$ff,$ff ; Octave 7
.endif
.if FAMISTUDIO_EXP_N163_CHN_CNT = 7
famistudio_exp_note_table_lsb:
famistudio_n163_note_table_lsb:
.byte $00
.byte $f6,$14,$34,$56,$79,$9f,$c7,$f1,$1e,$4d,$80,$b5 ; Octave 0
.byte $ed,$29,$69,$ac,$f3,$3e,$8e,$e3,$3c,$9b,$00,$6a ; Octave 1
.byte $db,$53,$d2,$58,$e6,$7d,$1d,$c6,$79,$37,$00,$d5 ; Octave 2
.byte $b7,$a6,$a4,$b0,$cd,$fa,$3a,$8c,$f3,$6e,$01,$ab ; Octave 3
.byte $6f,$4d,$48,$61,$9a,$f5,$74,$19,$e6,$dd,$02,$56 ; Octave 4
.byte $de,$9b,$91,$c3,$35,$eb,$e8,$32,$cc,$bb,$04,$ad ; Octave 5
.byte $bc,$36,$22,$86,$6b,$d6,$d1,$64,$98,$76,$09,$5b ; Octave 6
.byte $79,$ff,$ff,$ff,$ff,$ff,$ff,$ff,$ff,$ff,$ff,$ff ; Octave 7
famistudio_exp_note_table_msb:
famistudio_n163_note_table_msb:
.byte $00
.byte $01,$02,$02,$02,$02,$02,$02,$02,$03,$03,$03,$03 ; Octave 0
.byte $03,$04,$04,$04,$04,$05,$05,$05,$06,$06,$07,$07 ; Octave 1
.byte $07,$08,$08,$09,$09,$0a,$0b,$0b,$0c,$0d,$0e,$0e ; Octave 2
.byte $0f,$10,$11,$12,$13,$14,$16,$17,$18,$1a,$1c,$1d ; Octave 3
.byte $1f,$21,$23,$25,$27,$29,$2c,$2f,$31,$34,$38,$3b ; Octave 4
.byte $3e,$42,$46,$4a,$4f,$53,$58,$5e,$63,$69,$70,$76 ; Octave 5
.byte $7d,$85,$8d,$95,$9e,$a7,$b1,$bc,$c7,$d3,$e0,$ed ; Octave 6
.byte $fb,$ff,$ff,$ff,$ff,$ff,$ff,$ff,$ff,$ff,$ff,$ff ; Octave 7
.endif
.if FAMISTUDIO_EXP_N163_CHN_CNT = 8
famistudio_exp_note_table_lsb:
famistudio_n163_note_table_lsb:
.byte $00
.byte $3e,$60,$85,$ab,$d4,$ff,$2c,$5d,$90,$c6,$00,$3d ; Octave 0
.byte $7d,$c1,$0a,$57,$a8,$fe,$59,$ba,$20,$8d,$00,$7a ; Octave 1
.byte $fb,$83,$14,$ae,$50,$fd,$b3,$74,$41,$1a,$00,$f4 ; Octave 2
.byte $f6,$07,$29,$5c,$a1,$fa,$67,$e9,$83,$35,$01,$e8 ; Octave 3
.byte $ec,$0f,$52,$b8,$43,$f4,$ce,$d3,$06,$6a,$02,$d1 ; Octave 4
.byte $d9,$1f,$a5,$71,$86,$e8,$9c,$a7,$0d,$d5,$05,$a2 ; Octave 5
.byte $b2,$3e,$4b,$e3,$0c,$d0,$38,$4e,$1b,$ab,$ff,$ff ; Octave 6
.byte $ff,$ff,$ff,$ff,$ff,$ff,$ff,$ff,$ff,$ff,$ff,$ff ; Octave 7
famistudio_exp_note_table_msb:
famistudio_n163_note_table_msb:
.byte $00
.byte $02,$02,$02,$02,$02,$02,$03,$03,$03,$03,$04,$04 ; Octave 0
.byte $04,$04,$05,$05,$05,$05,$06,$06,$07,$07,$08,$08 ; Octave 1
.byte $08,$09,$0a,$0a,$0b,$0b,$0c,$0d,$0e,$0f,$10,$10 ; Octave 2
.byte $11,$13,$14,$15,$16,$17,$19,$1a,$1c,$1e,$20,$21 ; Octave 3
.byte $23,$26,$28,$2a,$2d,$2f,$32,$35,$39,$3c,$40,$43 ; Octave 4
.byte $47,$4c,$50,$55,$5a,$5f,$65,$6b,$72,$78,$80,$87 ; Octave 5
.byte $8f,$98,$a1,$aa,$b5,$bf,$cb,$d7,$e4,$f1,$ff,$ff ; Octave 6
.byte $ff,$ff,$ff,$ff,$ff,$ff,$ff,$ff,$ff,$ff,$ff,$ff ; Octave 7
.endif
.endif
; For a given channel, returns the index of the volume envelope.
famistudio_channel_env:
famistudio_channel_to_volume_env:
.byte FAMISTUDIO_CH0_ENVS+FAMISTUDIO_ENV_VOLUME_OFF
.byte FAMISTUDIO_CH1_ENVS+FAMISTUDIO_ENV_VOLUME_OFF
.byte FAMISTUDIO_CH2_ENVS+FAMISTUDIO_ENV_VOLUME_OFF
.byte FAMISTUDIO_CH3_ENVS+FAMISTUDIO_ENV_VOLUME_OFF
.byte $ff
.ifdef FAMISTUDIO_CH5_ENVS
.byte FAMISTUDIO_CH5_ENVS+FAMISTUDIO_ENV_VOLUME_OFF
.endif
.ifdef FAMISTUDIO_CH6_ENVS
.byte FAMISTUDIO_CH6_ENVS+FAMISTUDIO_ENV_VOLUME_OFF
.endif
.ifdef FAMISTUDIO_CH7_ENVS
.byte FAMISTUDIO_CH7_ENVS+FAMISTUDIO_ENV_VOLUME_OFF
.endif
.ifdef FAMISTUDIO_CH8_ENVS
.byte FAMISTUDIO_CH8_ENVS+FAMISTUDIO_ENV_VOLUME_OFF
.endif
.ifdef FAMISTUDIO_CH9_ENVS
.byte FAMISTUDIO_CH9_ENVS+FAMISTUDIO_ENV_VOLUME_OFF
.endif
.ifdef FAMISTUDIO_CH10_ENVS
.byte FAMISTUDIO_CH10_ENVS+FAMISTUDIO_ENV_VOLUME_OFF
.endif
.ifdef FAMISTUDIO_CH11_ENVS
.byte FAMISTUDIO_CH11_ENVS+FAMISTUDIO_ENV_VOLUME_OFF
.endif
.ifdef FAMISTUDIO_CH12_ENVS
.byte FAMISTUDIO_CH12_ENVS+FAMISTUDIO_ENV_VOLUME_OFF
.endif
.if FAMISTUDIO_USE_ARPEGGIO
; For a given channel, returns the index of the arpeggio envelope.
famistudio_channel_to_arpeggio_env:
.byte FAMISTUDIO_CH0_ENVS+FAMISTUDIO_ENV_NOTE_OFF
.byte FAMISTUDIO_CH1_ENVS+FAMISTUDIO_ENV_NOTE_OFF
.byte FAMISTUDIO_CH2_ENVS+FAMISTUDIO_ENV_NOTE_OFF
.byte FAMISTUDIO_CH3_ENVS+FAMISTUDIO_ENV_NOTE_OFF
.byte $ff
.ifdef FAMISTUDIO_CH5_ENVS
.byte FAMISTUDIO_CH5_ENVS+FAMISTUDIO_ENV_NOTE_OFF
.endif
.ifdef FAMISTUDIO_CH6_ENVS
.byte FAMISTUDIO_CH6_ENVS+FAMISTUDIO_ENV_NOTE_OFF
.endif
.ifdef FAMISTUDIO_CH7_ENVS
.byte FAMISTUDIO_CH7_ENVS+FAMISTUDIO_ENV_NOTE_OFF
.endif
.ifdef FAMISTUDIO_CH8_ENVS
.byte FAMISTUDIO_CH8_ENVS+FAMISTUDIO_ENV_NOTE_OFF
.endif
.ifdef FAMISTUDIO_CH9_ENVS
.byte FAMISTUDIO_CH9_ENVS+FAMISTUDIO_ENV_NOTE_OFF
.endif
.ifdef FAMISTUDIO_CH10_ENVS
.byte FAMISTUDIO_CH10_ENVS+FAMISTUDIO_ENV_NOTE_OFF
.endif
.ifdef FAMISTUDIO_CH11_ENVS
.byte FAMISTUDIO_CH11_ENVS+FAMISTUDIO_ENV_NOTE_OFF
.endif
.ifdef FAMISTUDIO_CH12_ENVS
.byte FAMISTUDIO_CH12_ENVS+FAMISTUDIO_ENV_NOTE_OFF
.endif
.endif
.if (FAMISTUDIO_USE_SLIDE_NOTES != 0)
famistudio_channel_to_slide:
; This table will only be defined if we use noise slides, otherwise identical to "famistudio_channel_to_pitch_env".
.if FAMISTUDIO_USE_NOISE_SLIDE_NOTES
.byte $00
.byte $01
.byte $02
.byte FAMISTUDIO_NOISE_SLIDE_INDEX ; Keep the noise slide at the end so the pitch envelopes/slides are in sync.
.byte $ff ; no slide for DPCM
.if FAMISTUDIO_NUM_SLIDES >= 4
.byte $03
.endif
.if FAMISTUDIO_NUM_SLIDES >= 5
.byte $04
.endif
.if FAMISTUDIO_NUM_SLIDES >= 6
.byte $05
.endif
.if FAMISTUDIO_NUM_SLIDES >= 7
.byte $06
.endif
.if FAMISTUDIO_NUM_SLIDES >= 8
.byte $07
.endif
.if FAMISTUDIO_NUM_SLIDES >= 9
.byte $08
.endif
.if FAMISTUDIO_NUM_SLIDES >= 10
.byte $09
.endif
.if FAMISTUDIO_NUM_SLIDES >= 11
.byte $0a
.endif
.endif
.endif
; For a given channel, returns the index of the pitch envelope.
famistudio_channel_to_pitch_env:
.byte $00
.byte $01
.byte $02
.byte $ff ; no pitch envelopes for noise
.byte $ff ; no pitch envelopes slide for DPCM
.if FAMISTUDIO_NUM_PITCH_ENVELOPES >= 4
.byte $03
.endif
.if FAMISTUDIO_NUM_PITCH_ENVELOPES >= 5
.byte $04
.endif
.if FAMISTUDIO_NUM_PITCH_ENVELOPES >= 6
.byte $05
.endif
.if FAMISTUDIO_NUM_PITCH_ENVELOPES >= 7
.byte $06
.endif
.if FAMISTUDIO_NUM_PITCH_ENVELOPES >= 8
.byte $07
.endif
.if FAMISTUDIO_NUM_PITCH_ENVELOPES >= 9
.byte $08
.endif
.if FAMISTUDIO_NUM_PITCH_ENVELOPES >= 10
.byte $09
.endif
.if FAMISTUDIO_NUM_PITCH_ENVELOPES >= 11
.byte $0a
.endif
.if FAMISTUDIO_USE_DUTYCYCLE_EFFECT
; For a given channel, returns the index of the duty cycle in the "famistudio_duty_cycle" array.
famistudio_channel_to_dutycycle:
.byte $00
.byte $01
.byte $ff
.byte $02
.byte $ff
.if (FAMISTUDIO_EXP_MMC5 != 0) | (FAMISTUDIO_EXP_VRC6 != 0)
.byte $03
.byte $04
.endif
.if (FAMISTUDIO_EXP_VRC6 != 0)
.byte $05
.endif
; For a given channel, returns the index of the duty cycle envelope.
famistudio_channel_to_duty:
.byte FAMISTUDIO_CH0_ENVS+FAMISTUDIO_ENV_DUTY_OFF
.byte FAMISTUDIO_CH1_ENVS+FAMISTUDIO_ENV_DUTY_OFF
.byte $ff
.byte FAMISTUDIO_CH3_ENVS+FAMISTUDIO_ENV_DUTY_OFF
.byte $ff
.if (FAMISTUDIO_EXP_MMC5 != 0) | (FAMISTUDIO_EXP_VRC6 != 0)
.byte FAMISTUDIO_CH5_ENVS+FAMISTUDIO_ENV_DUTY_OFF
.byte FAMISTUDIO_CH6_ENVS+FAMISTUDIO_ENV_DUTY_OFF
.endif
.if (FAMISTUDIO_EXP_VRC6 != 0)
.byte FAMISTUDIO_CH7_ENVS+FAMISTUDIO_ENV_DUTY_OFF
.endif
.endif
; Duty lookup table.
famistudio_duty_lookup:
.byte $30
.byte $70
.byte $b0
.byte $f0
.if FAMISTUDIO_EXP_VRC6
; Duty lookup table for VRC6.
famistudio_vrc6_duty_lookup:
.byte $00
.byte $10
.byte $20
.byte $30
.byte $40
.byte $50
.byte $60
.byte $70
.endif
.if !FAMISTUDIO_USE_FAMITRACKER_TEMPO
famistudio_tempo_frame_lookup:
.byte $01, $02 ; NTSC -> NTSC, NTSC -> PAL
.byte $00, $01 ; PAL -> NTSC, PAL -> PAL
.endif
.if FAMISTUDIO_CFG_SMOOTH_VIBRATO
; lookup table for the 2 registers we need to set for smooth vibrato.
; Index 0 decrement the hi-period, index 2 increments. Index 1 is unused.
famistudio_smooth_vibrato_period_lo_lookup:
.byte $00, $00, $ff
famistudio_smooth_vibrato_sweep_lookup:
.byte $8f, $00, $87
.endif
.if FAMISTUDIO_USE_VOLUME_TRACK
; Precomputed volume multiplication table (rounded but never to zero unless one of the value is zero).
; Load the 2 volumes in the lo/hi nibble and fetch.
famistudio_volume_table:
.byte $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00
.byte $00, $01, $01, $01, $01, $01, $01, $01, $01, $01, $01, $01, $01, $01, $01, $01
.byte $00, $01, $01, $01, $01, $01, $01, $01, $01, $01, $01, $01, $02, $02, $02, $02
.byte $00, $01, $01, $01, $01, $01, $01, $01, $02, $02, $02, $02, $02, $03, $03, $03
.byte $00, $01, $01, $01, $01, $01, $02, $02, $02, $02, $03, $03, $03, $03, $04, $04
.byte $00, $01, $01, $01, $01, $02, $02, $02, $03, $03, $03, $04, $04, $04, $05, $05
.byte $00, $01, $01, $01, $02, $02, $02, $03, $03, $04, $04, $04, $05, $05, $06, $06
.byte $00, $01, $01, $01, $02, $02, $03, $03, $04, $04, $05, $05, $06, $06, $07, $07
.byte $00, $01, $01, $02, $02, $03, $03, $04, $04, $05, $05, $06, $06, $07, $07, $08
.byte $00, $01, $01, $02, $02, $03, $04, $04, $05, $05, $06, $07, $07, $08, $08, $09
.byte $00, $01, $01, $02, $03, $03, $04, $05, $05, $06, $07, $07, $08, $09, $09, $0a
.byte $00, $01, $01, $02, $03, $04, $04, $05, $06, $07, $07, $08, $09, $0a, $0a, $0b
.byte $00, $01, $02, $02, $03, $04, $05, $06, $06, $07, $08, $09, $0a, $0a, $0b, $0c
.byte $00, $01, $02, $03, $03, $04, $05, $06, $07, $08, $09, $0a, $0a, $0b, $0c, $0d
.byte $00, $01, $02, $03, $04, $05, $06, $07, $07, $08, $09, $0a, $0b, $0c, $0d, $0e
.byte $00, $01, $02, $03, $04, $05, $06, $07, $08, $09, $0a, $0b, $0c, $0d, $0e, $0f
.endif
|
%ifdef CONFIG
{
"RegData": {
"RAX": "8"
}
}
%endif
mov rdx, 0xe0000000
; This behaviour was seen around Wine 32-bit libraries
; Anything doing a call to a double application would spin
; the x87 stack on to the stack looking for fxam to return empty
; Empty in this case is that C0 and C3 is set whiel C2 is not
fninit
; Fill the x87 stack
fldz
fldz
fldz
fldz
fldz
fldz
fldz
fldz
mov eax, 0
mov ecx, 0
.ExamineStack:
; Examine st(0)
fxam
fwait
; Get the results in to AX
fnstsw ax
and ax, 0x4500
; Check for empty
cmp ax, 0x4100
je .Done
; Now push the x87 stack value
; We know it isn't empty
fstp qword [rdx + rcx * 8]
fwait
inc ecx
jmp .ExamineStack
.Done:
; Save how many we stored
mov eax, ecx
; Now fill with "Garbage"
fld1
fld1
fld1
fld1
fld1
fld1
fld1
fld1
.Reload:
; Now reload the stack
dec ecx
fld qword [rdx + rcx * 8]
cmp ecx, 0x0
jne .Reload;
hlt
|
###############################################################################
# Copyright 2018 Intel Corporation
# All Rights Reserved.
#
# If this software was obtained under the Intel Simplified Software License,
# the following terms apply:
#
# The source code, information and material ("Material") contained herein is
# owned by Intel Corporation or its suppliers or licensors, and title to such
# Material remains with Intel Corporation or its suppliers or licensors. The
# Material contains proprietary information of Intel or its suppliers and
# licensors. The Material is protected by worldwide copyright laws and treaty
# provisions. No part of the Material may be used, copied, reproduced,
# modified, published, uploaded, posted, transmitted, distributed or disclosed
# in any way without Intel's prior express written permission. No license under
# any patent, copyright or other intellectual property rights in the Material
# is granted to or conferred upon you, either expressly, by implication,
# inducement, estoppel or otherwise. Any license under such intellectual
# property rights must be express and approved by Intel in writing.
#
# Unless otherwise agreed by Intel in writing, you may not remove or alter this
# notice or any other notice embedded in Materials by Intel or Intel's
# suppliers or licensors in any way.
#
#
# If this software was obtained under the Apache License, Version 2.0 (the
# "License"), the following terms apply:
#
# You may not use this file except in compliance with the License. You may
# obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
#
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#
# See the License for the specific language governing permissions and
# limitations under the License.
###############################################################################
.text
.p2align 5, 0x90
.p2align 5, 0x90
.globl _e9_gf256_add
_e9_gf256_add:
push %r12
push %r13
push %r14
xor %r14, %r14
movq (%rsi), %r8
movq (8)(%rsi), %r9
movq (16)(%rsi), %r10
movq (24)(%rsi), %r11
addq (%rdx), %r8
adcq (8)(%rdx), %r9
adcq (16)(%rdx), %r10
adcq (24)(%rdx), %r11
adc $(0), %r14
mov %r8, %rax
mov %r9, %rdx
mov %r10, %r12
mov %r11, %r13
subq (%rcx), %rax
sbbq (8)(%rcx), %rdx
sbbq (16)(%rcx), %r12
sbbq (24)(%rcx), %r13
sbb $(0), %r14
cmove %rax, %r8
cmove %rdx, %r9
cmove %r12, %r10
cmove %r13, %r11
movq %r8, (%rdi)
movq %r9, (8)(%rdi)
movq %r10, (16)(%rdi)
movq %r11, (24)(%rdi)
mov %rdi, %rax
vzeroupper
pop %r14
pop %r13
pop %r12
ret
.p2align 5, 0x90
.globl _e9_gf256_sub
_e9_gf256_sub:
push %r12
push %r13
push %r14
xor %r14, %r14
movq (%rsi), %r8
movq (8)(%rsi), %r9
movq (16)(%rsi), %r10
movq (24)(%rsi), %r11
subq (%rdx), %r8
sbbq (8)(%rdx), %r9
sbbq (16)(%rdx), %r10
sbbq (24)(%rdx), %r11
sbb $(0), %r14
mov %r8, %rax
mov %r9, %rdx
mov %r10, %r12
mov %r11, %r13
addq (%rcx), %rax
adcq (8)(%rcx), %rdx
adcq (16)(%rcx), %r12
adcq (24)(%rcx), %r13
test %r14, %r14
cmovne %rax, %r8
cmovne %rdx, %r9
cmovne %r12, %r10
cmovne %r13, %r11
movq %r8, (%rdi)
movq %r9, (8)(%rdi)
movq %r10, (16)(%rdi)
movq %r11, (24)(%rdi)
mov %rdi, %rax
vzeroupper
pop %r14
pop %r13
pop %r12
ret
.p2align 5, 0x90
.globl _e9_gf256_neg
_e9_gf256_neg:
push %r12
push %r13
push %r14
xor %r14, %r14
xor %r8, %r8
xor %r9, %r9
xor %r10, %r10
xor %r11, %r11
subq (%rsi), %r8
sbbq (8)(%rsi), %r9
sbbq (16)(%rsi), %r10
sbbq (24)(%rsi), %r11
sbb $(0), %r14
mov %r8, %rax
mov %r9, %rcx
mov %r10, %r12
mov %r11, %r13
addq (%rdx), %rax
adcq (8)(%rdx), %rcx
adcq (16)(%rdx), %r12
adcq (24)(%rdx), %r13
test %r14, %r14
cmovne %rax, %r8
cmovne %rcx, %r9
cmovne %r12, %r10
cmovne %r13, %r11
movq %r8, (%rdi)
movq %r9, (8)(%rdi)
movq %r10, (16)(%rdi)
movq %r11, (24)(%rdi)
mov %rdi, %rax
vzeroupper
pop %r14
pop %r13
pop %r12
ret
.p2align 5, 0x90
.globl _e9_gf256_div2
_e9_gf256_div2:
push %r12
push %r13
push %r14
movq (%rsi), %r8
movq (8)(%rsi), %r9
movq (16)(%rsi), %r10
movq (24)(%rsi), %r11
xor %r14, %r14
xor %rsi, %rsi
mov %r8, %rax
mov %r9, %rcx
mov %r10, %r12
mov %r11, %r13
addq (%rdx), %rax
adcq (8)(%rdx), %rcx
adcq (16)(%rdx), %r12
adcq (24)(%rdx), %r13
adc $(0), %r14
test $(1), %r8
cmovne %rax, %r8
cmovne %rcx, %r9
cmovne %r12, %r10
cmovne %r13, %r11
cmovne %r14, %rsi
shrd $(1), %r9, %r8
shrd $(1), %r10, %r9
shrd $(1), %r11, %r10
shrd $(1), %rsi, %r11
movq %r8, (%rdi)
movq %r9, (8)(%rdi)
movq %r10, (16)(%rdi)
movq %r11, (24)(%rdi)
mov %rdi, %rax
vzeroupper
pop %r14
pop %r13
pop %r12
ret
.p2align 5, 0x90
.globl _e9_gf256_mulm
_e9_gf256_mulm:
push %rbx
push %rbp
push %r12
push %r13
push %r14
push %r15
sub $(24), %rsp
movq %rdi, (%rsp)
mov %rdx, %rbx
mov %rcx, %rdi
movq %r8, (8)(%rsp)
movq (%rbx), %r14
movq (8)(%rsp), %r15
movq (%rsi), %rax
mul %r14
mov %rax, %r8
mov %rdx, %r9
imul %r8, %r15
movq (8)(%rsi), %rax
mul %r14
add %rax, %r9
adc $(0), %rdx
mov %rdx, %r10
movq (16)(%rsi), %rax
mul %r14
add %rax, %r10
adc $(0), %rdx
mov %rdx, %r11
movq (24)(%rsi), %rax
mul %r14
add %rax, %r11
adc $(0), %rdx
mov %rdx, %r12
xor %r13, %r13
movq (%rdi), %rax
mul %r15
add %rax, %r8
adc $(0), %rdx
mov %rdx, %r8
movq (8)(%rdi), %rax
mul %r15
add %r8, %r9
adc $(0), %rdx
add %rax, %r9
adc $(0), %rdx
mov %rdx, %r8
movq (16)(%rdi), %rax
mul %r15
add %r8, %r10
adc $(0), %rdx
add %rax, %r10
adc $(0), %rdx
mov %rdx, %r8
movq (24)(%rdi), %rax
mul %r15
add %r8, %r11
adc $(0), %rdx
add %rax, %r11
adc $(0), %rdx
add %rdx, %r12
adc $(0), %r13
xor %r8, %r8
movq (8)(%rbx), %r14
movq (8)(%rsp), %r15
movq (%rsi), %rax
mul %r14
add %rax, %r9
adc $(0), %rdx
mov %rdx, %rcx
imul %r9, %r15
movq (8)(%rsi), %rax
mul %r14
add %rcx, %r10
adc $(0), %rdx
add %rax, %r10
adc $(0), %rdx
mov %rdx, %rcx
movq (16)(%rsi), %rax
mul %r14
add %rcx, %r11
adc $(0), %rdx
add %rax, %r11
adc $(0), %rdx
mov %rdx, %rcx
movq (24)(%rsi), %rax
mul %r14
add %rcx, %r12
adc $(0), %rdx
add %rax, %r12
adc %rdx, %r13
adc $(0), %r8
movq (%rdi), %rax
mul %r15
add %rax, %r9
adc $(0), %rdx
mov %rdx, %r9
movq (8)(%rdi), %rax
mul %r15
add %r9, %r10
adc $(0), %rdx
add %rax, %r10
adc $(0), %rdx
mov %rdx, %r9
movq (16)(%rdi), %rax
mul %r15
add %r9, %r11
adc $(0), %rdx
add %rax, %r11
adc $(0), %rdx
mov %rdx, %r9
movq (24)(%rdi), %rax
mul %r15
add %r9, %r12
adc $(0), %rdx
add %rax, %r12
adc $(0), %rdx
add %rdx, %r13
adc $(0), %r8
xor %r9, %r9
movq (16)(%rbx), %r14
movq (8)(%rsp), %r15
movq (%rsi), %rax
mul %r14
add %rax, %r10
adc $(0), %rdx
mov %rdx, %rcx
imul %r10, %r15
movq (8)(%rsi), %rax
mul %r14
add %rcx, %r11
adc $(0), %rdx
add %rax, %r11
adc $(0), %rdx
mov %rdx, %rcx
movq (16)(%rsi), %rax
mul %r14
add %rcx, %r12
adc $(0), %rdx
add %rax, %r12
adc $(0), %rdx
mov %rdx, %rcx
movq (24)(%rsi), %rax
mul %r14
add %rcx, %r13
adc $(0), %rdx
add %rax, %r13
adc %rdx, %r8
adc $(0), %r9
movq (%rdi), %rax
mul %r15
add %rax, %r10
adc $(0), %rdx
mov %rdx, %r10
movq (8)(%rdi), %rax
mul %r15
add %r10, %r11
adc $(0), %rdx
add %rax, %r11
adc $(0), %rdx
mov %rdx, %r10
movq (16)(%rdi), %rax
mul %r15
add %r10, %r12
adc $(0), %rdx
add %rax, %r12
adc $(0), %rdx
mov %rdx, %r10
movq (24)(%rdi), %rax
mul %r15
add %r10, %r13
adc $(0), %rdx
add %rax, %r13
adc $(0), %rdx
add %rdx, %r8
adc $(0), %r9
xor %r10, %r10
movq (24)(%rbx), %r14
movq (8)(%rsp), %r15
movq (%rsi), %rax
mul %r14
add %rax, %r11
adc $(0), %rdx
mov %rdx, %rcx
imul %r11, %r15
movq (8)(%rsi), %rax
mul %r14
add %rcx, %r12
adc $(0), %rdx
add %rax, %r12
adc $(0), %rdx
mov %rdx, %rcx
movq (16)(%rsi), %rax
mul %r14
add %rcx, %r13
adc $(0), %rdx
add %rax, %r13
adc $(0), %rdx
mov %rdx, %rcx
movq (24)(%rsi), %rax
mul %r14
add %rcx, %r8
adc $(0), %rdx
add %rax, %r8
adc %rdx, %r9
adc $(0), %r10
movq (%rdi), %rax
mul %r15
add %rax, %r11
adc $(0), %rdx
mov %rdx, %r11
movq (8)(%rdi), %rax
mul %r15
add %r11, %r12
adc $(0), %rdx
add %rax, %r12
adc $(0), %rdx
mov %rdx, %r11
movq (16)(%rdi), %rax
mul %r15
add %r11, %r13
adc $(0), %rdx
add %rax, %r13
adc $(0), %rdx
mov %rdx, %r11
movq (24)(%rdi), %rax
mul %r15
add %r11, %r8
adc $(0), %rdx
add %rax, %r8
adc $(0), %rdx
add %rdx, %r9
adc $(0), %r10
xor %r11, %r11
movq (%rsp), %rsi
mov %r12, %rax
mov %r13, %rbx
mov %r8, %rcx
mov %r9, %rdx
subq (%rdi), %rax
sbbq (8)(%rdi), %rbx
sbbq (16)(%rdi), %rcx
sbbq (24)(%rdi), %rdx
sbb $(0), %r10
cmovnc %rax, %r12
cmovnc %rbx, %r13
cmovnc %rcx, %r8
cmovnc %rdx, %r9
movq %r12, (%rsi)
movq %r13, (8)(%rsi)
movq %r8, (16)(%rsi)
movq %r9, (24)(%rsi)
mov %rsi, %rax
add $(24), %rsp
vzeroupper
pop %r15
pop %r14
pop %r13
pop %r12
pop %rbp
pop %rbx
ret
.p2align 5, 0x90
.globl _e9_gf256_sqrm
_e9_gf256_sqrm:
push %rbx
push %rbp
push %r12
push %r13
push %r14
push %r15
sub $(24), %rsp
movq %rdi, (%rsp)
mov %rdx, %rdi
movq %rcx, (8)(%rsp)
movq (%rsi), %rbx
movq (8)(%rsi), %rax
mul %rbx
mov %rax, %r9
mov %rdx, %r10
movq (16)(%rsi), %rax
mul %rbx
add %rax, %r10
adc $(0), %rdx
mov %rdx, %r11
movq (24)(%rsi), %rax
mul %rbx
add %rax, %r11
adc $(0), %rdx
mov %rdx, %r12
movq (8)(%rsi), %rbx
movq (16)(%rsi), %rax
mul %rbx
add %rax, %r11
adc $(0), %rdx
mov %rdx, %rbp
movq (24)(%rsi), %rax
mul %rbx
add %rax, %r12
adc $(0), %rdx
add %rbp, %r12
adc $(0), %rdx
mov %rdx, %r13
movq (16)(%rsi), %rbx
movq (24)(%rsi), %rax
mul %rbx
add %rax, %r13
adc $(0), %rdx
mov %rdx, %r14
xor %r15, %r15
shld $(1), %r14, %r15
shld $(1), %r13, %r14
shld $(1), %r12, %r13
shld $(1), %r11, %r12
shld $(1), %r10, %r11
shld $(1), %r9, %r10
shl $(1), %r9
movq (%rsi), %rax
mul %rax
mov %rax, %r8
add %rdx, %r9
adc $(0), %r10
movq (8)(%rsi), %rax
mul %rax
add %rax, %r10
adc %rdx, %r11
adc $(0), %r12
movq (16)(%rsi), %rax
mul %rax
add %rax, %r12
adc %rdx, %r13
adc $(0), %r14
movq (24)(%rsi), %rax
mul %rax
add %rax, %r14
adc %rdx, %r15
movq (8)(%rsp), %rcx
imul %r8, %rcx
movq (%rdi), %rax
mul %rcx
add %rax, %r8
adc $(0), %rdx
mov %rdx, %r8
movq (8)(%rdi), %rax
mul %rcx
add %r8, %r9
adc $(0), %rdx
add %rax, %r9
adc $(0), %rdx
mov %rdx, %r8
movq (16)(%rdi), %rax
mul %rcx
add %r8, %r10
adc $(0), %rdx
add %rax, %r10
adc $(0), %rdx
mov %rdx, %r8
movq (24)(%rdi), %rax
mul %rcx
add %r8, %r11
adc $(0), %rdx
add %rax, %r11
adc $(0), %rdx
add %rdx, %r12
adc $(0), %r13
xor %r8, %r8
movq (8)(%rsp), %rcx
imul %r9, %rcx
movq (%rdi), %rax
mul %rcx
add %rax, %r9
adc $(0), %rdx
mov %rdx, %r9
movq (8)(%rdi), %rax
mul %rcx
add %r9, %r10
adc $(0), %rdx
add %rax, %r10
adc $(0), %rdx
mov %rdx, %r9
movq (16)(%rdi), %rax
mul %rcx
add %r9, %r11
adc $(0), %rdx
add %rax, %r11
adc $(0), %rdx
mov %rdx, %r9
movq (24)(%rdi), %rax
mul %rcx
add %r9, %r12
adc $(0), %rdx
add %rax, %r12
adc $(0), %rdx
add %rdx, %r13
adc $(0), %r14
xor %r9, %r9
movq (8)(%rsp), %rcx
imul %r10, %rcx
movq (%rdi), %rax
mul %rcx
add %rax, %r10
adc $(0), %rdx
mov %rdx, %r10
movq (8)(%rdi), %rax
mul %rcx
add %r10, %r11
adc $(0), %rdx
add %rax, %r11
adc $(0), %rdx
mov %rdx, %r10
movq (16)(%rdi), %rax
mul %rcx
add %r10, %r12
adc $(0), %rdx
add %rax, %r12
adc $(0), %rdx
mov %rdx, %r10
movq (24)(%rdi), %rax
mul %rcx
add %r10, %r13
adc $(0), %rdx
add %rax, %r13
adc $(0), %rdx
add %rdx, %r14
adc $(0), %r15
xor %r10, %r10
movq (8)(%rsp), %rcx
imul %r11, %rcx
movq (%rdi), %rax
mul %rcx
add %rax, %r11
adc $(0), %rdx
mov %rdx, %r11
movq (8)(%rdi), %rax
mul %rcx
add %r11, %r12
adc $(0), %rdx
add %rax, %r12
adc $(0), %rdx
mov %rdx, %r11
movq (16)(%rdi), %rax
mul %rcx
add %r11, %r13
adc $(0), %rdx
add %rax, %r13
adc $(0), %rdx
mov %rdx, %r11
movq (24)(%rdi), %rax
mul %rcx
add %r11, %r14
adc $(0), %rdx
add %rax, %r14
adc $(0), %rdx
add %rdx, %r15
adc $(0), %r8
xor %r11, %r11
movq (%rsp), %rsi
mov %r12, %rax
mov %r13, %rbx
mov %r14, %rcx
mov %r15, %rdx
subq (%rdi), %rax
sbbq (8)(%rdi), %rbx
sbbq (16)(%rdi), %rcx
sbbq (24)(%rdi), %rdx
sbb $(0), %r8
cmovnc %rax, %r12
cmovnc %rbx, %r13
cmovnc %rcx, %r14
cmovnc %rdx, %r15
movq %r12, (%rsi)
movq %r13, (8)(%rsi)
movq %r14, (16)(%rsi)
movq %r15, (24)(%rsi)
mov %rsi, %rax
add $(24), %rsp
vzeroupper
pop %r15
pop %r14
pop %r13
pop %r12
pop %rbp
pop %rbx
ret
|
#include "csg.h"
#include "color.h"
#define EPS 1e-10
/******************************************************************/
CSGCube::CSGCube (double x, double y, double z) : size_x(x), size_y(y), size_z(z), center(true) {};
void CSGCube::toString() const {
printf("cube([%lf, %lf, %lf], true);\n", size_x, size_y, size_z);
}
bool CSGCube::isInside(const Vector3D &p, Color &color) const {
if (center) {
if (p.pt[0] <= size_x/2 && p.pt[0] >= -size_x/2 &&
p.pt[1] <= size_y/2 && p.pt[1] >= -size_y/2 &&
p.pt[2] <= size_z/2 && p.pt[2] >= -size_z/2)
return true;
}
else { // TODO
if (p.pt[0] <= size_x && p.pt[0] >= 0 &&
p.pt[1] <= size_y && p.pt[1] >= 0 &&
p.pt[2] <= size_z && p.pt[2] >= 0)
return true;
}
return false;
}
bool CSGCube::isInBorder(const Vector3D &p, Color &color, double border) const {
if (center) {
if (isInside(p, color) && (
(p.pt[0] <= size_x/2 && p.pt[0] >= size_x/2 - border) ||
(p.pt[1] <= size_y/2 && p.pt[1] >= size_y/2 - border) ||
(p.pt[2] <= size_z/2 && p.pt[2] >= size_z/2 - border) ||
(p.pt[0] >= -size_x/2 && p.pt[0] <= -size_x/2 + border) ||
(p.pt[1] >= -size_y/2 && p.pt[1] <= -size_y/2 + border) ||
(p.pt[2] >= -size_z/2 && p.pt[2] <= -size_z/2 + border)))
return true;
}
else { // TODO
if (p.pt[0] <= size_x && p.pt[0] >= 0 &&
p.pt[1] <= size_y && p.pt[1] >= 0 &&
p.pt[2] <= size_z && p.pt[2] >= 0)
return true;
}
return false;
}
void CSGCube::boundingBox(BoundingBox &bb) {
if (center) {
bb.P0.set(-size_x/2,-size_y/2,-size_z/2,1);
bb.P1.set(size_x/2, size_y/2, size_z/2, 1);
}
else {
bb.P0.set(0, 0, 0, 1);
bb.P1.set(size_x, size_y, size_z, 1);
}
}
/******************************************************************/
void CSGSphere::toString() const {
printf("sphere(%lf);\n", radius);
}
bool CSGSphere::isInside(const Vector3D &p, Color &color) const {
double dist = sqrt(pow(p.pt[0], 2) + pow(p.pt[1], 2) + pow(p.pt[2], 2));
if (dist <= radius)
return true;
return false;
}
bool CSGSphere::isInBorder(const Vector3D &p, Color &color, double border) const {
double dist = sqrt(pow(p.pt[0], 2) + pow(p.pt[1], 2) + pow(p.pt[2], 2));
if (dist <= radius && dist >= radius - border)
return true;
return false;
}
void CSGSphere::boundingBox(BoundingBox &bb) {
bb.P0.set(-radius, -radius, -radius,1);
bb.P1.set(radius, radius, radius, 1);
}
/******************************************************************/
CSGCylinder::CSGCylinder (double h, double r) : height(h), radius(r), center(true) {};
void CSGCylinder::toString() const {
printf("cylinder(%lf, %lf, %lf, true);\n", height, radius, radius);
}
bool CSGCylinder::isInside(const Vector3D &p, Color &color) const {
double dist = sqrt(pow(p.pt[0], 2) + pow(p.pt[1], 2));
if (center) {
if (p.pt[2] <= height/2. && p.pt[2] >= -height/2.) {
if (dist <= radius) {
return true;
}
}
}
else {
if (p.pt[2] <= height && p.pt[2] >= 0) {
if (dist <= radius) {
return true;
}
}
}
return false;
}
bool CSGCylinder::isInBorder(const Vector3D &p, Color &color, double border) const {
double dist = sqrt(pow(p.pt[0], 2) + pow(p.pt[1], 2));
if (center) {
if (p.pt[2] <= height/2. && p.pt[2] >= -height/2.) {
if (dist <= radius && dist >= radius - border) {
return true;
}
}
if ((p.pt[2] <= height/2. && p.pt[2] >= height/2. - border && dist <= radius) ||
(p.pt[2] >= -height/2. && p.pt[2] <= -height/2. + border && dist <= radius)) {
return true;
}
}
else { //TODO
if (p.pt[2] <= height && p.pt[2] >= 0) {
if (dist <= radius && dist >= radius - border) {
return true;
}
}
}
return false;
}
void CSGCylinder::boundingBox(BoundingBox &bb) {
if (center) {
bb.P0.set(-radius, -radius, -height/2,1);
bb.P1.set(radius, radius, height/2, 1);
}
else {
bb.P0.set(-radius, -radius, 0, 1);
bb.P1.set(radius, radius, height, 1);
}
}
/******************************************************************/
void CSGTranslate::toString() const {
printf("translate([%lf, %lf, %lf]) ", translate[0], translate[1], translate[2]);
for (unsigned int i = 0; i < children.size(); i++)
children[i]->toString();
}
bool CSGTranslate::isInside(const Vector3D &p, Color &color) const {
Vector3D new_point(p[0]-translate[0], p[1]-translate[1], p[2]-translate[2], 1.0);
for (unsigned int i = 0; i < children.size(); i++) {
if (children[i]->isInside(new_point, color)) return true;
}
return false;
}
bool CSGTranslate::isInBorder(const Vector3D &p, Color &color, double border) const {
Vector3D new_point(p[0]-translate[0], p[1]-translate[1], p[2]-translate[2], 1.0);
for (unsigned int i = 0; i < children.size(); i++) {
if (children[i]->isInBorder(new_point, color, border)) return true;
}
return false;
}
void CSGTranslate::boundingBox(BoundingBox &bb) {
for (unsigned int i = 0; i < children.size(); i++) {
children[i]->boundingBox(bb);
}
bb.P0.set(bb.P0[0]+translate[0], bb.P0[1]+translate[1], bb.P0[2]+translate[2],1);
bb.P1.set(bb.P1[0]+translate[0], bb.P1[1]+translate[1], bb.P1[2]+translate[2],1);
}
/******************************************************************/
CSGRotate::CSGRotate(float x, float y, float z) {
vec.set(x,y,z,1.0);
Matrix mat;
mat.setRotationX(x);
rotate = rotate*mat;
mat.setRotationY(y);
rotate = rotate*mat;
mat.setRotationZ(z);
rotate = rotate*mat;
rotate.inverse(rotate_1);
}
void CSGRotate::toString() const {
printf("rotate([%lf, %lf, %lf]) ", vec[0], vec[1], vec[2]);
for (unsigned int i = 0; i < children.size(); i++)
children[i]->toString();
}
bool CSGRotate::isInside(const Vector3D &p, Color &color) const {
Vector3D new_point = rotate_1*((Vector3D&)p);
for (unsigned int i = 0; i < children.size(); i++) {
if (children[i]->isInside(new_point, color)) return true;
}
return false;
}
bool CSGRotate::isInBorder(const Vector3D &p, Color &color, double border) const {
Vector3D new_point = rotate_1*((Vector3D&)p);
for (unsigned int i = 0; i < children.size(); i++) {
if (children[i]->isInBorder(new_point, color, border)) return true;
}
return false;
}
void CSGRotate::boundingBox(BoundingBox &bb) {
for (unsigned int i = 0; i < children.size(); i++) {
children[i]->boundingBox(bb);
}
Vector3D P0 = rotate*bb.P0;
Vector3D P1 = rotate*bb.P1;
bb.P0.set(min(P0[0], P1[0]), min(P0[1],P1[1]), min(P0[2], P1[2]),1);
bb.P1.set(max(P0[0], P1[0]), max(P0[1],P1[1]), max(P0[2], P1[2]),1);
}
/******************************************************************/
void CSGScale::toString() const {
printf("scale([%lf, %lf, %lf]) ", scale[0], scale[1], scale[2]);
for (unsigned int i = 0; i < children.size(); i++)
children[i]->toString();
}
bool CSGScale::isInside(const Vector3D &p, Color &color) const {
Vector3D new_point(p[0]/scale[0], p[1]/scale[1], p[2]/scale[2], 1.0);
for (unsigned int i = 0; i < children.size(); i++) {
if (children[i]->isInside(new_point, color)) return true;
}
return false;
}
bool CSGScale::isInBorder(const Vector3D &p, Color &color, double border) const {
Vector3D new_point(p[0]/scale[0], p[1]/scale[1], p[2]/scale[2], 1.0);
for (unsigned int i = 0; i < children.size(); i++) {
if (children[i]->isInBorder(new_point, color, border)) return true;
}
return false;
}
void CSGScale::boundingBox(BoundingBox &bb) {
for (unsigned int i = 0; i < children.size(); i++) {
children[i]->boundingBox(bb);
}
bb.P0.set(bb.P0[0]*scale[0], bb.P0[1]*scale[1], bb.P0[2]*scale[2],1);
bb.P1.set(bb.P1[0]*scale[0], bb.P1[1]*scale[1], bb.P1[2]*scale[2],1);
}
/******************************************************************/
void CSGUnion::toString() const {
printf("union() {\n");
for (unsigned int i = 0; i < children.size(); i++)
children[i]->toString();
printf("}\n");
}
bool CSGUnion::isInside(const Vector3D &p, Color &color) const {
for (unsigned int i = 0; i < children.size(); i++) {
if (children[i]->isInside(p, color)) return true;
}
return false;
}
bool CSGUnion::isInBorder(const Vector3D &p, Color &color, double border) const {
bool flagInside;
for (unsigned int i = 0; i < children.size(); i++) {
if (children[i]->isInBorder(p, color, border)) {
flagInside = true;
for (unsigned int j = 0; j < children.size(); j++) {
if (i != j && children[j]->isInside(p, color)) flagInside = false;
}
if (flagInside)
return true;
}
}
return false;
}
void CSGUnion::boundingBox(BoundingBox &bb) {
if (children.size() != 0) {
children[0]->boundingBox(bb);
}
BoundingBox bbChild;
for (unsigned int i = 1; i < children.size(); i++) {
children[i]->boundingBox(bbChild);
bb = bb | bbChild;
}
}
/******************************************************************/
void CSGDifference::toString() const {
printf("difference() {\n");
for (unsigned int i = 0; i < children.size(); i++)
children[i]->toString();
printf("}\n");
}
bool CSGDifference::isInside(const Vector3D &p, Color &color) const {
if (children.size() > 0 && children[0]->isInside(p, color)) {
for (unsigned int i = 1; i < children.size(); i++) {
if (children[i]->isInside(p, color)) return false;
}
return true;
}
return false;
}
bool CSGDifference::isInBorder(const Vector3D &p, Color &color, double border) const {
if (children.size() > 0 && children[0]->isInBorder(p, color, border)) {
for (unsigned int i = 1; i < children.size(); i++) {
if (children[i]->isInside(p, color)) return false;
}
return true;
}
return false;
}
void CSGDifference::boundingBox(BoundingBox &bb) {
if (children.size() != 0) {
children[0]->boundingBox(bb);
}
}
/******************************************************************/
void CSGIntersection::toString() const {
printf("intersection() {\n");
for (unsigned int i = 0; i < children.size(); i++)
children[i]->toString();
printf("}\n");
}
bool CSGIntersection::isInside(const Vector3D &p, Color &color) const {
for (unsigned int i = 0; i < children.size(); i++) {
if (!children[i]->isInside(p, color)) return false;
}
return children.size() > 0 ? true : false;
}
bool CSGIntersection::isInBorder(const Vector3D &p, Color &color, double border) const {
bool flagInside;
for (unsigned int i = 0; i < children.size(); i++) {
if (children[i]->isInBorder(p, color, border)) {
flagInside = true;
for (unsigned int j = 0; j < children.size(); j++) {
if (i != j && !children[j]->isInside(p, color)) flagInside = false;
}
if (flagInside)
return true;
}
}
return false;
}
void CSGIntersection::boundingBox(BoundingBox &bb) {
if (children.size() != 0) {
children[0]->boundingBox(bb);
}
}
/******************************************************************/
void CSGColor::toString() const {
printf("color([%lf, %lf, %lf]) ", color[0], color[1], color[2]);
for (unsigned int i = 0; i < children.size(); i++)
children[i]->toString();
}
bool CSGColor::isInside(const Vector3D &p, Color &color) const {
for (unsigned int i = 0; i < children.size(); i++) {
if (children[i]->isInside(p, color)) {
color = this->color;
return true;
}
}
return false;
}
bool CSGColor::isInBorder(const Vector3D &p, Color &color, double border) const {
for (unsigned int i = 0; i < children.size(); i++) {
if (children[i]->isInBorder(p, color, border)) {
color = this->color;
return true;
}
}
return false;
}
void CSGColor::boundingBox(BoundingBox &bb) {
for (unsigned int i = 0; i < children.size(); i++) {
children[i]->boundingBox(bb);
}
}
/******************************************************************/
void CSGNode::addChild(CSGNode *node) {
children.push_back(node);
}
void CSGNode::getStats(CSGTreeStats &stats, int depth) {
if (children.size() == 0) {
stats.leaf++;
stats.depth = max(stats.depth, depth);
}
else {
stats.internal++;
for (unsigned int i = 0; i < children.size(); i++) {
children[i]->getStats(stats, depth+1);
}
}
}
/******************************************************************/
const BoundingBox operator |(const BoundingBox bb1,const BoundingBox bb2) {
BoundingBox bb;
bb.P0.set(min(bb1.P0[0],bb2.P0[0]),min(bb1.P0[1],bb2.P0[1]),min(bb1.P0[2],bb2.P0[2]), 1.0);
bb.P1.set(max(bb1.P1[0],bb2.P1[0]),max(bb1.P1[1],bb2.P1[1]),max(bb1.P1[2],bb2.P1[2]), 1.0);
return bb;
}
|
#pragma once
#include "common/Outcome.hpp"
namespace chatterino {
class IrcChannel;
Outcome invokeIrcCommand(const QString &command, const QString ¶ms,
IrcChannel &channel);
} // namespace chatterino
|
; Listing generated by Microsoft (R) Optimizing Compiler Version 19.00.23506.0
include listing.inc
INCLUDELIB MSVCRT
INCLUDELIB OLDNAMES
PUBLIC __local_stdio_printf_options
PUBLIC _vfprintf_l
PUBLIC printf
PUBLIC main
EXTRN __imp___acrt_iob_func:PROC
EXTRN __imp___stdio_common_vfprintf:PROC
EXTRN gets:PROC
_DATA SEGMENT
COMM ?_OptionsStorage@?1??__local_stdio_printf_options@@9@9:QWORD ; `__local_stdio_printf_options'::`2'::_OptionsStorage
_DATA ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$_vfprintf_l DD imagerel $LN3
DD imagerel $LN3+68
DD imagerel $unwind$_vfprintf_l
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$printf DD imagerel $LN3
DD imagerel $LN3+88
DD imagerel $unwind$printf
pdata ENDS
pdata SEGMENT
$pdata$main DD imagerel $LN3
DD imagerel $LN3+31
DD imagerel $unwind$main
pdata ENDS
xdata SEGMENT
$unwind$main DD 010401H
DD 06204H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$printf DD 011801H
DD 06218H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$_vfprintf_l DD 011801H
DD 06218H
xdata ENDS
; Function compile flags: /Odtp
; File d:\projects\taintanalysis\antitaint\epilog\src\main.c
_TEXT SEGMENT
buf$ = 32
main PROC
; 10 : {
$LN3:
sub rsp, 56 ; 00000038H
; 11 : char buf[8];
; 12 : gets(buf);
lea rcx, QWORD PTR buf$[rsp]
call gets
; 13 : printf(buf);
lea rcx, QWORD PTR buf$[rsp]
call printf
; 14 : return 0;
xor eax, eax
; 15 : }
add rsp, 56 ; 00000038H
ret 0
main ENDP
_TEXT ENDS
; Function compile flags: /Odtp
; File c:\program files (x86)\windows kits\10\include\10.0.10240.0\ucrt\stdio.h
; COMDAT printf
_TEXT SEGMENT
_Result$ = 32
_ArgList$ = 40
_Format$ = 64
printf PROC ; COMDAT
; 950 : {
$LN3:
mov QWORD PTR [rsp+8], rcx
mov QWORD PTR [rsp+16], rdx
mov QWORD PTR [rsp+24], r8
mov QWORD PTR [rsp+32], r9
sub rsp, 56 ; 00000038H
; 951 : int _Result;
; 952 : va_list _ArgList;
; 953 : __crt_va_start(_ArgList, _Format);
lea rax, QWORD PTR _Format$[rsp+8]
mov QWORD PTR _ArgList$[rsp], rax
; 954 : _Result = _vfprintf_l(stdout, _Format, NULL, _ArgList);
mov ecx, 1
call QWORD PTR __imp___acrt_iob_func
mov r9, QWORD PTR _ArgList$[rsp]
xor r8d, r8d
mov rdx, QWORD PTR _Format$[rsp]
mov rcx, rax
call _vfprintf_l
mov DWORD PTR _Result$[rsp], eax
; 955 : __crt_va_end(_ArgList);
mov QWORD PTR _ArgList$[rsp], 0
; 956 : return _Result;
mov eax, DWORD PTR _Result$[rsp]
; 957 : }
add rsp, 56 ; 00000038H
ret 0
printf ENDP
_TEXT ENDS
; Function compile flags: /Odtp
; File c:\program files (x86)\windows kits\10\include\10.0.10240.0\ucrt\stdio.h
; COMDAT _vfprintf_l
_TEXT SEGMENT
_Stream$ = 64
_Format$ = 72
_Locale$ = 80
_ArgList$ = 88
_vfprintf_l PROC ; COMDAT
; 638 : {
$LN3:
mov QWORD PTR [rsp+32], r9
mov QWORD PTR [rsp+24], r8
mov QWORD PTR [rsp+16], rdx
mov QWORD PTR [rsp+8], rcx
sub rsp, 56 ; 00000038H
; 639 : return __stdio_common_vfprintf(_CRT_INTERNAL_LOCAL_PRINTF_OPTIONS, _Stream, _Format, _Locale, _ArgList);
call __local_stdio_printf_options
mov rcx, QWORD PTR _ArgList$[rsp]
mov QWORD PTR [rsp+32], rcx
mov r9, QWORD PTR _Locale$[rsp]
mov r8, QWORD PTR _Format$[rsp]
mov rdx, QWORD PTR _Stream$[rsp]
mov rcx, QWORD PTR [rax]
call QWORD PTR __imp___stdio_common_vfprintf
; 640 : }
add rsp, 56 ; 00000038H
ret 0
_vfprintf_l ENDP
_TEXT ENDS
; Function compile flags: /Odtp
; File c:\program files (x86)\windows kits\10\include\10.0.10240.0\ucrt\corecrt_stdio_config.h
; COMDAT __local_stdio_printf_options
_TEXT SEGMENT
__local_stdio_printf_options PROC ; COMDAT
; 74 : static unsigned __int64 _OptionsStorage;
; 75 : return &_OptionsStorage;
lea rax, OFFSET FLAT:?_OptionsStorage@?1??__local_stdio_printf_options@@9@9 ; `__local_stdio_printf_options'::`2'::_OptionsStorage
; 76 : }
ret 0
__local_stdio_printf_options ENDP
_TEXT ENDS
END
|
/*
Copyright 2021 Smart Engines Service LLC
Redistribution and use in source and binary forms, with or without modification,
are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
3. Neither the name of the copyright holder nor the names of its contributors
may be used to endorse or promote products derived from this software
without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR
IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#pragma once
#ifndef MINBASE_MINSTD_HPP_INCLUDED
#define MINBASE_MINSTD_HPP_INCLUDED
#include <minbase/crossplat.h>
#if MIN_HAVE_CPLUSPLUS
# if defined(__GNUC__) && !defined(__clang__)
# if defined(ANDROID) || defined(PLATFORM_ELBRUS)
#include <string>
#include <sstream>
# endif // defined(ANDROID) || defined(PLATFORM_ELBRUS)
# if defined(ANDROID) || defined(PLATFORM_ELBRUS) || ((__GNUC__ == 4) && (__GNUC_MINOR <= 8))
#include <stdexcept>
# endif // defined(ANDROID) || defined(PLATFORM_ELBRUS) || ((__GNUC__ == 4) && (__GNUC_MINOR <= 8))
#endif // defined(__GNUC__) && !defined(__clang__)
# if MIN_HAVE_CPLUSPLUS_11
# include <type_traits>
# else // MIN_HAVE_CPLUSPLUS_11
namespace std {
template<class T, T v>
struct integral_constant {
static const T value = v;
typedef T value_type;
typedef integral_constant type;
operator value_type() const { return value; }
};
typedef integral_constant<bool, true> true_type;
typedef integral_constant<bool, false> false_type;
template<class T, class U>
struct is_same : std::false_type {};
template<class T>
struct is_same<T, T> : std::true_type {};
template<bool cond, class T = void>
struct enable_if {};
template<class T>
struct enable_if<true, T> { typedef T type; };
template<bool B, class T, class F>
struct conditional { typedef T type; };
template<class T, class F>
struct conditional<false, T, F> { typedef F type; };
} // namespace std
# endif // MIN_HAVE_CPLUSPLUS_11 #else
# if defined(__GNUC__) && !defined(__clang__)
# if defined(ANDROID) || defined(PLATFORM_ELBRUS)
namespace std {
template <typename T>
std::string to_string(T value) {
std::ostringstream os;
os << value;
return os.str();
}
static double stod(const std::string& str) {
std::istringstream istr(str);
double ret = 0.0;
istr >> ret;
return ret;
}
} // namespace std
# endif // defined(ANDROID) || defined(PLATFORM_ELBRUS)
# if defined(ANDROID)
namespace std {
static int stoi(const std::string& str) {
std::istringstream istr(str);
int ret = 0;
istr >> ret;
return ret;
}
static unsigned long stoul(const std::string& str) {
std::istringstream istr(str);
unsigned long ret = 0;
istr >> ret;
return ret;
}
template<typename T>
T cbrt(T value) {
return std::pow(value, 1.0 / 3.0);
}
} // namespace std
# endif // defined(ANDROID)
# if defined(ANDROID) || ((__GNUC__ == 4) && (__GNUC_MINOR <= 8))
namespace std {
static std::ios_base& hexfloat(std::ios_base& base) {
throw std::runtime_error(
"minstd impl of std::hexfloat on android is not supported");
}
} // namespace std
# endif // defined(ANDROID) || ((__GNUC__ == 4) && (__GNUC_MINOR <= 8))
# if (__GNUC__ < 4) || ((__GNUC__ == 4) && (__GNUC_MINOR <= 8))
namespace std {
static inline void* align(
std::size_t alignment,
std::size_t size,
void*& ptr,
std::size_t& space) {
void* dst = reinterpret_cast<void*>((reinterpret_cast<ptrdiff_t>(ptr) + alignment - 1) /
alignment * alignment);
ptrdiff_t shift = reinterpret_cast<ptrdiff_t>(dst) - reinterpret_cast<ptrdiff_t>(ptr);
if (space < shift + size)
return nullptr;
space -= shift;
ptr = dst;
return ptr;
}
} // namespace std
# endif // (__GNUC__ < 4) || ((__GNUC__ == 4) && (__GNUC_MINOR <= 8))
# endif // defined(__GNUC__) && !defined(__clang__)
#endif // MIN_HAVE_CPLUSPLUS
#endif // #ifndef MINBASE_MINSTD_HPP_INCLUDED
|
.global s_prepare_buffers
s_prepare_buffers:
push %r10
push %r12
push %r14
push %r15
push %r9
push %rax
push %rbp
push %rcx
push %rdi
push %rsi
lea addresses_WC_ht+0x8720, %r10
nop
nop
nop
nop
and %r14, %r14
mov $0x6162636465666768, %r9
movq %r9, %xmm5
vmovups %ymm5, (%r10)
nop
nop
nop
and %r15, %r15
lea addresses_D_ht+0x4d20, %rbp
clflush (%rbp)
nop
and %r10, %r10
mov (%rbp), %eax
nop
nop
nop
nop
nop
and $57046, %rbp
lea addresses_normal_ht+0x1662d, %r10
cmp %r12, %r12
mov $0x6162636465666768, %r9
movq %r9, %xmm5
movups %xmm5, (%r10)
nop
nop
nop
add %rax, %rax
lea addresses_normal_ht+0x4860, %r14
nop
add $36669, %r9
vmovups (%r14), %ymm1
vextracti128 $0, %ymm1, %xmm1
vpextrq $1, %xmm1, %r15
sub %rbp, %rbp
lea addresses_UC_ht+0xf320, %rsi
lea addresses_normal_ht+0x40a0, %rdi
nop
nop
nop
nop
nop
sub %r9, %r9
mov $106, %rcx
rep movsq
nop
nop
nop
nop
sub %rax, %rax
lea addresses_D_ht+0x2720, %rbp
nop
nop
nop
nop
nop
and %r14, %r14
mov (%rbp), %rsi
cmp $44148, %rdi
lea addresses_normal_ht+0x14920, %rax
nop
nop
cmp $41167, %r15
movb $0x61, (%rax)
nop
nop
nop
add %r9, %r9
lea addresses_WT_ht+0x5d20, %rax
nop
nop
nop
nop
nop
cmp %r10, %r10
and $0xffffffffffffffc0, %rax
vmovntdqa (%rax), %ymm6
vextracti128 $1, %ymm6, %xmm6
vpextrq $0, %xmm6, %rcx
nop
nop
nop
nop
inc %rdi
lea addresses_UC_ht+0xf620, %r9
dec %r15
mov $0x6162636465666768, %rdi
movq %rdi, (%r9)
xor %r14, %r14
lea addresses_D_ht+0xf720, %rcx
nop
nop
nop
nop
sub %rsi, %rsi
mov $0x6162636465666768, %rdi
movq %rdi, (%rcx)
nop
nop
nop
nop
nop
cmp $15096, %rbp
lea addresses_WC_ht+0xbb20, %rsi
nop
nop
nop
sub %r15, %r15
mov (%rsi), %r12
nop
nop
nop
and $11675, %rdi
lea addresses_normal_ht+0xf1cc, %rcx
nop
nop
nop
nop
cmp $1512, %rsi
movups (%rcx), %xmm1
vpextrq $1, %xmm1, %rax
nop
cmp %r15, %r15
lea addresses_D_ht+0x145a0, %rbp
nop
nop
nop
nop
nop
dec %rax
mov (%rbp), %r10
nop
nop
nop
nop
sub $24527, %r12
lea addresses_WC_ht+0xf6e0, %rsi
lea addresses_normal_ht+0xd750, %rdi
nop
nop
nop
and $21255, %r15
mov $126, %rcx
rep movsq
nop
nop
nop
sub $13068, %rcx
pop %rsi
pop %rdi
pop %rcx
pop %rbp
pop %rax
pop %r9
pop %r15
pop %r14
pop %r12
pop %r10
ret
.global s_faulty_load
s_faulty_load:
push %r10
push %r14
push %rbp
push %rcx
push %rdi
push %rsi
// Faulty Load
lea addresses_WT+0x16b20, %rbp
nop
nop
nop
nop
nop
xor %rcx, %rcx
vmovups (%rbp), %ymm7
vextracti128 $1, %ymm7, %xmm7
vpextrq $1, %xmm7, %rdi
lea oracles, %rcx
and $0xff, %rdi
shlq $12, %rdi
mov (%rcx,%rdi,1), %rdi
pop %rsi
pop %rdi
pop %rcx
pop %rbp
pop %r14
pop %r10
ret
/*
<gen_faulty_load>
[REF]
{'OP': 'LOAD', 'src': {'size': 16, 'NT': False, 'type': 'addresses_WT', 'same': False, 'AVXalign': False, 'congruent': 0}}
[Faulty Load]
{'OP': 'LOAD', 'src': {'size': 32, 'NT': False, 'type': 'addresses_WT', 'same': True, 'AVXalign': False, 'congruent': 0}}
<gen_prepare_buffer>
{'OP': 'STOR', 'dst': {'size': 32, 'NT': False, 'type': 'addresses_WC_ht', 'same': False, 'AVXalign': False, 'congruent': 9}}
{'OP': 'LOAD', 'src': {'size': 4, 'NT': False, 'type': 'addresses_D_ht', 'same': False, 'AVXalign': False, 'congruent': 9}}
{'OP': 'STOR', 'dst': {'size': 16, 'NT': False, 'type': 'addresses_normal_ht', 'same': True, 'AVXalign': False, 'congruent': 0}}
{'OP': 'LOAD', 'src': {'size': 32, 'NT': False, 'type': 'addresses_normal_ht', 'same': False, 'AVXalign': False, 'congruent': 4}}
{'OP': 'REPM', 'src': {'same': False, 'type': 'addresses_UC_ht', 'congruent': 10}, 'dst': {'same': False, 'type': 'addresses_normal_ht', 'congruent': 4}}
{'OP': 'LOAD', 'src': {'size': 8, 'NT': False, 'type': 'addresses_D_ht', 'same': False, 'AVXalign': True, 'congruent': 10}}
{'OP': 'STOR', 'dst': {'size': 1, 'NT': False, 'type': 'addresses_normal_ht', 'same': False, 'AVXalign': False, 'congruent': 9}}
{'OP': 'LOAD', 'src': {'size': 32, 'NT': True, 'type': 'addresses_WT_ht', 'same': False, 'AVXalign': False, 'congruent': 7}}
{'OP': 'STOR', 'dst': {'size': 8, 'NT': False, 'type': 'addresses_UC_ht', 'same': False, 'AVXalign': False, 'congruent': 5}}
{'OP': 'STOR', 'dst': {'size': 8, 'NT': False, 'type': 'addresses_D_ht', 'same': False, 'AVXalign': False, 'congruent': 10}}
{'OP': 'LOAD', 'src': {'size': 8, 'NT': False, 'type': 'addresses_WC_ht', 'same': False, 'AVXalign': False, 'congruent': 11}}
{'OP': 'LOAD', 'src': {'size': 16, 'NT': False, 'type': 'addresses_normal_ht', 'same': False, 'AVXalign': False, 'congruent': 1}}
{'OP': 'LOAD', 'src': {'size': 8, 'NT': False, 'type': 'addresses_D_ht', 'same': False, 'AVXalign': False, 'congruent': 3}}
{'OP': 'REPM', 'src': {'same': False, 'type': 'addresses_WC_ht', 'congruent': 5}, 'dst': {'same': False, 'type': 'addresses_normal_ht', 'congruent': 4}}
{'44': 872, '49': 2933, '00': 14980, '48': 3044}
00 48 48 00 00 00 49 48 00 00 49 00 44 48 00 00 00 49 48 00 00 00 49 00 00 00 48 48 00 00 49 00 44 00 49 00 00 00 49 48 48 49 00 00 00 49 48 00 00 49 00 44 00 49 48 48 49 48 00 44 49 48 00 00 00 48 00 00 00 48 00 00 00 00 49 48 00 49 00 00 49 00 00 00 49 00 00 00 00 00 00 00 49 00 00 44 49 48 00 00 49 48 00 00 00 00 00 00 00 48 00 00 49 00 48 00 00 00 00 49 00 00 00 49 48 00 48 00 00 00 00 48 00 00 00 48 48 00 48 00 00 00 48 00 00 49 00 00 44 00 49 00 00 00 48 00 00 49 00 00 00 48 00 00 49 00 00 00 48 00 00 00 00 00 44 00 00 00 00 00 00 00 00 49 48 00 00 00 48 00 00 44 49 00 48 00 00 49 00 00 44 00 48 00 00 00 00 00 00 00 49 00 00 00 49 48 00 00 00 00 44 00 00 00 00 00 00 00 44 00 48 00 00 00 00 00 00 00 00 00 00 00 00 00 00 49 00 00 00 48 00 00 49 48 00 00 49 48 00 44 00 00 00 44 49 48 00 48 49 00 00 00 44 48 48 00 00 49 00 00 49 00 44 00 49 00 44 00 49 00 00 00 49 48 00 49 00 00 00 49 00 00 00 00 00 00 00 00 00 00 00 49 48 00 00 48 48 00 48 00 00 48 00 49 00 00 49 48 00 00 00 00 00 00 48 00 00 44 48 00 00 00 49 00 48 00 00 49 00 48 00 49 00 00 00 48 49 48 00 00 00 49 48 00 00 00 49 48 44 00 49 00 00 00 00 49 48 48 00 00 48 00 00 00 49 00 00 00 49 00 00 00 48 00 00 00 49 00 00 00 49 00 44 00 00 00 00 00 00 49 00 00 49 48 00 00 48 48 00 49 00 00 49 48 00 00 49 48 00 49 00 00 48 49 00 00 49 00 00 49 48 00 00 00 48 00 00 49 00 00 00 00 00 00 49 00 00 00 48 00 00 44 00 00 00 00 00 00 00 00 49 00 00 00 49 00 00 00 49 48 00 48 49 48 00 00 00 49 00 00 00 49 48 00 48 00 00 49 00 44 00 49 00 00 00 49 00 00 00 48 48 00 49 00 00 00 00 49 00 00 44 00 00 00 00 00 00 00 00 00 49 00 00 00 48 00 00 00 49 00 00 00 00 48 48 48 49 00 48 00 48 44 00 49 00 00 00 49 00 00 00 00 49 00 00 00 00 00 00 48 00 00 00 00 00 00 00 00 00 00 00 00 49 00 48 00 00 49 48 00 00 00 49 00 44 00 49 48 00 49 00 00 44 00 49 48 44 49 00 00 00 49 00 00 49 00 00 00 00 00 48 48 49 00 48 00 49 48 00 48 49 00 00 00 00 49 48 48 00 00 00 00 44 00 48 00 00 00 49 00 00 00 49 00 00 00 49 48 00 00 49 00 48 00 00 49 00 44 48 49 00 00 00 00 00 44 00 48 00 00 00 49 00 00 00 48 00 00 00 48 00 00 00 49 00 00 00 49 00 00 44 48 00 00 00 48 00 00 00 49 48 00 00 49 48 48 00 49 00 00 00 00 00 00 00 44 00 00 00 00 00 49 00 00 00 00 00 00 49 48 00 00 00 48 48 00 00 49 00 00 00 49 48 00 49 00 00 00 49 00 00 48 00 48 00 00 44 00 49 00 00 49 00 48 00 48 00 00 00 49 48 44 00 49 00 48 00 00 49 48 00 00 49 48 00 00 49 48 00 49 00 00 00 49 48 44 00 49 00 00 00 49 48 00 00 49 48 00 00 00 48 00 00 00 49 00 00 00 00 49 48 00 00 00 00 00 44 00 48 00 00 00 49 48 00 00 49 48 44 00 00 00 00 00 49 00 00 48 00 48 00 00 00 49 48 00 00 49 48 00 00 49 00 00 00 00 00 00 49 00 00 00 48 48 00 00 49 00 00 00 00 00 00 44 00 48 00 00 48 00 00 48 00 00 48 00 00 00 49 00 00 00 00 48 00 00 00 00 00 00 49 48 00 00 49 48 00 48 49 48 00 00 49 00 00 00 49 48 00 00 00 00 00 00 00 48 00 00 00 49 00 00 00 49 00 00 00 48 00 00 00 49 00 00 00 49 48 00 00 00 49 48 00 00 00 00 00 48 00 00 49 48 00 00 00 48 00 00 00 49 00 48 00 00 00 49 00 00 00 49
*/
|
; A118265: Coefficient of q^n in (1-q)^4/(1-4q); dimensions of the enveloping algebra of the derived free Lie algebra on 4 letters.
; 1,0,6,20,81,324,1296,5184,20736,82944,331776,1327104,5308416,21233664,84934656,339738624,1358954496,5435817984,21743271936,86973087744,347892350976,1391569403904,5566277615616,22265110462464,89060441849856
mov $8,2
mov $10,$0
lpb $8,1
mov $0,$10
sub $8,1
add $0,$8
sub $0,1
mov $4,2
mov $6,$0
lpb $4,1
mov $0,$6
sub $4,1
add $0,$4
sub $0,1
mov $15,$0
mov $17,2
lpb $17,1
mov $0,$15
sub $17,1
add $0,$17
sub $0,1
mov $11,$0
mov $13,2
lpb $13,1
sub $13,1
add $0,$13
sub $0,1
mov $3,1
mul $3,$0
mov $9,4
pow $9,$3
mov $14,$13
lpb $14,1
mov $12,$9
sub $14,1
lpe
lpe
lpb $11,1
mov $11,0
sub $12,$9
lpe
mov $9,$12
mov $18,$17
lpb $18,1
mov $16,$9
sub $18,1
lpe
lpe
lpb $15,1
mov $15,0
sub $16,$9
lpe
mov $2,$4
mov $9,$16
lpb $2,1
sub $2,1
mov $5,$9
lpe
lpe
lpb $6,1
sub $5,$9
mov $6,0
lpe
mov $7,$8
mov $9,$5
lpb $7,1
mov $1,$9
sub $7,1
lpe
lpe
lpb $10,1
sub $1,$9
mov $10,0
lpe
|
// -*- mode: c++; indent-tabs-mode: nil; -*-
//
// Paragraph
// Copyright (c) 2016-2019 Illumina, Inc.
// All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// You may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied
// See the License for the specific language governing permissions and limitations
//
//
/**
* \brief Graph Helper
*
* \file Graph.cpp
* \author Peter Krusche
* \email pkrusche@illumina.com
*
*/
#include <algorithm>
#include <string>
#include "grm/GraphInput.hh"
#include "common/Error.hh"
#include "common/Fasta.hh"
#include "common/StringUtil.hh"
using graphtools::Graph;
using graphtools::NodeId;
using std::string;
namespace grm
{
/**
* Initialize graph from JSON
* @param in Input JSON node
* @param reference reference fasta name
* @param out Output graph to initialize
*/
Graph graphFromJson(Json::Value const& in, string const& reference, bool store_ref_sequence)
{
common::FastaFile ref(reference);
Json::Value const* in_graph = ∈
if (in.isMember("graph"))
{
in_graph = &in["graph"];
}
assert((*in_graph)["nodes"].type() == Json::ValueType::arrayValue);
Graph result{ (*in_graph)["nodes"].size(), false };
if ((*in_graph)["edges"].type() != Json::ValueType::nullValue)
{
assert((*in_graph)["edges"].type() == Json::ValueType::arrayValue);
}
LOG()->critical("Iterating over nodes");
std::map<string, NodeId> node_map;
for (NodeId i = 0; i < (*in_graph)["nodes"].size(); ++i)
{
auto const& in_n = (*in_graph)["nodes"][(int)i];
const string name = in_n.isMember("name") ? in_n["name"].asString() : string("node-") + std::to_string(i + 1);
assert(!node_map.count(name));
node_map[name] = i;
result.setNodeName(i, name);
LOG()->critical("node name {}", name);
string uc_name = name;
common::stringutil::toUpper(uc_name);
const bool is_source_or_sink
= (i == 0 || i == (*in_graph)["nodes"].size() - 1) && (uc_name == "SOURCE" || uc_name == "SINK");
assert(in_n.isMember("sequence") || in_n.isMember("reference") || is_source_or_sink);
LOG()->critical("node name {}, source or sinck known, now using t", name);
if (is_source_or_sink)
{
result.setNodeSeq(i, "X");
}
else if (in_n.isMember("sequence"))
{
result.setNodeSeq(i, in_n["sequence"].asString());
}
else
{
string reference_sequence;
if (in_n["reference"].type() == Json::ValueType::stringValue)
{
LOG()->critical("setting reference location {}", name);
const string reference_location = in_n["reference"].asString();
reference_sequence = ref.query(reference_location);
LOG()->critical("reference sequence location obtained {}", name);
}
else
{
assert(in_n["reference"].type() == Json::ValueType::arrayValue);
LOG()->critical("accessing reference as list {}", name);
for (const auto& ref_inst : in_n["reference"])
{
assert(ref_inst.type() == Json::ValueType::stringValue);
const string reference_location = ref_inst.asString();
const string curr_seq(ref.query(reference_location));
if (!reference_sequence.empty())
{
assert(reference_sequence == curr_seq);
}
reference_sequence = curr_seq;
}
}
if (store_ref_sequence)
{
assert(!reference_sequence.empty());
result.setNodeSeq(i, reference_sequence);
}
}
}
LOG()->critical("Iterating over edges");
for (size_t i = 0; i < (*in_graph)["edges"].size(); ++i)
{
LOG()->critical("Iterating over edge {}", i);
auto const& in_e = (*in_graph)["edges"][(int)i];
assert(node_map.count(in_e["from"].asString()));
assert(node_map.count(in_e["to"].asString()));
LOG()->critical("Accessing from node through {}", in_e["from"].asString());
const auto from_node = node_map[in_e["from"].asString()];
LOG()->critical("Accessing to node through {}", in_e["to"].asString());
const auto to_node = node_map[in_e["to"].asString()];
result.addEdge(from_node, to_node);
LOG()->critical("Iterating over sequences of in_e");
for (auto& sequence : in_e["sequences"])
{
result.addLabelToEdge(from_node, to_node, sequence.asString());
}
LOG()->critical("Iterated over sequences of in_e");
}
LOG()->critical("Node labels Iterating over nodes");
// Node label shortcut: add label to all in and out edges
for (NodeId i = 0; i < (*in_graph)["nodes"].size(); ++i)
{
auto const& in_n = (*in_graph)["nodes"][(int)i];
for (auto& sequence : in_n["sequences"])
{
for (auto h : result.predecessors(i))
{
LOG()->critical("Node labels predesessor");
result.addLabelToEdge(h, i, sequence.asString());
}
for (auto j : result.successors(i))
{
LOG()->critical("Node labels successor ");
result.addLabelToEdge(i, j, sequence.asString());
}
}
}
LOG()->critical("returning result ");
return result;
}
/**
* Read paths from JSON
* @param graph graph to use for the paths
* @param in_paths Input JSON node with paths
*/
std::list<graphtools::Path> pathsFromJson(graphtools::Graph const* graph, Json::Value const& in_paths)
{
std::list<graphtools::Path> paths;
assert(in_paths.type() == Json::ValueType::arrayValue);
std::unordered_map<std::string, NodeId> node_id_map;
for (NodeId node_id = 0; node_id != graph->numNodes(); ++node_id)
{
node_id_map[graph->nodeName(node_id)] = node_id;
}
for (const auto& path : in_paths)
{
auto const& path_nodes = path["nodes"];
assert(path_nodes.type() == Json::ValueType::arrayValue);
std::vector<NodeId> nodes;
nodes.reserve(path_nodes.size());
for (const auto& node_json : path_nodes)
{
const auto& node_name = node_json.asString();
assert(node_id_map.count(node_name) == 1);
nodes.push_back(node_id_map[node_name]);
}
paths.emplace_back(graph, 0, nodes, graph->nodeSeq(nodes.back()).size() - 1);
}
return paths;
}
}
|
/******ros header*****/
#include <ros/ros.h>
#include <sensor_msgs/JointState.h>
#include <std_msgs/Float32MultiArray.h>
/********************/
#include <string>
#include <math.h>
#define _USE_MATH_DEFINE
float x=0, y=0, z=0; //target point
float angle1=0,angle2=0; //set angle
float C1=0, C2=0; //cos1, cos2
float S1=0, S2=0; //sin1, sin2
const float L1=0.16, L2=0.16; //leg length(m)
sensor_msgs::JointState joint_state;
void ik_callback(const std_msgs::Float32MultiArray& target_point)
{
x=target_point.data[0]; // target y
y=target_point.data[1]; //target z
z=target_point.data[2]; //target z
/****Movable area evaluation**********/
if(!(pow((L1-L2),2.0)<=(pow(z,2.0)+pow(y,2.0))&&(pow(z,2.0)+pow(y,2.0))<=pow((L1+L2),2.0))){
y=0;
z=sqrt(pow(L1,2.0)+pow(L2,2.0));
ROS_WARN("Outside the movable field");
}
/********angle2 solution******/
C2=(pow(z,2.0)+pow(y,2.0)-pow(L1,2.0)-pow(L2,2.0))/(2*L1*L2);
S2=sqrt(1-pow(C2,2.0));
angle2=atan2(S2,C2);
/*******angle1 solution*******/
C1=(pow(z,2.0)+pow(y,2.0)+pow(L1,2.0)-pow(L2,2.0))/(2*L1*sqrt(pow(L1,2.0)+pow(L2,2.0)));
S1=sqrt(1-pow(C2,2.0));
angle1=atan2(y,z)-atan2(S1,C1);
joint_state.position[1] = -angle1;
joint_state.position[2] = -angle2;
}
int main(int argc, char** argv)
{
ros::init(argc, argv, "pos_to_angle");
ros::NodeHandle nh;
ros::Publisher joint_pub = nh.advertise<sensor_msgs::JointState>("joint_states", 10);
ros::Subscriber target_sub = nh.subscribe("target_point", 10, ik_callback);
joint_state.name.resize(3);
joint_state.name[0] = "joint0";
joint_state.name[1] = "joint1";
joint_state.name[2] = "joint2";
joint_state.position.resize(3);
ros::Rate loop_rate(10);
while (ros::ok())
{
joint_state.header.stamp = ros::Time::now();
joint_state.position[0]= 0;
joint_pub.publish(joint_state);
ros::spinOnce();
loop_rate.sleep();
}
return 0;
}
|
.global s_prepare_buffers
s_prepare_buffers:
push %r11
push %r12
push %r14
push %r15
push %rbx
push %rcx
push %rdi
push %rsi
lea addresses_WT_ht+0x179e7, %rcx
nop
nop
nop
nop
nop
dec %r12
mov (%rcx), %esi
nop
nop
xor %r11, %r11
lea addresses_D_ht+0xcee7, %r14
nop
nop
nop
nop
nop
sub $62927, %r15
mov $0x6162636465666768, %rbx
movq %rbx, %xmm4
vmovups %ymm4, (%r14)
nop
nop
nop
nop
xor %rbx, %rbx
lea addresses_UC_ht+0x1dee7, %rsi
lea addresses_WC_ht+0xf7c7, %rdi
nop
nop
nop
and $19050, %rbx
mov $34, %rcx
rep movsq
sub %r12, %r12
lea addresses_WT_ht+0x11f4b, %rsi
lea addresses_WT_ht+0x14ae7, %rdi
nop
nop
dec %r12
mov $88, %rcx
rep movsw
add $52559, %r14
lea addresses_A_ht+0x172e7, %rsi
lea addresses_UC_ht+0x1d813, %rdi
nop
nop
nop
dec %r12
mov $64, %rcx
rep movsw
nop
dec %r12
lea addresses_A_ht+0x5273, %rsi
lea addresses_WC_ht+0x1deeb, %rdi
nop
nop
nop
nop
sub $6868, %r15
mov $87, %rcx
rep movsb
nop
nop
nop
nop
nop
xor $10589, %rsi
pop %rsi
pop %rdi
pop %rcx
pop %rbx
pop %r15
pop %r14
pop %r12
pop %r11
ret
.global s_faulty_load
s_faulty_load:
push %r12
push %r15
push %r8
push %r9
push %rbp
push %rbx
push %rcx
// Store
lea addresses_WT+0x126ff, %rbx
nop
nop
nop
nop
inc %rcx
mov $0x5152535455565758, %rbp
movq %rbp, %xmm5
vmovups %ymm5, (%rbx)
add %r12, %r12
// Store
lea addresses_WC+0x1f27, %rbx
nop
nop
nop
nop
nop
sub %r15, %r15
mov $0x5152535455565758, %r12
movq %r12, %xmm2
vmovntdq %ymm2, (%rbx)
nop
nop
inc %r15
// Store
lea addresses_WC+0x1fc87, %r15
nop
nop
nop
nop
dec %r9
mov $0x5152535455565758, %r8
movq %r8, %xmm5
vmovups %ymm5, (%r15)
nop
nop
nop
nop
cmp %rbp, %rbp
// Faulty Load
lea addresses_normal+0x1eae7, %r8
clflush (%r8)
nop
nop
nop
dec %rcx
movups (%r8), %xmm7
vpextrq $0, %xmm7, %r9
lea oracles, %rbp
and $0xff, %r9
shlq $12, %r9
mov (%rbp,%r9,1), %r9
pop %rcx
pop %rbx
pop %rbp
pop %r9
pop %r8
pop %r15
pop %r12
ret
/*
<gen_faulty_load>
[REF]
{'OP': 'LOAD', 'src': {'type': 'addresses_normal', 'AVXalign': False, 'congruent': 0, 'size': 16, 'same': False, 'NT': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_WT', 'AVXalign': False, 'congruent': 2, 'size': 32, 'same': False, 'NT': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_WC', 'AVXalign': False, 'congruent': 2, 'size': 32, 'same': False, 'NT': True}}
{'OP': 'STOR', 'dst': {'type': 'addresses_WC', 'AVXalign': False, 'congruent': 4, 'size': 32, 'same': False, 'NT': False}}
[Faulty Load]
{'OP': 'LOAD', 'src': {'type': 'addresses_normal', 'AVXalign': False, 'congruent': 0, 'size': 16, 'same': True, 'NT': False}}
<gen_prepare_buffer>
{'OP': 'LOAD', 'src': {'type': 'addresses_WT_ht', 'AVXalign': False, 'congruent': 7, 'size': 4, 'same': False, 'NT': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_D_ht', 'AVXalign': False, 'congruent': 10, 'size': 32, 'same': False, 'NT': False}}
{'OP': 'REPM', 'src': {'type': 'addresses_UC_ht', 'congruent': 10, 'same': False}, 'dst': {'type': 'addresses_WC_ht', 'congruent': 3, 'same': False}}
{'OP': 'REPM', 'src': {'type': 'addresses_WT_ht', 'congruent': 2, 'same': False}, 'dst': {'type': 'addresses_WT_ht', 'congruent': 11, 'same': True}}
{'OP': 'REPM', 'src': {'type': 'addresses_A_ht', 'congruent': 10, 'same': True}, 'dst': {'type': 'addresses_UC_ht', 'congruent': 0, 'same': False}}
{'OP': 'REPM', 'src': {'type': 'addresses_A_ht', 'congruent': 2, 'same': False}, 'dst': {'type': 'addresses_WC_ht', 'congruent': 2, 'same': True}}
{'34': 21829}
34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34
*/
|
class Solution {
public:
int missingNumber(vector<int>& nums) {
int xorNum = 0, n = nums.size();
for (int i = 0; i < n; i++) {
xorNum ^= nums[i];
xorNum ^= i;
}
xorNum ^= n;
return xorNum;
}
}; |
; The msp M430G2553 contains 16 kb flash and 256 bytes ram
; interrupt vector of 16 pieces
section reset_vector
dw 0 ; 0
dw 0 ; 1
dw 0 ; 2
dw 0 ; 3
dw 0 ; 4
dw 0 ; 5
dw 0 ; 6
dw 0 ; 7
dw 0 ; 8
dw 0 ; 9
dw 0 ; 10
dw 0 ; 11
dw 0 ; 12
dw 0 ; 13
dw 0 ; 14
dw reset_handler ; 15 = reset
; P1IN 0x20
; P1OUT 0x21
; P1DIR 0x22
; P1.0 (red led)
; P1.6 green led
; P1.3 switch
; main code:
section code
reset_handler:
mov.w #0x280, sp ; setup stack pointer
bis.b #0x41, 0x22(r2) ; config P1.0 and P1.6 as output
; Send char a to output:
mov.b #0x41, 0x67(r2)
mov.b #0x42, 0x67(r2)
mov.b #0x43, 0x67(r2)
main:
xor.b #0x41, 0x21(r2)
wait:
mov.b #0x4, 0x67(r2) ; end of transmission
jmp main
main_on:
ret
main_off:
ret
main_delay:
ret
|
COMMENT @%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
Copyright (c) Berkeley Softworks 1990 -- All Rights Reserved
PROJECT: PC GEOS
MODULE: PostScript Print Driver
FILE: psbStyles.asm
AUTHOR: Jim DeFrisco
ROUTINES:
Name Description
---- -----------
REVISION HISTORY:
Name Date Description
---- ---- -----------
Jim 6/11/91 Initial revision
DC_ESCRIPTION:
This file contains all the style setting routines for the PostScript
driver.
$Id: psbStyles.asm,v 1.1 97/04/18 11:52:01 newdeal Exp $
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%@
COMMENT @%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
PrintSendFont
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
SYNOPSIS: Send the right stuff to set the font in the printer
CALLED BY: INTERNAL
PrintSetFont
PASS: es - PState segment
RETURN: nothing
DESTROYED: nothing
PSEUDO CODE/STRATEGY:
KNOWN BUGS/SIDE EFFECTS/IDEAS:
none
REVISION HISTORY:
Name Date Description
---- ---- -----------
Jim 01/90 Initial version
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%@
PrintSendFont proc near
clc
ret
PrintSendFont endp
|
; Provided under the CC0 license. See the included LICENSE.txt for details.
; every bank has this stuff at the same place
; this code can switch to/from any bank at any entry point
; and can preserve register values
; note: lines not starting with a space are not placed in all banks
;
; line below tells the compiler how long this is - do not remove
;size=32
begin_bscode
ldx #$ff
ifconst FASTFETCH ; using DPC+
stx FASTFETCH
endif
txs
if bankswitch == 64
lda #(((>(start-1)) & $0F) | $F0)
else
lda #>(start-1)
endif
pha
lda #<(start-1)
pha
BS_return
pha
txa
pha
tsx
if bankswitch != 64
lda 4,x ; get high byte of return address
rol
rol
rol
rol
and #bs_mask ;1 3 or 7 for F8/F6/F4
tax
inx
else
lda 4,x ; get high byte of return address
tay
ora #$10 ; change our bank nibble into a valid rom mirror
sta 4,x
tya
lsr
lsr
lsr
lsr
tax
inx
endif
BS_jsr
lda bankswitch_hotspot-1,x
pla
tax
pla
rts
if ((* & $1FFF) > ((bankswitch_hotspot & $1FFF) - 1))
echo "WARNING: size parameter in banksw.asm too small - the program probably will not work."
echo "Change to",[(*-begin_bscode+1)&$FF]d,"and try again."
endif
|
;;; $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
;;;
;;; ASM Source code for Red GBC, by Evan Bowman, 2021
;;;
;;;
;;; The following licence covers the source code included in this file. The
;;; game's characters and artwork belong to Evan Bowman, and should not be used
;;; without permission.
;;;
;;;
;;; Redistribution and use in source and binary forms, with or without
;;; modification, are permitted provided that the following conditions are met:
;;;
;;; 1. Redistributions of source code must retain the above copyright notice,
;;; this list of conditions and the following disclaimer.
;;;
;;; 2. Redistributions in binary form must reproduce the above copyright notice,
;;; this list of conditions and the following disclaimer in the documentation
;;; and/or other materials provided with the distribution.
;;;
;;; THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
;;; AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
;;; IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
;;; ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
;;; LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
;;; CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
;;; SUBSTITUTE GOODS OR SERVICES LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
;;; INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
;;; CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
;;; ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
;;; POSSIBILITY OF SUCH DAMAGE.
;;;
;;; $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
;;; $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
;;;
;;;
;;; Room Transition Scene
;;;
;;; TODO: there's a bunch of repeated code here. We could save a decent amount
;;; of ROM by refactoring this stuff. e.g. the down and right vblank handlers
;;; differ only by MapShowRow/MapShowColumn
;;;
;;; $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
RoomTransitionSceneDownVBlank:
ld a, [var_room_load_counter]
;;; Why only 30 rows? Otherwise, we will see the rows change as the screen
;;; scrolls. We will finish up the rest of the rows after the transition.
cp 30
ret Z
ld c, a
push bc
LONG_CALL r1_MapShowRow
pop bc
inc c
ld a, c
ld [var_room_load_counter], a
.done:
ret
;;; ----------------------------------------------------------------------------
RoomTransitionDone:
ld de, OverworldSceneUpdate
fcall SceneSetUpdateFn
fcall .setHooks
LONG_CALL r1_SetRoomVisited
;;; In case we missed any key presses during the transition
ld a, [var_room_load_joypad_cache]
ld [hvar_joypad_raw], a
LONG_CALL r1_LoadRoomEntities
fcall VBlankIntrWait
ret
.setHooks:
ld a, [var_blizzard_active]
or a
jr Z, .normal
.blizzard:
fcall .currentRoomHasBlizzardEffect
jr Z, .blizzardExit
ld de, BlizzardSceneUpdate
fcall SceneSetUpdateFn
ld de, BlizzardSceneVBlank
fcall SceneSetVBlankFn
ret
.blizzardExit:
xor a ; \ Turn off blizzard effect flags.
ld [var_blizzard_active], a ; /
ld a, 60 ; \
ld [var_scene_counter], a ; | Set blizzard effect to fade out.
ld de, BlizzardSceneExitVBlank ; |
fcall SceneSetVBlankFn ; /
ret
.normal:
fcall .currentRoomHasBlizzardEffect
jr NZ, .blizzardEnter
ld de, OverworldSceneOnVBlank
fcall SceneSetVBlankFn
ret
.blizzardEnter:
ld a, 1
ld [var_blizzard_active], a
ld a, 0
ld [var_scene_counter], a
ld de, BlizzardSceneFadeInVBlank
fcall SceneSetVBlankFn
ld de, BlizzardSceneFadeInUpdate
fcall SceneSetUpdateFn
ret
.currentRoomHasBlizzardEffect:
RAM_BANK 1
ld a, [var_room_x]
ld b, a
ld a, [var_room_y]
ld c, a
LONG_CALL r1_LoadRoom
ld a, [hl] ; Fetch first byte of room data
and ROOM_BLIZZARD
ret
;;; ----------------------------------------------------------------------------
;;; This handler takes care of the remaining rows, after the transition is
;;; complete.
RoomTransitionSceneDownFinishUpVBlank:
ld a, [var_room_load_counter]
cp 32
jr Z, .done
ld c, a
push bc
LONG_CALL r1_MapShowRow
pop bc
inc c
ld a, c
ld [var_room_load_counter], a
jr .return
.done:
fcall RoomTransitionDone
.return:
ret
;;; ----------------------------------------------------------------------------
RoomTransitionSceneSetPlayerAnchor:
ld hl, var_player_coord_y ; \
ld de, var_player_anchor_y ; | Set View Anchor
ld bc, FIXNUM_SIZE * 2 ; |
fcall Memcpy ; /
ret
;;; ----------------------------------------------------------------------------
RoomTransitionSceneDownUpdate:
ldh a, [hvar_view_y]
cp 0
jr Z, .done
add 4
cp 5
jr C, .correct
jr .skip
.correct:
ld a, 0
.skip:
ldh [hvar_view_y], a
ld hl, var_player_coord_y
ld b, 0
ld c, 148
fcall FixnumAdd
fcall RoomTransitionSceneSetPlayerAnchor
fcall RoomTransitionSceneSetPlayerAnchor
fcall DrawEntitiesSimple
ld a, [var_room_load_counter]
ld c, a
LONG_CALL r1_MapExpandRow
jr .continue
.done:
;;; The vblank handler is still updating map rows, so we won't set the vblank
;;; handler for remapping sprites yet. But if we don't allow the player to move
;;; while we're copying the rest of the map rows, it's kind of annoying to the
;;; user, because there's a split-second pause otherwise.
ld de, RoomTransitionSceneUDUpdateRest
fcall SceneSetUpdateFn
ld de, RoomTransitionSceneDownFinishUpVBlank
fcall SceneSetVBlankFn
;;; ...
.continue:
ret
;;; ----------------------------------------------------------------------------
RoomTransitionSceneUpUpdate:
ldh a, [hvar_view_y]
cp 121
jr Z, .done
sub 4
cp 121
jr C, .fixView ; fix overcorrection (aka clamp)
jr .setView
.fixView:
ld a, 121
.setView:
ldh [hvar_view_y], a
ld hl, var_player_coord_y
ld b, 0
ld c, 148
fcall FixnumSub
fcall RoomTransitionSceneSetPlayerAnchor
fcall DrawEntitiesSimple
ld a, [var_room_load_counter]
ld c, a
LONG_CALL r1_MapExpandRow
jr .continue
.done:
ld de, RoomTransitionSceneUDUpdateRest
fcall SceneSetUpdateFn
ld de, RoomTransitionSceneUpFinishUpVBlank
fcall SceneSetVBlankFn
.continue:
ret
;;; ----------------------------------------------------------------------------
RoomTransitionSceneUpVBlank:
ld a, [var_room_load_counter]
cp 2
jr Z, .done
ld c, a
push bc
LONG_CALL r1_MapShowRow
pop bc
dec c
ld a, c
ld [var_room_load_counter], a
.done:
ret
;;; ----------------------------------------------------------------------------
RoomTransitionSceneUpFinishUpVBlank:
ld a, [var_room_load_counter]
cp 255 ; Intentional overflow
jr Z, .done
ld c, a
push bc
LONG_CALL r1_MapShowRow
pop bc
dec c
ld a, c
ld [var_room_load_counter], a
jr .return
.done:
fcall RoomTransitionDone
.return:
ret
;;; ----------------------------------------------------------------------------
RoomTransitionSceneRightUpdate:
ldh a, [hvar_view_x]
cp 0
jr Z, .done
add 4
cp 5
jr C, .correct
jr .skip
.correct:
ld a, 0
.skip:
ldh [hvar_view_x], a
ld hl, var_player_coord_x
ld b, 0
ld c, 148
fcall FixnumAdd
fcall RoomTransitionSceneSetPlayerAnchor
fcall DrawEntitiesSimple
ld a, [var_room_load_counter]
ld c, a
LONG_CALL r1_MapExpandColumn
jr .continue
.done:
ld de, RoomTransitionSceneLRUpdateRest
fcall SceneSetUpdateFn
ld de, RoomTransitionSceneRightFinishUpVBlank
fcall SceneSetVBlankFn
.continue:
ret
;;; ----------------------------------------------------------------------------
RoomTransitionSceneRightFinishUpVBlank:
ld a, [var_room_load_counter]
cp 32
jr Z, .done
ld c, a
push bc
LONG_CALL r1_MapShowColumn
pop bc
inc c
ld a, c
ld [var_room_load_counter], a
jr .return
.done:
fcall RoomTransitionDone
.return:
ret
;;; ----------------------------------------------------------------------------
RoomTransitionSceneRightVBlank:
ld a, [var_room_load_counter]
cp 23
jr Z, .done
ld c, a
push bc
LONG_CALL r1_MapShowColumn
pop bc
inc c
ld a, c
ld [var_room_load_counter], a
.done:
ret
;;; ----------------------------------------------------------------------------
RoomTransitionSceneLeftUpdate:
ldh a, [hvar_view_x]
cp 95
jr Z, .done
sub 4
cp 95
jr C, .fixView ; fix overcorrection (aka clamp)
jr .setView
.fixView:
ld a, 95
.setView:
ldh [hvar_view_x], a
ld hl, var_player_coord_x
ld b, 0
ld c, 148
fcall FixnumSub
fcall RoomTransitionSceneSetPlayerAnchor
fcall DrawEntitiesSimple
ld a, [var_room_load_counter]
ld c, a
LONG_CALL r1_MapExpandColumn
jr .continue
.done:
ld de, RoomTransitionSceneLRUpdateRest
fcall SceneSetUpdateFn
ld de, RoomTransitionSceneLeftFinishUpVBlank
fcall SceneSetVBlankFn
.continue:
ret
;;; ----------------------------------------------------------------------------
RoomTransitionSceneUDUpdateRest:
ld a, [var_room_load_counter]
ld c, a
LONG_CALL r1_MapExpandRow
ret
;;; ----------------------------------------------------------------------------
RoomTransitionSceneLRUpdateRest:
ld a, [var_room_load_counter]
ld c, a
LONG_CALL r1_MapExpandColumn
ret
;;; ----------------------------------------------------------------------------
RoomTransitionSceneLeftVBlank:
ld a, [var_room_load_counter]
cp 7
jr Z, .done
ld c, a
push bc
LONG_CALL r1_MapShowColumn
pop bc
dec c
ld a, c
ld [var_room_load_counter], a
.done:
ret
;;; ----------------------------------------------------------------------------
RoomTransitionSceneLeftFinishUpVBlank:
ld a, [var_room_load_counter]
cp 255 ; Intentional overflow
jr Z, .done
ld c, a
push bc
LONG_CALL r1_MapShowColumn
pop bc
dec c
ld a, c
ld [var_room_load_counter], a
jr .return
.done:
fcall RoomTransitionDone
.return:
ret
;;; ----------------------------------------------------------------------------
|
CheckMagikarpLength:
; Returns 3 if you select a Magikarp that beats the previous record.
; Returns 2 if you select a Magikarp, but the current record is longer.
; Returns 1 if you press B in the Pokemon selection menu.
; Returns 0 if the Pokemon you select is not a Magikarp.
; Let's start by selecting a Magikarp.
farcall SelectMonFromParty
jr c, .declined
ld a, [wCurPartySpecies]
call GetPokemonIndexFromID
ld a, l
sub LOW(MAGIKARP)
if HIGH(MAGIKARP) == 0
or h
else
jr nz, .not_magikarp
if HIGH(MAGIKARP) == 1
dec h
else
ld a, h
cp HIGH(MAGIKARP)
endc
endc
jr nz, .not_magikarp
; Now let's compute its length based on its DVs and ID.
ld a, [wCurPartyMon]
ld hl, wPartyMon1Species
ld bc, PARTYMON_STRUCT_LENGTH
call AddNTimes
push hl
ld bc, MON_DVS
add hl, bc
ld d, h
ld e, l
pop hl
ld bc, MON_ID
add hl, bc
ld b, h
ld c, l
call CalcMagikarpLength
call PrintMagikarpLength
farcall StubbedTrainerRankings_MagikarpLength
ld hl, .MeasureItText
call PrintText
; Did we beat the record?
ld hl, wMagikarpLength
ld de, wBestMagikarpLengthFeet
ld c, 2
call CompareBytes
jr nc, .not_long_enough
; NEW RECORD!!! Let's save that.
ld hl, wMagikarpLength
ld de, wBestMagikarpLengthFeet
ld a, [hli]
ld [de], a
inc de
ld a, [hl]
ld [de], a
inc de
ld a, [wCurPartyMon]
ld hl, wPartyMonOT
call SkipNames
call CopyBytes
ld a, MAGIKARPLENGTH_BEAT_RECORD
ld [wScriptVar], a
ret
.not_long_enough
ld a, MAGIKARPLENGTH_TOO_SHORT
ld [wScriptVar], a
ret
.declined
ld a, MAGIKARPLENGTH_REFUSED
ld [wScriptVar], a
ret
.not_magikarp
xor a ; MAGIKARPLENGTH_NOT_MAGIKARP
ld [wScriptVar], a
ret
.MeasureItText:
; Let me measure that MAGIKARP. …Hm, it measures @ .
text_far UnknownText_0x1c1203
text_end
PrintMagikarpLength:
ld hl, wStringBuffer1
ld de, wMagikarpLength
lb bc, PRINTNUM_RIGHTALIGN | 1, 2
call PrintNum
ld [hl], "′"
inc hl
ld de, wMagikarpLength + 1
lb bc, PRINTNUM_RIGHTALIGN | 1, 2
call PrintNum
ld [hl], "″"
inc hl
ld [hl], "@"
ret
CalcMagikarpLength:
; Return Magikarp's length (in feet and inches) at wMagikarpLength (big endian).
;
; input:
; de: wEnemyMonDVs
; bc: wPlayerID
; This function is poorly commented.
; In short, it generates a value between 190 and 1786 using
; a Magikarp's DVs and its trainer ID. This value is further
; filtered in LoadEnemyMon to make longer Magikarp even rarer.
; The value is generated from a lookup table.
; The index is determined by the dv xored with the player's trainer id.
; bc = rrc(dv[0]) ++ rrc(dv[1]) ^ rrc(id)
; if bc < 10: [wMagikarpLength] = c + 190
; if bc ≥ $ff00: [wMagikarpLength] = c + 1370
; else: [wMagikarpLength] = z * 100 + (bc - x) / y
; X, Y, and Z depend on the value of b as follows:
; if b = 0: x = 310, y = 2, z = 3
; if b = 1: x = 710, y = 4, z = 4
; if b = 2-9: x = 2710, y = 20, z = 5
; if b = 10-29: x = 7710, y = 50, z = 6
; if b = 30-68: x = 17710, y = 100, z = 7
; if b = 69-126: x = 32710, y = 150, z = 8
; if b = 127-185: x = 47710, y = 150, z = 9
; if b = 186-224: x = 57710, y = 100, z = 10
; if b = 225-243: x = 62710, y = 50, z = 11
; if b = 244-251: x = 64710, y = 20, z = 12
; if b = 252-253: x = 65210, y = 5, z = 13
; if b = 254: x = 65410, y = 2, z = 14
; bc = rrc(dv[0]) ++ rrc(dv[1]) ^ rrc(id)
; id
ld h, b
ld l, c
ld a, [hli]
ld b, a
ld c, [hl]
rrc b
rrc c
; dv
ld a, [de]
inc de
rrca
rrca
xor b
ld b, a
ld a, [de]
rrca
rrca
xor c
ld c, a
; if bc < 10:
; de = bc + 190
; break
ld a, b
and a
jr nz, .no
ld a, c
cp 10
jr nc, .no
ld hl, 190
add hl, bc
ld d, h
ld e, l
jr .done
.no
ld hl, MagikarpLengths
ld a, 2
ld [wTempByteValue], a
.read
ld a, [hli]
ld e, a
ld a, [hli]
ld d, a
call .BCLessThanDE
jr nc, .next
; c = (bc - de) / [hl]
call .BCMinusDE
ld a, b
ldh [hDividend + 0], a
ld a, c
ldh [hDividend + 1], a
ld a, [hl]
ldh [hDivisor], a
ld b, 2
call Divide
ldh a, [hQuotient + 3]
ld c, a
; de = c + 100 × (2 + i)
xor a
ldh [hMultiplicand + 0], a
ldh [hMultiplicand + 1], a
ld a, 100
ldh [hMultiplicand + 2], a
ld a, [wTempByteValue]
ldh [hMultiplier], a
call Multiply
ld b, 0
ldh a, [hProduct + 3]
add c
ld e, a
ldh a, [hProduct + 2]
adc b
ld d, a
jr .done
.next
inc hl ; align to next triplet
ld a, [wTempByteValue]
inc a
ld [wTempByteValue], a
cp 16
jr c, .read
call .BCMinusDE
ld hl, 1600
add hl, bc
ld d, h
ld e, l
.done
; convert from mm to feet and inches
; in = mm / 25.4
; ft = in / 12
; hl = de × 10
ld h, d
ld l, e
add hl, hl
add hl, hl
add hl, de
add hl, hl
; hl = hl / 254
ld de, -254
ld a, -1
.div_254
inc a
add hl, de
jr c, .div_254
; d, e = hl / 12, hl % 12
ld d, 0
.mod_12
cp 12
jr c, .ok
sub 12
inc d
jr .mod_12
.ok
ld e, a
ld hl, wMagikarpLength
ld [hl], d ; ft
inc hl
ld [hl], e ; in
ret
.BCLessThanDE:
; Intention: Return bc < de.
; Reality: Return b < d.
ld a, b
cp d
ret c
ret nc ; whoops
ld a, c
cp e
ret
.BCMinusDE:
; bc -= de
ld a, c
sub e
ld c, a
ld a, b
sbc d
ld b, a
ret
INCLUDE "data/events/magikarp_lengths.asm"
MagikarpHouseSign:
ld a, [wBestMagikarpLengthFeet]
ld [wMagikarpLength], a
ld a, [wBestMagikarpLengthInches]
ld [wMagikarpLength + 1], a
call PrintMagikarpLength
ld hl, .CurrentRecordtext
call PrintText
ret
.CurrentRecordtext:
; "CURRENT RECORD"
text_far UnknownText_0x1c123a
text_end
|
; A026219: Position of n in A026218.
; Submitted by Jamie Morken(s1)
; 1,2,5,3,9,4,13,6,17,7,21,8,25,10,29,11,33,12,37,14,41,15,45,16,49,18,53,19,57,20,61,22,65,23,69,24,73,26,77,27,81,28,85,30,89,31,93,32,97,34,101,35,105,36,109,38,113,39,117,40,121
mul $0,2
add $0,1
mov $1,$0
mod $0,4
div $1,$0
mul $1,2
add $0,$1
div $0,2
|
db "BOUNCE@" ; species name
db "It bounces around"
next "on its tail to"
next "keep its heart"
page "pumping. It"
next "carries a CLAMPERL"
next "pearl on its head.@"
|
//
// main.cpp
// 120_minimumTotal
//
// Created by Bella Yang on 2019/10/13.
// Copyright © 2019 Bella Yang. All rights reserved.
//
#include <iostream>
#include <vector>
using namespace std;
class Solution {
public:
int minimumTotal(vector<vector<int>>& triangle) {
vector<int> lastMiniLen;
lastMiniLen.push_back(triangle[0][0]);
vector<int> miniLen;
for (int i = 1; i < triangle.size(); ++i) {
miniLen.clear();
miniLen.push_back(triangle[i][0] + lastMiniLen[0]);
for (int j = 1; j < i; ++j) {
miniLen.push_back(triangle[i][j] + min(lastMiniLen[j - 1], lastMiniLen[j]));
}
miniLen.push_back(triangle[i][i] + lastMiniLen[i - 1]);
lastMiniLen.clear();
lastMiniLen = miniLen;
}
return *min_element(lastMiniLen.begin(), lastMiniLen.end());
}
};
int main(int argc, const char * argv[]) {
vector<vector<int>> triangle;
int array1[1] = {2};
triangle.push_back(vector<int>(array1, array1 + 1));
int array2[2] = {3,4};
triangle.push_back(vector<int>(array2, array2 + 2));
int array3[3] = {6, 5, 7};
triangle.push_back(vector<int>(array3, array3 + 3));
int array4[4] = {4, 1, 8, 3};
triangle.push_back(vector<int>(array4, array4 + 4));
Solution s;
cout << s.minimumTotal(triangle) << endl;
return 0;
}
|
; Test for bug previously found with scan-build. Important: no CR/LF at EOF
jmp |
; A192965: Coefficient of x in the reduction by x^2 -> x+1 of the polynomial p(n,x) defined at Comments.
; 0,1,1,4,11,27,58,115,215,386,673,1149,1932,3213,5301,8696,14207,23143,37622,61071,99035,160486,259941,420889,681336,1102777,1784713,2888140,4673555,7562451,12236818,19800139,32037887,51839018,83877961,135718101,219597252,355316613,574915197,930233216,1505149895,2435384671,3940536206,6375922599,10316460611,16692385102,27008847693,43701234865,70710084720,114411321841,185121408913,299532733204,484654144667,784186880523,1268841027946,2053027911331,3321868942247,5374896856658,8696765802097,14071662662061,22768428467580,36840091133181,59608519604421,96448610741384,156057130349711,252505741095127,408562871448998,661068612548415,1069631484001835,1730700096554806,2800331580561333,4531031677120969,7331363257687272
mov $2,$0
mov $9,$0
lpb $2
mov $0,$9
sub $2,1
sub $0,$2
mov $5,$0
mov $7,2
lpb $7
mov $0,$5
sub $7,1
add $0,$7
sub $0,1
mov $3,$0
add $3,2
mul $3,$0
cal $0,192754 ; Constant term of the reduction by x^2->x+1 of the polynomial p(n,x) defined below in Comments.
sub $0,$3
mul $0,2
mov $4,$0
mov $8,$7
lpb $8
mov $6,$4
sub $8,1
lpe
lpe
lpb $5
mov $5,0
sub $6,$4
lpe
mov $4,$6
sub $4,2
div $4,2
add $1,$4
lpe
|
; A272130: a(n) = 16*n^3 + 10*n^2 + 4*n + 1.
; Submitted by Jamie Morken(s1)
; 1,31,177,535,1201,2271,3841,6007,8865,12511,17041,22551,29137,36895,45921,56311,68161,81567,96625,113431,132081,152671,175297,200055,227041,256351,288081,322327,359185,398751,441121,486391,534657,586015,640561,698391,759601,824287,892545,964471,1040161,1119711,1203217,1290775,1382481,1478431,1578721,1683447,1792705,1906591,2025201,2148631,2276977,2410335,2548801,2692471,2841441,2995807,3155665,3321111,3492241,3669151,3851937,4040695,4235521,4436511,4643761,4857367,5077425,5304031,5537281
mul $0,4
mov $1,$0
add $1,1
add $0,$1
mul $0,$1
add $0,4
mul $1,$0
mov $0,$1
div $0,8
add $0,1
|
;
; Copyright (C) 2021 by Intel Corporation
;
; Permission to use, copy, modify, and/or distribute this software for any
; purpose with or without fee is hereby granted.
;
; THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
; REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
; AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
; INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
; LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
; OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
; PERFORMANCE OF THIS SOFTWARE.
;
; .globl software_scatter
; void software_scatter(const uint64_t *input, const uint32_t *indices, uint64_t count, float *output);
;
; On entry:
; rcx = input
; rdx = indices
; r8 = count
; r9 = output
_RDATA SEGMENT READ ALIGN(32) 'DATA'
shufMaskP DQ 0000000200000001h
DQ 0000000400000003h
DQ 0000000600000005h
DQ 0000000800000007h
_RDATA ENDS
.code
software_scatter PROC public
push rbx
mov rax, rcx ; mov rax, pImage // input
; mov r9, pOutImage //output
mov rbx, rdx ; mov rbx, pIndex //indexes
; mov r8, len //length
lea r10, ymmword ptr shufMaskP ; mov r10, shufMaskP
vmovaps ymm2, [r10]
mainloop:
vmovaps zmm1, [rax + r8*2 - 80h] ; load data
vcvtuqq2ps ymm0, zmm1 ; convert to float
movsxd r10, DWORD PTR [rbx + r8 - 40h] ; load 8th index
vmovss DWORD PTR [r9 + 4*r10], xmm0
vpermd ymm0, ymm2, ymm0
movsxd r10, DWORD PTR [rbx + r8 - 3ch] ; load 7th index
vmovss DWORD PTR [r9 + 4*r10], xmm0
vpermd ymm0, ymm2, ymm0
movsxd r10, DWORD PTR [rbx + r8 - 38h] ; load 6th index
vmovss DWORD PTR [r9 + 4*r10], xmm0
vpermd ymm0, ymm2, ymm0
movsxd r10, DWORD PTR [rbx + r8 - 34h] ; load 5th index
vmovss DWORD PTR [r9 + 4*r10], xmm0
vpermd ymm0, ymm2, ymm0
movsxd r10, DWORD PTR [rbx + r8 - 30h] ; load 4th index
vmovss DWORD PTR [r9 + 4*r10], xmm0
vpermd ymm0, ymm2, ymm0
movsxd r10, DWORD PTR [rbx + r8 - 2ch] ; load 3rd index
vmovss DWORD PTR [r9 + 4*r10], xmm0
vpermd ymm0, ymm2, ymm0
movsxd r10, DWORD PTR [rbx + r8 - 28h] ; load 2nd index
vmovss DWORD PTR [r9 + 4*r10], xmm0
vpermd ymm0, ymm2, ymm0
movsxd r10, DWORD PTR [rbx + r8 - 24h] ; load 1st index
vmovss DWORD PTR [r9 + 4*r10], xmm0
vmovaps zmm1, [rax + r8*2 - 40h] ; load data
vcvtuqq2ps ymm0, zmm1 ; convert to float
movsxd r10, DWORD PTR [rbx + r8 - 20h] ; load 8th index
vmovss DWORD PTR [r9 + 4*r10], xmm0
vpermd ymm0, ymm2, ymm0
movsxd r10, DWORD PTR [rbx + r8 - 1ch] ; load 7th index
vmovss DWORD PTR [r9 + 4*r10], xmm0
vpermd ymm0, ymm2, ymm0
movsxd r10, DWORD PTR [rbx + r8 - 18h] ; load 6th index
vmovss DWORD PTR [r9 + 4*r10], xmm0
vpermd ymm0, ymm2, ymm0
movsxd r10, DWORD PTR [rbx + r8 - 14h] ; load 5th index
vmovss DWORD PTR [r9 + 4*r10], xmm0
vpermd ymm0, ymm2, ymm0
movsxd r10, DWORD PTR [rbx + r8 - 10h] ; load 4th index
vmovss DWORD PTR [r9 + 4*r10], xmm0
vpermd ymm0, ymm2, ymm0
movsxd r10, DWORD PTR [rbx + r8 - 0ch] ; load 3rd index
vmovss DWORD PTR [r9 + 4*r10], xmm0
vpermd ymm0, ymm2, ymm0
movsxd r10, DWORD PTR [rbx + r8 - 08h] ; load 2nd index
vmovss DWORD PTR [r9 + 4*r10], xmm0
vpermd ymm0, ymm2, ymm0
movsxd r10, DWORD PTR [rbx + r8 - 04h] ; load 1st index
vmovss DWORD PTR [r9 + 4*r10], xmm0
sub r8, 40h
jnz mainloop
vzeroupper
pop rbx
ret
software_scatter ENDP
end
|
// Copyright 2019-2021 Lawrence Livermore National Security, LLC and other YGM
// Project Developers. See the top-level COPYRIGHT file for details.
//
// SPDX-License-Identifier: MIT
#pragma once
#include <atomic>
#include <deque>
#include <memory>
#include <mutex>
#include <thread>
#include <vector>
#include <ygm/detail/mpi.hpp>
#include <ygm/detail/ygm_cereal_archive.hpp>
#include <ygm/meta/functional.hpp>
namespace ygm {
class comm::impl {
public:
impl(MPI_Comm c, int buffer_capacity) {
ASSERT_MPI(MPI_Comm_dup(c, &m_comm_async));
ASSERT_MPI(MPI_Comm_dup(c, &m_comm_barrier));
ASSERT_MPI(MPI_Comm_dup(c, &m_comm_other));
ASSERT_MPI(MPI_Comm_size(m_comm_async, &m_comm_size));
ASSERT_MPI(MPI_Comm_rank(m_comm_async, &m_comm_rank));
m_buffer_capacity = buffer_capacity;
// Allocate send buffers
for (int i = 0; i < m_comm_size; ++i) {
m_vec_send_buffers.push_back(allocate_buffer());
}
// launch listener thread
m_listener = std::thread(&impl::listen, this);
}
~impl() {
barrier();
// send kill signal to self (listener thread)
MPI_Send(NULL, 0, MPI_BYTE, m_comm_rank, 0, m_comm_async);
// Join listener thread.
m_listener.join();
// Free cloned communicator.
ASSERT_RELEASE(MPI_Barrier(m_comm_async) == MPI_SUCCESS);
MPI_Comm_free(&m_comm_async);
MPI_Comm_free(&m_comm_barrier);
MPI_Comm_free(&m_comm_other);
}
int size() const { return m_comm_size; }
int rank() const { return m_comm_rank; }
template <typename... SendArgs>
void async(int dest, const SendArgs &... args) {
ASSERT_DEBUG(dest < m_comm_size);
if (dest == m_comm_rank) {
local_receive(std::forward<const SendArgs>(args)...);
} else {
m_send_count++;
std::vector<char> data =
pack_lambda(std::forward<const SendArgs>(args)...);
m_local_bytes_sent += data.size();
if (data.size() < m_buffer_capacity) {
// check if buffer doesn't have enough space
if (data.size() + m_vec_send_buffers[dest]->size() >
m_buffer_capacity) {
async_flush(dest);
}
// add data to the to dest buffer
m_vec_send_buffers[dest]->insert(m_vec_send_buffers[dest]->end(),
data.begin(), data.end());
} else { // Large message
send_large_message(data, dest);
}
}
// check if listener has queued receives to process
if (receive_queue_peek_size() > 0) {
receive_queue_process();
}
}
template <typename... SendArgs>
void async_preempt(int dest, const SendArgs &... args) {
async(dest, std::forward<const SendArgs>(args)...);
}
template <typename... SendArgs>
void async_bcast(const SendArgs &... args) {
for (int dest = 0; dest < m_comm_size; ++dest) {
async(dest, std::forward<const SendArgs>(args)...);
}
}
template <typename... SendArgs>
void async_bcast_preempt(const SendArgs &... args) {
bcast(std::forward<const SendArgs>(args)...);
}
template <typename... SendArgs>
void async_mcast(const std::vector<int> &dests, const SendArgs &... args) {
for (auto dest : dests) {
async(dest, std::forward<const SendArgs>(args)...);
}
}
template <typename... SendArgs>
void async_mcast_preempt(const std::vector<int> &dests,
const SendArgs &... args) {
mcast(dests, std::forward<const SendArgs>(args)...);
}
// //
// // Blocking barrier
// void barrier() {
// int64_t all_count = -1;
// while (all_count != 0) {
// receive_queue_process();
// do {
// async_flush_all();
// std::this_thread::yield();
// } while (receive_queue_process());
// int64_t local_count = m_send_count - m_recv_count;
// ASSERT_MPI(MPI_Allreduce(&local_count, &all_count, 1, MPI_INT64_T,
// MPI_SUM, m_comm_barrier));
// std::this_thread::yield();
// // std::cout << "MPI_Allreduce() " << std::endl;
// }
// }
void wait_local_idle() {
receive_queue_process();
do {
async_flush_all();
std::this_thread::yield();
} while (receive_queue_process());
}
void barrier() {
while (true) {
wait_local_idle();
MPI_Request req = MPI_REQUEST_NULL;
int64_t first_all_count{-1};
int64_t first_local_count = m_send_count - m_recv_count;
ASSERT_MPI(MPI_Iallreduce(&first_local_count, &first_all_count, 1,
MPI_INT64_T, MPI_SUM, m_comm_barrier, &req));
while (true) {
int test_flag{-1};
ASSERT_MPI(MPI_Test(&req, &test_flag, MPI_STATUS_IGNORE));
if (test_flag) {
if (first_all_count == 0) {
// double check
int64_t second_all_count{-1};
int64_t second_local_count = m_send_count - m_recv_count;
ASSERT_MPI(MPI_Allreduce(&second_local_count, &second_all_count, 1,
MPI_INT64_T, MPI_SUM, m_comm_barrier));
if (second_all_count == 0) {
ASSERT_RELEASE(first_local_count == second_local_count);
return;
}
}
break; // failed, start over
} else {
wait_local_idle();
}
}
}
}
// // SOMETHING WRONG :(
// // Non-blocking barrier loop
// void barrier() {
// std::pair<int64_t, int64_t> last{-1, -2}, current{-3, -4}, local{-5,
// -6}; MPI_Request req = MPI_REQUEST_NULL;
// do {
// receive_queue_process();
// do { async_flush_all(); } while (receive_queue_process());
// int64_t local_count = m_send_count - m_recv_count;
// if (req == MPI_REQUEST_NULL) {
// last = current;
// current = {-3, -4};
// local = std::make_pair(m_send_count, m_recv_count);
// ASSERT_MPI(MPI_Iallreduce(&local, ¤t, 2, MPI_INT64_T,
// MPI_SUM,
// m_comm_barrier, &req));
// } else {
// int flag{-1};
// ASSERT_MPI(MPI_Test(&req, &flag, MPI_STATUS_IGNORE));
// if (flag) {
// req = MPI_REQUEST_NULL;
// } else {
// std::this_thread::yield();
// }
// }
// } while (req != MPI_REQUEST_NULL || current.first != current.second ||
// last != current);
// ASSERT_MPI(MPI_Barrier(m_comm_barrier));
// }
void async_flush(int dest) {
if (dest != m_comm_rank) {
// Skip dest == m_comm_rank; Only kill messages go to self.
if (m_vec_send_buffers[dest]->size() == 0) return;
auto buffer = allocate_buffer();
std::swap(buffer, m_vec_send_buffers[dest]);
ASSERT_MPI(MPI_Send(buffer->data(), buffer->size(), MPI_BYTE, dest, 0,
m_comm_async));
free_buffer(buffer);
}
}
void async_flush_all() {
for (int i = 0; i < size(); ++i) {
int dest = (rank() + i) % size();
async_flush(dest);
}
// TODO async_flush_bcast(); goes here
}
int64_t local_bytes_sent() const { return m_local_bytes_sent; }
void reset_bytes_sent_counter() { m_local_bytes_sent = 0; }
int64_t local_rpc_calls() const { return m_local_rpc_calls; }
void reset_rpc_call_counter() { m_local_rpc_calls = 0; }
template <typename T>
T all_reduce_sum(const T &t) const {
T to_return;
ASSERT_MPI(MPI_Allreduce(&t, &to_return, 1, detail::mpi_typeof(T()),
MPI_SUM, m_comm_other));
return to_return;
}
template <typename T>
T all_reduce_min(const T &t) const {
T to_return;
ASSERT_MPI(MPI_Allreduce(&t, &to_return, 1, detail::mpi_typeof(T()),
MPI_MIN, m_comm_other));
return to_return;
}
template <typename T>
T all_reduce_max(const T &t) const {
T to_return;
ASSERT_MPI(MPI_Allreduce(&t, &to_return, 1, detail::mpi_typeof(T()),
MPI_MAX, m_comm_other));
return to_return;
}
template <typename T>
void mpi_send(const T &data, int dest, int tag, MPI_Comm comm) const {
std::vector<char> packed;
cereal::YGMOutputArchive oarchive(packed);
oarchive(data);
size_t packed_size = packed.size();
ASSERT_RELEASE(packed_size < 1024 * 1024 * 1024);
ASSERT_MPI(MPI_Send(&packed_size, 1, detail::mpi_typeof(packed_size), dest,
tag, comm));
ASSERT_MPI(MPI_Send(packed.data(), packed_size, MPI_BYTE, dest, tag, comm));
}
template <typename T>
T mpi_recv(int source, int tag, MPI_Comm comm) const {
std::vector<char> packed;
size_t packed_size{0};
ASSERT_MPI(MPI_Recv(&packed_size, 1, detail::mpi_typeof(packed_size),
source, tag, comm, MPI_STATUS_IGNORE));
packed.resize(packed_size);
ASSERT_MPI(MPI_Recv(packed.data(), packed_size, MPI_BYTE, source, tag, comm,
MPI_STATUS_IGNORE));
T to_return;
cereal::YGMInputArchive iarchive(packed.data(), packed.size());
iarchive(to_return);
return to_return;
}
template <typename T>
T mpi_bcast(const T &to_bcast, int root, MPI_Comm comm) const {
std::vector<char> packed;
cereal::YGMOutputArchive oarchive(packed);
if (rank() == root) {
oarchive(to_bcast);
}
size_t packed_size = packed.size();
ASSERT_RELEASE(packed_size < 1024 * 1024 * 1024);
ASSERT_MPI(MPI_Bcast(&packed_size, 1, detail::mpi_typeof(packed_size), root,
comm));
if (rank() != root) {
packed.resize(packed_size);
}
ASSERT_MPI(MPI_Bcast(packed.data(), packed_size, MPI_BYTE, root, comm));
cereal::YGMInputArchive iarchive(packed.data(), packed.size());
T to_return;
iarchive(to_return);
return to_return;
}
/**
* @brief Tree based reduction, could be optimized significantly
*
* @tparam T
* @tparam MergeFunction
* @param in
* @param merge
* @return T
*/
template <typename T, typename MergeFunction>
T all_reduce(const T &in, MergeFunction merge) const {
int first_child = 2 * rank() + 1;
int second_child = 2 * (rank() + 1);
int parent = (rank() - 1) / 2;
// Step 1: Receive from children, merge into tmp
T tmp = in;
if (first_child < size()) {
T fc = mpi_recv<T>(first_child, 0, m_comm_other);
tmp = merge(tmp, fc);
}
if (second_child < size()) {
T sc = mpi_recv<T>(second_child, 0, m_comm_other);
tmp = merge(tmp, sc);
}
// Step 2: Send merged to parent
if (rank() != 0) {
mpi_send(tmp, parent, 0, m_comm_other);
}
// Step 3: Rank 0 bcasts
T to_return = mpi_bcast(tmp, 0, m_comm_other);
return to_return;
}
private:
/**
* @brief Listener thread
*
*/
void listen() {
while (true) {
auto recv_buffer = allocate_buffer();
recv_buffer->resize(m_buffer_capacity); // TODO: does this clear?
MPI_Status status;
ASSERT_MPI(MPI_Recv(recv_buffer->data(), m_buffer_capacity, MPI_BYTE,
MPI_ANY_SOURCE, MPI_ANY_TAG, m_comm_async, &status));
int tag = status.MPI_TAG;
if (tag == large_message_announce_tag) {
// Determine size and source of message
size_t size = *(reinterpret_cast<size_t *>(recv_buffer->data()));
int src = status.MPI_SOURCE;
// Allocate large buffer
auto large_recv_buff = std::make_shared<std::vector<char>>(size);
// Receive large message
receive_large_message(large_recv_buff, src, size);
// Add buffer to receive queue
receive_queue_push_back(large_recv_buff, src);
} else {
int count;
ASSERT_MPI(MPI_Get_count(&status, MPI_BYTE, &count))
// std::cout << "RANK: " << rank() << " received count: " << count
// << std::endl;
// Resize buffer to cout MPI actually received
recv_buffer->resize(count);
// Check for kill signal
if (status.MPI_SOURCE == m_comm_rank) break;
// Add buffer to receive queue
receive_queue_push_back(recv_buffer, status.MPI_SOURCE);
}
}
}
/*
* @brief Send a large message
*
* @param dest Destination for message
* @param msg Packed message to send
*/
void send_large_message(const std::vector<char> &msg, const int dest) {
// Announce the large message and its size
size_t size = msg.size();
ASSERT_MPI(MPI_Send(&size, 8, MPI_BYTE, dest, large_message_announce_tag,
m_comm_async));
// Send message
ASSERT_MPI(MPI_Send(msg.data(), size, MPI_BYTE, dest, large_message_tag,
m_comm_async));
}
/*
* @brief Receive a large message that has been announced
*
* @param src Source of message
* @param msg Buffer to hold message
*/
void receive_large_message(std::shared_ptr<std::vector<char>> msg,
const int src, const size_t size) {
ASSERT_MPI(MPI_Recv(msg->data(), size, MPI_BYTE, src, large_message_tag,
m_comm_async, MPI_STATUS_IGNORE));
}
/**
* @brief Allocates buffer; checks free pool first.
*
* @return std::shared_ptr<std::vector<char>>
*/
std::shared_ptr<std::vector<char>> allocate_buffer() {
std::scoped_lock lock(m_vec_free_buffers_mutex);
if (m_vec_free_buffers.empty()) {
auto to_return = std::make_shared<std::vector<char>>();
to_return->reserve(m_buffer_capacity);
return to_return;
} else {
auto to_return = m_vec_free_buffers.back();
m_vec_free_buffers.pop_back();
return to_return;
}
}
/**
* @brief Frees a previously allocated buffer. Adds buffer to free pool.
*
* @param b buffer to free
*/
void free_buffer(std::shared_ptr<std::vector<char>> b) {
b->clear();
std::scoped_lock lock(m_vec_free_buffers_mutex);
m_vec_free_buffers.push_back(b);
}
size_t receive_queue_peek_size() const { return m_receive_queue.size(); }
std::pair<std::shared_ptr<std::vector<char>>, int> receive_queue_try_pop() {
std::scoped_lock lock(m_receive_queue_mutex);
if (m_receive_queue.empty()) {
return std::make_pair(std::shared_ptr<std::vector<char>>(), int(-1));
} else {
auto to_return = m_receive_queue.front();
m_receive_queue.pop_front();
return to_return;
}
}
void receive_queue_push_back(std::shared_ptr<std::vector<char>> b, int from) {
size_t current_size = 0;
{
std::scoped_lock lock(m_receive_queue_mutex);
m_receive_queue.push_back(std::make_pair(b, from));
current_size = m_receive_queue.size();
}
if (current_size > 16) {
std::this_thread::sleep_for(std::chrono::microseconds(current_size - 16));
}
}
// Used if dest = m_comm_rank
template <typename Lambda, typename... Args>
int32_t local_receive(Lambda l, const Args &... args) {
ASSERT_DEBUG(sizeof(Lambda) == 1);
// Question: should this be std::forward(...)
// \pp was: (l)(this, m_comm_rank, args...);
ygm::meta::apply_optional(l, std::make_tuple(this, m_comm_rank),
std::make_tuple(args...));
return 1;
}
template <typename Lambda, typename... PackArgs>
std::vector<char> pack_lambda(Lambda l, const PackArgs &... args) {
std::vector<char> to_return;
const std::tuple<PackArgs...> tuple_args(
std::forward<const PackArgs>(args)...);
ASSERT_DEBUG(sizeof(Lambda) == 1);
void (*fun_ptr)(impl *, int, cereal::YGMInputArchive &) =
[](impl *t, int from, cereal::YGMInputArchive &bia) {
std::tuple<PackArgs...> ta;
bia(ta);
Lambda *pl;
auto t1 = std::make_tuple((impl *)t, from);
// \pp was: std::apply(*pl, std::tuple_cat(t1, ta));
ygm::meta::apply_optional(*pl, std::move(t1), std::move(ta));
};
cereal::YGMOutputArchive oarchive(to_return); // Create an output archive
// // oarchive(fun_ptr);
int64_t iptr = (int64_t)fun_ptr - (int64_t)&reference;
oarchive(iptr, tuple_args);
return to_return;
}
// this is used to fix address space randomization
static void reference() {}
bool receive_queue_process() {
bool received = false;
while (true) {
auto buffer_source = receive_queue_try_pop();
auto buffer = buffer_source.first;
if (buffer == nullptr) break;
int from = buffer_source.second;
received = true;
cereal::YGMInputArchive iarchive(buffer->data(), buffer->size());
while (!iarchive.empty()) {
int64_t iptr;
iarchive(iptr);
iptr += (int64_t)&reference;
void (*fun_ptr)(impl *, int, cereal::YGMInputArchive &);
memcpy(&fun_ptr, &iptr, sizeof(uint64_t));
fun_ptr(this, from, iarchive);
m_recv_count++;
m_local_rpc_calls++;
}
// Only keep buffers of size m_buffer_capacity in pool of buffers
if (buffer->capacity() == m_buffer_capacity) free_buffer(buffer);
}
return received;
}
MPI_Comm m_comm_async;
MPI_Comm m_comm_barrier;
MPI_Comm m_comm_other;
int m_comm_size;
int m_comm_rank;
size_t m_buffer_capacity;
std::vector<std::shared_ptr<std::vector<char>>> m_vec_send_buffers;
std::mutex m_vec_free_buffers_mutex;
std::vector<std::shared_ptr<std::vector<char>>> m_vec_free_buffers;
std::deque<std::pair<std::shared_ptr<std::vector<char>>, int>>
m_receive_queue;
std::mutex m_receive_queue_mutex;
std::thread m_listener;
int64_t m_recv_count = 0;
int64_t m_send_count = 0;
int64_t m_local_rpc_calls = 0;
int64_t m_local_bytes_sent = 0;
int large_message_announce_tag = 32766;
int large_message_tag = 32767;
};
inline comm::comm(int *argc, char ***argv, int buffer_capacity = 16 * 1024) {
pimpl_if = std::make_shared<detail::mpi_init_finalize>(argc, argv);
pimpl = std::make_shared<comm::impl>(MPI_COMM_WORLD, buffer_capacity);
}
inline comm::comm(MPI_Comm mcomm, int buffer_capacity = 16 * 1024) {
pimpl_if.reset();
int flag(0);
ASSERT_MPI(MPI_Initialized(&flag));
if (!flag) {
throw std::runtime_error("ERROR: MPI not initialized");
}
int provided(0);
ASSERT_MPI(MPI_Query_thread(&provided));
if (provided != MPI_THREAD_MULTIPLE) {
throw std::runtime_error("ERROR: MPI_THREAD_MULTIPLE not provided");
}
pimpl = std::make_shared<comm::impl>(mcomm, buffer_capacity);
}
inline comm::~comm() {
ASSERT_RELEASE(MPI_Barrier(MPI_COMM_WORLD) == MPI_SUCCESS);
pimpl.reset();
ASSERT_RELEASE(MPI_Barrier(MPI_COMM_WORLD) == MPI_SUCCESS);
pimpl_if.reset();
}
template <typename AsyncFunction, typename... SendArgs>
inline void comm::async(int dest, AsyncFunction fn, const SendArgs &... args) {
static_assert(std::is_empty<AsyncFunction>::value,
"Only stateless lambdas are supported");
pimpl->async(dest, fn, std::forward<const SendArgs>(args)...);
}
template <typename AsyncFunction, typename... SendArgs>
inline void comm::async_preempt(int dest, AsyncFunction fn,
const SendArgs &... args) {
static_assert(std::is_empty<AsyncFunction>::value,
"Only stateless lambdas are supported");
pimpl->async_preempt(dest, fn, std::forward<const SendArgs>(args)...);
}
template <typename AsyncFunction, typename... SendArgs>
inline void comm::async_bcast(AsyncFunction fn, const SendArgs &... args) {
static_assert(std::is_empty<AsyncFunction>::value,
"Only stateless lambdas are supported");
pimpl->async_bcast(fn, std::forward<const SendArgs>(args)...);
}
template <typename AsyncFunction, typename... SendArgs>
inline void comm::async_bcast_preempt(AsyncFunction fn,
const SendArgs &... args) {
static_assert(std::is_empty<AsyncFunction>::value,
"Only stateless lambdas are supported");
pimpl->async_bcast_preempt(fn, std::forward<const SendArgs>(args)...);
}
template <typename AsyncFunction, typename... SendArgs>
inline void comm::async_mcast(const std::vector<int> &dests, AsyncFunction fn,
const SendArgs &... args) {
static_assert(std::is_empty<AsyncFunction>::value,
"Only stateless lambdas are supported");
pimpl->async_mcast(dests, fn, std::forward<const SendArgs>(args)...);
}
template <typename AsyncFunction, typename... SendArgs>
inline void comm::async_mcast_preempt(const std::vector<int> &dests,
AsyncFunction fn,
const SendArgs &... args) {
static_assert(std::is_empty<AsyncFunction>::value,
"Only stateless lambdas are supported");
pimpl->async_mcast_preempt(dests, fn, std::forward<const SendArgs>(args)...);
}
inline int comm::size() const { return pimpl->size(); }
inline int comm::rank() const { return pimpl->rank(); }
inline int64_t comm::local_bytes_sent() const {
return pimpl->local_bytes_sent();
}
inline int64_t comm::global_bytes_sent() const {
return all_reduce_sum(local_bytes_sent());
}
inline void comm::reset_bytes_sent_counter() {
pimpl->reset_bytes_sent_counter();
}
inline int64_t comm::local_rpc_calls() const {
return pimpl->local_rpc_calls();
}
inline int64_t comm::global_rpc_calls() const {
return all_reduce_sum(local_rpc_calls());
}
inline void comm::reset_rpc_call_counter() { pimpl->reset_rpc_call_counter(); }
inline void comm::barrier() { pimpl->barrier(); }
inline void comm::async_flush(int rank) { pimpl->async_flush(rank); }
inline void comm::async_flush_all() { pimpl->async_flush_all(); }
template <typename T>
inline T comm::all_reduce_sum(const T &t) const {
return pimpl->all_reduce_sum(t);
}
template <typename T>
inline T comm::all_reduce_min(const T &t) const {
return pimpl->all_reduce_min(t);
}
template <typename T>
inline T comm::all_reduce_max(const T &t) const {
return pimpl->all_reduce_max(t);
}
template <typename T, typename MergeFunction>
inline T comm::all_reduce(const T &t, MergeFunction merge) {
return pimpl->all_reduce(t, merge);
}
} // namespace ygm
|
; ******************************************************************************
;
; Draw a pixel line from (x0,y0) defined in (COORDS) - the current plot
; coordinate, to the relative distance points (x0+x,y0+y).
;
; Design & programming by Gunther Strube, Copyright (C) InterLogic 1995
;
; The (COORDS+0) pointer contains the current y coordinate, (COORDS+1) the
; current x coordinate. The main program should reset the (COORDS) variables
; before using line drawing.
;
; The routine checks the range of specified coordinates which is the
; boundaries of the graphics area (256x64 pixels).
; If a boundary error occurs the routine exits automatically. This may be
; useful if you are trying to draw a line longer than allowed. Only the
; visible part will be drawn.
;
; The hardware graphics memory is organized as (0,0) in the top left corner.
;
; The plot routine is defined by an address pointer in IX.
;
; IN: HL = move relative x horisontal points (maximum +/- 255).
; DE = move relative y vertical points (maximum +/- 255).
; IX = pointer to plot routine that uses HL = (x,y) of plot coordinate.
;
; OUT: None.
;
; Registers used by routine:
; N : B, loop counter
; i : line balance variable
; x : H/L, horisontal, vertical distance variables
; y : H/L, horisontal, vertical distance variables
; (x0,y0) : (h,l)
; direc_x : d, horisontal step increment
; direc_y : e, vertical step increment
; ddx : b, horisontal step increment
; ddy : c, vertical step increment
;
; DE, A work registers.
;
; The algorithm in pseudo-code:
;
; direc_x = SGN x: direc_y = SGN y
; x = ABS x: y = ABS y
;
; if x >= y
; if x+y=0 then return
; H = x
; L = y
; ddx = direc_x
; ddy = 0
; else
; H = y
; L = x
; ddx = 0
; ddy = direc_y
; endif
;
; B = H
; i = INT(B/2)
; FOR N=B TO 1 STEP -1
; i = i + L
; if i < H
; ix = ddx
; iy = ddy
; else
; i = i - H
; ix = direc_x
; iy = direc_y
; endif
; x0 = x0 + ix
; y0 = y0 + iy
; plot (x0,y0)
; NEXT N
;
;
; Registers changed after return:
; ..BCDEHL/IXIY/af...... same
; AF....../..../..bcdehl different
;
line_gfx_colour db $DF
line_gfx_coords dw 0
LineHLtoDE:
TestMaxY: ld a,h ; were h = y or l = y?
cp 192
jr nc, exit_line ; y0 coordinate out of range
ld a,d
cp 192
jr nc, exit_line ; y1 coordinate out of range
ld (line_gfx_coords),hl ; the starting point is now default
push hl
push de
ld l,h ; L = x0
ld h,d ; H = x1
distanceX: ld a,h
sub l
ld l,a
ld h,0
jr nc, distanceXDone
ld h,-1
distanceXDone: pop de
ex (sp),hl ; L = y0
ld h,e ; H = y1
distanceY: ld a,h
sub l
ld l,a
ld h,0
jr nc, distanceYDone
ld h,-1
distanceYDone: pop de
ex de,hl ; h.dist. = HL, v.dist. = DE
call DrawLineRelative ; draw line...
exit_line: ret
; ***************************************************************************
;
; IN: HL = move relative x horisontal points (maximum +/- 255).
; DE = move relative y vertical points (maximum +/- 255).
;
; OUT: h - l distance in HL
;
DrawLineRelative: push de
push hl
exx
pop hl ; get relative horisontal movement
call sgn
ld d,a ; direc_x = SGN(x) installed d = +/-1 for horizontal update
call absValue
ld b,l ; x = ABS(x)
DrawLineGetVertRelative:pop hl ; get relative vertical movement
call sgn
ld e,a ; direc_y = SGN(y) installed = +/-1 for vertical update
call absValue
ld c,l ; y = ABS(y) so now bc = dxdy
; so by here BC = dx dy HL in increment/decrement x y
push bc
exx
pop hl ; H = absolute x dist., L = absolute y distance
ld a,h
cp l
jr c, x_smaller_y ; if x >= y
areXandYZero: or h ; if x+y = 0
jr z, exit_draw ; return
y_lessorequal_x: exx ; else
ld b,d ; ddx = direc_x
ld c,0 ; ddy = 0
exx
jr init_drawloop ; else
x_smaller_y: ld a,h
ld h,l ; H = y
ld l,a ; L = x
exx
ld b,0 ; ddx = 0
ld c,e ; ddy = direc_y
exx
init_drawloop: ld b,h
ld c,h ; B = H
srl c ; i = INT(B/2)
; FOR N=B TO 1 STEP -1
drawloop: ld a,c
add a,l
jr c, i_greater ; i + L > 255 (i > H)
cp h
jr nc, i_greater ; if i < H
ld c,a ; i = i + L
exx
push bc ; ix = ddx: iy = ddy
exx
jr check_plot ; else
i_greater: sub h ; i = i - H
ld c,a
exx
push de ; ix = direc_x: iy = direc_y
exx ; endif
check_plot: ex (sp),hl ; preserve H,L distances on stack
ex de,hl ; D,E = ix, iy
ld hl,(line_gfx_coords)
ld a,l
add a,e ;
ld l,a ; y0 = y0 + iy (y0 is checked by plot)
ld a,d
inc a
add a,h
jr c, check_range ; check out of range
jr z, range_error ; Fz=1 & Fc=0 denotes x0 < 0
jr plot_point
check_range: jr nz, range_error ; Fz=0 & Fc=1 denotes x0 > 255
plot_point: dec a
push bc
push af
ld b,a ; x0 = x0 + ix
ld c,l
ld a,(line_gfx_colour)
ld (line_gfx_coords),bc
call l2_plot_pixel:
pop af
pop bc
plot_RET: pop hl ; restore H,L distances...
djnz drawloop ; NEXT N
jr exit_draw
range_error: pop hl ; remove H,L distances...
exit_draw: ret
; ******************************************************************************
;
; SGN (Signum value) of 16 bit signed integer.
;
; IN: HL = integer
; OUT: A = result: 0,1,-1 (if zero, positive, negative)
;
; Registers changed after return:
; ..BCDEHL/IXIY same
; AF....../.... different
;
sgn: ld a,h
or l
ret z ; integer is zero, return 0...
bit 7,h
jr nz, negative_int
ld a,1
ret
negative_int: ld a,-1
ret
; ******************************************************************************
;
; ABS (Absolute value) of 16 bit signed integer.
;
; IN: HL = integer
; OUT: HL = converted integer
;
; Registers changed after return:
; A.BCDE../IXIY same
; .F....HL/.... different
;
absValue: bit 7,h
ret z ; integer is positive...
push de
ex de,hl
ld hl,0
cp a ; Fc = 0, may not be used...
sbc hl,de ; convert negative integer
pop de
ret
|
/*!
* @file Adafruit_INA219.cpp
*
* @mainpage Adafruit INA219 current/power monitor IC
*
* @section intro_sec Introduction
*
* Driver for the INA219 current sensor
*
* This is a library for the Adafruit INA219 breakout
* ----> https://www.adafruit.com/products/904
*
* Adafruit invests time and resources providing this open source code,
* please support Adafruit and open-source hardware by purchasing
* products from Adafruit!
*
* @section author Author
*
* Written by Kevin "KTOWN" Townsend for Adafruit Industries.
*
* @section license License
*
* BSD license, all text here must be included in any redistribution.
*
*/
#include "Arduino.h"
#include <Wire.h>
#include "Adafruit_INA219.h"
/*!
* @brief Sends a single command byte over I2C
* @param reg
* register address
* @param value
* value to write
*/
void Adafruit_INA219::wireWriteRegister(uint8_t reg, uint16_t value) {
_i2c->beginTransmission(ina219_i2caddr);
_i2c->write(reg); // Register
_i2c->write((value >> 8) & 0xFF); // Upper 8-bits
_i2c->write(value & 0xFF); // Lower 8-bits
_i2c->endTransmission();
}
/*!
* @brief Reads a 16 bit values over I2C
* @param reg
* register address
* @param *value
* read value
*/
void Adafruit_INA219::wireReadRegister(uint8_t reg, uint16_t *value) {
_i2c->beginTransmission(ina219_i2caddr);
_i2c->write(reg); // Register
_i2c->endTransmission();
delay(1); // Max 12-bit conversion time is 586us per sample
_i2c->requestFrom(ina219_i2caddr, (uint8_t)2);
// Shift values to create properly formed integer
*value = ((_i2c->read() << 8) | _i2c->read());
}
/*!
* @brief Configures to INA219 to be able to measure up to 32V and 2A
* of current. Each unit of current corresponds to 100uA, and
* each unit of power corresponds to 2mW. Counter overflow
* occurs at 3.2A.
* @note These calculations assume a 0.1 ohm resistor is present
*/
void Adafruit_INA219::setCalibration_32V_2A() {
// By default we use a pretty huge range for the input voltage,
// which probably isn't the most appropriate choice for system
// that don't use a lot of power. But all of the calculations
// are shown below if you want to change the settings. You will
// also need to change any relevant register settings, such as
// setting the VBUS_MAX to 16V instead of 32V, etc.
// VBUS_MAX = 32V (Assumes 32V, can also be set to 16V)
// VSHUNT_MAX = 0.32 (Assumes Gain 8, 320mV, can also be 0.16, 0.08, 0.04)
// RSHUNT = 0.1 (Resistor value in ohms)
// 1. Determine max possible current
// MaxPossible_I = VSHUNT_MAX / RSHUNT
// MaxPossible_I = 3.2A
// 2. Determine max expected current
// MaxExpected_I = 2.0A
// 3. Calculate possible range of LSBs (Min = 15-bit, Max = 12-bit)
// MinimumLSB = MaxExpected_I/32767
// MinimumLSB = 0.000061 (61uA per bit)
// MaximumLSB = MaxExpected_I/4096
// MaximumLSB = 0,000488 (488uA per bit)
// 4. Choose an LSB between the min and max values
// (Preferrably a roundish number close to MinLSB)
// CurrentLSB = 0.0001 (100uA per bit)
// 5. Compute the calibration register
// Cal = trunc (0.04096 / (Current_LSB * RSHUNT))
// Cal = 4096 (0x1000)
ina219_calValue = 4096;
// 6. Calculate the power LSB
// PowerLSB = 20 * CurrentLSB
// PowerLSB = 0.002 (2mW per bit)
// 7. Compute the maximum current and shunt voltage values before overflow
//
// Max_Current = Current_LSB * 32767
// Max_Current = 3.2767A before overflow
//
// If Max_Current > Max_Possible_I then
// Max_Current_Before_Overflow = MaxPossible_I
// Else
// Max_Current_Before_Overflow = Max_Current
// End If
//
// Max_ShuntVoltage = Max_Current_Before_Overflow * RSHUNT
// Max_ShuntVoltage = 0.32V
//
// If Max_ShuntVoltage >= VSHUNT_MAX
// Max_ShuntVoltage_Before_Overflow = VSHUNT_MAX
// Else
// Max_ShuntVoltage_Before_Overflow = Max_ShuntVoltage
// End If
// 8. Compute the Maximum Power
// MaximumPower = Max_Current_Before_Overflow * VBUS_MAX
// MaximumPower = 3.2 * 32V
// MaximumPower = 102.4W
// Set multipliers to convert raw current/power values
ina219_currentDivider_mA = 10; // Current LSB = 100uA per bit (1000/100 = 10)
ina219_powerMultiplier_mW = 2; // Power LSB = 1mW per bit (2/1)
// Set Calibration register to 'Cal' calculated above
wireWriteRegister(INA219_REG_CALIBRATION, ina219_calValue);
// Set Config register to take into account the settings above
uint16_t config = INA219_CONFIG_BVOLTAGERANGE_32V |
INA219_CONFIG_GAIN_8_320MV | INA219_CONFIG_BADCRES_12BIT |
INA219_CONFIG_SADCRES_12BIT_1S_532US |
INA219_CONFIG_MODE_SANDBVOLT_CONTINUOUS;
wireWriteRegister(INA219_REG_CONFIG, config);
}
/*!
* @brief Set power save mode according to parameters
* @param on
* boolean value
*/
void Adafruit_INA219::powerSave(bool on) {
uint16_t current;
wireReadRegister(INA219_REG_CONFIG, ¤t);
uint8_t next;
if (on) {
next = current | INA219_CONFIG_MODE_POWERDOWN;
} else {
next = current & ~INA219_CONFIG_MODE_POWERDOWN;
}
wireWriteRegister(INA219_REG_CONFIG, next);
}
/*!
* @brief Configures to INA219 to be able to measure up to 32V and 1A
* of current. Each unit of current corresponds to 40uA, and each
* unit of power corresponds to 800�W. Counter overflow occurs at
* 1.3A.
* @note These calculations assume a 0.1 ohm resistor is present
*/
void Adafruit_INA219::setCalibration_32V_1A() {
// By default we use a pretty huge range for the input voltage,
// which probably isn't the most appropriate choice for system
// that don't use a lot of power. But all of the calculations
// are shown below if you want to change the settings. You will
// also need to change any relevant register settings, such as
// setting the VBUS_MAX to 16V instead of 32V, etc.
// VBUS_MAX = 32V (Assumes 32V, can also be set to 16V)
// VSHUNT_MAX = 0.32 (Assumes Gain 8, 320mV, can also be 0.16, 0.08, 0.04)
// RSHUNT = 0.1 (Resistor value in ohms)
// 1. Determine max possible current
// MaxPossible_I = VSHUNT_MAX / RSHUNT
// MaxPossible_I = 3.2A
// 2. Determine max expected current
// MaxExpected_I = 1.0A
// 3. Calculate possible range of LSBs (Min = 15-bit, Max = 12-bit)
// MinimumLSB = MaxExpected_I/32767
// MinimumLSB = 0.0000305 (30.5�A per bit)
// MaximumLSB = MaxExpected_I/4096
// MaximumLSB = 0.000244 (244�A per bit)
// 4. Choose an LSB between the min and max values
// (Preferrably a roundish number close to MinLSB)
// CurrentLSB = 0.0000400 (40�A per bit)
// 5. Compute the calibration register
// Cal = trunc (0.04096 / (Current_LSB * RSHUNT))
// Cal = 10240 (0x2800)
ina219_calValue = 10240;
// 6. Calculate the power LSB
// PowerLSB = 20 * CurrentLSB
// PowerLSB = 0.0008 (800�W per bit)
// 7. Compute the maximum current and shunt voltage values before overflow
//
// Max_Current = Current_LSB * 32767
// Max_Current = 1.31068A before overflow
//
// If Max_Current > Max_Possible_I then
// Max_Current_Before_Overflow = MaxPossible_I
// Else
// Max_Current_Before_Overflow = Max_Current
// End If
//
// ... In this case, we're good though since Max_Current is less than
// MaxPossible_I
//
// Max_ShuntVoltage = Max_Current_Before_Overflow * RSHUNT
// Max_ShuntVoltage = 0.131068V
//
// If Max_ShuntVoltage >= VSHUNT_MAX
// Max_ShuntVoltage_Before_Overflow = VSHUNT_MAX
// Else
// Max_ShuntVoltage_Before_Overflow = Max_ShuntVoltage
// End If
// 8. Compute the Maximum Power
// MaximumPower = Max_Current_Before_Overflow * VBUS_MAX
// MaximumPower = 1.31068 * 32V
// MaximumPower = 41.94176W
// Set multipliers to convert raw current/power values
ina219_currentDivider_mA = 25; // Current LSB = 40uA per bit (1000/40 = 25)
ina219_powerMultiplier_mW = 0.8f; // Power LSB = 800uW per bit
// Set Calibration register to 'Cal' calculated above
wireWriteRegister(INA219_REG_CALIBRATION, ina219_calValue);
// Set Config register to take into account the settings above
uint16_t config = INA219_CONFIG_BVOLTAGERANGE_32V |
INA219_CONFIG_GAIN_8_320MV | INA219_CONFIG_BADCRES_12BIT |
INA219_CONFIG_SADCRES_12BIT_1S_532US |
INA219_CONFIG_MODE_SANDBVOLT_CONTINUOUS;
wireWriteRegister(INA219_REG_CONFIG, config);
}
/*!
* @brief set device to alibration which uses the highest precision for
* current measurement (0.1mA), at the expense of
* only supporting 16V at 400mA max.
*/
void Adafruit_INA219::setCalibration_16V_400mA() {
// Calibration which uses the highest precision for
// current measurement (0.1mA), at the expense of
// only supporting 16V at 400mA max.
// VBUS_MAX = 16V
// VSHUNT_MAX = 0.04 (Assumes Gain 1, 40mV)
// RSHUNT = 0.1 (Resistor value in ohms)
// 1. Determine max possible current
// MaxPossible_I = VSHUNT_MAX / RSHUNT
// MaxPossible_I = 0.4A
// 2. Determine max expected current
// MaxExpected_I = 0.4A
// 3. Calculate possible range of LSBs (Min = 15-bit, Max = 12-bit)
// MinimumLSB = MaxExpected_I/32767
// MinimumLSB = 0.0000122 (12uA per bit)
// MaximumLSB = MaxExpected_I/4096
// MaximumLSB = 0.0000977 (98uA per bit)
// 4. Choose an LSB between the min and max values
// (Preferrably a roundish number close to MinLSB)
// CurrentLSB = 0.00005 (50uA per bit)
// 5. Compute the calibration register
// Cal = trunc (0.04096 / (Current_LSB * RSHUNT))
// Cal = 8192 (0x2000)
ina219_calValue = 8192;
// 6. Calculate the power LSB
// PowerLSB = 20 * CurrentLSB
// PowerLSB = 0.001 (1mW per bit)
// 7. Compute the maximum current and shunt voltage values before overflow
//
// Max_Current = Current_LSB * 32767
// Max_Current = 1.63835A before overflow
//
// If Max_Current > Max_Possible_I then
// Max_Current_Before_Overflow = MaxPossible_I
// Else
// Max_Current_Before_Overflow = Max_Current
// End If
//
// Max_Current_Before_Overflow = MaxPossible_I
// Max_Current_Before_Overflow = 0.4
//
// Max_ShuntVoltage = Max_Current_Before_Overflow * RSHUNT
// Max_ShuntVoltage = 0.04V
//
// If Max_ShuntVoltage >= VSHUNT_MAX
// Max_ShuntVoltage_Before_Overflow = VSHUNT_MAX
// Else
// Max_ShuntVoltage_Before_Overflow = Max_ShuntVoltage
// End If
//
// Max_ShuntVoltage_Before_Overflow = VSHUNT_MAX
// Max_ShuntVoltage_Before_Overflow = 0.04V
// 8. Compute the Maximum Power
// MaximumPower = Max_Current_Before_Overflow * VBUS_MAX
// MaximumPower = 0.4 * 16V
// MaximumPower = 6.4W
// Set multipliers to convert raw current/power values
ina219_currentDivider_mA = 20; // Current LSB = 50uA per bit (1000/50 = 20)
ina219_powerMultiplier_mW = 1.0f; // Power LSB = 1mW per bit
// Set Calibration register to 'Cal' calculated above
wireWriteRegister(INA219_REG_CALIBRATION, ina219_calValue);
// Set Config register to take into account the settings above
uint16_t config = INA219_CONFIG_BVOLTAGERANGE_16V |
INA219_CONFIG_GAIN_1_40MV | INA219_CONFIG_BADCRES_12BIT |
INA219_CONFIG_SADCRES_12BIT_1S_532US |
INA219_CONFIG_MODE_SANDBVOLT_CONTINUOUS;
wireWriteRegister(INA219_REG_CONFIG, config);
}
/*!
* @brief Instantiates a new INA219 class
* @param addr the I2C address the device can be found on. Default is 0x40
*/
Adafruit_INA219::Adafruit_INA219(uint8_t addr) {
ina219_i2caddr = addr;
ina219_currentDivider_mA = 0;
ina219_powerMultiplier_mW = 0.0f;
}
/*!
* @brief Setups the HW (defaults to 32V and 2A for calibration values)
* @param theWire the TwoWire object to use
*/
void Adafruit_INA219::begin(TwoWire *theWire) {
_i2c = theWire;
init();
}
/*!
* @brief begin I2C and set up the hardware
*/
void Adafruit_INA219::init() {
_i2c->begin();
_i2c->setClock(400000);
// Set chip to large range config values to start
setCalibration_32V_2A();
}
/*!
* @brief Gets the raw bus voltage (16-bit signed integer, so +-32767)
* @return the raw bus voltage reading
*/
int16_t Adafruit_INA219::getBusVoltage_raw() {
uint16_t value;
wireReadRegister(INA219_REG_BUSVOLTAGE, &value);
// Shift to the right 3 to drop CNVR and OVF and multiply by LSB
return (int16_t)((value >> 3) * 4);
}
/*!
* @brief Gets the raw shunt voltage (16-bit signed integer, so +-32767)
* @return the raw shunt voltage reading
*/
int16_t Adafruit_INA219::getShuntVoltage_raw() {
uint16_t value;
wireReadRegister(INA219_REG_SHUNTVOLTAGE, &value);
return (int16_t)value;
}
/*!
* @brief Gets the raw current value (16-bit signed integer, so +-32767)
* @return the raw current reading
*/
int16_t Adafruit_INA219::getCurrent_raw() {
uint16_t value;
// Sometimes a sharp load will reset the INA219, which will
// reset the cal register, meaning CURRENT and POWER will
// not be available ... avoid this by always setting a cal
// value even if it's an unfortunate extra step
wireWriteRegister(INA219_REG_CALIBRATION, ina219_calValue);
// Now we can safely read the CURRENT register!
wireReadRegister(INA219_REG_CURRENT, &value);
return (int16_t)value;
}
/*!
* @brief Gets the raw power value (16-bit signed integer, so +-32767)
* @return raw power reading
*/
int16_t Adafruit_INA219::getPower_raw() {
uint16_t value;
// Sometimes a sharp load will reset the INA219, which will
// reset the cal register, meaning CURRENT and POWER will
// not be available ... avoid this by always setting a cal
// value even if it's an unfortunate extra step
wireWriteRegister(INA219_REG_CALIBRATION, ina219_calValue);
// Now we can safely read the POWER register!
wireReadRegister(INA219_REG_POWER, &value);
return (int16_t)value;
}
/*!
* @brief Gets the shunt voltage in mV (so +-327mV)
* @return the shunt voltage converted to millivolts
*/
float Adafruit_INA219::getShuntVoltage_mV() {
int16_t value;
value = getShuntVoltage_raw();
return value * 0.01;
}
/*!
* @brief Gets the shunt voltage in volts
* @return the bus voltage converted to volts
*/
float Adafruit_INA219::getBusVoltage_V() {
int16_t value = getBusVoltage_raw();
return value * 0.001;
}
/*!
* @brief Gets the current value in mA, taking into account the
* config settings and current LSB
* @return the current reading convereted to milliamps
*/
float Adafruit_INA219::getCurrent_mA() {
float valueDec = getCurrent_raw();
valueDec /= ina219_currentDivider_mA;
return valueDec;
}
/*!
* @brief Gets the power value in mW, taking into account the
* config settings and current LSB
* @return power reading converted to milliwatts
*/
float Adafruit_INA219::getPower_mW() {
float valueDec = getPower_raw();
valueDec *= ina219_powerMultiplier_mW;
return valueDec;
}
|
// Copyright 2014 PDFium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
#include "xfa/fxfa/app/xfa_ffbarcode.h"
#include "core/fxcrt/include/fx_ext.h"
#include "xfa/fwl/core/fwl_noteimp.h"
#include "xfa/fwl/core/ifwl_app.h"
#include "xfa/fwl/lightwidget/cfwl_barcode.h"
#include "xfa/fxfa/app/xfa_fffield.h"
#include "xfa/fxfa/app/xfa_fftextedit.h"
#include "xfa/fxfa/app/xfa_fwladapter.h"
#include "xfa/fxfa/include/xfa_ffpageview.h"
#include "xfa/fxfa/include/xfa_ffwidget.h"
namespace {
const XFA_BARCODETYPEENUMINFO g_XFABarCodeTypeEnumData[] = {
{0x7fb4a18, L"ean13", XFA_BARCODETYPE_ean13, BC_EAN13},
{0x8d13a3d, L"code11", XFA_BARCODETYPE_code11, BC_UNKNOWN},
{0x8d149a8, L"code49", XFA_BARCODETYPE_code49, BC_UNKNOWN},
{0x8d16347, L"code93", XFA_BARCODETYPE_code93, BC_UNKNOWN},
{0x91a92e2, L"upsMaxicode", XFA_BARCODETYPE_upsMaxicode, BC_UNKNOWN},
{0xa7d48dc, L"fim", XFA_BARCODETYPE_fim, BC_UNKNOWN},
{0xb359fe9, L"msi", XFA_BARCODETYPE_msi, BC_UNKNOWN},
{0x121f738c, L"code2Of5Matrix", XFA_BARCODETYPE_code2Of5Matrix, BC_UNKNOWN},
{0x15358616, L"ucc128", XFA_BARCODETYPE_ucc128, BC_UNKNOWN},
{0x1f4bfa05, L"rfid", XFA_BARCODETYPE_rfid, BC_UNKNOWN},
{0x1fda71bc, L"rss14Stacked", XFA_BARCODETYPE_rss14Stacked, BC_UNKNOWN},
{0x22065087, L"ean8add2", XFA_BARCODETYPE_ean8add2, BC_UNKNOWN},
{0x2206508a, L"ean8add5", XFA_BARCODETYPE_ean8add5, BC_UNKNOWN},
{0x2278366c, L"codabar", XFA_BARCODETYPE_codabar, BC_CODABAR},
{0x2a039a8d, L"telepen", XFA_BARCODETYPE_telepen, BC_UNKNOWN},
{0x323ed337, L"upcApwcd", XFA_BARCODETYPE_upcApwcd, BC_UNKNOWN},
{0x347a1846, L"postUSIMB", XFA_BARCODETYPE_postUSIMB, BC_UNKNOWN},
{0x391bb836, L"code128", XFA_BARCODETYPE_code128, BC_CODE128},
{0x398eddaf, L"dataMatrix", XFA_BARCODETYPE_dataMatrix, BC_DATAMATRIX},
{0x3cff60a8, L"upcEadd2", XFA_BARCODETYPE_upcEadd2, BC_UNKNOWN},
{0x3cff60ab, L"upcEadd5", XFA_BARCODETYPE_upcEadd5, BC_UNKNOWN},
{0x402cb188, L"code2Of5Standard", XFA_BARCODETYPE_code2Of5Standard,
BC_UNKNOWN},
{0x411764f7, L"aztec", XFA_BARCODETYPE_aztec, BC_UNKNOWN},
{0x44d4e84c, L"ean8", XFA_BARCODETYPE_ean8, BC_EAN8},
{0x48468902, L"ucc128sscc", XFA_BARCODETYPE_ucc128sscc, BC_UNKNOWN},
{0x4880aea4, L"upcAadd2", XFA_BARCODETYPE_upcAadd2, BC_UNKNOWN},
{0x4880aea7, L"upcAadd5", XFA_BARCODETYPE_upcAadd5, BC_UNKNOWN},
{0x54f18256, L"code2Of5Industrial", XFA_BARCODETYPE_code2Of5Industrial,
BC_UNKNOWN},
{0x58e15f25, L"rss14Limited", XFA_BARCODETYPE_rss14Limited, BC_UNKNOWN},
{0x5c08d1b9, L"postAUSReplyPaid", XFA_BARCODETYPE_postAUSReplyPaid,
BC_UNKNOWN},
{0x5fa700bd, L"rss14", XFA_BARCODETYPE_rss14, BC_UNKNOWN},
{0x631a7e35, L"logmars", XFA_BARCODETYPE_logmars, BC_UNKNOWN},
{0x6a236236, L"pdf417", XFA_BARCODETYPE_pdf417, BC_PDF417},
{0x6d098ece, L"upcean2", XFA_BARCODETYPE_upcean2, BC_UNKNOWN},
{0x6d098ed1, L"upcean5", XFA_BARCODETYPE_upcean5, BC_UNKNOWN},
{0x76b04eed, L"code3Of9extended", XFA_BARCODETYPE_code3Of9extended,
BC_UNKNOWN},
{0x7c7db84a, L"maxicode", XFA_BARCODETYPE_maxicode, BC_UNKNOWN},
{0x8266f7f7, L"ucc128random", XFA_BARCODETYPE_ucc128random, BC_UNKNOWN},
{0x83eca147, L"postUSDPBC", XFA_BARCODETYPE_postUSDPBC, BC_UNKNOWN},
{0x8dd71de0, L"postAUSStandard", XFA_BARCODETYPE_postAUSStandard,
BC_UNKNOWN},
{0x98adad85, L"plessey", XFA_BARCODETYPE_plessey, BC_UNKNOWN},
{0x9f84cce6, L"ean13pwcd", XFA_BARCODETYPE_ean13pwcd, BC_UNKNOWN},
{0xb514fbe9, L"upcA", XFA_BARCODETYPE_upcA, BC_UPCA},
{0xb514fbed, L"upcE", XFA_BARCODETYPE_upcE, BC_UNKNOWN},
{0xb5c6a853, L"ean13add2", XFA_BARCODETYPE_ean13add2, BC_UNKNOWN},
{0xb5c6a856, L"ean13add5", XFA_BARCODETYPE_ean13add5, BC_UNKNOWN},
{0xb81fc512, L"postUKRM4SCC", XFA_BARCODETYPE_postUKRM4SCC, BC_UNKNOWN},
{0xbad34b22, L"code128SSCC", XFA_BARCODETYPE_code128SSCC, BC_UNKNOWN},
{0xbfbe0cf6, L"postUS5Zip", XFA_BARCODETYPE_postUS5Zip, BC_UNKNOWN},
{0xc56618e8, L"pdf417macro", XFA_BARCODETYPE_pdf417macro, BC_UNKNOWN},
{0xca730f8a, L"code2Of5Interleaved", XFA_BARCODETYPE_code2Of5Interleaved,
BC_UNKNOWN},
{0xd0097ac6, L"rss14Expanded", XFA_BARCODETYPE_rss14Expanded, BC_UNKNOWN},
{0xd25a0240, L"postAUSCust2", XFA_BARCODETYPE_postAUSCust2, BC_UNKNOWN},
{0xd25a0241, L"postAUSCust3", XFA_BARCODETYPE_postAUSCust3, BC_UNKNOWN},
{0xd53ed3e7, L"rss14Truncated", XFA_BARCODETYPE_rss14Truncated, BC_UNKNOWN},
{0xe72bcd57, L"code128A", XFA_BARCODETYPE_code128A, BC_UNKNOWN},
{0xe72bcd58, L"code128B", XFA_BARCODETYPE_code128B, BC_CODE128_B},
{0xe72bcd59, L"code128C", XFA_BARCODETYPE_code128C, BC_CODE128_C},
{0xee83c50f, L"rss14StackedOmni", XFA_BARCODETYPE_rss14StackedOmni,
BC_UNKNOWN},
{0xf2a18f7e, L"QRCode", XFA_BARCODETYPE_QRCode, BC_QR_CODE},
{0xfaeaf37f, L"postUSStandard", XFA_BARCODETYPE_postUSStandard, BC_UNKNOWN},
{0xfb48155c, L"code3Of9", XFA_BARCODETYPE_code3Of9, BC_CODE39},
};
const int32_t g_iXFABarcodeTypeCount =
sizeof(g_XFABarCodeTypeEnumData) / sizeof(XFA_BARCODETYPEENUMINFO);
XFA_LPCBARCODETYPEENUMINFO XFA_GetBarcodeTypeByName(
const CFX_WideStringC& wsName) {
if (wsName.IsEmpty())
return nullptr;
uint32_t uHash = FX_HashCode_GetW(wsName, true);
int32_t iStart = 0;
int32_t iEnd = g_iXFABarcodeTypeCount - 1;
do {
int32_t iMid = (iStart + iEnd) / 2;
XFA_LPCBARCODETYPEENUMINFO pInfo = g_XFABarCodeTypeEnumData + iMid;
if (uHash == pInfo->uHash) {
return pInfo;
} else if (uHash < pInfo->uHash) {
iEnd = iMid - 1;
} else {
iStart = iMid + 1;
}
} while (iStart <= iEnd);
return nullptr;
}
} // namespace.
CXFA_FFBarcode::CXFA_FFBarcode(CXFA_FFPageView* pPageView,
CXFA_WidgetAcc* pDataAcc)
: CXFA_FFTextEdit(pPageView, pDataAcc) {}
CXFA_FFBarcode::~CXFA_FFBarcode() {}
FX_BOOL CXFA_FFBarcode::LoadWidget() {
CFWL_Barcode* pFWLBarcode = CFWL_Barcode::Create();
if (pFWLBarcode) {
pFWLBarcode->Initialize();
}
m_pNormalWidget = pFWLBarcode;
m_pNormalWidget->SetLayoutItem(this);
IFWL_Widget* pWidget = m_pNormalWidget->GetWidget();
CFWL_NoteDriver* pNoteDriver = FWL_GetApp()->GetNoteDriver();
pNoteDriver->RegisterEventTarget(pWidget, pWidget);
m_pOldDelegate = m_pNormalWidget->SetDelegate(this);
m_pNormalWidget->LockUpdate();
CFX_WideString wsText;
m_pDataAcc->GetValue(wsText, XFA_VALUEPICTURE_Display);
pFWLBarcode->SetText(wsText);
UpdateWidgetProperty();
m_pNormalWidget->UnlockUpdate();
return CXFA_FFField::LoadWidget();
}
void CXFA_FFBarcode::RenderWidget(CFX_Graphics* pGS,
CFX_Matrix* pMatrix,
uint32_t dwStatus) {
if (!IsMatchVisibleStatus(dwStatus)) {
return;
}
CFX_Matrix mtRotate;
GetRotateMatrix(mtRotate);
if (pMatrix) {
mtRotate.Concat(*pMatrix);
}
CXFA_FFWidget::RenderWidget(pGS, &mtRotate, dwStatus);
CXFA_Border borderUI = m_pDataAcc->GetUIBorder();
DrawBorder(pGS, borderUI, m_rtUI, &mtRotate);
RenderCaption(pGS, &mtRotate);
CFX_RectF rtWidget;
m_pNormalWidget->GetWidgetRect(rtWidget);
CFX_Matrix mt;
mt.Set(1, 0, 0, 1, rtWidget.left, rtWidget.top);
mt.Concat(mtRotate);
m_pNormalWidget->DrawWidget(pGS, &mt);
}
void CXFA_FFBarcode::UpdateWidgetProperty() {
CXFA_FFTextEdit::UpdateWidgetProperty();
CFWL_Barcode* pBarCodeWidget = (CFWL_Barcode*)m_pNormalWidget;
CFX_WideString wsType = GetDataAcc()->GetBarcodeType();
XFA_LPCBARCODETYPEENUMINFO pBarcodeTypeInfo =
XFA_GetBarcodeTypeByName(wsType.AsStringC());
pBarCodeWidget->SetType(pBarcodeTypeInfo->eBCType);
CXFA_WidgetAcc* pAcc = GetDataAcc();
int32_t intVal;
FX_CHAR charVal;
FX_BOOL boolVal;
FX_FLOAT floatVal;
if (pAcc->GetBarcodeAttribute_CharEncoding(intVal)) {
pBarCodeWidget->SetCharEncoding((BC_CHAR_ENCODING)intVal);
}
if (pAcc->GetBarcodeAttribute_Checksum(intVal)) {
pBarCodeWidget->SetCalChecksum(intVal);
}
if (pAcc->GetBarcodeAttribute_DataLength(intVal)) {
pBarCodeWidget->SetDataLength(intVal);
}
if (pAcc->GetBarcodeAttribute_StartChar(charVal)) {
pBarCodeWidget->SetStartChar(charVal);
}
if (pAcc->GetBarcodeAttribute_EndChar(charVal)) {
pBarCodeWidget->SetEndChar(charVal);
}
if (pAcc->GetBarcodeAttribute_ECLevel(intVal)) {
pBarCodeWidget->SetErrorCorrectionLevel(intVal);
}
if (pAcc->GetBarcodeAttribute_ModuleWidth(intVal)) {
pBarCodeWidget->SetModuleWidth(intVal);
}
if (pAcc->GetBarcodeAttribute_ModuleHeight(intVal)) {
pBarCodeWidget->SetModuleHeight(intVal);
}
if (pAcc->GetBarcodeAttribute_PrintChecksum(boolVal)) {
pBarCodeWidget->SetPrintChecksum(boolVal);
}
if (pAcc->GetBarcodeAttribute_TextLocation(intVal)) {
pBarCodeWidget->SetTextLocation((BC_TEXT_LOC)intVal);
}
if (pAcc->GetBarcodeAttribute_Truncate(boolVal)) {
pBarCodeWidget->SetTruncated(boolVal);
}
if (pAcc->GetBarcodeAttribute_WideNarrowRatio(floatVal)) {
pBarCodeWidget->SetWideNarrowRatio((int32_t)floatVal);
}
if (pBarcodeTypeInfo->eName == XFA_BARCODETYPE_code3Of9 ||
pBarcodeTypeInfo->eName == XFA_BARCODETYPE_ean8 ||
pBarcodeTypeInfo->eName == XFA_BARCODETYPE_ean13 ||
pBarcodeTypeInfo->eName == XFA_BARCODETYPE_upcA) {
pBarCodeWidget->SetPrintChecksum(TRUE);
}
}
FX_BOOL CXFA_FFBarcode::OnLButtonDown(uint32_t dwFlags,
FX_FLOAT fx,
FX_FLOAT fy) {
CFWL_Barcode* pBarCodeWidget = (CFWL_Barcode*)m_pNormalWidget;
if (!pBarCodeWidget || pBarCodeWidget->IsProtectedType()) {
return FALSE;
}
if (m_pDataAcc->GetAccess() != XFA_ATTRIBUTEENUM_Open) {
return FALSE;
}
return CXFA_FFTextEdit::OnLButtonDown(dwFlags, fx, fy);
}
FX_BOOL CXFA_FFBarcode::OnRButtonDown(uint32_t dwFlags,
FX_FLOAT fx,
FX_FLOAT fy) {
CFWL_Barcode* pBarCodeWidget = (CFWL_Barcode*)m_pNormalWidget;
if (!pBarCodeWidget || pBarCodeWidget->IsProtectedType()) {
return FALSE;
}
return CXFA_FFTextEdit::OnRButtonDown(dwFlags, fx, fy);
}
|
// Copyright 2014 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "components/dom_distiller/core/distilled_content_store.h"
#include <utility>
#include "base/threading/thread_task_runner_handle.h"
namespace dom_distiller {
InMemoryContentStore::InMemoryContentStore(const int max_num_entries)
: cache_(max_num_entries) {}
InMemoryContentStore::~InMemoryContentStore() {
// Clear the cache before destruction to ensure the CacheDeletor is not called
// after InMemoryContentStore has been destroyed.
cache_.Clear();
}
void InMemoryContentStore::SaveContent(
const ArticleEntry& entry,
const DistilledArticleProto& proto,
InMemoryContentStore::SaveCallback callback) {
InjectContent(entry, proto);
if (!callback.is_null()) {
base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
base::Bind(callback, true));
}
}
void InMemoryContentStore::LoadContent(
const ArticleEntry& entry,
InMemoryContentStore::LoadCallback callback) {
if (callback.is_null())
return;
ContentMap::const_iterator it = cache_.Get(entry.entry_id());
bool success = it != cache_.end();
if (!success) {
// Could not find article by entry ID, so try looking it up by URL.
for (int i = 0; i < entry.pages_size(); ++i) {
UrlMap::const_iterator url_it = url_to_id_.find(entry.pages(i).url());
if (url_it != url_to_id_.end()) {
it = cache_.Get(url_it->second);
success = it != cache_.end();
if (success) {
break;
}
}
}
}
std::unique_ptr<DistilledArticleProto> distilled_article;
if (success) {
distilled_article.reset(new DistilledArticleProto(*it->second));
} else {
distilled_article.reset(new DistilledArticleProto());
}
base::ThreadTaskRunnerHandle::Get()->PostTask(
FROM_HERE,
base::BindOnce(callback, success, std::move(distilled_article)));
}
void InMemoryContentStore::InjectContent(const ArticleEntry& entry,
const DistilledArticleProto& proto) {
cache_.Put(entry.entry_id(),
std::unique_ptr<DistilledArticleProto, CacheDeletor>(
new DistilledArticleProto(proto), CacheDeletor(this)));
AddUrlToIdMapping(entry, proto);
}
void InMemoryContentStore::AddUrlToIdMapping(
const ArticleEntry& entry,
const DistilledArticleProto& proto) {
for (int i = 0; i < proto.pages_size(); i++) {
const DistilledPageProto& page = proto.pages(i);
if (page.has_url()) {
url_to_id_[page.url()] = entry.entry_id();
}
}
}
void InMemoryContentStore::EraseUrlToIdMapping(
const DistilledArticleProto& proto) {
for (int i = 0; i < proto.pages_size(); i++) {
const DistilledPageProto& page = proto.pages(i);
if (page.has_url()) {
url_to_id_.erase(page.url());
}
}
}
InMemoryContentStore::CacheDeletor::CacheDeletor(InMemoryContentStore* store)
: store_(store) {
}
InMemoryContentStore::CacheDeletor::~CacheDeletor() {
}
void InMemoryContentStore::CacheDeletor::operator()(
DistilledArticleProto* proto) {
// When InMemoryContentStore is deleted, the |store_| pointer becomes invalid,
// but since the ContentMap is cleared in the InMemoryContentStore destructor,
// this should never be called after the destructor.
store_->EraseUrlToIdMapping(*proto);
delete proto;
}
} // namespace dom_distiller
|
scr_top equ $20000
num_sp equ 53
num_base equ 16
ut_con equ $c6
ut_mtext equ $d0
score_poshi equ 50
score_pos equ 480
bas_pos equ 5
nemalt equ 15
;
;
;
coldstart
moveq #0,d0
lea hiscore,a0
move.l d0,(a0)
bsr save_message
warm bsr dimbo
bsr clear
bsr setbarriers
bsr savebarriers
restart lea bulposx,a0
move.w #-1,(a0)
bsr clear
bsr loadbarriers
bsr new_gun
bsr paint
bsr print_score
bsr print_hiscore
bsr print_bases
bsr print_flags
bsr bombs
repeat bsr move_gun
move.b seq_num,d0
beq.s no_bang
bsr draws_bang
no_bang bsr drop_bomb
bsr bulmov
lea zeke,a0
subq.b #1,(a0)
tst.b (a0)
bpl.s no_mum
move.b #2,(a0)
move.w baddyx,d0
bmi.s no_mum
bsr baddybus
no_mum lea in_wait,a0
subq.b #1,(a0)
bne.s no_inv
move.b inv_speed,(a0)
bsr rev_bul
bsr un_paint
bsr slither
bsr.s paint
bsr rev_bul
lea flick,a2
eor.b #1,(a2)
move.w baddyx,d0
bpl.s no_inv
lea badwait,a0
subq.b #1,(a0)
bne.s no_inv
lea baddyx,a0
moveq #0,d6
move.w d6,(a0)
moveq #nemalt,d7
bsr saver
no_inv moveq #3,d1
bra.s repeat
;
;
;
paint
lea xpos,a0
lea ypos,a1
moveq #0,d5
move.b flick,d5
moveq #num_sp-1,d0
brush move.b (a1)+,d7
addq.b #2,d5
and.b #7,d5
move.w (a0)+,d6
bmi.s dead
bsr plot
dead dbf d0,brush
rts
;
;
;
new_gun
lea gunpos,a0
move.w #256,d6
move.w d6,(a0)
move.b #240,d7
moveq #8,d5
bra plot
;
;
;
dimbo
lea num_bas,a0
move.b #2,(a0)
lea accel,a0
move.w #4,(a0)
moveq #0,d0
lea seq_num,a0
move.b d0,(a0)
lea flick,a0
move.b d0,(a0)
lea xdir,a0
move.b d0,(a0)
lea baddyx,a0
move.w #-1,(a0)
lea sd_flag,a0
move.b d0,(a0)
lea numflag,a0
move.b d0,(a0)
lea score,a0
move.l d0,(a0)
lea invnext,a0
move.b #30,(a0)
;
;
;
new_screen
lea inv_speed,a0
move.b #210,(a0)
lea xpos,a0
lea ypos,a1
moveq #0,d7
move.b invnext,d7
moveq #3,d0
frog moveq #7,d1
moveq #30,d6
froglet move.w d6,(a0)+
move.b d7,(a1)+
add.w #48,d6
dbf d1,froglet
add.b #40,d7
dbf d0,frog
move.b invnext,d7
add.b #20,d7
moveq #2,d0
newt moveq #6,d1
moveq #54,d6
newtlet move.w d6,(a0)+
move.b d7,(a1)+
add.w #48,d6
dbf d1,newtlet
add.b #40,d7
dbf d0,newt
rts
;
;
;
clear
move.l #scr_top,a2
move.w #8191,d1
resnlw clr.l (a2)+
dbf d1,resnlw
rts
;
;
;
plot
movem.l d2-d3/d5-d7/a0-a1,-(a7)
bsr.s calc_addr
neg.b d2
add.b #8,d2
lea sprite_defs,a0
lsl.w #4,d5
add.l d5,a0
moveq #7,d5
loop2 clr.w d6
clr.w d7
move.b (a0)+,d6
move.b (a0)+,d7
lsl.w d2,d6
lsl.w d2,d7
move.w d6,d3
lsl.l #8,d3
move.w d7,d3
move.b d6,d3
lsl.l #8,d3
move.b d7,d3
eor.l d3,(a1)
add.w #128,a1
dbf d5,loop2
movem.l (a7)+,d2-d3/d5-d7/a0-a1
rts
; This rountine calculates the address of a screen word pointed to
; by d6 (x coord) and d7 (y coord). The address is returned in a1
; d6 and d7 are scrambled d2 returns with the bit number (0 - 7).
calc_addr
and.l #$1ff,d6
and.l #$ff,d7
move.w d6,d2
lsr.w #3,d6
lsl.w #1,d6
add.l #scr_top,d6
lsl.w #7,d7
add.l d6,d7
move.l d7,a1
and.l #7,d2
rts
;
;
;
slither
lea sd_flag,a2
tst.b (a2)
bne.s mo_down
move.w accel,d4
lea xdir,a1
move.b (a1),d0
move.b d0,d3
lea xpos,a0
moveq #0,d5
moveq #num_sp-1,d1
shuffl move.w (a0),d2
bmi.s deader
tst.b d0
bmi.s mo_left
sub.w d4,d2
bra.s no_left
mo_left add.w d4,d2
no_left cmp.w #499,d2
bhi.s dir_ch
cmp.w #3,d2
bhi.s deader
dir_ch move.b d0,d3
not.b d3
moveq #-1,d5
deader move.w d2,(a0)+
dbf d1,shuffl
move.b d3,(a1)
move.b d5,(a2)
rts
mo_down lea ypos,a0
lea accel,a1
moveq #num_sp-1,d0
drop move.b (a0),d1
cmp.b #-1,d1
beq.s notendg
add.b #6,d1
move.b d1,(a0)
cmp.b #224,d1
bls.s notendg
add.w #4,a7
bra endgame
notendg add.w #1,a0
dbf d0,drop
clr.b (a2)
rts
;
;
;
keyrow
lea temp,a3
move.b d1,6(a3)
moveq #17,d0
trap #1
rts
;
;
;
move_gun
moveq #1,d1
bsr.s keyrow
btst #6,d1
beq.s notfir
bsr.s fire
notfir lea gunpos,a0
move.w (a0),d0
move.w d0,d2
btst #1,d1
beq.s gnl
cmp.w #3,d0
ble.s gnl
subq.w #2,d0
gnl btst #4,d1
beq.s gnr
cmp.w #499,d0
bhi.s gnr
addq.w #2,d0
gnr move.w d0,(a0)
moveq #8,d5
move.w d0,d6
move.b #240,d7
bsr plot
move.w d2,d6
bra plot
;
;
;
fire
lea bulposx,a0
tst.w (a0)
bpl.s no_fire
move.w gunpos,d6
move.w d6,(a0)
lea bulposy,a0
move.b #232,d7
move.b d7,(a0)
moveq #9,d5
bsr plot
lea zap,a3
moveq #17,d0
trap #1
no_fire rts
;
;
;
bul_hit_bar
move.b d7,d3
lea rndpos,a2
moveq #7,d1
scruby move.w (a2),a1
move.b d3,d7
move.w (a1),d5
addq.w #2,(a2)
and.w #7,d5
sub.b d5,d7
move.b #224,d5
sub.b d7,d5
bsr vline
addq.w #1,d6
dbf d1,scruby
lea crunch,a3
moveq #17,d0
trap #1
rts
;
;
;
bulmov
lea bulposx,a0
move.w (a0),d6
bmi.s no_bul
lea bulposy,a1
move.b (a1),d7
moveq #9,d5
bsr plot
subq.b #1,d7
cmp.b #9,d7
bhi.s stilbul
move.w #-1,(a0)
no_bul rts
stilbul move.b d7,(a1)
addq.w #3,d6
bsr id_col
beq no_hit
move.w #-1,(a0)
cmp.b #199,d7
bls.s notbhb
and.w #$ff00,d2
beq bul_hit_bar
bra endbomb
notbhb lea xpos,a0
lea ypos,a1
moveq #num_sp-1,d4
nextst move.b d7,d5
sub.b (a1)+,d5
cmp.b #10,d5
bls.s poss
addq.l #2,a0
bra.s g_next
poss move.w d6,d0
sub.w (a0)+,d0
bpl.s not_neg
neg.w d0
not_neg cmp.w #10,d0
bhi.s g_next
move.w -(a0),d6
move.b -(a1),d7
bsr blank_out
move.w #-1,(a0)
move.b #-1,(a1)
bsr explode
lea zam,a3
moveq #17,d0
trap #1
bsr inc_score
lea inv_speed,a0
cmp.b #2,(a0)
bne.s notnew
lea invnext,a0
addq.b #8,(a0)
bra new_screen
notnew subq.b #4,(a0)
rts
g_next dbf d4,nextst
cmp.b #25,d7
bhi.s no_bus
moveq #nemalt,d7
lea baddyx,a0
move.w (a0),d6
bsr saver
bsr endbad
bsr explode
moveq #39,d0
morepts bsr inc_score
dbf d0,morepts
no_bus rts
no_hit subq.w #3,d6
bra plot
;
;
;
id_col
movem.l d6-d7/a0-a1,-(a7)
bsr calc_addr
lea mask_tab,a0
lsl.b #1,d2
add.l d2,a0
move.w (a1),d2
and.w (a0),d2
movem.l (a7)+,d6-d7/a0-a1
rts
;
;
;
blank_out
movem.l d2/d6-d7/a1,-(a7)
bsr calc_addr
moveq #7,d2
wipe clr.l (a1)
add.w #128,a1
dbf d2,wipe
movem.l (a7)+,d2/d6-d7/a1
rts
;
;
;
un_paint
lea xpos,a0
lea ypos,a1
moveq #num_sp-1,d2
scruber move.b (a1)+,d7
move.w (a0)+,d6
bmi.s nninv
bsr.s blank_out
nninv dbf d2,scruber
rts
;
;
;
print_score
movem.l d6-d7/a0,-(a7)
move.w #score_pos,d6
moveq #0,d7
lea score,a0
bsr.s print_num
movem.l (a7)+,d6-d7/a0
rts
;
;
;
print_hiscore
moveq #score_poshi,d6
moveq #0,d7
lea hiscore,a0
;
;
;
print_num
movem.l d0-d1/d5,-(a7)
move.w d6,d5
moveq #5,d1
next_w bsr.s blank_out
sub.w #8,d6
dbf d1,next_w
move.w d5,d6
moveq #0,d5
moveq #5,d1
move.l (a0),d0
nexdig move.b d0,d5
lsr.l #4,d0
and.b #15,d5
add.b #num_base,d5
bsr plot
sub.w #8,d6
dbf d1,nexdig
movem.l (a7)+,d0-d1/d5
rts
;
;
;
inc_score
and.b #$e7,sr
lea score,a0
lea mess,a1
move.l #$100,(a1)+
addq.l #4,a0
moveq #3,d0
sub_dig abcd -(a1),-(a0)
dbf d0,sub_dig
bsr.s print_score
move.w 2(a0),d0
and.w #$fff,d0
bne.s odd
lea numflag,a0
addq.b #1,(a0)
cmp.b #3,(a0)
bne print_flags
clr.b (a0)
lea num_bas,a0
move.b (a0),d6
addq.b #1,(a0)
lsl.w #4,d6
addq.w #5,d6
move.b #248,d7
moveq #8,d5
bsr plot
bsr rub_flag
odd rts
;
;
;
bombs
move.w gunpos,d6
moveq #0,d3
move.w #5000,d2
lea xpos,a0
lea ypos,a1
moveq #num_sp-1,d0
thing cmp.w #-1,(a0)
beq.s grogy
move.w d6,d1
sub.w (a0),d1
bpl.s itspos
neg.w d1
itspos cmp.w d2,d1
bhi.s grogy
move.w d1,d2
move.w (a0),d4
move.b (a1),d3
grogy addq.l #1,a1
addq.l #2,a0
dbf d0,thing
add.b #8,d3
lea x_bomb,a0
move.w d4,(a0)
lea y_bomb,a0
move.b d3,(a0)
move.b d3,d7
move.w d4,d6
moveq #9,d5
bra plot
;
;
;
drop_bomb
lea y_bomb,a1
move.b (a1),d7
move.w x_bomb,d6
moveq #9,d5
bsr plot
addq.b #1,d7
cmp.b #240,d7
beq.s fred
move.b d7,(a1)
addq.b #7,d7
addq.w #4,d6
bsr id_col
beq.s ex_drop
cmp.b #233,d7
bhi base_dead
and.w #$ff00,d2
bne.s fred
cmp.b #199,d7
bhi.s hit_barrier
fred bra bombs
joe bsr rev_bul
lea bulposx,a0
move.w #-1,(a0)
bra.s fred
ex_drop subq.b #7,d7
subq.w #4,d6
bra plot
;
;
;
hit_barrier
subq.w #4,d6
move.b d7,d3
move.b #200,d7
lea rndpos,a2
moveq #7,d1
scrub move.w (a2),a1
move.w (a1),d5
addq.w #2,(a2)
and.w #7,d5
add.b d3,d5
sub.b #200,d5
bsr.s vline
addq.w #1,d6
dbf d1,scrub
lea crunch,a3
moveq #17,d0
trap #1
bra bombs
;
; This routine draws a line vertically down of length (d5)
; starting at (d6,d7) .
vline
movem.l d6-d7,-(a7)
bsr calc_addr
lea mask_tab,a0
lsl.b #1,d2
add.l d2,a0
move.w (a0),d2
not.w d2
and.w #255,d5
zag and.w d2,(a1)
add.w #128,a1
dbf d5,zag
movem.l (a7)+,d6-d7
rts
;
;
;
base_dead
lea base_bang,a3
moveq #17,d0
trap #1
addq.l #4,a7
move.b #240,d7
waitexp move.b seq_num,d0
beq.s okexp
bsr draws_bang
bra waitexp
okexp bsr explode
bsr rev_bul
grows bsr draws_bang
move.w #3333,d0
phut dbf d0,phut
move.b seq_num,d0
bne.s grows
bsr savebarriers
lea baddyx,a0
move.w #-1,(a0)
lea num_bas,a0
subq.b #1,(a0)
bmi.s endgame
bsr waitkey
bra restart
endgame lea hiscore,a0
move.l score,d0
cmp.l (a0),d0
bls.s not_hi
move.l d0,(a0)
not_hi bsr load_message
none_p moveq #7,d1
bsr keyrow
btst #6,d1
bne.s reset
moveq #5,d1
bsr keyrow
btst #6,d1
beq.s none_p
bra warm
reset trap #0
move $0,a7
pea $4
rts
;
;
;
explode
lea order,a0
lea seq_reg,a1
move.l a0,(a1)
lea wumpx,a0
move.w d6,(a0)
lea wumpy,a0
move.b d7,(a0)
lea seq_num,a0
move.b #7,(a0)
rts
;
;
;
draws_bang
lea seq_reg,a3
move.l (a3),a2
lea wumpx,a1
move.w (a1),d6
lea wumpy,a1
move.b (a1),d7
lea seq_num,a1
subq.b #1,(a1)
cmp.b #3,(a1)
bls.s set_4
bsr blank_out
move.b (a2)+,d5
bsr plot
move.l a2,(a3)
rts
set_4 subq.w #4,d6
subq.b #4,d7
move.w d6,d0
move.b d7,d1
bsr blank_out
add.w #8,d6
bsr blank_out
add.b #8,d7
bsr blank_out
move.w d0,d6
bsr blank_out
tst.b (a1)
beq.s ex_bang
move.b d1,d7
move.b (a2)+,d5
bsr plot
move.b (a2)+,d5
add.w #8,d6
bsr plot
add.b #8,d7
move.b (a2)+,d5
bsr plot
move.w d0,d6
move.b (a2)+,d5
bsr plot
move.l a2,(a3)
ex_bang rts
;
;
;
print_flags
bsr.s rub_flag
move.w #240,d6
moveq #37,d5
moveq #0,d4
move.b numflag,d4
bra.s flaged
nexflag bsr plot
add.w #12,d6
flaged dbf d4,nexflag
rts
;
;
;
rub_flag
moveq #0,d7
move.w #240,d6
bsr blank_out
add.w #16,d6
bra blank_out
;
;
;
print_bases
clr.w d4
move.b num_bas,d4
subq.b #1,d4
bmi.s ex_prb
moveq #8,d5
moveq #bas_pos,d6
move.b #248,d7
pr_loop bsr plot
add.w #16,d6
dbf d4,pr_loop
ex_prb rts
;
;
;
baddybus
lea baddyx,a0
move.w (a0),d6
moveq #nemalt,d7
bsr.s saver
subq.w #5,d6
cmp.w #495,d6
bhi.s endbad
move.w d6,(a0)
saver moveq #35,d5
bsr plot
add.w #8,d6
moveq #36,d5
bra plot
endbad move.w #-1,(a0)
lea badwait,a0
lea rndpos,a1
move.w (a1),a2
move.b (a2),(a0)
and.b #63,(a0)
or.b #16,(a0)
addq.b #1,(a0)
addq.w #2,(a1)
rts
;
;
;
setbarriers
moveq #64,d6
move.b #200,d7
moveq #2,d3
barloop bsr.s barrier
add.w #176,d6
dbf d3,barloop
rts
;
;
;
barrier
lea bar_tab,a0
move.w d6,d2
moveq #2,d0
rowloop moveq #3,d1
colloop move.b (a0)+,d5
bsr plot
add.w #8,d6
dbf d1,colloop
move.w d2,d6
add.b #8,d7
dbf d0,rowloop
sub.b #24,d7
rts
;
;
;
savebarriers
lea base_buf, a0
move.l #$26410,a3
moveq #2,d7
save1 move.l a3,a1
moveq #23,d6
save2 move.l (a1)+,(a0)+
move.l (a1),(a0)+
add.w #$7c,a1
dbf d6,save2
add.w #$2c,a3
dbf d7,save1
rts
;
;
;
loadbarriers
lea base_buf, a0
move.l #$26410,a3
moveq #2,d7
load1 move.l a3,a1
moveq #23,d6
load2 move.l (a0)+,(a1)+
move.l (a0)+,(a1)
add.w #$7c,a1
dbf d6,load2
add.w #$2c,a3
dbf d7,load1
rts
;
;
;
rev_bul
move.w bulposx,d6
bmi.s no_rev
move.b bulposy,d7
moveq #9,d5
bra plot
no_rev rts
;
;
;
save_message
lea con_block,a1
move.w ut_con,a2
jsr (a2)
lea message,a1
move.w ut_mtext,a2
jsr (a2)
moveq #2,d0
trap #2
move.l #$2332e,a0
lea message_buff,a1
moveq #19,d0
mesave1 moveq #17,d1
mesave2 move.w (a0)+,(a1)+
dbf d1,mesave2
add.w #92,a0
dbf d0,mesave1
rts
;
;
;
load_message
move.l #$2332e,a1
lea message_buff,a0
moveq #19,d0
meload1 moveq #17,d1
meload2 move.w (a0)+,(a1)+
dbf d1,meload2
add.w #92,a1
dbf d0,meload1
rts
;
;
;
endbomb
move.b y_bomb,d7
move.w x_bomb,d6
moveq #9,d5
bsr plot
bra bombs
;
;
;
waitkey
movem.l d0-d7/a0-a6,-(a7)
no_spc moveq #1,d1
bsr keyrow
btst #3,d1
bne.s basic
btst #6,d1
beq.s no_spc
btst #3,d1
bne.s endwait
no_spc2 moveq #1,d1
bsr keyrow
btst #6,d1
bne.s no_spc2
endwait movem.l (a7)+,d0-d7/a0-a6
rts
basic add.w #68,a7
rts
;
;
;
sprite_defs
; Sprite # 0 invader 1a
dc.w $1918,$3d3c,$5b7e,$ffff,$d66a,$ea56,$a424,$2424
; Sprite # 1 invader 1b
dc.w $9818,$bc3c,$da7e,$ffff,$576a,$6b56,$2524,$4242
; Sprite # 2 invader 2a
dc.w $9190,$5258,$1438,$1030,$77ff,$1018,$0008,$0008
; Sprite # 3 invader 2b
dc.w $8188,$5258,$341c,$140c,$00fe,$341c,$5212,$9111
; Sprite # 4 invader 3a
dc.w $9818,$bc3c,$da7e,$ffff,$576a,$6b56,$2524,$4242
; Sprite # 5 invader 3b
dc.w $1918,$3d3c,$5b7e,$ffff,$d66a,$ea56,$a424,$2424
; Sprite # 6 invader 4a
dc.w $8188,$5258,$341c,$140c,$00fe,$341c,$5212,$9111
; Sprite # 7 invader 4b
dc.w $9190,$5258,$1438,$1030,$77ff,$1018,$0008,$0008
; Sprite # 8 base
dc.w $1818,$3c24,$7e5a,$e7bd,$db7e,$bdff,$7eff,$ffff
; Sprite # 9 bomb
dc.w $0808,$1010,$0808,$1010,$0808,$1010,$0808,$1010
; Sprite # 10
dc.w $0000,$0000,$0000,$1010,$0808,$0000,$0000,$0000
; Sprite # 11
dc.w $0000,$0000,$3030,$0404,$0000,$4c4c,$0000,$0000
; Sprite # 12
dc.w $0000,$2222,$0808,$0808,$4242,$2424,$2222,$0000
; Sprite # 13
dc.w $0000,$0000,$0000,$1414,$0000,$0a0a,$0000,$0000
; Sprite # 14
dc.w $0000,$0000,$0000,$4848,$2020,$0000,$1010,$0000
; Sprite # 15
dc.w $1414,$0000,$0101,$1010,$0000,$0000,$0000,$0000
; Sprite # 16 Number '0'
dc.w 0,15420,26214,28270,30326,26214,15420,0
; Sprite # 17 Number '1'
dc.w 0,6168,14392,6168,6168,6168,32382,0
; Sprite # 18 Number '2'
dc.w 0,15420,26214,3084,6168,12336,32382,0
; Sprite # 19 Number '3'
dc.w 0,32382,3084,6168,3084,26214,15420,0
; Sprite # 20 Number '4'
dc.w 0,3084,7196,15420,27756,32382,3084,0
; Sprite # 21 Number '5'
dc.w 0,32382,24672,31868,1542,26214,15420,0
; Sprite # 22 Number '6'
dc.w 0,15420,24672,31868,26214,26214,15420,0
; Sprite # 23 Number '7'
dc.w 0,32382,1542,3084,6168,12336,12336,0
; Sprite # 24 Number '8'
dc.w 0,15420,26214,15420,26214,26214,15420,0
; Sprite # 25 Number '9'
dc.w 0,15420,26214,15934,1542,3084,14392,0
; Sprite # 26
dc.w $0808,$0000,$2020,$0000,$8888,$0000,$0000,$0000
; Sprite # 27
dc.w $0000,$0000,$2121,$0808,$0000,$2020,$0000,$0000
; Sprite # 28
dc.w $0000,$0000,$2020,$0404,$0000,$0000,$0404,$0000
; Sprite # 29
dc.w $2020,$0000,$0000,$2020,$0808,$0202,$0000,$0000
; Sprite # 30
dc.w $0000,$0000,$0404,$0808,$0000,$2020,$0000,$0000
; Sprite # 31
dc.w $0000,$4040,$0101,$0000,$0000,$0000,$0000,$0000
; Sprite # 32
dc.w $0000,$0202,$0404,$0000,$0000,$0000,$0000,$0000
; Sprite # 33
dc.w $0000,$4040,$0000,$0000,$0000,$0000,$4040,$0000
; Sprite # 34
dc.w $0000,$0808,$0000,$0000,$0202,$4040,$0000,$0000
; Sprite # 35 Nemesis A
dc.w $4000,$2700,$1f00,$ff00,$1f00,$3f00,$7f00,$1000
; Sprite # 36 Nemesis B
dc.w $0200,$e400,$f800,$ff00,$f800,$fc00,$fe00,$0800
; Sprite # 37
dc.w $0010,$0038,$007c,$00fe,$1000,$1000,$1000,$1000
; Sprite # 38
dc.w $0001,$0003,$0007,$000f,$001f,$003f,$007f,$00ff
; Sprite # 39
dc.w $00ff,$00ff,$00ff,$00ff,$00ff,$00ff,$00ff,$00ff
; Sprite # 40
dc.w $0080,$00c0,$00e0,$00f0,$00f8,$00fc,$00fe,$00ff
; Sprite # 41
dc.w $00ff,$00ff,$00ff,$00ff,$0000,$0000,$0000,$0000
;
; positions of invaders (-1 = Dead)
;
align
ypos ds.b num_sp
xpos ds.w num_sp
align
accel dc.w 0
gunpos dc.w 0
in_wait dc.w 0
xdir dc.w 1
sd_flag dc.w 0
temp dc.l $09010000,$00000002
flick dc.w 0
bulposx dc.w 0
bulposy dc.b 0
y_bomb dc.b 0
x_bomb dc.w 0
inv_speed
dc.b 0
order dc.b 10
dc.b 11
dc.b 12
dc.b 13,14,26,15
dc.b 27,28,30,29
dc.b 31,32,34,33
align
seq_reg dc.l 0
wumpx dc.w 0
wumpy dc.b 0
seq_num dc.b 0
num_bas dc.b 0
invnext dc.b 0
badwait dc.b 1
numflag dc.b 0
align
mask_tab
dc.w $8080,$4040,$2020,$1010
dc.w $0808,$0404,$0202,$0101
mess dc.l 0
hiscore dc.l 0
score dc.l 0
baddyx dc.w 0
rndpos dc.w 0
base_buf
ds.b 576
message_buff
ds.w 360
con_block
dc.w $0302,$0007,144,20,184,102
message dc.w 20
dc.b " PLAY AGAIN (Y/N)"
align
ds.w 360
zap
dc.b $0a,8
dc.l $0000aaaa
dc.b 25,50
dc.b 2,0,112,23
dc.b 18,18,1
align
zam
dc.b $0a,8
dc.l $0000aaaa
dc.b 20,80
dc.b 32,3,184,11
dc.b 16,0,1
align
crunch
dc.b $0a,8
dc.l $0000aaaa
dc.b 250,255
dc.b 1,0,184,11
dc.b $23,$ff,1
align
base_bang
dc.b $0a,8
dc.l $0000aaaa
dc.b 50,55
dc.b 10,0,32,78
dc.b $a1,$ff,1
nexburp dc.b 0
zeke dc.b 3
bar_tab dc.b 38,39,39,40,39,39,39,39,39,41,41,39
|
; A097135: a(0) = 1; for n>0, a(n) = 3*Fibonacci(n).
; 1,3,3,6,9,15,24,39,63,102,165,267,432,699,1131,1830,2961,4791,7752,12543,20295,32838,53133,85971,139104,225075,364179,589254,953433,1542687,2496120,4038807,6534927,10573734,17108661,27682395,44791056,72473451,117264507
mov $1,1
lpb $0,1
sub $0,1
mov $1,$3
add $1,3
mov $3,$2
add $2,$1
lpe
|
DEFAULT REL
BITS 64
;-------------------------------------------------------------------------------
; ______ ______ _
; (_____ \ | ___ \ | |
; _____) )___ _ _ _ ____ ___ | | _ | | ___ ____ | | _ ____ _ _
; | ____// _ \ | | | | / _ ) / __)| || || | / _ \ | _ \ | | / )/ _ )| | | |
; | | | |_| || | | |( (/ / | | | || || || |_| || | | || |< (( (/ / | |_| |
; |_| \___/ \____| \____)|_| |_||_||_| \___/ |_| |_||_| \_)\____) \__ |
; (____/
; Copyright (C) 2021-2022 Ivan Dimkovic. All rights reserved.
;
; All trademarks, logos and brand names are the property of their respective
; owners. All company, product and service names used are for identification
; purposes only. Use of these names, trademarks and brands does not imply
; endorsement.
;
; SPDX-License-Identifier: Apache-2.0
; Full text of the license is available in project root directory (LICENSE)
;
; WARNING: This code is a proof of concept for educative purposes. It can
; modify internal computer configuration parameters and cause malfunctions or
; even permanent damage. It has been tested on a limited range of target CPUs
; and has minimal built-in failsafe mechanisms, thus making it unsuitable for
; recommended use by users not skilled in the art. Use it at your own risk.
;
;-------------------------------------------------------------------------------
; "ComboHell AVX2" - CPU Stressor kernel for undervolt or overclock testing
;
; Copyright (C) 2021 Ivan Dimkovic.
;
; WARNING: THIS IS A PROOF OF CONCEPT CODE, PROVIDED FOR EDUCATION / RESEARCH
; PURPOSES. NO TESTS OR VALIDATIONS HAVE BEEN CARRIED OUT IN THE PRODUCTION
; ENVIRONMENT. USAGE COULD DAMAGE HARDWARE OR VOID WARRANTIES!!!
;-------------------------------------------------------------------------------
section .text
align 16
;-------------------------------------------------------------------------------
; combohell_avx2_kernel - theory of operation:
;
; Perform a tight loop of instructions designed to utilize as much of
; available EUs as possible (ALUs, AGUs, etc.) with minimal dependencies
; so that we reach very high efficiency % (target >99.5%)
;
; On top of that, we want the routine to serve as a validator of correct CPU
; operation - so we will need to use some data transformation that is possible
; to attest for correctness.
;-------------------------------------------------------------------------------
global combohell_avx2_kernel
combohell_avx2_kernel:
push rsi
;
; Need to enable AVX on this CPU core, since we run on the bare metal
; and UEFI does not care about AVX. We will restore original state
; after we are done.
;push rcx
;push rax
;xor rcx, rcx
;xgetbv
;mov [ComboHell_SavedRdx], rdx
;mov [ComboHell_SavedRax], rax
;or rax, 0x7 ; Enable AVX
;xsetbv
;pop rax;
;pop rcx;
;
; Initialize ComboHell_AVX2
xor rdx, rdx
mov r10, [ComboHell_StopRequestPtr]
mov r11, [ComboHell_ErrorCounterPtr]
;
; Load Init Vectors
; rdi points to float[72] array
vmovdqa ymm0, [rcx]
vmovdqa ymm1, [rcx + 32]
vmovdqa ymm2, [rcx + 64]
vmovdqa ymm3, [rcx + 96]
vmovdqa ymm4, [rcx + 128]
vmovdqa ymm5, [rcx + 160]
vmovdqa ymm6, [rcx + 192]
vmovdqa ymm7, [rcx + 224]
vmovaps ymm8, [rcx + 256]
vmovaps ymm9, [rcx + 288]
vmovaps ymm10, [rcx + 320]
;
; Will be used to validate ymm0-5
vmovdqa ymm11, ymm0
vmovdqa ymm12, ymm1
vmovdqa ymm13, ymm2
vmovdqa ymm14, ymm3
;
; Stressor Loop
;
; We will run this sequence >very< tight
; 100M+ times, before checking for errors
mov esi, nloops
combohell:
;
; For this job, this is a completely useless instruction
; which we put inside to also keep AGUs busy while we CRUNCH...
vmovaps ymm15, [rcx]
;
; Work packages suitable for all ALUs
vpxor ymm0, ymm4, ymm0
vpxor ymm1, ymm5, ymm1
vpxor ymm2, ymm6, ymm2
vpxor ymm3, ymm7, ymm3
;
; If this is running on Skylake / Coffee Lake / Whatever Lake
; here is little something for more capable EUs...
vrcpps ymm15, ymm15
;
; Let's burn common ALUs a bit longer since the pure
; FP tasks will take longer and we do not want inefficient pipe
;
vpxor ymm11, ymm4, ymm11
vpxor ymm12, ymm5, ymm12
vpxor ymm13, ymm6, ymm13
vpxor ymm14, ymm7, ymm14
;
; Another heavy job for capable EUs
vdpps ymm8, ymm9, ymm10, 0xFF
sub esi, 1
jnz combohell
;
; Outer-loop
add rdx, 1
cmp rdx, [ComboHell_MaxRuns]
jg done
errcheck:
;
; Compare:
; (ymm0==ymm11) && (ymm1==ymm12) &&
; (ymm2==ymm13) && (ymm3==ymm14)
vpcmpeqd ymm11, ymm0, ymm11
vpcmpeqd ymm12, ymm1, ymm12
vpcmpeqd ymm13, ymm2, ymm13
vpcmpeqd ymm14, ymm3, ymm14
vpand ymm11, ymm11, ymm12
vpand ymm11, ymm11, ymm13
vpand ymm11, ymm11, ymm14
vpmovmskb r8d, ymm11
cmp r8d, 0xFFFFFFFF
jne cmperr
;
; Restore destroyed values
vmovdqa ymm11, ymm0
vmovdqa ymm12, ymm1
vmovdqa ymm13, ymm2
vmovdqa ymm14, ymm3
;
; Check for stop request
; and continue if no stop is requested
mov r9d, [r10]
test r9d, r9d
jz combohell
;
; User requested to stop testing
xor eax, eax
done:
;
; Restore original value of extended CR
;push rcx
;push rdx
;push rax
;xor rcx, rcx
;mov rdx, [ComboHell_SavedRdx]
;mov rax, [ComboHell_SavedRax]
;xsetbv
;pop rax;
;pop rdx;
;pop rcx;
;
; Bye...
pop rsi
ret
cmperr:
;
; We found an error, increase the error counter
mov r8, 1
lock xadd qword [r11], r8
;
; Shall we terminate immediately?
mov r8, ComboHell_TerminateOnError
test r8, r8
jnz errcleanup
;
; Check for stop request
; and continue if no stop is requested
mov r9d, [r10]
test r9d, r9d
jz combohell
seterr:
;
; Terminate with error code
mov eax, 0xBADDC0DE ; nonzero = errors detected
jmp done
errcleanup:
;
; This code is only reached if "stop on error"
; condition exists. In this case, we will do a small trick:
; we will set tue stop flag so all other threads exit.
; this is needed for enviroments with spartan MP support (UEFI)
mov qword [r10], 1
jmp seterr
section .data
align 16
global ComboHell_StopRequestPtr
ComboHell_StopRequestPtr: dq 0 ; Stop Request (external)
global ComboHell_ErrorCounterPtr
ComboHell_ErrorCounterPtr: dq 0 ; Number of errors detected
global ComboHell_MaxRuns
ComboHell_MaxRuns: dq 0 ; Max. number of runs
global ComboHell_TerminateOnError
ComboHell_TerminateOnError: dq 0 ; Terminate on Error?
nloops: equ 0x10000000 ; Number of inner ComboHell runs
ComboHell_SavedRdx: dq 0 ; Used for saving extended CR
ComboHell_SavedRax: dq 0 ; Used for saving extended CR |
if not defined @FADDP
; continue from @FADD (if it was included)
; Add two floating point numbers with the same sign
; In: HL, DE numbers to add, no restrictions
; Out: HL = HL + DE, if ( carry_flow_warning && overflow ) set carry
; Pollutes: AF, B, DE
; -------------- HL + DE ---------------
; HL = (+HL) + (+DE)
; HL = (-HL) + (-DE)
@FADDP:
if not defined FADDP
; *****************************************
FADDP ; *
; *****************************************
endif
LD A, H ; 1:4
SUB D ; 1:4
JR nc, FADDP_HL_GR ; 2:7/12
EX DE, HL ; 1:4
NEG ; 2:8
FADDP_HL_GR:
AND EXP_MASK ; 2:7
JR z, FADDP_EQ_EXP ; 2:12/7 neresime zaokrouhlovani
CP 2 + MANT_BITS ; 2:7 pri posunu o NEUKLADANY_BIT+BITS_MANTIS uz mantisy nemaji prekryt, ale jeste se muze zaokrouhlovat
RET nc ; 1:11/5 HL + DE = HL, RET with reset carry
; Out: A = --( E | 1 0000 0000 ) >> A
LD B, A ; 1:4
LD A, E ; 1:4
DEC A ; 1:4
CP $FF ; 2:7
db $1E ; 2:7 LD E, $B7
FADDP_LOOP:
OR A ; 1:4
RRA ; 1:4
DJNZ FADDP_LOOP ; 2:13/8
JR c, FADDP1 ; 2:12/7
ADD A, L ; 1:4 soucet mantis
JR nc, FADDP0_SAME_EXP ; 2:12/7
FADDP_EXP_PLUS: ; A = 10 mmmm mmmr, r = rounding bit
ADC A, B ; 1:4 rounding
RRA ; 1:4 A = 01 cmmm mmmm
LD L, A ; 1:4
LD A, H ; 1:4
INC H ; 1:4
XOR H ; 1:4 RET with reset carry
RET p ; 1:11/5
JR FADDP_OVERFLOW ; 2:12
FADDP0_SAME_EXP: ; A = 01 mmmm mmmm 0
LD L, A ; 1:4
RET ; 1:10
FADDP1:
ADD A, L ; 1:4 soucet mantis
JR c, FADDP_EXP_PLUS ; 2:12/7
FADDP1_SAME_EXP: ; A = 01 mmmm mmmm 1, reset carry
if 1
LD L, A ; 1:4
INC L ; 1:4
RET nz ; 1:11/5
LD A, H ; 1:4
INC H ; 1:4
XOR H ; 1:4 RET with reset carry
RET p ; 1:11/5
else
LD L, A ; 1:4
LD A, H ; 1:4
INC HL ; 1:6
XOR H ; 1:4 RET with reset carry
RET p ; 1:11/5
endif
JR FADDP_OVERFLOW ; 2:12
FADDP_EQ_EXP: ; HL exp = DE exp
LD A, L ; 1:4 1 mmmm mmmm
ADD A, E ; 1:4 +1 mmmm mmmm
; 1m mmmm mmmm
RRA ; 1:4 sign in && shift
LD L, A ; 1:4
LD A, H ; 1:4
INC H ; 1:4
XOR H ; 1:4 RET with reset carry
RET p ; 1:11/5
; fall
; In: H = s111 1111 + 1
; Out: HL = +- MAX
FADDP_OVERFLOW:
DEC H ; 1:4
LD L, $FF ; 2:7
if color_flow_warning
CALL OVER_COL_WARNING ; 3:17
endif
if carry_flow_warning
SCF ; 1:4 carry = error
endif
RET ; 1:10
include "color_flow_warning.asm"
endif
|
_sh: file format elf32-i386
Disassembly of section .text:
00000000 <main>:
return 0;
}
int
main(void)
{
0: 8d 4c 24 04 lea 0x4(%esp),%ecx
4: 83 e4 f0 and $0xfffffff0,%esp
7: ff 71 fc pushl -0x4(%ecx)
a: 55 push %ebp
b: 89 e5 mov %esp,%ebp
d: 51 push %ecx
e: 83 ec 04 sub $0x4,%esp
static char buf[100];
int fd;
// Ensure that three file descriptors are open.
while((fd = open("console", O_RDWR)) >= 0){
11: eb 0a jmp 1d <main+0x1d>
13: 90 nop
14: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
if(fd >= 3){
18: 83 f8 02 cmp $0x2,%eax
1b: 7f 76 jg 93 <main+0x93>
while((fd = open("console", O_RDWR)) >= 0){
1d: 83 ec 08 sub $0x8,%esp
20: 6a 02 push $0x2
22: 68 79 12 00 00 push $0x1279
27: e8 26 0d 00 00 call d52 <open>
2c: 83 c4 10 add $0x10,%esp
2f: 85 c0 test %eax,%eax
31: 79 e5 jns 18 <main+0x18>
33: eb 1f jmp 54 <main+0x54>
35: 8d 76 00 lea 0x0(%esi),%esi
}
}
// Read and run input commands.
while(getcmd(buf, sizeof(buf)) >= 0){
if(buf[0] == 'c' && buf[1] == 'd' && buf[2] == ' '){
38: 80 3d a2 18 00 00 20 cmpb $0x20,0x18a2
3f: 74 7a je bb <main+0xbb>
int
fork1(void)
{
int pid;
pid = fork();
41: e8 c4 0c 00 00 call d0a <fork>
if(pid == -1)
46: 83 f8 ff cmp $0xffffffff,%eax
49: 74 3b je 86 <main+0x86>
if(fork1() == 0)
4b: 85 c0 test %eax,%eax
4d: 74 57 je a6 <main+0xa6>
wait();
4f: e8 c6 0c 00 00 call d1a <wait>
while(getcmd(buf, sizeof(buf)) >= 0){
54: 83 ec 08 sub $0x8,%esp
57: 6a 64 push $0x64
59: 68 a0 18 00 00 push $0x18a0
5e: e8 9d 00 00 00 call 100 <getcmd>
63: 83 c4 10 add $0x10,%esp
66: 85 c0 test %eax,%eax
68: 78 37 js a1 <main+0xa1>
if(buf[0] == 'c' && buf[1] == 'd' && buf[2] == ' '){
6a: 80 3d a0 18 00 00 63 cmpb $0x63,0x18a0
71: 75 ce jne 41 <main+0x41>
73: 80 3d a1 18 00 00 64 cmpb $0x64,0x18a1
7a: 74 bc je 38 <main+0x38>
pid = fork();
7c: e8 89 0c 00 00 call d0a <fork>
if(pid == -1)
81: 83 f8 ff cmp $0xffffffff,%eax
84: 75 c5 jne 4b <main+0x4b>
panic("fork");
86: 83 ec 0c sub $0xc,%esp
89: 68 02 12 00 00 push $0x1202
8e: e8 bd 00 00 00 call 150 <panic>
close(fd);
93: 83 ec 0c sub $0xc,%esp
96: 50 push %eax
97: e8 9e 0c 00 00 call d3a <close>
break;
9c: 83 c4 10 add $0x10,%esp
9f: eb b3 jmp 54 <main+0x54>
exit();
a1: e8 6c 0c 00 00 call d12 <exit>
runcmd(parsecmd(buf));
a6: 83 ec 0c sub $0xc,%esp
a9: 68 a0 18 00 00 push $0x18a0
ae: e8 9d 09 00 00 call a50 <parsecmd>
b3: 89 04 24 mov %eax,(%esp)
b6: e8 b5 00 00 00 call 170 <runcmd>
buf[strlen(buf)-1] = 0; // chop \n
bb: 83 ec 0c sub $0xc,%esp
be: 68 a0 18 00 00 push $0x18a0
c3: e8 78 0a 00 00 call b40 <strlen>
if(chdir(buf+3) < 0)
c8: c7 04 24 a3 18 00 00 movl $0x18a3,(%esp)
buf[strlen(buf)-1] = 0; // chop \n
cf: c6 80 9f 18 00 00 00 movb $0x0,0x189f(%eax)
if(chdir(buf+3) < 0)
d6: e8 a7 0c 00 00 call d82 <chdir>
db: 83 c4 10 add $0x10,%esp
de: 85 c0 test %eax,%eax
e0: 0f 89 6e ff ff ff jns 54 <main+0x54>
printf(2, "cannot cd %s\n", buf+3);
e6: 50 push %eax
e7: 68 a3 18 00 00 push $0x18a3
ec: 68 81 12 00 00 push $0x1281
f1: 6a 02 push $0x2
f3: e8 88 0d 00 00 call e80 <printf>
f8: 83 c4 10 add $0x10,%esp
fb: e9 54 ff ff ff jmp 54 <main+0x54>
00000100 <getcmd>:
{
100: 55 push %ebp
101: 89 e5 mov %esp,%ebp
103: 56 push %esi
104: 53 push %ebx
105: 8b 75 0c mov 0xc(%ebp),%esi
108: 8b 5d 08 mov 0x8(%ebp),%ebx
printf(2, "$ ");
10b: 83 ec 08 sub $0x8,%esp
10e: 68 d8 11 00 00 push $0x11d8
113: 6a 02 push $0x2
115: e8 66 0d 00 00 call e80 <printf>
memset(buf, 0, nbuf);
11a: 83 c4 0c add $0xc,%esp
11d: 56 push %esi
11e: 6a 00 push $0x0
120: 53 push %ebx
121: e8 4a 0a 00 00 call b70 <memset>
gets(buf, nbuf);
126: 58 pop %eax
127: 5a pop %edx
128: 56 push %esi
129: 53 push %ebx
12a: e8 a1 0a 00 00 call bd0 <gets>
if(buf[0] == 0) // EOF
12f: 83 c4 10 add $0x10,%esp
132: 31 c0 xor %eax,%eax
134: 80 3b 00 cmpb $0x0,(%ebx)
137: 0f 94 c0 sete %al
}
13a: 8d 65 f8 lea -0x8(%ebp),%esp
if(buf[0] == 0) // EOF
13d: f7 d8 neg %eax
}
13f: 5b pop %ebx
140: 5e pop %esi
141: 5d pop %ebp
142: c3 ret
143: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
149: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
00000150 <panic>:
{
150: 55 push %ebp
151: 89 e5 mov %esp,%ebp
153: 83 ec 0c sub $0xc,%esp
printf(2, "%s\n", s);
156: ff 75 08 pushl 0x8(%ebp)
159: 68 75 12 00 00 push $0x1275
15e: 6a 02 push $0x2
160: e8 1b 0d 00 00 call e80 <printf>
exit();
165: e8 a8 0b 00 00 call d12 <exit>
16a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
00000170 <runcmd>:
{
170: 55 push %ebp
171: 89 e5 mov %esp,%ebp
173: 53 push %ebx
174: 83 ec 14 sub $0x14,%esp
177: 8b 5d 08 mov 0x8(%ebp),%ebx
if(cmd == 0)
17a: 85 db test %ebx,%ebx
17c: 74 3a je 1b8 <runcmd+0x48>
switch(cmd->type){
17e: 83 3b 05 cmpl $0x5,(%ebx)
181: 0f 87 06 01 00 00 ja 28d <runcmd+0x11d>
187: 8b 03 mov (%ebx),%eax
189: ff 24 85 90 12 00 00 jmp *0x1290(,%eax,4)
if(ecmd->argv[0] == 0)
190: 8b 43 04 mov 0x4(%ebx),%eax
193: 85 c0 test %eax,%eax
195: 74 21 je 1b8 <runcmd+0x48>
exec(ecmd->argv[0], ecmd->argv);
197: 52 push %edx
198: 52 push %edx
199: 8d 53 04 lea 0x4(%ebx),%edx
19c: 52 push %edx
19d: 50 push %eax
19e: e8 a7 0b 00 00 call d4a <exec>
printf(2, "exec %s failed\n", ecmd->argv[0]);
1a3: 83 c4 0c add $0xc,%esp
1a6: ff 73 04 pushl 0x4(%ebx)
1a9: 68 e2 11 00 00 push $0x11e2
1ae: 6a 02 push $0x2
1b0: e8 cb 0c 00 00 call e80 <printf>
break;
1b5: 83 c4 10 add $0x10,%esp
exit();
1b8: e8 55 0b 00 00 call d12 <exit>
pid = fork();
1bd: e8 48 0b 00 00 call d0a <fork>
if(pid == -1)
1c2: 83 f8 ff cmp $0xffffffff,%eax
1c5: 0f 84 cf 00 00 00 je 29a <runcmd+0x12a>
if(fork1() == 0)
1cb: 85 c0 test %eax,%eax
1cd: 75 e9 jne 1b8 <runcmd+0x48>
runcmd(bcmd->cmd);
1cf: 83 ec 0c sub $0xc,%esp
1d2: ff 73 04 pushl 0x4(%ebx)
1d5: e8 96 ff ff ff call 170 <runcmd>
close(rcmd->fd);
1da: 83 ec 0c sub $0xc,%esp
1dd: ff 73 14 pushl 0x14(%ebx)
1e0: e8 55 0b 00 00 call d3a <close>
if(open(rcmd->file, rcmd->mode) < 0){
1e5: 59 pop %ecx
1e6: 58 pop %eax
1e7: ff 73 10 pushl 0x10(%ebx)
1ea: ff 73 08 pushl 0x8(%ebx)
1ed: e8 60 0b 00 00 call d52 <open>
1f2: 83 c4 10 add $0x10,%esp
1f5: 85 c0 test %eax,%eax
1f7: 79 d6 jns 1cf <runcmd+0x5f>
printf(2, "open %s failed\n", rcmd->file);
1f9: 52 push %edx
1fa: ff 73 08 pushl 0x8(%ebx)
1fd: 68 f2 11 00 00 push $0x11f2
202: 6a 02 push $0x2
204: e8 77 0c 00 00 call e80 <printf>
exit();
209: e8 04 0b 00 00 call d12 <exit>
if(pipe(p) < 0)
20e: 8d 45 f0 lea -0x10(%ebp),%eax
211: 83 ec 0c sub $0xc,%esp
214: 50 push %eax
215: e8 08 0b 00 00 call d22 <pipe>
21a: 83 c4 10 add $0x10,%esp
21d: 85 c0 test %eax,%eax
21f: 0f 88 b0 00 00 00 js 2d5 <runcmd+0x165>
pid = fork();
225: e8 e0 0a 00 00 call d0a <fork>
if(pid == -1)
22a: 83 f8 ff cmp $0xffffffff,%eax
22d: 74 6b je 29a <runcmd+0x12a>
if(fork1() == 0){
22f: 85 c0 test %eax,%eax
231: 0f 84 ab 00 00 00 je 2e2 <runcmd+0x172>
pid = fork();
237: e8 ce 0a 00 00 call d0a <fork>
if(pid == -1)
23c: 83 f8 ff cmp $0xffffffff,%eax
23f: 74 59 je 29a <runcmd+0x12a>
if(fork1() == 0){
241: 85 c0 test %eax,%eax
243: 74 62 je 2a7 <runcmd+0x137>
close(p[0]);
245: 83 ec 0c sub $0xc,%esp
248: ff 75 f0 pushl -0x10(%ebp)
24b: e8 ea 0a 00 00 call d3a <close>
close(p[1]);
250: 58 pop %eax
251: ff 75 f4 pushl -0xc(%ebp)
254: e8 e1 0a 00 00 call d3a <close>
wait();
259: e8 bc 0a 00 00 call d1a <wait>
wait();
25e: e8 b7 0a 00 00 call d1a <wait>
break;
263: 83 c4 10 add $0x10,%esp
266: e9 4d ff ff ff jmp 1b8 <runcmd+0x48>
pid = fork();
26b: e8 9a 0a 00 00 call d0a <fork>
if(pid == -1)
270: 83 f8 ff cmp $0xffffffff,%eax
273: 74 25 je 29a <runcmd+0x12a>
if(fork1() == 0)
275: 85 c0 test %eax,%eax
277: 0f 84 52 ff ff ff je 1cf <runcmd+0x5f>
wait();
27d: e8 98 0a 00 00 call d1a <wait>
runcmd(lcmd->right);
282: 83 ec 0c sub $0xc,%esp
285: ff 73 08 pushl 0x8(%ebx)
288: e8 e3 fe ff ff call 170 <runcmd>
panic("runcmd");
28d: 83 ec 0c sub $0xc,%esp
290: 68 db 11 00 00 push $0x11db
295: e8 b6 fe ff ff call 150 <panic>
panic("fork");
29a: 83 ec 0c sub $0xc,%esp
29d: 68 02 12 00 00 push $0x1202
2a2: e8 a9 fe ff ff call 150 <panic>
close(0);
2a7: 83 ec 0c sub $0xc,%esp
2aa: 6a 00 push $0x0
2ac: e8 89 0a 00 00 call d3a <close>
dup(p[0]);
2b1: 5a pop %edx
2b2: ff 75 f0 pushl -0x10(%ebp)
2b5: e8 d0 0a 00 00 call d8a <dup>
close(p[0]);
2ba: 59 pop %ecx
2bb: ff 75 f0 pushl -0x10(%ebp)
2be: e8 77 0a 00 00 call d3a <close>
close(p[1]);
2c3: 58 pop %eax
2c4: ff 75 f4 pushl -0xc(%ebp)
2c7: e8 6e 0a 00 00 call d3a <close>
runcmd(pcmd->right);
2cc: 58 pop %eax
2cd: ff 73 08 pushl 0x8(%ebx)
2d0: e8 9b fe ff ff call 170 <runcmd>
panic("pipe");
2d5: 83 ec 0c sub $0xc,%esp
2d8: 68 07 12 00 00 push $0x1207
2dd: e8 6e fe ff ff call 150 <panic>
close(1);
2e2: 83 ec 0c sub $0xc,%esp
2e5: 6a 01 push $0x1
2e7: e8 4e 0a 00 00 call d3a <close>
dup(p[1]);
2ec: 58 pop %eax
2ed: ff 75 f4 pushl -0xc(%ebp)
2f0: e8 95 0a 00 00 call d8a <dup>
close(p[0]);
2f5: 58 pop %eax
2f6: ff 75 f0 pushl -0x10(%ebp)
2f9: e8 3c 0a 00 00 call d3a <close>
close(p[1]);
2fe: 58 pop %eax
2ff: ff 75 f4 pushl -0xc(%ebp)
302: e8 33 0a 00 00 call d3a <close>
runcmd(pcmd->left);
307: 58 pop %eax
308: ff 73 04 pushl 0x4(%ebx)
30b: e8 60 fe ff ff call 170 <runcmd>
00000310 <fork1>:
{
310: 55 push %ebp
311: 89 e5 mov %esp,%ebp
313: 83 ec 08 sub $0x8,%esp
pid = fork();
316: e8 ef 09 00 00 call d0a <fork>
if(pid == -1)
31b: 83 f8 ff cmp $0xffffffff,%eax
31e: 74 02 je 322 <fork1+0x12>
return pid;
}
320: c9 leave
321: c3 ret
panic("fork");
322: 83 ec 0c sub $0xc,%esp
325: 68 02 12 00 00 push $0x1202
32a: e8 21 fe ff ff call 150 <panic>
32f: 90 nop
00000330 <execcmd>:
//PAGEBREAK!
// Constructors
struct cmd*
execcmd(void)
{
330: 55 push %ebp
331: 89 e5 mov %esp,%ebp
333: 53 push %ebx
334: 83 ec 10 sub $0x10,%esp
struct execcmd *cmd;
cmd = malloc(sizeof(*cmd));
337: 6a 54 push $0x54
339: e8 a2 0d 00 00 call 10e0 <malloc>
memset(cmd, 0, sizeof(*cmd));
33e: 83 c4 0c add $0xc,%esp
cmd = malloc(sizeof(*cmd));
341: 89 c3 mov %eax,%ebx
memset(cmd, 0, sizeof(*cmd));
343: 6a 54 push $0x54
345: 6a 00 push $0x0
347: 50 push %eax
348: e8 23 08 00 00 call b70 <memset>
cmd->type = EXEC;
34d: c7 03 01 00 00 00 movl $0x1,(%ebx)
return (struct cmd*)cmd;
}
353: 89 d8 mov %ebx,%eax
355: 8b 5d fc mov -0x4(%ebp),%ebx
358: c9 leave
359: c3 ret
35a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
00000360 <redircmd>:
struct cmd*
redircmd(struct cmd *subcmd, char *file, char *efile, int mode, int fd)
{
360: 55 push %ebp
361: 89 e5 mov %esp,%ebp
363: 53 push %ebx
364: 83 ec 10 sub $0x10,%esp
struct redircmd *cmd;
cmd = malloc(sizeof(*cmd));
367: 6a 18 push $0x18
369: e8 72 0d 00 00 call 10e0 <malloc>
memset(cmd, 0, sizeof(*cmd));
36e: 83 c4 0c add $0xc,%esp
cmd = malloc(sizeof(*cmd));
371: 89 c3 mov %eax,%ebx
memset(cmd, 0, sizeof(*cmd));
373: 6a 18 push $0x18
375: 6a 00 push $0x0
377: 50 push %eax
378: e8 f3 07 00 00 call b70 <memset>
cmd->type = REDIR;
cmd->cmd = subcmd;
37d: 8b 45 08 mov 0x8(%ebp),%eax
cmd->type = REDIR;
380: c7 03 02 00 00 00 movl $0x2,(%ebx)
cmd->cmd = subcmd;
386: 89 43 04 mov %eax,0x4(%ebx)
cmd->file = file;
389: 8b 45 0c mov 0xc(%ebp),%eax
38c: 89 43 08 mov %eax,0x8(%ebx)
cmd->efile = efile;
38f: 8b 45 10 mov 0x10(%ebp),%eax
392: 89 43 0c mov %eax,0xc(%ebx)
cmd->mode = mode;
395: 8b 45 14 mov 0x14(%ebp),%eax
398: 89 43 10 mov %eax,0x10(%ebx)
cmd->fd = fd;
39b: 8b 45 18 mov 0x18(%ebp),%eax
39e: 89 43 14 mov %eax,0x14(%ebx)
return (struct cmd*)cmd;
}
3a1: 89 d8 mov %ebx,%eax
3a3: 8b 5d fc mov -0x4(%ebp),%ebx
3a6: c9 leave
3a7: c3 ret
3a8: 90 nop
3a9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
000003b0 <pipecmd>:
struct cmd*
pipecmd(struct cmd *left, struct cmd *right)
{
3b0: 55 push %ebp
3b1: 89 e5 mov %esp,%ebp
3b3: 53 push %ebx
3b4: 83 ec 10 sub $0x10,%esp
struct pipecmd *cmd;
cmd = malloc(sizeof(*cmd));
3b7: 6a 0c push $0xc
3b9: e8 22 0d 00 00 call 10e0 <malloc>
memset(cmd, 0, sizeof(*cmd));
3be: 83 c4 0c add $0xc,%esp
cmd = malloc(sizeof(*cmd));
3c1: 89 c3 mov %eax,%ebx
memset(cmd, 0, sizeof(*cmd));
3c3: 6a 0c push $0xc
3c5: 6a 00 push $0x0
3c7: 50 push %eax
3c8: e8 a3 07 00 00 call b70 <memset>
cmd->type = PIPE;
cmd->left = left;
3cd: 8b 45 08 mov 0x8(%ebp),%eax
cmd->type = PIPE;
3d0: c7 03 03 00 00 00 movl $0x3,(%ebx)
cmd->left = left;
3d6: 89 43 04 mov %eax,0x4(%ebx)
cmd->right = right;
3d9: 8b 45 0c mov 0xc(%ebp),%eax
3dc: 89 43 08 mov %eax,0x8(%ebx)
return (struct cmd*)cmd;
}
3df: 89 d8 mov %ebx,%eax
3e1: 8b 5d fc mov -0x4(%ebp),%ebx
3e4: c9 leave
3e5: c3 ret
3e6: 8d 76 00 lea 0x0(%esi),%esi
3e9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
000003f0 <listcmd>:
struct cmd*
listcmd(struct cmd *left, struct cmd *right)
{
3f0: 55 push %ebp
3f1: 89 e5 mov %esp,%ebp
3f3: 53 push %ebx
3f4: 83 ec 10 sub $0x10,%esp
struct listcmd *cmd;
cmd = malloc(sizeof(*cmd));
3f7: 6a 0c push $0xc
3f9: e8 e2 0c 00 00 call 10e0 <malloc>
memset(cmd, 0, sizeof(*cmd));
3fe: 83 c4 0c add $0xc,%esp
cmd = malloc(sizeof(*cmd));
401: 89 c3 mov %eax,%ebx
memset(cmd, 0, sizeof(*cmd));
403: 6a 0c push $0xc
405: 6a 00 push $0x0
407: 50 push %eax
408: e8 63 07 00 00 call b70 <memset>
cmd->type = LIST;
cmd->left = left;
40d: 8b 45 08 mov 0x8(%ebp),%eax
cmd->type = LIST;
410: c7 03 04 00 00 00 movl $0x4,(%ebx)
cmd->left = left;
416: 89 43 04 mov %eax,0x4(%ebx)
cmd->right = right;
419: 8b 45 0c mov 0xc(%ebp),%eax
41c: 89 43 08 mov %eax,0x8(%ebx)
return (struct cmd*)cmd;
}
41f: 89 d8 mov %ebx,%eax
421: 8b 5d fc mov -0x4(%ebp),%ebx
424: c9 leave
425: c3 ret
426: 8d 76 00 lea 0x0(%esi),%esi
429: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
00000430 <backcmd>:
struct cmd*
backcmd(struct cmd *subcmd)
{
430: 55 push %ebp
431: 89 e5 mov %esp,%ebp
433: 53 push %ebx
434: 83 ec 10 sub $0x10,%esp
struct backcmd *cmd;
cmd = malloc(sizeof(*cmd));
437: 6a 08 push $0x8
439: e8 a2 0c 00 00 call 10e0 <malloc>
memset(cmd, 0, sizeof(*cmd));
43e: 83 c4 0c add $0xc,%esp
cmd = malloc(sizeof(*cmd));
441: 89 c3 mov %eax,%ebx
memset(cmd, 0, sizeof(*cmd));
443: 6a 08 push $0x8
445: 6a 00 push $0x0
447: 50 push %eax
448: e8 23 07 00 00 call b70 <memset>
cmd->type = BACK;
cmd->cmd = subcmd;
44d: 8b 45 08 mov 0x8(%ebp),%eax
cmd->type = BACK;
450: c7 03 05 00 00 00 movl $0x5,(%ebx)
cmd->cmd = subcmd;
456: 89 43 04 mov %eax,0x4(%ebx)
return (struct cmd*)cmd;
}
459: 89 d8 mov %ebx,%eax
45b: 8b 5d fc mov -0x4(%ebp),%ebx
45e: c9 leave
45f: c3 ret
00000460 <gettoken>:
char whitespace[] = " \t\r\n\v";
char symbols[] = "<|>&;()";
int
gettoken(char **ps, char *es, char **q, char **eq)
{
460: 55 push %ebp
461: 89 e5 mov %esp,%ebp
463: 57 push %edi
464: 56 push %esi
465: 53 push %ebx
466: 83 ec 0c sub $0xc,%esp
char *s;
int ret;
s = *ps;
469: 8b 45 08 mov 0x8(%ebp),%eax
{
46c: 8b 5d 0c mov 0xc(%ebp),%ebx
46f: 8b 7d 10 mov 0x10(%ebp),%edi
s = *ps;
472: 8b 30 mov (%eax),%esi
while(s < es && strchr(whitespace, *s))
474: 39 de cmp %ebx,%esi
476: 72 0f jb 487 <gettoken+0x27>
478: eb 25 jmp 49f <gettoken+0x3f>
47a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
s++;
480: 83 c6 01 add $0x1,%esi
while(s < es && strchr(whitespace, *s))
483: 39 f3 cmp %esi,%ebx
485: 74 18 je 49f <gettoken+0x3f>
487: 0f be 06 movsbl (%esi),%eax
48a: 83 ec 08 sub $0x8,%esp
48d: 50 push %eax
48e: 68 8c 18 00 00 push $0x188c
493: e8 f8 06 00 00 call b90 <strchr>
498: 83 c4 10 add $0x10,%esp
49b: 85 c0 test %eax,%eax
49d: 75 e1 jne 480 <gettoken+0x20>
if(q)
49f: 85 ff test %edi,%edi
4a1: 74 02 je 4a5 <gettoken+0x45>
*q = s;
4a3: 89 37 mov %esi,(%edi)
ret = *s;
4a5: 0f be 06 movsbl (%esi),%eax
switch(*s){
4a8: 3c 29 cmp $0x29,%al
4aa: 7f 54 jg 500 <gettoken+0xa0>
4ac: 3c 28 cmp $0x28,%al
4ae: 0f 8d c8 00 00 00 jge 57c <gettoken+0x11c>
4b4: 31 ff xor %edi,%edi
4b6: 84 c0 test %al,%al
4b8: 0f 85 d2 00 00 00 jne 590 <gettoken+0x130>
ret = 'a';
while(s < es && !strchr(whitespace, *s) && !strchr(symbols, *s))
s++;
break;
}
if(eq)
4be: 8b 55 14 mov 0x14(%ebp),%edx
4c1: 85 d2 test %edx,%edx
4c3: 74 05 je 4ca <gettoken+0x6a>
*eq = s;
4c5: 8b 45 14 mov 0x14(%ebp),%eax
4c8: 89 30 mov %esi,(%eax)
while(s < es && strchr(whitespace, *s))
4ca: 39 de cmp %ebx,%esi
4cc: 72 09 jb 4d7 <gettoken+0x77>
4ce: eb 1f jmp 4ef <gettoken+0x8f>
s++;
4d0: 83 c6 01 add $0x1,%esi
while(s < es && strchr(whitespace, *s))
4d3: 39 f3 cmp %esi,%ebx
4d5: 74 18 je 4ef <gettoken+0x8f>
4d7: 0f be 06 movsbl (%esi),%eax
4da: 83 ec 08 sub $0x8,%esp
4dd: 50 push %eax
4de: 68 8c 18 00 00 push $0x188c
4e3: e8 a8 06 00 00 call b90 <strchr>
4e8: 83 c4 10 add $0x10,%esp
4eb: 85 c0 test %eax,%eax
4ed: 75 e1 jne 4d0 <gettoken+0x70>
*ps = s;
4ef: 8b 45 08 mov 0x8(%ebp),%eax
4f2: 89 30 mov %esi,(%eax)
return ret;
}
4f4: 8d 65 f4 lea -0xc(%ebp),%esp
4f7: 89 f8 mov %edi,%eax
4f9: 5b pop %ebx
4fa: 5e pop %esi
4fb: 5f pop %edi
4fc: 5d pop %ebp
4fd: c3 ret
4fe: 66 90 xchg %ax,%ax
switch(*s){
500: 3c 3e cmp $0x3e,%al
502: 75 1c jne 520 <gettoken+0xc0>
if(*s == '>'){
504: 80 7e 01 3e cmpb $0x3e,0x1(%esi)
s++;
508: 8d 46 01 lea 0x1(%esi),%eax
if(*s == '>'){
50b: 0f 84 a4 00 00 00 je 5b5 <gettoken+0x155>
s++;
511: 89 c6 mov %eax,%esi
513: bf 3e 00 00 00 mov $0x3e,%edi
518: eb a4 jmp 4be <gettoken+0x5e>
51a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
switch(*s){
520: 7f 56 jg 578 <gettoken+0x118>
522: 8d 48 c5 lea -0x3b(%eax),%ecx
525: 80 f9 01 cmp $0x1,%cl
528: 76 52 jbe 57c <gettoken+0x11c>
while(s < es && !strchr(whitespace, *s) && !strchr(symbols, *s))
52a: 39 f3 cmp %esi,%ebx
52c: 77 24 ja 552 <gettoken+0xf2>
52e: eb 70 jmp 5a0 <gettoken+0x140>
530: 0f be 06 movsbl (%esi),%eax
533: 83 ec 08 sub $0x8,%esp
536: 50 push %eax
537: 68 84 18 00 00 push $0x1884
53c: e8 4f 06 00 00 call b90 <strchr>
541: 83 c4 10 add $0x10,%esp
544: 85 c0 test %eax,%eax
546: 75 1f jne 567 <gettoken+0x107>
s++;
548: 83 c6 01 add $0x1,%esi
while(s < es && !strchr(whitespace, *s) && !strchr(symbols, *s))
54b: 39 f3 cmp %esi,%ebx
54d: 74 51 je 5a0 <gettoken+0x140>
54f: 0f be 06 movsbl (%esi),%eax
552: 83 ec 08 sub $0x8,%esp
555: 50 push %eax
556: 68 8c 18 00 00 push $0x188c
55b: e8 30 06 00 00 call b90 <strchr>
560: 83 c4 10 add $0x10,%esp
563: 85 c0 test %eax,%eax
565: 74 c9 je 530 <gettoken+0xd0>
ret = 'a';
567: bf 61 00 00 00 mov $0x61,%edi
56c: e9 4d ff ff ff jmp 4be <gettoken+0x5e>
571: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
switch(*s){
578: 3c 7c cmp $0x7c,%al
57a: 75 ae jne 52a <gettoken+0xca>
ret = *s;
57c: 0f be f8 movsbl %al,%edi
s++;
57f: 83 c6 01 add $0x1,%esi
break;
582: e9 37 ff ff ff jmp 4be <gettoken+0x5e>
587: 89 f6 mov %esi,%esi
589: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
switch(*s){
590: 3c 26 cmp $0x26,%al
592: 75 96 jne 52a <gettoken+0xca>
594: eb e6 jmp 57c <gettoken+0x11c>
596: 8d 76 00 lea 0x0(%esi),%esi
599: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
if(eq)
5a0: 8b 45 14 mov 0x14(%ebp),%eax
5a3: bf 61 00 00 00 mov $0x61,%edi
5a8: 85 c0 test %eax,%eax
5aa: 0f 85 15 ff ff ff jne 4c5 <gettoken+0x65>
5b0: e9 3a ff ff ff jmp 4ef <gettoken+0x8f>
s++;
5b5: 83 c6 02 add $0x2,%esi
ret = '+';
5b8: bf 2b 00 00 00 mov $0x2b,%edi
5bd: e9 fc fe ff ff jmp 4be <gettoken+0x5e>
5c2: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
5c9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
000005d0 <peek>:
int
peek(char **ps, char *es, char *toks)
{
5d0: 55 push %ebp
5d1: 89 e5 mov %esp,%ebp
5d3: 57 push %edi
5d4: 56 push %esi
5d5: 53 push %ebx
5d6: 83 ec 0c sub $0xc,%esp
5d9: 8b 7d 08 mov 0x8(%ebp),%edi
5dc: 8b 75 0c mov 0xc(%ebp),%esi
char *s;
s = *ps;
5df: 8b 1f mov (%edi),%ebx
while(s < es && strchr(whitespace, *s))
5e1: 39 f3 cmp %esi,%ebx
5e3: 72 12 jb 5f7 <peek+0x27>
5e5: eb 28 jmp 60f <peek+0x3f>
5e7: 89 f6 mov %esi,%esi
5e9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
s++;
5f0: 83 c3 01 add $0x1,%ebx
while(s < es && strchr(whitespace, *s))
5f3: 39 de cmp %ebx,%esi
5f5: 74 18 je 60f <peek+0x3f>
5f7: 0f be 03 movsbl (%ebx),%eax
5fa: 83 ec 08 sub $0x8,%esp
5fd: 50 push %eax
5fe: 68 8c 18 00 00 push $0x188c
603: e8 88 05 00 00 call b90 <strchr>
608: 83 c4 10 add $0x10,%esp
60b: 85 c0 test %eax,%eax
60d: 75 e1 jne 5f0 <peek+0x20>
*ps = s;
60f: 89 1f mov %ebx,(%edi)
return *s && strchr(toks, *s);
611: 0f be 13 movsbl (%ebx),%edx
614: 31 c0 xor %eax,%eax
616: 84 d2 test %dl,%dl
618: 74 17 je 631 <peek+0x61>
61a: 83 ec 08 sub $0x8,%esp
61d: 52 push %edx
61e: ff 75 10 pushl 0x10(%ebp)
621: e8 6a 05 00 00 call b90 <strchr>
626: 83 c4 10 add $0x10,%esp
629: 85 c0 test %eax,%eax
62b: 0f 95 c0 setne %al
62e: 0f b6 c0 movzbl %al,%eax
}
631: 8d 65 f4 lea -0xc(%ebp),%esp
634: 5b pop %ebx
635: 5e pop %esi
636: 5f pop %edi
637: 5d pop %ebp
638: c3 ret
639: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
00000640 <parseredirs>:
return cmd;
}
struct cmd*
parseredirs(struct cmd *cmd, char **ps, char *es)
{
640: 55 push %ebp
641: 89 e5 mov %esp,%ebp
643: 57 push %edi
644: 56 push %esi
645: 53 push %ebx
646: 83 ec 1c sub $0x1c,%esp
649: 8b 75 0c mov 0xc(%ebp),%esi
64c: 8b 5d 10 mov 0x10(%ebp),%ebx
64f: 90 nop
int tok;
char *q, *eq;
while(peek(ps, es, "<>")){
650: 83 ec 04 sub $0x4,%esp
653: 68 29 12 00 00 push $0x1229
658: 53 push %ebx
659: 56 push %esi
65a: e8 71 ff ff ff call 5d0 <peek>
65f: 83 c4 10 add $0x10,%esp
662: 85 c0 test %eax,%eax
664: 74 6a je 6d0 <parseredirs+0x90>
tok = gettoken(ps, es, 0, 0);
666: 6a 00 push $0x0
668: 6a 00 push $0x0
66a: 53 push %ebx
66b: 56 push %esi
66c: e8 ef fd ff ff call 460 <gettoken>
671: 89 c7 mov %eax,%edi
if(gettoken(ps, es, &q, &eq) != 'a')
673: 8d 45 e4 lea -0x1c(%ebp),%eax
676: 50 push %eax
677: 8d 45 e0 lea -0x20(%ebp),%eax
67a: 50 push %eax
67b: 53 push %ebx
67c: 56 push %esi
67d: e8 de fd ff ff call 460 <gettoken>
682: 83 c4 20 add $0x20,%esp
685: 83 f8 61 cmp $0x61,%eax
688: 75 51 jne 6db <parseredirs+0x9b>
panic("missing file for redirection");
switch(tok){
68a: 83 ff 3c cmp $0x3c,%edi
68d: 74 31 je 6c0 <parseredirs+0x80>
68f: 83 ff 3e cmp $0x3e,%edi
692: 74 05 je 699 <parseredirs+0x59>
694: 83 ff 2b cmp $0x2b,%edi
697: 75 b7 jne 650 <parseredirs+0x10>
break;
case '>':
cmd = redircmd(cmd, q, eq, O_WRONLY|O_CREATE, 1);
break;
case '+': // >>
cmd = redircmd(cmd, q, eq, O_WRONLY|O_CREATE, 1);
699: 83 ec 0c sub $0xc,%esp
69c: 6a 01 push $0x1
69e: 68 01 02 00 00 push $0x201
6a3: ff 75 e4 pushl -0x1c(%ebp)
6a6: ff 75 e0 pushl -0x20(%ebp)
6a9: ff 75 08 pushl 0x8(%ebp)
6ac: e8 af fc ff ff call 360 <redircmd>
break;
6b1: 83 c4 20 add $0x20,%esp
cmd = redircmd(cmd, q, eq, O_WRONLY|O_CREATE, 1);
6b4: 89 45 08 mov %eax,0x8(%ebp)
break;
6b7: eb 97 jmp 650 <parseredirs+0x10>
6b9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
cmd = redircmd(cmd, q, eq, O_RDONLY, 0);
6c0: 83 ec 0c sub $0xc,%esp
6c3: 6a 00 push $0x0
6c5: 6a 00 push $0x0
6c7: eb da jmp 6a3 <parseredirs+0x63>
6c9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
}
}
return cmd;
}
6d0: 8b 45 08 mov 0x8(%ebp),%eax
6d3: 8d 65 f4 lea -0xc(%ebp),%esp
6d6: 5b pop %ebx
6d7: 5e pop %esi
6d8: 5f pop %edi
6d9: 5d pop %ebp
6da: c3 ret
panic("missing file for redirection");
6db: 83 ec 0c sub $0xc,%esp
6de: 68 0c 12 00 00 push $0x120c
6e3: e8 68 fa ff ff call 150 <panic>
6e8: 90 nop
6e9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
000006f0 <parseexec>:
return cmd;
}
struct cmd*
parseexec(char **ps, char *es)
{
6f0: 55 push %ebp
6f1: 89 e5 mov %esp,%ebp
6f3: 57 push %edi
6f4: 56 push %esi
6f5: 53 push %ebx
6f6: 83 ec 30 sub $0x30,%esp
6f9: 8b 75 08 mov 0x8(%ebp),%esi
6fc: 8b 7d 0c mov 0xc(%ebp),%edi
char *q, *eq;
int tok, argc;
struct execcmd *cmd;
struct cmd *ret;
if(peek(ps, es, "("))
6ff: 68 2c 12 00 00 push $0x122c
704: 57 push %edi
705: 56 push %esi
706: e8 c5 fe ff ff call 5d0 <peek>
70b: 83 c4 10 add $0x10,%esp
70e: 85 c0 test %eax,%eax
710: 0f 85 92 00 00 00 jne 7a8 <parseexec+0xb8>
716: 89 c3 mov %eax,%ebx
return parseblock(ps, es);
ret = execcmd();
718: e8 13 fc ff ff call 330 <execcmd>
cmd = (struct execcmd*)ret;
argc = 0;
ret = parseredirs(ret, ps, es);
71d: 83 ec 04 sub $0x4,%esp
ret = execcmd();
720: 89 45 d0 mov %eax,-0x30(%ebp)
ret = parseredirs(ret, ps, es);
723: 57 push %edi
724: 56 push %esi
725: 50 push %eax
726: e8 15 ff ff ff call 640 <parseredirs>
72b: 83 c4 10 add $0x10,%esp
72e: 89 45 d4 mov %eax,-0x2c(%ebp)
731: eb 18 jmp 74b <parseexec+0x5b>
733: 90 nop
734: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
cmd->argv[argc] = q;
cmd->eargv[argc] = eq;
argc++;
if(argc >= MAXARGS)
panic("too many args");
ret = parseredirs(ret, ps, es);
738: 83 ec 04 sub $0x4,%esp
73b: 57 push %edi
73c: 56 push %esi
73d: ff 75 d4 pushl -0x2c(%ebp)
740: e8 fb fe ff ff call 640 <parseredirs>
745: 83 c4 10 add $0x10,%esp
748: 89 45 d4 mov %eax,-0x2c(%ebp)
while(!peek(ps, es, "|)&;")){
74b: 83 ec 04 sub $0x4,%esp
74e: 68 43 12 00 00 push $0x1243
753: 57 push %edi
754: 56 push %esi
755: e8 76 fe ff ff call 5d0 <peek>
75a: 83 c4 10 add $0x10,%esp
75d: 85 c0 test %eax,%eax
75f: 75 67 jne 7c8 <parseexec+0xd8>
if((tok=gettoken(ps, es, &q, &eq)) == 0)
761: 8d 45 e4 lea -0x1c(%ebp),%eax
764: 50 push %eax
765: 8d 45 e0 lea -0x20(%ebp),%eax
768: 50 push %eax
769: 57 push %edi
76a: 56 push %esi
76b: e8 f0 fc ff ff call 460 <gettoken>
770: 83 c4 10 add $0x10,%esp
773: 85 c0 test %eax,%eax
775: 74 51 je 7c8 <parseexec+0xd8>
if(tok != 'a')
777: 83 f8 61 cmp $0x61,%eax
77a: 75 6b jne 7e7 <parseexec+0xf7>
cmd->argv[argc] = q;
77c: 8b 45 e0 mov -0x20(%ebp),%eax
77f: 8b 55 d0 mov -0x30(%ebp),%edx
782: 89 44 9a 04 mov %eax,0x4(%edx,%ebx,4)
cmd->eargv[argc] = eq;
786: 8b 45 e4 mov -0x1c(%ebp),%eax
789: 89 44 9a 2c mov %eax,0x2c(%edx,%ebx,4)
argc++;
78d: 83 c3 01 add $0x1,%ebx
if(argc >= MAXARGS)
790: 83 fb 0a cmp $0xa,%ebx
793: 75 a3 jne 738 <parseexec+0x48>
panic("too many args");
795: 83 ec 0c sub $0xc,%esp
798: 68 35 12 00 00 push $0x1235
79d: e8 ae f9 ff ff call 150 <panic>
7a2: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
return parseblock(ps, es);
7a8: 83 ec 08 sub $0x8,%esp
7ab: 57 push %edi
7ac: 56 push %esi
7ad: e8 5e 01 00 00 call 910 <parseblock>
7b2: 83 c4 10 add $0x10,%esp
7b5: 89 45 d4 mov %eax,-0x2c(%ebp)
}
cmd->argv[argc] = 0;
cmd->eargv[argc] = 0;
return ret;
}
7b8: 8b 45 d4 mov -0x2c(%ebp),%eax
7bb: 8d 65 f4 lea -0xc(%ebp),%esp
7be: 5b pop %ebx
7bf: 5e pop %esi
7c0: 5f pop %edi
7c1: 5d pop %ebp
7c2: c3 ret
7c3: 90 nop
7c4: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
7c8: 8b 45 d0 mov -0x30(%ebp),%eax
7cb: 8d 04 98 lea (%eax,%ebx,4),%eax
cmd->argv[argc] = 0;
7ce: c7 40 04 00 00 00 00 movl $0x0,0x4(%eax)
cmd->eargv[argc] = 0;
7d5: c7 40 2c 00 00 00 00 movl $0x0,0x2c(%eax)
}
7dc: 8b 45 d4 mov -0x2c(%ebp),%eax
7df: 8d 65 f4 lea -0xc(%ebp),%esp
7e2: 5b pop %ebx
7e3: 5e pop %esi
7e4: 5f pop %edi
7e5: 5d pop %ebp
7e6: c3 ret
panic("syntax");
7e7: 83 ec 0c sub $0xc,%esp
7ea: 68 2e 12 00 00 push $0x122e
7ef: e8 5c f9 ff ff call 150 <panic>
7f4: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
7fa: 8d bf 00 00 00 00 lea 0x0(%edi),%edi
00000800 <parsepipe>:
{
800: 55 push %ebp
801: 89 e5 mov %esp,%ebp
803: 57 push %edi
804: 56 push %esi
805: 53 push %ebx
806: 83 ec 14 sub $0x14,%esp
809: 8b 5d 08 mov 0x8(%ebp),%ebx
80c: 8b 75 0c mov 0xc(%ebp),%esi
cmd = parseexec(ps, es);
80f: 56 push %esi
810: 53 push %ebx
811: e8 da fe ff ff call 6f0 <parseexec>
if(peek(ps, es, "|")){
816: 83 c4 0c add $0xc,%esp
cmd = parseexec(ps, es);
819: 89 c7 mov %eax,%edi
if(peek(ps, es, "|")){
81b: 68 48 12 00 00 push $0x1248
820: 56 push %esi
821: 53 push %ebx
822: e8 a9 fd ff ff call 5d0 <peek>
827: 83 c4 10 add $0x10,%esp
82a: 85 c0 test %eax,%eax
82c: 75 12 jne 840 <parsepipe+0x40>
}
82e: 8d 65 f4 lea -0xc(%ebp),%esp
831: 89 f8 mov %edi,%eax
833: 5b pop %ebx
834: 5e pop %esi
835: 5f pop %edi
836: 5d pop %ebp
837: c3 ret
838: 90 nop
839: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
gettoken(ps, es, 0, 0);
840: 6a 00 push $0x0
842: 6a 00 push $0x0
844: 56 push %esi
845: 53 push %ebx
846: e8 15 fc ff ff call 460 <gettoken>
cmd = pipecmd(cmd, parsepipe(ps, es));
84b: 58 pop %eax
84c: 5a pop %edx
84d: 56 push %esi
84e: 53 push %ebx
84f: e8 ac ff ff ff call 800 <parsepipe>
854: 89 7d 08 mov %edi,0x8(%ebp)
857: 89 45 0c mov %eax,0xc(%ebp)
85a: 83 c4 10 add $0x10,%esp
}
85d: 8d 65 f4 lea -0xc(%ebp),%esp
860: 5b pop %ebx
861: 5e pop %esi
862: 5f pop %edi
863: 5d pop %ebp
cmd = pipecmd(cmd, parsepipe(ps, es));
864: e9 47 fb ff ff jmp 3b0 <pipecmd>
869: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
00000870 <parseline>:
{
870: 55 push %ebp
871: 89 e5 mov %esp,%ebp
873: 57 push %edi
874: 56 push %esi
875: 53 push %ebx
876: 83 ec 14 sub $0x14,%esp
879: 8b 5d 08 mov 0x8(%ebp),%ebx
87c: 8b 75 0c mov 0xc(%ebp),%esi
cmd = parsepipe(ps, es);
87f: 56 push %esi
880: 53 push %ebx
881: e8 7a ff ff ff call 800 <parsepipe>
while(peek(ps, es, "&")){
886: 83 c4 10 add $0x10,%esp
cmd = parsepipe(ps, es);
889: 89 c7 mov %eax,%edi
while(peek(ps, es, "&")){
88b: eb 1b jmp 8a8 <parseline+0x38>
88d: 8d 76 00 lea 0x0(%esi),%esi
gettoken(ps, es, 0, 0);
890: 6a 00 push $0x0
892: 6a 00 push $0x0
894: 56 push %esi
895: 53 push %ebx
896: e8 c5 fb ff ff call 460 <gettoken>
cmd = backcmd(cmd);
89b: 89 3c 24 mov %edi,(%esp)
89e: e8 8d fb ff ff call 430 <backcmd>
8a3: 83 c4 10 add $0x10,%esp
8a6: 89 c7 mov %eax,%edi
while(peek(ps, es, "&")){
8a8: 83 ec 04 sub $0x4,%esp
8ab: 68 4a 12 00 00 push $0x124a
8b0: 56 push %esi
8b1: 53 push %ebx
8b2: e8 19 fd ff ff call 5d0 <peek>
8b7: 83 c4 10 add $0x10,%esp
8ba: 85 c0 test %eax,%eax
8bc: 75 d2 jne 890 <parseline+0x20>
if(peek(ps, es, ";")){
8be: 83 ec 04 sub $0x4,%esp
8c1: 68 46 12 00 00 push $0x1246
8c6: 56 push %esi
8c7: 53 push %ebx
8c8: e8 03 fd ff ff call 5d0 <peek>
8cd: 83 c4 10 add $0x10,%esp
8d0: 85 c0 test %eax,%eax
8d2: 75 0c jne 8e0 <parseline+0x70>
}
8d4: 8d 65 f4 lea -0xc(%ebp),%esp
8d7: 89 f8 mov %edi,%eax
8d9: 5b pop %ebx
8da: 5e pop %esi
8db: 5f pop %edi
8dc: 5d pop %ebp
8dd: c3 ret
8de: 66 90 xchg %ax,%ax
gettoken(ps, es, 0, 0);
8e0: 6a 00 push $0x0
8e2: 6a 00 push $0x0
8e4: 56 push %esi
8e5: 53 push %ebx
8e6: e8 75 fb ff ff call 460 <gettoken>
cmd = listcmd(cmd, parseline(ps, es));
8eb: 58 pop %eax
8ec: 5a pop %edx
8ed: 56 push %esi
8ee: 53 push %ebx
8ef: e8 7c ff ff ff call 870 <parseline>
8f4: 89 7d 08 mov %edi,0x8(%ebp)
8f7: 89 45 0c mov %eax,0xc(%ebp)
8fa: 83 c4 10 add $0x10,%esp
}
8fd: 8d 65 f4 lea -0xc(%ebp),%esp
900: 5b pop %ebx
901: 5e pop %esi
902: 5f pop %edi
903: 5d pop %ebp
cmd = listcmd(cmd, parseline(ps, es));
904: e9 e7 fa ff ff jmp 3f0 <listcmd>
909: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
00000910 <parseblock>:
{
910: 55 push %ebp
911: 89 e5 mov %esp,%ebp
913: 57 push %edi
914: 56 push %esi
915: 53 push %ebx
916: 83 ec 10 sub $0x10,%esp
919: 8b 5d 08 mov 0x8(%ebp),%ebx
91c: 8b 75 0c mov 0xc(%ebp),%esi
if(!peek(ps, es, "("))
91f: 68 2c 12 00 00 push $0x122c
924: 56 push %esi
925: 53 push %ebx
926: e8 a5 fc ff ff call 5d0 <peek>
92b: 83 c4 10 add $0x10,%esp
92e: 85 c0 test %eax,%eax
930: 74 4a je 97c <parseblock+0x6c>
gettoken(ps, es, 0, 0);
932: 6a 00 push $0x0
934: 6a 00 push $0x0
936: 56 push %esi
937: 53 push %ebx
938: e8 23 fb ff ff call 460 <gettoken>
cmd = parseline(ps, es);
93d: 58 pop %eax
93e: 5a pop %edx
93f: 56 push %esi
940: 53 push %ebx
941: e8 2a ff ff ff call 870 <parseline>
if(!peek(ps, es, ")"))
946: 83 c4 0c add $0xc,%esp
cmd = parseline(ps, es);
949: 89 c7 mov %eax,%edi
if(!peek(ps, es, ")"))
94b: 68 68 12 00 00 push $0x1268
950: 56 push %esi
951: 53 push %ebx
952: e8 79 fc ff ff call 5d0 <peek>
957: 83 c4 10 add $0x10,%esp
95a: 85 c0 test %eax,%eax
95c: 74 2b je 989 <parseblock+0x79>
gettoken(ps, es, 0, 0);
95e: 6a 00 push $0x0
960: 6a 00 push $0x0
962: 56 push %esi
963: 53 push %ebx
964: e8 f7 fa ff ff call 460 <gettoken>
cmd = parseredirs(cmd, ps, es);
969: 83 c4 0c add $0xc,%esp
96c: 56 push %esi
96d: 53 push %ebx
96e: 57 push %edi
96f: e8 cc fc ff ff call 640 <parseredirs>
}
974: 8d 65 f4 lea -0xc(%ebp),%esp
977: 5b pop %ebx
978: 5e pop %esi
979: 5f pop %edi
97a: 5d pop %ebp
97b: c3 ret
panic("parseblock");
97c: 83 ec 0c sub $0xc,%esp
97f: 68 4c 12 00 00 push $0x124c
984: e8 c7 f7 ff ff call 150 <panic>
panic("syntax - missing )");
989: 83 ec 0c sub $0xc,%esp
98c: 68 57 12 00 00 push $0x1257
991: e8 ba f7 ff ff call 150 <panic>
996: 8d 76 00 lea 0x0(%esi),%esi
999: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
000009a0 <nulterminate>:
// NUL-terminate all the counted strings.
struct cmd*
nulterminate(struct cmd *cmd)
{
9a0: 55 push %ebp
9a1: 89 e5 mov %esp,%ebp
9a3: 53 push %ebx
9a4: 83 ec 04 sub $0x4,%esp
9a7: 8b 5d 08 mov 0x8(%ebp),%ebx
struct execcmd *ecmd;
struct listcmd *lcmd;
struct pipecmd *pcmd;
struct redircmd *rcmd;
if(cmd == 0)
9aa: 85 db test %ebx,%ebx
9ac: 74 20 je 9ce <nulterminate+0x2e>
return 0;
switch(cmd->type){
9ae: 83 3b 05 cmpl $0x5,(%ebx)
9b1: 77 1b ja 9ce <nulterminate+0x2e>
9b3: 8b 03 mov (%ebx),%eax
9b5: ff 24 85 a8 12 00 00 jmp *0x12a8(,%eax,4)
9bc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
nulterminate(lcmd->right);
break;
case BACK:
bcmd = (struct backcmd*)cmd;
nulterminate(bcmd->cmd);
9c0: 83 ec 0c sub $0xc,%esp
9c3: ff 73 04 pushl 0x4(%ebx)
9c6: e8 d5 ff ff ff call 9a0 <nulterminate>
break;
9cb: 83 c4 10 add $0x10,%esp
}
return cmd;
}
9ce: 89 d8 mov %ebx,%eax
9d0: 8b 5d fc mov -0x4(%ebp),%ebx
9d3: c9 leave
9d4: c3 ret
9d5: 8d 76 00 lea 0x0(%esi),%esi
nulterminate(lcmd->left);
9d8: 83 ec 0c sub $0xc,%esp
9db: ff 73 04 pushl 0x4(%ebx)
9de: e8 bd ff ff ff call 9a0 <nulterminate>
nulterminate(lcmd->right);
9e3: 58 pop %eax
9e4: ff 73 08 pushl 0x8(%ebx)
9e7: e8 b4 ff ff ff call 9a0 <nulterminate>
}
9ec: 89 d8 mov %ebx,%eax
break;
9ee: 83 c4 10 add $0x10,%esp
}
9f1: 8b 5d fc mov -0x4(%ebp),%ebx
9f4: c9 leave
9f5: c3 ret
9f6: 8d 76 00 lea 0x0(%esi),%esi
9f9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
for(i=0; ecmd->argv[i]; i++)
a00: 8b 4b 04 mov 0x4(%ebx),%ecx
a03: 8d 43 08 lea 0x8(%ebx),%eax
a06: 85 c9 test %ecx,%ecx
a08: 74 c4 je 9ce <nulterminate+0x2e>
a0a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
*ecmd->eargv[i] = 0;
a10: 8b 50 24 mov 0x24(%eax),%edx
a13: 83 c0 04 add $0x4,%eax
a16: c6 02 00 movb $0x0,(%edx)
for(i=0; ecmd->argv[i]; i++)
a19: 8b 50 fc mov -0x4(%eax),%edx
a1c: 85 d2 test %edx,%edx
a1e: 75 f0 jne a10 <nulterminate+0x70>
}
a20: 89 d8 mov %ebx,%eax
a22: 8b 5d fc mov -0x4(%ebp),%ebx
a25: c9 leave
a26: c3 ret
a27: 89 f6 mov %esi,%esi
a29: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
nulterminate(rcmd->cmd);
a30: 83 ec 0c sub $0xc,%esp
a33: ff 73 04 pushl 0x4(%ebx)
a36: e8 65 ff ff ff call 9a0 <nulterminate>
*rcmd->efile = 0;
a3b: 8b 43 0c mov 0xc(%ebx),%eax
break;
a3e: 83 c4 10 add $0x10,%esp
*rcmd->efile = 0;
a41: c6 00 00 movb $0x0,(%eax)
}
a44: 89 d8 mov %ebx,%eax
a46: 8b 5d fc mov -0x4(%ebp),%ebx
a49: c9 leave
a4a: c3 ret
a4b: 90 nop
a4c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
00000a50 <parsecmd>:
{
a50: 55 push %ebp
a51: 89 e5 mov %esp,%ebp
a53: 56 push %esi
a54: 53 push %ebx
es = s + strlen(s);
a55: 8b 5d 08 mov 0x8(%ebp),%ebx
a58: 83 ec 0c sub $0xc,%esp
a5b: 53 push %ebx
a5c: e8 df 00 00 00 call b40 <strlen>
cmd = parseline(&s, es);
a61: 59 pop %ecx
es = s + strlen(s);
a62: 01 c3 add %eax,%ebx
cmd = parseline(&s, es);
a64: 8d 45 08 lea 0x8(%ebp),%eax
a67: 5e pop %esi
a68: 53 push %ebx
a69: 50 push %eax
a6a: e8 01 fe ff ff call 870 <parseline>
a6f: 89 c6 mov %eax,%esi
peek(&s, es, "");
a71: 8d 45 08 lea 0x8(%ebp),%eax
a74: 83 c4 0c add $0xc,%esp
a77: 68 f1 11 00 00 push $0x11f1
a7c: 53 push %ebx
a7d: 50 push %eax
a7e: e8 4d fb ff ff call 5d0 <peek>
if(s != es){
a83: 8b 45 08 mov 0x8(%ebp),%eax
a86: 83 c4 10 add $0x10,%esp
a89: 39 d8 cmp %ebx,%eax
a8b: 75 12 jne a9f <parsecmd+0x4f>
nulterminate(cmd);
a8d: 83 ec 0c sub $0xc,%esp
a90: 56 push %esi
a91: e8 0a ff ff ff call 9a0 <nulterminate>
}
a96: 8d 65 f8 lea -0x8(%ebp),%esp
a99: 89 f0 mov %esi,%eax
a9b: 5b pop %ebx
a9c: 5e pop %esi
a9d: 5d pop %ebp
a9e: c3 ret
printf(2, "leftovers: %s\n", s);
a9f: 52 push %edx
aa0: 50 push %eax
aa1: 68 6a 12 00 00 push $0x126a
aa6: 6a 02 push $0x2
aa8: e8 d3 03 00 00 call e80 <printf>
panic("syntax");
aad: c7 04 24 2e 12 00 00 movl $0x122e,(%esp)
ab4: e8 97 f6 ff ff call 150 <panic>
ab9: 66 90 xchg %ax,%ax
abb: 66 90 xchg %ax,%ax
abd: 66 90 xchg %ax,%ax
abf: 90 nop
00000ac0 <strcpy>:
#include "user.h"
#include "x86.h"
char*
strcpy(char *s, const char *t)
{
ac0: 55 push %ebp
ac1: 89 e5 mov %esp,%ebp
ac3: 53 push %ebx
ac4: 8b 45 08 mov 0x8(%ebp),%eax
ac7: 8b 4d 0c mov 0xc(%ebp),%ecx
char *os;
os = s;
while((*s++ = *t++) != 0)
aca: 89 c2 mov %eax,%edx
acc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
ad0: 83 c1 01 add $0x1,%ecx
ad3: 0f b6 59 ff movzbl -0x1(%ecx),%ebx
ad7: 83 c2 01 add $0x1,%edx
ada: 84 db test %bl,%bl
adc: 88 5a ff mov %bl,-0x1(%edx)
adf: 75 ef jne ad0 <strcpy+0x10>
;
return os;
}
ae1: 5b pop %ebx
ae2: 5d pop %ebp
ae3: c3 ret
ae4: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
aea: 8d bf 00 00 00 00 lea 0x0(%edi),%edi
00000af0 <strcmp>:
int
strcmp(const char *p, const char *q)
{
af0: 55 push %ebp
af1: 89 e5 mov %esp,%ebp
af3: 53 push %ebx
af4: 8b 55 08 mov 0x8(%ebp),%edx
af7: 8b 4d 0c mov 0xc(%ebp),%ecx
while(*p && *p == *q)
afa: 0f b6 02 movzbl (%edx),%eax
afd: 0f b6 19 movzbl (%ecx),%ebx
b00: 84 c0 test %al,%al
b02: 75 1c jne b20 <strcmp+0x30>
b04: eb 2a jmp b30 <strcmp+0x40>
b06: 8d 76 00 lea 0x0(%esi),%esi
b09: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
p++, q++;
b10: 83 c2 01 add $0x1,%edx
while(*p && *p == *q)
b13: 0f b6 02 movzbl (%edx),%eax
p++, q++;
b16: 83 c1 01 add $0x1,%ecx
b19: 0f b6 19 movzbl (%ecx),%ebx
while(*p && *p == *q)
b1c: 84 c0 test %al,%al
b1e: 74 10 je b30 <strcmp+0x40>
b20: 38 d8 cmp %bl,%al
b22: 74 ec je b10 <strcmp+0x20>
return (uchar)*p - (uchar)*q;
b24: 29 d8 sub %ebx,%eax
}
b26: 5b pop %ebx
b27: 5d pop %ebp
b28: c3 ret
b29: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
b30: 31 c0 xor %eax,%eax
return (uchar)*p - (uchar)*q;
b32: 29 d8 sub %ebx,%eax
}
b34: 5b pop %ebx
b35: 5d pop %ebp
b36: c3 ret
b37: 89 f6 mov %esi,%esi
b39: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
00000b40 <strlen>:
uint
strlen(const char *s)
{
b40: 55 push %ebp
b41: 89 e5 mov %esp,%ebp
b43: 8b 4d 08 mov 0x8(%ebp),%ecx
int n;
for(n = 0; s[n]; n++)
b46: 80 39 00 cmpb $0x0,(%ecx)
b49: 74 15 je b60 <strlen+0x20>
b4b: 31 d2 xor %edx,%edx
b4d: 8d 76 00 lea 0x0(%esi),%esi
b50: 83 c2 01 add $0x1,%edx
b53: 80 3c 11 00 cmpb $0x0,(%ecx,%edx,1)
b57: 89 d0 mov %edx,%eax
b59: 75 f5 jne b50 <strlen+0x10>
;
return n;
}
b5b: 5d pop %ebp
b5c: c3 ret
b5d: 8d 76 00 lea 0x0(%esi),%esi
for(n = 0; s[n]; n++)
b60: 31 c0 xor %eax,%eax
}
b62: 5d pop %ebp
b63: c3 ret
b64: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
b6a: 8d bf 00 00 00 00 lea 0x0(%edi),%edi
00000b70 <memset>:
void*
memset(void *dst, int c, uint n)
{
b70: 55 push %ebp
b71: 89 e5 mov %esp,%ebp
b73: 57 push %edi
b74: 8b 55 08 mov 0x8(%ebp),%edx
}
static inline void
stosb(void *addr, int data, int cnt)
{
asm volatile("cld; rep stosb" :
b77: 8b 4d 10 mov 0x10(%ebp),%ecx
b7a: 8b 45 0c mov 0xc(%ebp),%eax
b7d: 89 d7 mov %edx,%edi
b7f: fc cld
b80: f3 aa rep stos %al,%es:(%edi)
stosb(dst, c, n);
return dst;
}
b82: 89 d0 mov %edx,%eax
b84: 5f pop %edi
b85: 5d pop %ebp
b86: c3 ret
b87: 89 f6 mov %esi,%esi
b89: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
00000b90 <strchr>:
char*
strchr(const char *s, char c)
{
b90: 55 push %ebp
b91: 89 e5 mov %esp,%ebp
b93: 53 push %ebx
b94: 8b 45 08 mov 0x8(%ebp),%eax
b97: 8b 5d 0c mov 0xc(%ebp),%ebx
for(; *s; s++)
b9a: 0f b6 10 movzbl (%eax),%edx
b9d: 84 d2 test %dl,%dl
b9f: 74 1d je bbe <strchr+0x2e>
if(*s == c)
ba1: 38 d3 cmp %dl,%bl
ba3: 89 d9 mov %ebx,%ecx
ba5: 75 0d jne bb4 <strchr+0x24>
ba7: eb 17 jmp bc0 <strchr+0x30>
ba9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
bb0: 38 ca cmp %cl,%dl
bb2: 74 0c je bc0 <strchr+0x30>
for(; *s; s++)
bb4: 83 c0 01 add $0x1,%eax
bb7: 0f b6 10 movzbl (%eax),%edx
bba: 84 d2 test %dl,%dl
bbc: 75 f2 jne bb0 <strchr+0x20>
return (char*)s;
return 0;
bbe: 31 c0 xor %eax,%eax
}
bc0: 5b pop %ebx
bc1: 5d pop %ebp
bc2: c3 ret
bc3: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
bc9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
00000bd0 <gets>:
char*
gets(char *buf, int max)
{
bd0: 55 push %ebp
bd1: 89 e5 mov %esp,%ebp
bd3: 57 push %edi
bd4: 56 push %esi
bd5: 53 push %ebx
int i, cc;
char c;
for(i=0; i+1 < max; ){
bd6: 31 f6 xor %esi,%esi
bd8: 89 f3 mov %esi,%ebx
{
bda: 83 ec 1c sub $0x1c,%esp
bdd: 8b 7d 08 mov 0x8(%ebp),%edi
for(i=0; i+1 < max; ){
be0: eb 2f jmp c11 <gets+0x41>
be2: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
cc = read(0, &c, 1);
be8: 8d 45 e7 lea -0x19(%ebp),%eax
beb: 83 ec 04 sub $0x4,%esp
bee: 6a 01 push $0x1
bf0: 50 push %eax
bf1: 6a 00 push $0x0
bf3: e8 32 01 00 00 call d2a <read>
if(cc < 1)
bf8: 83 c4 10 add $0x10,%esp
bfb: 85 c0 test %eax,%eax
bfd: 7e 1c jle c1b <gets+0x4b>
break;
buf[i++] = c;
bff: 0f b6 45 e7 movzbl -0x19(%ebp),%eax
c03: 83 c7 01 add $0x1,%edi
c06: 88 47 ff mov %al,-0x1(%edi)
if(c == '\n' || c == '\r')
c09: 3c 0a cmp $0xa,%al
c0b: 74 23 je c30 <gets+0x60>
c0d: 3c 0d cmp $0xd,%al
c0f: 74 1f je c30 <gets+0x60>
for(i=0; i+1 < max; ){
c11: 83 c3 01 add $0x1,%ebx
c14: 3b 5d 0c cmp 0xc(%ebp),%ebx
c17: 89 fe mov %edi,%esi
c19: 7c cd jl be8 <gets+0x18>
c1b: 89 f3 mov %esi,%ebx
break;
}
buf[i] = '\0';
return buf;
}
c1d: 8b 45 08 mov 0x8(%ebp),%eax
buf[i] = '\0';
c20: c6 03 00 movb $0x0,(%ebx)
}
c23: 8d 65 f4 lea -0xc(%ebp),%esp
c26: 5b pop %ebx
c27: 5e pop %esi
c28: 5f pop %edi
c29: 5d pop %ebp
c2a: c3 ret
c2b: 90 nop
c2c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
c30: 8b 75 08 mov 0x8(%ebp),%esi
c33: 8b 45 08 mov 0x8(%ebp),%eax
c36: 01 de add %ebx,%esi
c38: 89 f3 mov %esi,%ebx
buf[i] = '\0';
c3a: c6 03 00 movb $0x0,(%ebx)
}
c3d: 8d 65 f4 lea -0xc(%ebp),%esp
c40: 5b pop %ebx
c41: 5e pop %esi
c42: 5f pop %edi
c43: 5d pop %ebp
c44: c3 ret
c45: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
c49: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
00000c50 <stat>:
int
stat(const char *n, struct stat *st)
{
c50: 55 push %ebp
c51: 89 e5 mov %esp,%ebp
c53: 56 push %esi
c54: 53 push %ebx
int fd;
int r;
fd = open(n, O_RDONLY);
c55: 83 ec 08 sub $0x8,%esp
c58: 6a 00 push $0x0
c5a: ff 75 08 pushl 0x8(%ebp)
c5d: e8 f0 00 00 00 call d52 <open>
if(fd < 0)
c62: 83 c4 10 add $0x10,%esp
c65: 85 c0 test %eax,%eax
c67: 78 27 js c90 <stat+0x40>
return -1;
r = fstat(fd, st);
c69: 83 ec 08 sub $0x8,%esp
c6c: ff 75 0c pushl 0xc(%ebp)
c6f: 89 c3 mov %eax,%ebx
c71: 50 push %eax
c72: e8 f3 00 00 00 call d6a <fstat>
close(fd);
c77: 89 1c 24 mov %ebx,(%esp)
r = fstat(fd, st);
c7a: 89 c6 mov %eax,%esi
close(fd);
c7c: e8 b9 00 00 00 call d3a <close>
return r;
c81: 83 c4 10 add $0x10,%esp
}
c84: 8d 65 f8 lea -0x8(%ebp),%esp
c87: 89 f0 mov %esi,%eax
c89: 5b pop %ebx
c8a: 5e pop %esi
c8b: 5d pop %ebp
c8c: c3 ret
c8d: 8d 76 00 lea 0x0(%esi),%esi
return -1;
c90: be ff ff ff ff mov $0xffffffff,%esi
c95: eb ed jmp c84 <stat+0x34>
c97: 89 f6 mov %esi,%esi
c99: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
00000ca0 <atoi>:
int
atoi(const char *s)
{
ca0: 55 push %ebp
ca1: 89 e5 mov %esp,%ebp
ca3: 53 push %ebx
ca4: 8b 4d 08 mov 0x8(%ebp),%ecx
int n;
n = 0;
while('0' <= *s && *s <= '9')
ca7: 0f be 11 movsbl (%ecx),%edx
caa: 8d 42 d0 lea -0x30(%edx),%eax
cad: 3c 09 cmp $0x9,%al
n = 0;
caf: b8 00 00 00 00 mov $0x0,%eax
while('0' <= *s && *s <= '9')
cb4: 77 1f ja cd5 <atoi+0x35>
cb6: 8d 76 00 lea 0x0(%esi),%esi
cb9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
n = n*10 + *s++ - '0';
cc0: 8d 04 80 lea (%eax,%eax,4),%eax
cc3: 83 c1 01 add $0x1,%ecx
cc6: 8d 44 42 d0 lea -0x30(%edx,%eax,2),%eax
while('0' <= *s && *s <= '9')
cca: 0f be 11 movsbl (%ecx),%edx
ccd: 8d 5a d0 lea -0x30(%edx),%ebx
cd0: 80 fb 09 cmp $0x9,%bl
cd3: 76 eb jbe cc0 <atoi+0x20>
return n;
}
cd5: 5b pop %ebx
cd6: 5d pop %ebp
cd7: c3 ret
cd8: 90 nop
cd9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
00000ce0 <memmove>:
void*
memmove(void *vdst, const void *vsrc, int n)
{
ce0: 55 push %ebp
ce1: 89 e5 mov %esp,%ebp
ce3: 56 push %esi
ce4: 53 push %ebx
ce5: 8b 5d 10 mov 0x10(%ebp),%ebx
ce8: 8b 45 08 mov 0x8(%ebp),%eax
ceb: 8b 75 0c mov 0xc(%ebp),%esi
char *dst;
const char *src;
dst = vdst;
src = vsrc;
while(n-- > 0)
cee: 85 db test %ebx,%ebx
cf0: 7e 14 jle d06 <memmove+0x26>
cf2: 31 d2 xor %edx,%edx
cf4: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
*dst++ = *src++;
cf8: 0f b6 0c 16 movzbl (%esi,%edx,1),%ecx
cfc: 88 0c 10 mov %cl,(%eax,%edx,1)
cff: 83 c2 01 add $0x1,%edx
while(n-- > 0)
d02: 39 d3 cmp %edx,%ebx
d04: 75 f2 jne cf8 <memmove+0x18>
return vdst;
}
d06: 5b pop %ebx
d07: 5e pop %esi
d08: 5d pop %ebp
d09: c3 ret
00000d0a <fork>:
name: \
movl $SYS_ ## name, %eax; \
int $T_SYSCALL; \
ret
SYSCALL(fork)
d0a: b8 01 00 00 00 mov $0x1,%eax
d0f: cd 40 int $0x40
d11: c3 ret
00000d12 <exit>:
SYSCALL(exit)
d12: b8 02 00 00 00 mov $0x2,%eax
d17: cd 40 int $0x40
d19: c3 ret
00000d1a <wait>:
SYSCALL(wait)
d1a: b8 03 00 00 00 mov $0x3,%eax
d1f: cd 40 int $0x40
d21: c3 ret
00000d22 <pipe>:
SYSCALL(pipe)
d22: b8 04 00 00 00 mov $0x4,%eax
d27: cd 40 int $0x40
d29: c3 ret
00000d2a <read>:
SYSCALL(read)
d2a: b8 05 00 00 00 mov $0x5,%eax
d2f: cd 40 int $0x40
d31: c3 ret
00000d32 <write>:
SYSCALL(write)
d32: b8 10 00 00 00 mov $0x10,%eax
d37: cd 40 int $0x40
d39: c3 ret
00000d3a <close>:
SYSCALL(close)
d3a: b8 15 00 00 00 mov $0x15,%eax
d3f: cd 40 int $0x40
d41: c3 ret
00000d42 <kill>:
SYSCALL(kill)
d42: b8 06 00 00 00 mov $0x6,%eax
d47: cd 40 int $0x40
d49: c3 ret
00000d4a <exec>:
SYSCALL(exec)
d4a: b8 07 00 00 00 mov $0x7,%eax
d4f: cd 40 int $0x40
d51: c3 ret
00000d52 <open>:
SYSCALL(open)
d52: b8 0f 00 00 00 mov $0xf,%eax
d57: cd 40 int $0x40
d59: c3 ret
00000d5a <mknod>:
SYSCALL(mknod)
d5a: b8 11 00 00 00 mov $0x11,%eax
d5f: cd 40 int $0x40
d61: c3 ret
00000d62 <unlink>:
SYSCALL(unlink)
d62: b8 12 00 00 00 mov $0x12,%eax
d67: cd 40 int $0x40
d69: c3 ret
00000d6a <fstat>:
SYSCALL(fstat)
d6a: b8 08 00 00 00 mov $0x8,%eax
d6f: cd 40 int $0x40
d71: c3 ret
00000d72 <link>:
SYSCALL(link)
d72: b8 13 00 00 00 mov $0x13,%eax
d77: cd 40 int $0x40
d79: c3 ret
00000d7a <mkdir>:
SYSCALL(mkdir)
d7a: b8 14 00 00 00 mov $0x14,%eax
d7f: cd 40 int $0x40
d81: c3 ret
00000d82 <chdir>:
SYSCALL(chdir)
d82: b8 09 00 00 00 mov $0x9,%eax
d87: cd 40 int $0x40
d89: c3 ret
00000d8a <dup>:
SYSCALL(dup)
d8a: b8 0a 00 00 00 mov $0xa,%eax
d8f: cd 40 int $0x40
d91: c3 ret
00000d92 <getpid>:
SYSCALL(getpid)
d92: b8 0b 00 00 00 mov $0xb,%eax
d97: cd 40 int $0x40
d99: c3 ret
00000d9a <sbrk>:
SYSCALL(sbrk)
d9a: b8 0c 00 00 00 mov $0xc,%eax
d9f: cd 40 int $0x40
da1: c3 ret
00000da2 <sleep>:
SYSCALL(sleep)
da2: b8 0d 00 00 00 mov $0xd,%eax
da7: cd 40 int $0x40
da9: c3 ret
00000daa <uptime>:
SYSCALL(uptime)
daa: b8 0e 00 00 00 mov $0xe,%eax
daf: cd 40 int $0x40
db1: c3 ret
00000db2 <getpriority>:
SYSCALL(getpriority)
db2: b8 16 00 00 00 mov $0x16,%eax
db7: cd 40 int $0x40
db9: c3 ret
00000dba <setpriority>:
SYSCALL(setpriority)
dba: b8 17 00 00 00 mov $0x17,%eax
dbf: cd 40 int $0x40
dc1: c3 ret
00000dc2 <getusage>:
SYSCALL(getusage)
dc2: b8 18 00 00 00 mov $0x18,%eax
dc7: cd 40 int $0x40
dc9: c3 ret
00000dca <trace>:
SYSCALL(trace)
dca: b8 19 00 00 00 mov $0x19,%eax
dcf: cd 40 int $0x40
dd1: c3 ret
00000dd2 <getptable>:
SYSCALL(getptable)
dd2: b8 1a 00 00 00 mov $0x1a,%eax
dd7: cd 40 int $0x40
dd9: c3 ret
dda: 66 90 xchg %ax,%ax
ddc: 66 90 xchg %ax,%ax
dde: 66 90 xchg %ax,%ax
00000de0 <printint>:
write(fd, &c, 1);
}
static void
printint(int fd, int xx, int base, int sgn)
{
de0: 55 push %ebp
de1: 89 e5 mov %esp,%ebp
de3: 57 push %edi
de4: 56 push %esi
de5: 53 push %ebx
de6: 83 ec 3c sub $0x3c,%esp
char buf[16];
int i, neg;
uint x;
neg = 0;
if(sgn && xx < 0){
de9: 85 d2 test %edx,%edx
{
deb: 89 45 c0 mov %eax,-0x40(%ebp)
neg = 1;
x = -xx;
dee: 89 d0 mov %edx,%eax
if(sgn && xx < 0){
df0: 79 76 jns e68 <printint+0x88>
df2: f6 45 08 01 testb $0x1,0x8(%ebp)
df6: 74 70 je e68 <printint+0x88>
x = -xx;
df8: f7 d8 neg %eax
neg = 1;
dfa: c7 45 c4 01 00 00 00 movl $0x1,-0x3c(%ebp)
} else {
x = xx;
}
i = 0;
e01: 31 f6 xor %esi,%esi
e03: 8d 5d d7 lea -0x29(%ebp),%ebx
e06: eb 0a jmp e12 <printint+0x32>
e08: 90 nop
e09: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
do{
buf[i++] = digits[x % base];
e10: 89 fe mov %edi,%esi
e12: 31 d2 xor %edx,%edx
e14: 8d 7e 01 lea 0x1(%esi),%edi
e17: f7 f1 div %ecx
e19: 0f b6 92 c8 12 00 00 movzbl 0x12c8(%edx),%edx
}while((x /= base) != 0);
e20: 85 c0 test %eax,%eax
buf[i++] = digits[x % base];
e22: 88 14 3b mov %dl,(%ebx,%edi,1)
}while((x /= base) != 0);
e25: 75 e9 jne e10 <printint+0x30>
if(neg)
e27: 8b 45 c4 mov -0x3c(%ebp),%eax
e2a: 85 c0 test %eax,%eax
e2c: 74 08 je e36 <printint+0x56>
buf[i++] = '-';
e2e: c6 44 3d d8 2d movb $0x2d,-0x28(%ebp,%edi,1)
e33: 8d 7e 02 lea 0x2(%esi),%edi
e36: 8d 74 3d d7 lea -0x29(%ebp,%edi,1),%esi
e3a: 8b 7d c0 mov -0x40(%ebp),%edi
e3d: 8d 76 00 lea 0x0(%esi),%esi
e40: 0f b6 06 movzbl (%esi),%eax
write(fd, &c, 1);
e43: 83 ec 04 sub $0x4,%esp
e46: 83 ee 01 sub $0x1,%esi
e49: 6a 01 push $0x1
e4b: 53 push %ebx
e4c: 57 push %edi
e4d: 88 45 d7 mov %al,-0x29(%ebp)
e50: e8 dd fe ff ff call d32 <write>
while(--i >= 0)
e55: 83 c4 10 add $0x10,%esp
e58: 39 de cmp %ebx,%esi
e5a: 75 e4 jne e40 <printint+0x60>
putc(fd, buf[i]);
}
e5c: 8d 65 f4 lea -0xc(%ebp),%esp
e5f: 5b pop %ebx
e60: 5e pop %esi
e61: 5f pop %edi
e62: 5d pop %ebp
e63: c3 ret
e64: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
neg = 0;
e68: c7 45 c4 00 00 00 00 movl $0x0,-0x3c(%ebp)
e6f: eb 90 jmp e01 <printint+0x21>
e71: eb 0d jmp e80 <printf>
e73: 90 nop
e74: 90 nop
e75: 90 nop
e76: 90 nop
e77: 90 nop
e78: 90 nop
e79: 90 nop
e7a: 90 nop
e7b: 90 nop
e7c: 90 nop
e7d: 90 nop
e7e: 90 nop
e7f: 90 nop
00000e80 <printf>:
// Print to the given fd. Only understands %d, %x, %p, %s.
void
printf(int fd, const char *fmt, ...)
{
e80: 55 push %ebp
e81: 89 e5 mov %esp,%ebp
e83: 57 push %edi
e84: 56 push %esi
e85: 53 push %ebx
e86: 83 ec 2c sub $0x2c,%esp
int c, i, state;
uint *ap;
state = 0;
ap = (uint*)(void*)&fmt + 1;
for(i = 0; fmt[i]; i++){
e89: 8b 75 0c mov 0xc(%ebp),%esi
e8c: 0f b6 1e movzbl (%esi),%ebx
e8f: 84 db test %bl,%bl
e91: 0f 84 b3 00 00 00 je f4a <printf+0xca>
ap = (uint*)(void*)&fmt + 1;
e97: 8d 45 10 lea 0x10(%ebp),%eax
e9a: 83 c6 01 add $0x1,%esi
state = 0;
e9d: 31 ff xor %edi,%edi
ap = (uint*)(void*)&fmt + 1;
e9f: 89 45 d4 mov %eax,-0x2c(%ebp)
ea2: eb 2f jmp ed3 <printf+0x53>
ea4: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
c = fmt[i] & 0xff;
if(state == 0){
if(c == '%'){
ea8: 83 f8 25 cmp $0x25,%eax
eab: 0f 84 a7 00 00 00 je f58 <printf+0xd8>
write(fd, &c, 1);
eb1: 8d 45 e2 lea -0x1e(%ebp),%eax
eb4: 83 ec 04 sub $0x4,%esp
eb7: 88 5d e2 mov %bl,-0x1e(%ebp)
eba: 6a 01 push $0x1
ebc: 50 push %eax
ebd: ff 75 08 pushl 0x8(%ebp)
ec0: e8 6d fe ff ff call d32 <write>
ec5: 83 c4 10 add $0x10,%esp
ec8: 83 c6 01 add $0x1,%esi
for(i = 0; fmt[i]; i++){
ecb: 0f b6 5e ff movzbl -0x1(%esi),%ebx
ecf: 84 db test %bl,%bl
ed1: 74 77 je f4a <printf+0xca>
if(state == 0){
ed3: 85 ff test %edi,%edi
c = fmt[i] & 0xff;
ed5: 0f be cb movsbl %bl,%ecx
ed8: 0f b6 c3 movzbl %bl,%eax
if(state == 0){
edb: 74 cb je ea8 <printf+0x28>
state = '%';
} else {
putc(fd, c);
}
} else if(state == '%'){
edd: 83 ff 25 cmp $0x25,%edi
ee0: 75 e6 jne ec8 <printf+0x48>
if(c == 'd'){
ee2: 83 f8 64 cmp $0x64,%eax
ee5: 0f 84 05 01 00 00 je ff0 <printf+0x170>
printint(fd, *ap, 10, 1);
ap++;
} else if(c == 'x' || c == 'p'){
eeb: 81 e1 f7 00 00 00 and $0xf7,%ecx
ef1: 83 f9 70 cmp $0x70,%ecx
ef4: 74 72 je f68 <printf+0xe8>
printint(fd, *ap, 16, 0);
ap++;
} else if(c == 's'){
ef6: 83 f8 73 cmp $0x73,%eax
ef9: 0f 84 99 00 00 00 je f98 <printf+0x118>
s = "(null)";
while(*s != 0){
putc(fd, *s);
s++;
}
} else if(c == 'c'){
eff: 83 f8 63 cmp $0x63,%eax
f02: 0f 84 08 01 00 00 je 1010 <printf+0x190>
putc(fd, *ap);
ap++;
} else if(c == '%'){
f08: 83 f8 25 cmp $0x25,%eax
f0b: 0f 84 ef 00 00 00 je 1000 <printf+0x180>
write(fd, &c, 1);
f11: 8d 45 e7 lea -0x19(%ebp),%eax
f14: 83 ec 04 sub $0x4,%esp
f17: c6 45 e7 25 movb $0x25,-0x19(%ebp)
f1b: 6a 01 push $0x1
f1d: 50 push %eax
f1e: ff 75 08 pushl 0x8(%ebp)
f21: e8 0c fe ff ff call d32 <write>
f26: 83 c4 0c add $0xc,%esp
f29: 8d 45 e6 lea -0x1a(%ebp),%eax
f2c: 88 5d e6 mov %bl,-0x1a(%ebp)
f2f: 6a 01 push $0x1
f31: 50 push %eax
f32: ff 75 08 pushl 0x8(%ebp)
f35: 83 c6 01 add $0x1,%esi
} else {
// Unknown % sequence. Print it to draw attention.
putc(fd, '%');
putc(fd, c);
}
state = 0;
f38: 31 ff xor %edi,%edi
write(fd, &c, 1);
f3a: e8 f3 fd ff ff call d32 <write>
for(i = 0; fmt[i]; i++){
f3f: 0f b6 5e ff movzbl -0x1(%esi),%ebx
write(fd, &c, 1);
f43: 83 c4 10 add $0x10,%esp
for(i = 0; fmt[i]; i++){
f46: 84 db test %bl,%bl
f48: 75 89 jne ed3 <printf+0x53>
}
}
}
f4a: 8d 65 f4 lea -0xc(%ebp),%esp
f4d: 5b pop %ebx
f4e: 5e pop %esi
f4f: 5f pop %edi
f50: 5d pop %ebp
f51: c3 ret
f52: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
state = '%';
f58: bf 25 00 00 00 mov $0x25,%edi
f5d: e9 66 ff ff ff jmp ec8 <printf+0x48>
f62: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
printint(fd, *ap, 16, 0);
f68: 83 ec 0c sub $0xc,%esp
f6b: b9 10 00 00 00 mov $0x10,%ecx
f70: 6a 00 push $0x0
f72: 8b 7d d4 mov -0x2c(%ebp),%edi
f75: 8b 45 08 mov 0x8(%ebp),%eax
f78: 8b 17 mov (%edi),%edx
f7a: e8 61 fe ff ff call de0 <printint>
ap++;
f7f: 89 f8 mov %edi,%eax
f81: 83 c4 10 add $0x10,%esp
state = 0;
f84: 31 ff xor %edi,%edi
ap++;
f86: 83 c0 04 add $0x4,%eax
f89: 89 45 d4 mov %eax,-0x2c(%ebp)
f8c: e9 37 ff ff ff jmp ec8 <printf+0x48>
f91: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
s = (char*)*ap;
f98: 8b 45 d4 mov -0x2c(%ebp),%eax
f9b: 8b 08 mov (%eax),%ecx
ap++;
f9d: 83 c0 04 add $0x4,%eax
fa0: 89 45 d4 mov %eax,-0x2c(%ebp)
if(s == 0)
fa3: 85 c9 test %ecx,%ecx
fa5: 0f 84 8e 00 00 00 je 1039 <printf+0x1b9>
while(*s != 0){
fab: 0f b6 01 movzbl (%ecx),%eax
state = 0;
fae: 31 ff xor %edi,%edi
s = (char*)*ap;
fb0: 89 cb mov %ecx,%ebx
while(*s != 0){
fb2: 84 c0 test %al,%al
fb4: 0f 84 0e ff ff ff je ec8 <printf+0x48>
fba: 89 75 d0 mov %esi,-0x30(%ebp)
fbd: 89 de mov %ebx,%esi
fbf: 8b 5d 08 mov 0x8(%ebp),%ebx
fc2: 8d 7d e3 lea -0x1d(%ebp),%edi
fc5: 8d 76 00 lea 0x0(%esi),%esi
write(fd, &c, 1);
fc8: 83 ec 04 sub $0x4,%esp
s++;
fcb: 83 c6 01 add $0x1,%esi
fce: 88 45 e3 mov %al,-0x1d(%ebp)
write(fd, &c, 1);
fd1: 6a 01 push $0x1
fd3: 57 push %edi
fd4: 53 push %ebx
fd5: e8 58 fd ff ff call d32 <write>
while(*s != 0){
fda: 0f b6 06 movzbl (%esi),%eax
fdd: 83 c4 10 add $0x10,%esp
fe0: 84 c0 test %al,%al
fe2: 75 e4 jne fc8 <printf+0x148>
fe4: 8b 75 d0 mov -0x30(%ebp),%esi
state = 0;
fe7: 31 ff xor %edi,%edi
fe9: e9 da fe ff ff jmp ec8 <printf+0x48>
fee: 66 90 xchg %ax,%ax
printint(fd, *ap, 10, 1);
ff0: 83 ec 0c sub $0xc,%esp
ff3: b9 0a 00 00 00 mov $0xa,%ecx
ff8: 6a 01 push $0x1
ffa: e9 73 ff ff ff jmp f72 <printf+0xf2>
fff: 90 nop
write(fd, &c, 1);
1000: 83 ec 04 sub $0x4,%esp
1003: 88 5d e5 mov %bl,-0x1b(%ebp)
1006: 8d 45 e5 lea -0x1b(%ebp),%eax
1009: 6a 01 push $0x1
100b: e9 21 ff ff ff jmp f31 <printf+0xb1>
putc(fd, *ap);
1010: 8b 7d d4 mov -0x2c(%ebp),%edi
write(fd, &c, 1);
1013: 83 ec 04 sub $0x4,%esp
putc(fd, *ap);
1016: 8b 07 mov (%edi),%eax
write(fd, &c, 1);
1018: 6a 01 push $0x1
ap++;
101a: 83 c7 04 add $0x4,%edi
putc(fd, *ap);
101d: 88 45 e4 mov %al,-0x1c(%ebp)
write(fd, &c, 1);
1020: 8d 45 e4 lea -0x1c(%ebp),%eax
1023: 50 push %eax
1024: ff 75 08 pushl 0x8(%ebp)
1027: e8 06 fd ff ff call d32 <write>
ap++;
102c: 89 7d d4 mov %edi,-0x2c(%ebp)
102f: 83 c4 10 add $0x10,%esp
state = 0;
1032: 31 ff xor %edi,%edi
1034: e9 8f fe ff ff jmp ec8 <printf+0x48>
s = "(null)";
1039: bb c0 12 00 00 mov $0x12c0,%ebx
while(*s != 0){
103e: b8 28 00 00 00 mov $0x28,%eax
1043: e9 72 ff ff ff jmp fba <printf+0x13a>
1048: 66 90 xchg %ax,%ax
104a: 66 90 xchg %ax,%ax
104c: 66 90 xchg %ax,%ax
104e: 66 90 xchg %ax,%ax
00001050 <free>:
static Header base;
static Header *freep;
void
free(void *ap)
{
1050: 55 push %ebp
Header *bp, *p;
bp = (Header*)ap - 1;
for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
1051: a1 04 19 00 00 mov 0x1904,%eax
{
1056: 89 e5 mov %esp,%ebp
1058: 57 push %edi
1059: 56 push %esi
105a: 53 push %ebx
105b: 8b 5d 08 mov 0x8(%ebp),%ebx
bp = (Header*)ap - 1;
105e: 8d 4b f8 lea -0x8(%ebx),%ecx
1061: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
1068: 39 c8 cmp %ecx,%eax
106a: 8b 10 mov (%eax),%edx
106c: 73 32 jae 10a0 <free+0x50>
106e: 39 d1 cmp %edx,%ecx
1070: 72 04 jb 1076 <free+0x26>
if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
1072: 39 d0 cmp %edx,%eax
1074: 72 32 jb 10a8 <free+0x58>
break;
if(bp + bp->s.size == p->s.ptr){
1076: 8b 73 fc mov -0x4(%ebx),%esi
1079: 8d 3c f1 lea (%ecx,%esi,8),%edi
107c: 39 fa cmp %edi,%edx
107e: 74 30 je 10b0 <free+0x60>
bp->s.size += p->s.ptr->s.size;
bp->s.ptr = p->s.ptr->s.ptr;
} else
bp->s.ptr = p->s.ptr;
1080: 89 53 f8 mov %edx,-0x8(%ebx)
if(p + p->s.size == bp){
1083: 8b 50 04 mov 0x4(%eax),%edx
1086: 8d 34 d0 lea (%eax,%edx,8),%esi
1089: 39 f1 cmp %esi,%ecx
108b: 74 3a je 10c7 <free+0x77>
p->s.size += bp->s.size;
p->s.ptr = bp->s.ptr;
} else
p->s.ptr = bp;
108d: 89 08 mov %ecx,(%eax)
freep = p;
108f: a3 04 19 00 00 mov %eax,0x1904
}
1094: 5b pop %ebx
1095: 5e pop %esi
1096: 5f pop %edi
1097: 5d pop %ebp
1098: c3 ret
1099: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
10a0: 39 d0 cmp %edx,%eax
10a2: 72 04 jb 10a8 <free+0x58>
10a4: 39 d1 cmp %edx,%ecx
10a6: 72 ce jb 1076 <free+0x26>
{
10a8: 89 d0 mov %edx,%eax
10aa: eb bc jmp 1068 <free+0x18>
10ac: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
bp->s.size += p->s.ptr->s.size;
10b0: 03 72 04 add 0x4(%edx),%esi
10b3: 89 73 fc mov %esi,-0x4(%ebx)
bp->s.ptr = p->s.ptr->s.ptr;
10b6: 8b 10 mov (%eax),%edx
10b8: 8b 12 mov (%edx),%edx
10ba: 89 53 f8 mov %edx,-0x8(%ebx)
if(p + p->s.size == bp){
10bd: 8b 50 04 mov 0x4(%eax),%edx
10c0: 8d 34 d0 lea (%eax,%edx,8),%esi
10c3: 39 f1 cmp %esi,%ecx
10c5: 75 c6 jne 108d <free+0x3d>
p->s.size += bp->s.size;
10c7: 03 53 fc add -0x4(%ebx),%edx
freep = p;
10ca: a3 04 19 00 00 mov %eax,0x1904
p->s.size += bp->s.size;
10cf: 89 50 04 mov %edx,0x4(%eax)
p->s.ptr = bp->s.ptr;
10d2: 8b 53 f8 mov -0x8(%ebx),%edx
10d5: 89 10 mov %edx,(%eax)
}
10d7: 5b pop %ebx
10d8: 5e pop %esi
10d9: 5f pop %edi
10da: 5d pop %ebp
10db: c3 ret
10dc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
000010e0 <malloc>:
return freep;
}
void*
malloc(uint nbytes)
{
10e0: 55 push %ebp
10e1: 89 e5 mov %esp,%ebp
10e3: 57 push %edi
10e4: 56 push %esi
10e5: 53 push %ebx
10e6: 83 ec 0c sub $0xc,%esp
Header *p, *prevp;
uint nunits;
nunits = (nbytes + sizeof(Header) - 1)/sizeof(Header) + 1;
10e9: 8b 45 08 mov 0x8(%ebp),%eax
if((prevp = freep) == 0){
10ec: 8b 15 04 19 00 00 mov 0x1904,%edx
nunits = (nbytes + sizeof(Header) - 1)/sizeof(Header) + 1;
10f2: 8d 78 07 lea 0x7(%eax),%edi
10f5: c1 ef 03 shr $0x3,%edi
10f8: 83 c7 01 add $0x1,%edi
if((prevp = freep) == 0){
10fb: 85 d2 test %edx,%edx
10fd: 0f 84 9d 00 00 00 je 11a0 <malloc+0xc0>
1103: 8b 02 mov (%edx),%eax
1105: 8b 48 04 mov 0x4(%eax),%ecx
base.s.ptr = freep = prevp = &base;
base.s.size = 0;
}
for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
if(p->s.size >= nunits){
1108: 39 cf cmp %ecx,%edi
110a: 76 6c jbe 1178 <malloc+0x98>
110c: 81 ff 00 10 00 00 cmp $0x1000,%edi
1112: bb 00 10 00 00 mov $0x1000,%ebx
1117: 0f 43 df cmovae %edi,%ebx
p = sbrk(nu * sizeof(Header));
111a: 8d 34 dd 00 00 00 00 lea 0x0(,%ebx,8),%esi
1121: eb 0e jmp 1131 <malloc+0x51>
1123: 90 nop
1124: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
1128: 8b 02 mov (%edx),%eax
if(p->s.size >= nunits){
112a: 8b 48 04 mov 0x4(%eax),%ecx
112d: 39 f9 cmp %edi,%ecx
112f: 73 47 jae 1178 <malloc+0x98>
p->s.size = nunits;
}
freep = prevp;
return (void*)(p + 1);
}
if(p == freep)
1131: 39 05 04 19 00 00 cmp %eax,0x1904
1137: 89 c2 mov %eax,%edx
1139: 75 ed jne 1128 <malloc+0x48>
p = sbrk(nu * sizeof(Header));
113b: 83 ec 0c sub $0xc,%esp
113e: 56 push %esi
113f: e8 56 fc ff ff call d9a <sbrk>
if(p == (char*)-1)
1144: 83 c4 10 add $0x10,%esp
1147: 83 f8 ff cmp $0xffffffff,%eax
114a: 74 1c je 1168 <malloc+0x88>
hp->s.size = nu;
114c: 89 58 04 mov %ebx,0x4(%eax)
free((void*)(hp + 1));
114f: 83 ec 0c sub $0xc,%esp
1152: 83 c0 08 add $0x8,%eax
1155: 50 push %eax
1156: e8 f5 fe ff ff call 1050 <free>
return freep;
115b: 8b 15 04 19 00 00 mov 0x1904,%edx
if((p = morecore(nunits)) == 0)
1161: 83 c4 10 add $0x10,%esp
1164: 85 d2 test %edx,%edx
1166: 75 c0 jne 1128 <malloc+0x48>
return 0;
}
}
1168: 8d 65 f4 lea -0xc(%ebp),%esp
return 0;
116b: 31 c0 xor %eax,%eax
}
116d: 5b pop %ebx
116e: 5e pop %esi
116f: 5f pop %edi
1170: 5d pop %ebp
1171: c3 ret
1172: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
if(p->s.size == nunits)
1178: 39 cf cmp %ecx,%edi
117a: 74 54 je 11d0 <malloc+0xf0>
p->s.size -= nunits;
117c: 29 f9 sub %edi,%ecx
117e: 89 48 04 mov %ecx,0x4(%eax)
p += p->s.size;
1181: 8d 04 c8 lea (%eax,%ecx,8),%eax
p->s.size = nunits;
1184: 89 78 04 mov %edi,0x4(%eax)
freep = prevp;
1187: 89 15 04 19 00 00 mov %edx,0x1904
}
118d: 8d 65 f4 lea -0xc(%ebp),%esp
return (void*)(p + 1);
1190: 83 c0 08 add $0x8,%eax
}
1193: 5b pop %ebx
1194: 5e pop %esi
1195: 5f pop %edi
1196: 5d pop %ebp
1197: c3 ret
1198: 90 nop
1199: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
base.s.ptr = freep = prevp = &base;
11a0: c7 05 04 19 00 00 08 movl $0x1908,0x1904
11a7: 19 00 00
11aa: c7 05 08 19 00 00 08 movl $0x1908,0x1908
11b1: 19 00 00
base.s.size = 0;
11b4: b8 08 19 00 00 mov $0x1908,%eax
11b9: c7 05 0c 19 00 00 00 movl $0x0,0x190c
11c0: 00 00 00
11c3: e9 44 ff ff ff jmp 110c <malloc+0x2c>
11c8: 90 nop
11c9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
prevp->s.ptr = p->s.ptr;
11d0: 8b 08 mov (%eax),%ecx
11d2: 89 0a mov %ecx,(%edx)
11d4: eb b1 jmp 1187 <malloc+0xa7>
|
; A145934: Expansion of 1/(1-x*(1-6*x)).
; 1,1,-5,-11,19,85,-29,-539,-365,2869,5059,-12155,-42509,30421,285475,102949,-1609901,-2227595,7431811,20797381,-23793485,-148577771,-5816861,885649765,920550931,-4393347659,-9916653245,16443432709,75943352179,-22717244075,-478377357149,-342073892699,2528190250195,4580633606389,-10588507894781,-38072309533115,25458737835571,253892595034261,101140168020835,-1422215402184731,-2029056410309741,6504236002798645,18678574464657091,-20346841552134779,-132418288340077325,-10337239027268651,784172491013195299,846195925176807205,-3858839020902364589,-8936014571963207819,14217019553450979715,67833106985230226629,-17469010335475651661,-424467652246857011435,-319653590234003101469,2227152323247138967141,4145073864651157575955,-9217840074831676226891,-34088283262738621682621,21218757186251435678725,225748456762683165774451,98435913645174551702101,-1256054826930924442944605,-1846670308801971753157211,5689658652783574904510419,16769680505595405423453685,-17368271411106044003608829,-117986354444678476544330939,-13776725978042212522677965,694141400690028646743307669,776801756558281921879375459,-3388046647581889958580470555,-8048857186931581489856723309,12279422698559758261626100021,60572565820149247200766439875,-13103970371209302368990160251,-376539365292104785573588799501,-297915543064848971359647837995,1961320648687779742081884959011,3748813907076873570239771986981,-8019109985049804882251537767085,-30511993427511046303690169688971,17602666482787782989819056913539,200674627047854060811960075047365,95058628151127362873045733566131,-1108989134135997001998714716718059,-1679340903042761179236989118114845,4974593901773220832755299182193509,15050639320029787908177233890882579,-14796924090609537088354561202278475,-105100760010788264537417964547573949,-16319215467131042007290597333903099,614285344597598545217217189951540595,712200637400384797260960773954959189
mul $0,2
mov $1,1
lpb $0
sub $0,2
sub $1,$2
add $2,$1
mul $2,6
lpe
mov $0,$1
|
-- HUMAN RESOURCE MACHINE PROGRAM --
COPYFROM 24
COPYTO 20
BUMPUP 20
a:
COPYFROM 24
COPYTO 22
BUMPUP 22
BUMPUP 22
INBOX
COPYTO 0
COMMENT 0
b:
COPYFROM 24
COPYTO 23
COPYFROM 0
COPYTO 21
SUB 20
JUMPZ j
c:
COPYFROM 21
SUB 22
JUMPN e
JUMPZ d
COPYTO 21
BUMPUP 23
JUMP c
d:
COPYFROM 22
OUTBOX
BUMPUP 23
COPYTO 0
JUMP b
e:
COMMENT 1
BUMPUP 22
f:
COPYFROM 24
COPYTO 23
COPYFROM 0
COPYTO 21
SUB 20
JUMPZ k
g:
COPYFROM 21
SUB 22
JUMPN i
JUMPZ h
COPYTO 21
BUMPUP 23
JUMP g
h:
COPYFROM 22
OUTBOX
BUMPUP 23
COPYTO 0
JUMP f
i:
COPYFROM 0
OUTBOX
j:
k:
JUMP a
DEFINE COMMENT 0
eJwTZGBgeJH1SCuw+JGWd2mKjlntH5u1DV3ui1qWRMq12efKtZ0rV2i916zZ9GeGXgPHou0109dcKjI6
8DXV59LZkqNn+XqOnmUYBaNgFAxZAAAhuiCV;
DEFINE COMMENT 1
eJwTYWBgeJtxTdG6+prirup76tbVldaeZUsi7+eG1DzNjmn6lPa8szExs9uzLLN7a21u36rGwonzW6um
z2ljmDOnTXS1Wa31sej8W3fu5z5+9CIr8znDKBgFo2BIAQBoWigf;
DEFINE LABEL 20
eJxjZWBguJV/UuJW/oqYuDyGOfdzL11joCOY5KyXCGYkfbdkTZhc7R4/fQ2I+zep0FQx18wyrLDJ8VLR
o4hLRTszgouOFkYWnCt/lCNYdTjhUpVfybVanlLJBp7S1z2nSq1ngPSdKmWYA6K9S82mupVHrAWx+Xo4
SoK6Jldf6bzVMKXzfb9w1+dJJ3vrZtVMaltgNTlkle2kiLUXuyBq4+fW2SnNmV63cE7iZhC/eK1im/ma
skMg9v8VWyabrH3fL7JTq4eeYTQKRgEtAQA4mVLv;
DEFINE LABEL 22
eJzzZ2BgUFV1P6+q6i+rpHZW+o/xWelHtiEK1x0faYU6NTm+sQyoLDO71dBgdK95nvq9Znn1Ww2zNW41
ALUxWPieu2zhm2u03fe57nZff1mQ2B7vo6LLg4+KKoe6i/PGJmiyJuQaMSX+sWFKbHNhTRD0mRK1Jn5l
kHWWdpB7sUHArQbdwIh65dBbDdMiUzt4Yz9PYkiavLIuacnWX8kb9v1KNj8MMjOs0OdSWKGgT2QBg0Nk
QYoOSGx7jdGB7TURypY1ziK7qt3Ft9eEKMxvnR4g0WGU0tWb0NrS/7qnZlLhxN+THrd9m3Ku/Nks2dAb
809KhC/4Y3N28a2GAyuMDhxYcfQsyCyVze7ib467i4PYm9deU9y81rlgwzqGOWvXC67Q2bBm99JN7ucl
tzuf8b3sfAakRnPjltSCY0YpDKNgFAwDAAC7jYIO;
DEFINE LABEL 23
eJxzY2BguOmQqR/tkGt0x17QJ8Fufthza++y59b9yxLs1uw+7+J+3trn3OXtvucub/E7eWF9wM4jsuGS
63piCyd2xj3vbIs/V94WvyaeI14tui9GMsjY/7vlGdcUnWDnR1qhTq8Nbjq8NgBawWDhG9Nk4Vs3a16Y
3t6ZEVsOikYdPCUU7XwGJPchPUHzQ/rjtpxMlvn3c7ccPF/sfGZvlfOZ5U1q2+Xacvuk25/rgtRdXhii
cGN+jFr83FyjD9PUooumbUgqmnar4fPUhNaiaSzzX8w0OpA45+jZmHnnLocsDLlxeHnIDZXN7ufltjqf
6dg7fU3T/rYF/w5kdv87sDNj0s5bKjO2hyjIbb0kp7LZW0png7u44wp3cZflJyVOL4lQZhgFo2CEAABl
XoK6;
|
; A323649: Corner sequence of the cellular automaton of A323650.
; 1,3,6,12,15,21,30,48,51,57,66,84,93,111,138,192,195,201,210,228,237,255,282,336,345,363,390,444,471,525,606,768
mov $3,$0
add $3,1
mov $6,$0
lpb $3
mov $0,$6
sub $3,1
sub $0,$3
cmp $4,0
add $2,$4
add $2,1
cal $0,161411 ; First differences of A160410.
mul $2,$0
add $0,$2
mul $0,3
mod $2,2
mov $5,$0
sub $5,21
div $5,36
add $5,1
add $1,$5
lpe
|
#include "Selected.h"
unsigned long COMPONENT_SELECTED = 1 << 5;
Selected::Selected() : Component(COMPONENT_SELECTED) {
_selected = false;
}
Selected::~Selected() {}
void Selected::select() {
_selected = true;
}
void Selected::deselect() {
_selected = false;
}
const bool & Selected::selected() {
return _selected;
}
|
;---------------------------------------------------------------------------
;
; Module: cpuspeed.asm
;
; Purpose:
; Computes the CPU speed using the 8254 and the NOP instruction.
;
; Development Team:
; Bryan A. Woodruff
;
; History: Date Author Comment
; 8/13/92 BryanW Wrote it
;
;---------------------------------------------------------------------------
;
; Written by Microsoft Product Support Service, Windows Developer Support.
; Copyright (c) 1992 Microsoft Corporation. All Rights Reserved.
;
;---------------------------------------------------------------------------
NAME CPUSPEED
.286p
;-------------------------------------------------------------------------
.xlist ; suspend listing
?PLM=1 ; support Pascal calling
?WIN=1 ; support Windows
memM=1 ; medium model
include CMacros.Inc
include Windows.Inc
.list
;-------------------------------------------------------------------------
;-------------------------------------------------------------------------
; local definitions
;-------------------------------------------------------------------------
Timer1_Ctl_Port equ 43h
Timer1_Ctr2 equ 42h
System_Port_B equ 61h
; SC1 SC0 RW1 RW0 M2 M1 M0 BCD
Ctr2_Access equ 10110100b ; 1 0 1 1 0 1 0 0
; Counter 2 (Speaker tone)
; Read/Write LSB first, then MSB
; Rate generator (count down)
; Binary counter
; SC1 SC0 RW1 RW0 D3 D2 D1 D0
Ctr2_Latch equ 10000000b ; 1 0 0 0 X X X X
; Counter 2 (Speaker tone)
; Counter latch command
assumes DS, NOTHING
;-------------------------------------------------------------------------
; segment definition
;-------------------------------------------------------------------------
createSeg CPUSPEED, CPUSPEED, PARA, PUBLIC, CODE
sBegin CPUSPEED
assumes CS, CPUSPEED
;------------------------------------------------------------------------
; DWORD ComputeCPUSpeed, <PUBLIC, FAR>
;
; Description:
;
;
; Parameters:
;
;
;
; History: Date Author Comment
; 8/13/92 BryanW Wrote it.
;
;------------------------------------------------------------------------
cProc ComputeCPUSpeed, <PUBLIC, FAR>
LocalW wTicks
cBegin
mov dx, System_Port_B ; turn off speaker
in al, dx ; & timer 2...
and al, 0fch
out dx, al
mov dx, Timer1_Ctl_Port
mov al, Ctr2_Access
out dx, al
mov dx, Timer1_Ctr2
xor al, al
out dx, al ; reset counter
nop
out dx, al
pushf
cli
mov dx, System_Port_B ; enable input
in al, dx ; to timer 1 / ctr 2
mov bl, al
or al, 1
out dx, al
; db 250 dup (0f8h) ; clc
dw 250 dup (0ad4h) ; aam
mov al, bl
out dx, al
pop ax
cmp ah, 2
jz SHORT @F
sti
@@:
mov dx, Timer1_Ctr2
in al, dx ; al <- LSB
mov ah, al
nop
in al, dx ; al <- MSB
xchg al, ah ; order AX
neg ax
mov dx, 250 * 15
cEnd
sEnd CPUSPEED
end
;---------------------------------------------------------------------------
; End of File: cpuspeed.asm
;---------------------------------------------------------------------------
|
# Sorting Arrays
# Lab 5.4
# Vo Huy
# Data Memory Location
.data
array1: .word 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, -1, -2, -3, -4, -5, -6, -7, -8, -9, -100
.align 2
length1:.word 20
.align 2
array2: .word -20, 8, -4, 3, -3, 4, -8, 20
.align 2
length2:.word 8
.align 2
array3: .word -9, -1, 0, 3, 9, 100, 1
.align 2
length3:.word 7
.align 2
array4: .word -99, -100, -1, -3, -9, -99, -100, -3, -1, -9
.align 2
length4:.word 10
.align 2
hex: .space 40
.align 2
comma: .asciiz ", "
.align 2
newline: .asciiz "\n"
.align 2
original_array:
.asciiz "The original array: "
sorted_array:
.asciiz "The sorted array: "
.text
.globl main
main:
# ORIGINAL ARRAY 1
li $v0, 4
la $a0, original_array #"The original array: "
syscall
la $a0, array1
lw $a1, length1
jal print_array #Original array 1
li $v0, 4
la $a0, newline #newline
syscall
# SORTING ARRAY 1
li $v0, 4
la $a0, sorted_array #"The sorted array: "
syscall
la $a0, array1
jal selection_sort #selection_sort(*array1, length1)
jal print_array #Sorted array 1
li $v0, 4
la $a0, newline #newline
syscall
li $v0, 4
la $a0, newline #newline
syscall
# ORIGINAL ARRAY 2
li $v0, 4
la $a0, original_array #"The original array: "
syscall
la $a0, array2
lw $a1, length2
jal print_array
li $v0, 4
la $a0, newline #newline
syscall
# SORTING ARRAY 2
li $v0, 4
la $a0, sorted_array #"The sorted array: "
syscall
la $a0, array2
jal selection_sort #selection_sort(*array2, length2)
jal print_array
li $v0, 4
la $a0, newline #newline
syscall
li $v0, 4
la $a0, newline #newline
syscall
# ORIGINAL ARRAY 3
li $v0, 4
la $a0, original_array #"The original array: "
syscall
la $a0, array3
lw $a1, length3
jal print_array
li $v0, 4
la $a0, newline #newline
syscall
# SORTING ARRAY 3
li $v0, 4
la $a0, sorted_array #"The sorted array: "
syscall
la $a0, array3
jal selection_sort #selection_sort(*array3, length3)
jal print_array
li $v0, 4
la $a0, newline #newline
syscall
li $v0, 4
la $a0, newline #newline
syscall
# ORIGINAL ARRAY 4
li $v0, 4
la $a0, original_array #"The original array: "
syscall
la $a0, array4
lw $a1, length4
jal print_array
li $v0, 4
la $a0, newline #newline
syscall
# SORTING ARRAY 4
li $v0, 4
la $a0, sorted_array #"The sorted array: "
syscall
la $a0, array4
jal selection_sort #selection_sort(*array4, length4)
jal print_array
li $v0, 10 #EXIT
syscall
li $v0, 4
la $a0, newline #newline
syscall
#void SELECTION_SORT(int *nums, int length)
selection_sort:
addi $sp, $sp, -8
sw $ra, 8($sp) #push $ra to the stack
addi $s0, $a1, 0 #s0 = length
addi $s1, $zero, 0 #int i = 0
for11: bge $s1, $s0, after_for11 #if i >= length, exit the loop
addi $s2, $s1, 0 #index_of_min = i;
addi $s3, $s1, 0 #int j = i
j for22
after_for22:
#SWAPPING ELEMENTS
sw $a1, 4($sp) #push a1 of selection_sort (length) to the stack
#a0 is still *sum
addi $a1, $s1, 0 #a1 = i
addi $a2, $s2, 0 #a2 = index_of_min
jal swap
lw $a1, 4($sp) #pop a1 of selection_sort (length) from the stack
add $s1, $s1, 1 #i++
j for11 #looping for1
for22: bge $s3, $s0, after_for22 #if j >= length, exit the loop
sll $t0, $s2, 2 #t0 = index_of_min*4 the distance from the element to the base adress
add $t0, $t0, $a0 #the address of nums[index_of_min]
lw $t1, ($t0) #nums[index_of_min]
sll $t0, $s3, 2 #t0 = j*4 the distance from the element to the base adress
add $t0, $t0, $a0 #the address of nums[j]
lw $t2, ($t0) #nums[j]
ble $t1, $t2, skip_new_min
addi $s2, $s3, 0
skip_new_min:
add $s3, $s3, 1 #j++
j for22 #looping for1
after_for11:
lw $ra, 8($sp) #pop $ra from the stack for selection_sort function
addi $sp, $sp, 8
jr $ra #finish selection_sort function
#void SWAP(int *nums, index1, index2)
swap:
addi $s7, $a0, 0 #the address of the array (the base address)
sll $t4, $a1, 2 #t4 = index1 * 4 = the distance to index1 from the base address
add $t4, $s7, $t4 #the address of index1
lw $t5, ($t4) #int temp = nums[index1]
sll $t6, $a2, 2 #t2 = index2 * 4 = the distance to index2 from the base address
add $t6, $s7, $t6 #the address of index2
lw $t7, ($t6) #t3 = nums[index2]
sw $t7, ($t4) #nums[index1] = nums[index2]
sw $t5, ($t6) #nums[index2] = temp
jr $ra
#void PRINT_ARRAY(int *nums, int length)
print_array:
addi $sp, $sp, -4
sw $ra, 4($sp) #push $ra of print_array to the stack
la $s5, ($a0) #adress of nums
addi $t1, $a1, 0 #t1 = length
addi $t7, $a1, -1 #t7 = length - 1
addi $s4, $zero, 0 #int i = 0;
loop_myarray:
bge $s4, $t1, after_loop_myarray# if i >= length run after_for1
lw $a0, ($s5) #load each number to print out
jal print_hex #print_hex(a0)
beq $s4, $t7, skip_comma #skip the comma at the end of the sequence
li $v0, 4 #print string
la $a0, comma #, "
syscall
skip_comma:
addi $s5, $s5, 4 #next number
addi $s4, $s4, 1 #i++
j loop_myarray
after_loop_myarray:
lw $ra, 4($sp) #pop $ra of print_array from the stack
addi $sp, $sp, 4
jr $ra #going back to jal print_array
print_hex:
addi $sp, $sp, -4
sw $ra, 4($sp)
add $s6, $a0, $zero #s6 = array element
la $s0, hex #adress of result
addi $t0, $zero, 48 #set $t0 to 48
sw $t0, 0($s0) #store 48('0') at location 0 in result
addi $t0, $0, 120 #set $t0 equal to 120
sw $t0, 4($s0) #store 120('x) at location 1 in $a1
addi $s1, $s0, 36 # adress of location 9 in result
addi $s2, $zero, 0 # int i = 0;
for3: bge $s2, 8, after_for3 # if i >= 8 run after_for3
move $a0, $s6 #set user input as argument 0 for converting hex function
jal convert_hex #convert_hex(user input)
move $t1, $v0 # update the new adress to convert
srl $s6, $s6, 4 #shift right 4 bits to deal with the next 4digit number
addi $s2, $s2, 1 # i++
j for3 # looping
after_for3:
# loop through the 'result' array to print out one by one character
addi $s2, $zero, 0 # int i = 0
for4: bge $s2, 10, after_for4 # if i >= 10 run after_for4
li $v0, 4 # print string
la $a0, ($s0) # print each character in result
syscall
addi $s0, $s0, 4 # move to the next character
addi $s2, $s2, 1 # i++
j for4 # looping
after_for4:
lw $ra, 4($sp)
addi $sp, $sp, 4
#finished print_hex()
jr $ra #going back to jal print_hex
convert_hex:
andi $s3, $a0, 0x0f # get the last 4 digit
ble $s3, 9, lessThan9
addi $s3, $s3, 7
lessThan9:
addi $t3, $s3, 48
sw $t3, ($s1) #result[s1] = hex number
subi $s1, $s1, 4 #move to the next address on the left
jr $ra #going back to jal convert_hex
|
//*********************************************************
//
// Copyright (c) Microsoft. All rights reserved.
// This code is licensed under the MIT License (MIT).
// THIS CODE IS PROVIDED *AS IS* WITHOUT WARRANTY OF
// ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING ANY
// IMPLIED WARRANTIES OF FITNESS FOR A PARTICULAR
// PURPOSE, MERCHANTABILITY, OR NON-INFRINGEMENT.
//
//*********************************************************
#include "pch.h"
#include "Scenario2_XmlWriter.h"
#include "Scenario2_XmlWriter.g.cpp"
using namespace winrt;
using namespace Windows::ApplicationModel;
using namespace Windows::Foundation;
using namespace Windows::Storage;
using namespace Windows::Storage::Streams;
using namespace Windows::UI::Xaml;
namespace winrt::SDKTemplate::implementation
{
Scenario2_XmlWriter::Scenario2_XmlWriter()
{
InitializeComponent();
}
fire_and_forget Scenario2_XmlWriter::DoSomething_Click(IInspectable const&, RoutedEventArgs const&)
{
auto lifetime = get_strong();
hstring result;
try
{
StorageFolder localFolder = ApplicationData::Current().LocalFolder();
StorageFile file = co_await localFolder.CreateFileAsync(L"XmlWriterOutput.xml", CreationCollisionOption::OpenIfExists);
IRandomAccessStream randomAccessWriteStream = co_await file.OpenAsync(FileAccessMode::ReadWrite);
com_ptr<IStream> writeStream = capture<IStream>(::CreateStreamOverRandomAccessStream, winrt::get_unknown(randomAccessWriteStream));
WriteXml(writeStream);
result = L"File is written to " + file.Path() + L" successfully";
}
catch (hresult_error const& e)
{
result = L"Exception occured while writing the xml file: " + e.message() +
L"\nError code: " + to_hstring(e.code());
}
OutputTextBlock1().Text(result);
}
void Scenario2_XmlWriter::WriteXml(com_ptr<IStream> const& writeStream)
{
com_ptr<IXmlWriter> writer;
check_hresult(::CreateXmlWriter(IID_PPV_ARGS(&writer), nullptr));
check_hresult(writer->SetOutput(writeStream.get()));
check_hresult(writer->SetProperty(XmlWriterProperty_Indent, TRUE));
check_hresult(writer->WriteStartDocument(XmlStandalone_Omit));
check_hresult(writer->WriteDocType(L"root", nullptr, nullptr, nullptr));
check_hresult(writer->WriteProcessingInstruction(L"xml-stylesheet",
L"href=\"mystyle.css\" title=\"Compact\" type=\"text/css\""));
check_hresult(writer->WriteStartElement(nullptr, L"root", nullptr));
check_hresult(writer->WriteStartElement(nullptr, L"sub", nullptr));
check_hresult(writer->WriteAttributeString(nullptr, L"myAttr", nullptr, L"1234"));
check_hresult(writer->WriteString(L"Markup is <escaped> for this string"));
check_hresult(writer->WriteFullEndElement());
check_hresult(writer->WriteStartElement(nullptr, L"anotherChild", nullptr));
check_hresult(writer->WriteString(L"some text"));
check_hresult(writer->WriteFullEndElement());
check_hresult(writer->WriteWhitespace(L"\n"));
check_hresult(writer->WriteCData(L"This is CDATA text."));
check_hresult(writer->WriteWhitespace(L"\n"));
check_hresult(writer->WriteStartElement(nullptr, L"containsCharacterEntity", nullptr));
check_hresult(writer->WriteCharEntity(L'a'));
check_hresult(writer->WriteFullEndElement());
check_hresult(writer->WriteWhitespace(L"\n"));
check_hresult(writer->WriteStartElement(nullptr, L"containsChars", nullptr));
check_hresult(writer->WriteChars(L"abcdefghijklm", 5));
check_hresult(writer->WriteFullEndElement());
check_hresult(writer->WriteWhitespace(L"\n"));
check_hresult(writer->WriteStartElement(nullptr, L"containsName", nullptr));
check_hresult(writer->WriteName(L"myName"));
check_hresult(writer->WriteEndElement());
check_hresult(writer->WriteWhitespace(L"\n"));
check_hresult(writer->WriteStartElement(nullptr, L"containsNmToken", nullptr));
check_hresult(writer->WriteNmToken(L"myNmToken"));
check_hresult(writer->WriteEndElement());
check_hresult(writer->WriteWhitespace(L"\n"));
check_hresult(writer->WriteComment(L"This is a comment"));
check_hresult(writer->WriteWhitespace(L"\n"));
check_hresult(writer->WriteRaw(L"<elementWrittenRaw/>"));
check_hresult(writer->WriteWhitespace(L"\n"));
check_hresult(writer->WriteRawChars(L"<rawCharacters/>", 16));
check_hresult(writer->WriteWhitespace(L"\n"));
check_hresult(writer->WriteElementString(nullptr, L"myElement", nullptr, L"myValue"));
check_hresult(writer->WriteFullEndElement());
check_hresult(writer->WriteWhitespace(L"\n"));
check_hresult(writer->WriteEndDocument());
}
}
|
/**
* \file
* Reality plug-in
* Copyright (c) Pret-a-3D/Paolo Ciccone 2014. All rights reserved.
*/
#include <QtCore>
#include <QtGlobal>
#include <QSettings>
#include <QMutableMapIterator>
#include <QSize>
#include "ReAppVersion.h"
#include "Reality_DS.h"
#include "ReAppVersion.h"
#include "RealityAction.h"
#include "RealityBase.h"
#include "ReSceneDataGlobal.h"
#include "ReIPC.h"
#include "ReDSMaterialConverter.h"
#include "ReDSStorage.h"
#include "ReGeometryExporter.h"
#include "ReDSTools.h"
#include "ReAcsel.h"
#include "ReRenderContext.h"
#include "ReDRM.h"
// #include "ReDSDebugTools.h"
#include "crc.h"
#ifdef __APPLE__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wall"
#endif
#include "dzplugin.h"
#include "dzversion.h"
#include "dzappsettings.h"
#include "dzscene.h"
#include "dznode.h"
#include "dzscene.h"
#include "dzspotlight.h"
#include "dzbricklight.h"
#include "dzfloatproperty.h"
#include "dzactionmgr.h"
#include "dzobject.h"
#include "dzfacetshape.h"
#include "dzmaterial.h"
#include "dzdefaultmaterial.h"
#include "dzfacetmesh.h"
#include "dzcustomdata.h"
#include "dzsettings.h"
#include "dzprogress.h"
#include "dzcontentmgr.h"
#include "dzimagemgr.h"
#include "dzrendermgr.h"
#include "dzrenderoptions.h"
#include "dzinstancenode.h"
#include "dzassetmgr.h"
#include "dzstringproperty.h"
#ifdef __APPLE__
#pragma clang diagnostic pop
#endif
#include <iostream>
QString makeObjectUID( const DzNode* node );
void setGUIDForNode( DzNode* node, const QString& GUID );
bool isCamera( const DzNode* node ) {
return node->inherits("DzCamera") && !node->inherits("DzLight");
}
bool isLight( const DzNode* node ) {
return node->inherits("DzLight")
|| node->inherits("DzShaderLight")
|| node->inherits("DzBrickLight");
}
// Static variable initialization
bool Reality_DS::nodeAdditionActive = true;
void Reality_DS::enableNodeAddition( const bool newState ) {
nodeAdditionActive = newState;
}
#define RE_DEFAULT_WINDOWS_PATH "C:/Program Files/Reality_DS"
#define RE_DEFAULT_OSX_PATH "/Applications/Reality_DS"
/*****************************
Plugin Definition
*****************************/
static QString RealityDescription = QString(
"This plugin is a component of Reality for DAZ Studio by Pret-A-3D.<br> "
"Reality for DAZ Studio is copyright (c) 2010 by Pret-A-3D.<br>"
"Reality plugin is a trademark by Pret-a-3D. All rights reserved.\n"
"<p>Please visit <a href=\"http://preta3d.com\">preta3d.com</a> for the latest news about Reality</p>"
"<p>Pret-A-3D would like to thank the developers of LuxRender, their vision, "
"genius and generosity made having this kind of rendering for Studio "
"possible.</p><p>Please visit "
"<a href=\"http://www.luxrender.net\">luxrender.net</a> for all the "
"latest news about Lux Render.</p>"
);
Reality_DS* Reality_DS::instance = NULL;
Reality_DS* Reality_DS::getInstance() {
return instance;
}
Reality_DS::Reality_DS():
DzPlugin(REALITY_PLUGIN_NAME,
"Pret-a-3D - Paolo Ciccone",
RealityDescription,
REALITY_MAIN_VERSION,
REALITY_SUB_VERSION,
REALITY_PATCH_VERSION,
REALITY_BUILD_NUMBER
)
{
dataSize = 0;
sceneLevel = 0;
isSceneLoading = false;
sceneIsMerging = false;
instance = this;
};
Reality_DS::~Reality_DS() {
}
/****************************************************
* DAZ Studio entry point
****************************************************/
DZ_CUSTOM_PLUGIN_DEFINITION( Reality_DS );
DZ_PLUGIN_CLASS_GUID_OWNED( Reality_DS,
EF4D89D5-2406-4C13-903D-20A6960E7C41,
QScriptEngine::ScriptOwnership );
// Action for Menu
DZ_PLUGIN_CLASS_GUID( Reality3Action, 717463F9-6616-4CE9-8370-A03F0AF757E2 );
//! Registering the class that implements storage of the scene data
DZ_PLUGIN_CLASS_GUID( ReSceneBlock, F5E4F9D0-98AA-4A54-9535-057086EC8619 );
DZ_PLUGIN_CLASS_GUID( ReStorage, A780947C-3A11-4A24-B14D-F44709D2F22C );
DZ_PLUGIN_REGISTER_SCENEDATA_EXTRA_OBJECT_IO( "ReSceneDataBlock",
ReStorage,
ReSceneBlock );
/****************************************************/
void Reality_DS::checkForUpdates() {
};
void Reality_DS::installHooks() {
connect(dzScene, SIGNAL(cameraRemoved(DzCamera*)), this, SLOT(cameraRemoved(DzCamera*)));
connect(dzScene, SIGNAL(lightRemoved(DzLight*)), this, SLOT(lightRemoved(DzLight*)));
connect(dzScene, SIGNAL(nodeAdded(DzNode*)), this, SLOT(nodeAdded(DzNode*)));
connect(dzScene, SIGNAL(aboutToRemoveNode(DzNode*)), this, SLOT(nodeRemoved(DzNode*)));
// Scene handling events
connect(dzScene, SIGNAL(sceneLoadStarting()), this, SLOT(sceneLoadingStarted()));
connect(dzScene, SIGNAL(sceneLoaded()), this, SLOT(sceneLoaded()));
connect(dzScene, SIGNAL(sceneCleared()), this, SLOT(setNewScene()));
// Update the library paths if the user installs new content
auto contMgr = dzApp->getContentMgr();
connect(contMgr, SIGNAL(contentDirectoryListChanged()), this, SLOT(updateLibraryPaths()));
connect(contMgr, SIGNAL(poserDirectoryListChanged()), this, SLOT(updateLibraryPaths()));
}
void Reality_DS::removeHooks() {
disconnect(dzScene, SIGNAL(cameraRemoved(DzCamera*)), this, SLOT(cameraRemoved(DzCamera*)));
disconnect(dzScene, SIGNAL(lightRemoved(DzLight*)), this, SLOT(lightRemoved(DzLight*)));
disconnect(dzScene, SIGNAL(nodeAdded(DzNode*)), this, SLOT(nodeAdded(DzNode*)));
disconnect(dzScene, SIGNAL(aboutToRemoveNode(DzNode*)), this, SLOT(nodeRemoved(DzNode*)));
disconnect(dzScene, SIGNAL(sceneLoadStarting()), this, SLOT(sceneLoadingStarted()));
disconnect(dzScene, SIGNAL(sceneLoaded()), this, SLOT(sceneLoaded()));
disconnect(dzScene, SIGNAL(sceneCleared()), this, SLOT(setNewScene()));
}
bool Reality_DS::verifyRealityInstallation( const QString& realityPath ) {
QFileInfo realityInfo;
if (osType == WINDOWS) {
realityInfo.setFile(QString("%1/Reality.exe").arg(realityPath));
}
else if (osType == MAC_OS) {
realityInfo.setFile(QString("%1/Reality.app/Contents/MacOS/Reality").arg(realityPath));
}
return realityInfo.exists();
}
void Reality_DS::updateLibraryPaths() {
// Collect the paths of the content library of Studio and pass them to
// Reality for path expansion of the textures
auto contMgr = dzApp->getContentMgr();
int numDirs = contMgr->getNumContentDirectories();
QStringList dirs;
for (int i = 0; i < numDirs; i++) {
dirs << contMgr->getContentDirectoryPath(i);
}
numDirs = contMgr->getNumPoserDirectories();
for (int i = 0; i < numDirs; i++) {
dirs << contMgr->getPoserDirectoryPath(i);
}
RealityBase::getRealityBase()->setLibraryPaths(dirs);
}
void Reality_DS::startup() {
// sceneIsMerging = false;
RE_LOG_INFO() << "==================================================";
RE_LOG_INFO() << " Reality plugin Studio Edition started";
RE_LOG_INFO() << QString(" v. %1.%2.%3.%4")
.arg(REALITY_MAIN_VERSION)
.arg(REALITY_SUB_VERSION)
.arg(REALITY_PATCH_VERSION)
.arg(REALITY_BUILD_NUMBER);
RE_LOG_INFO() << "==================================================";
RealityBase* rBase = RealityBase::getRealityBase();
rBase->startHostSideServices(DAZStudio);
rBase->setHostVersion(dzApp->getLongVersionStringProp());
realityActive = false;
shuttingDown = false;
RE_LOG_INFO() << "Reality DS library v. " << REALITY_DS_LIBRARY_VERSION;
osType = RealityBase::getRealityBase()->getOSType();
QSettings configuration(RE_CFG_DOMAIN_NAME, RE_CFG_APPLICATION_NAME);
realityPath = configuration.value(RE_CFG_REALITY_DS_LOCATION).toString();
RE_LOG_INFO() << "Cfg file: " << configuration.fileName();
RE_LOG_INFO() << " realityPath: " << realityPath;
bool realityFound = false;
if (realityPath.isEmpty()) {
RE_LOG_INFO() << "No location found for Reality. Trying to locate it automatically.";
if (osType == WINDOWS) {
realityPath = RE_DEFAULT_WINDOWS_PATH;
}
else if (osType == MAC_OS) {
realityPath = RE_DEFAULT_OSX_PATH;
}
}
realityFound = verifyRealityInstallation(realityPath);
if (realityFound) {
RE_LOG_INFO() << "Reality for DS found in " << QSS(realityPath);
configuration.setValue(RE_CFG_REALITY_DS_LOCATION, realityPath);
configuration.sync();
}
else {
QMessageBox::information(
0,
tr("Reality not found"),
tr(
"The Reality app could not be found in the standard location.\n"
"You will be asked to locate the directory where the program is "
"installed on your computer. "
)
);
realityPath = QFileDialog::getExistingDirectory(
0,
"Chose the directory where Reality is installed",
(osType == MAC_OS ? "/Applications" : "C:/Program Files")
);
realityFound = verifyRealityInstallation(realityPath);
if (!realityFound) {
QMessageBox::warning(
0,
tr("Reality not found"),
tr("I'm sorry but Reality could not be found in that location.")
);
return;
}
else {
configuration.setValue(RE_CFG_REALITY_DS_LOCATION, realityPath);
configuration.sync();
}
}
realityActive = realityFound;
updateLibraryPaths();
// Add the path to the Reality content, if needed
installContentPath();
installHooks();
addSceneStorage();
scanScene( true );
//********************************************************************
// Find the 3D viewport and capture the signal to find when the user
// switches active camera
//********************************************************************
Dz3DViewport* dsViewPort = dzApp->getInterface()->getViewportMgr()
->getActiveViewport()->get3DViewport();
connect(dsViewPort, SIGNAL(activeCameraChanged (DzCamera*)),
this, SLOT(selectActiveCamera(DzCamera*)));
//********************************************************************
// Start a timer to update camera data every second. There are no
// reliable signals in Studio to do this on-demand.
//********************************************************************
cameraTimer = new QTimer(this);
connect(cameraTimer, SIGNAL(timeout()), this, SLOT(processTimedEvents()));
cameraTimer->start(RE_REALITY_TIMER_INTERVAL);
};
// We scan all the objects scheduled to be monitored, those are the
// objects loaded from the scene for whivh we have data saved. By scanning
// that list we focus the search on new objects and avoid reading data for
// objects that have been added to the scene in other ways. This is a possible
// scenerion because the same loading procedure is used whether we load a scene
// by itself or as a result of the user selecting File | Merge in DS.
//
// Once we found the object specified in objID, our target, we check if
// it has a GUID already. If it doesn't then we create a new GUID and return
// true.
bool Reality_DS::calcIDForObject( const QString& objID, QString& newID, QString& objLabel ) {
int nodeCount = monitoringList.count();
for (int i = 0; i < nodeCount; i++) {
auto node = dzScene->getNode(monitoringList[i]);
if (!node) {
return false;
}
QString oid;
// Tests need to be done in this sequence because DzLight inherits from DzCamera
if (node->inherits("DzLight")) {
oid = ReGUID::getGUID(node);
if (oid == ReGUID::InvalidGUID) {
oid = node->getName();
}
}
else if (node->inherits("DzCamera")) {
oid = ReGUID::getGUID(node);
if (oid == ReGUID::InvalidGUID) {
oid = node->getAssetId();
}
}
else {
// This is an object
oid = ReGUID::getGUID(node);
}
if (oid == objID) {
newID = makeObjectUID(node);
objLabel = node->getLabel();
setGUIDForNode(node, newID);
return true;
}
}
return false;
};
void Reality_DS::installContentPath() {
auto config = RealityBase::getConfiguration();
QString cfgUpdateKey = "configurationUpdated";
if (!config->value(cfgUpdateKey,false).toBool()) {
QString configKey = "DS_ContentDir";
auto contentPath = config->value(configKey,"").toString();
if (!contentPath.isEmpty()) {
auto contentMrg = dzApp->getContentMgr();
if (!contentMrg) {
return;
}
contentMrg->addContentDirectory(contentPath);
config->setValue(cfgUpdateKey, true);
}
}
}
void Reality_DS::shutdown() {
shuttingDown = true;
if (getStatus() != Loaded) {
return;
}
removeHooks();
realityIPC->closeGUI();
RealityBase::getRealityBase()->stopHostSideServices();
};
//! Add one instance of our scene data object that is used by the Studio
//! API to trigger the saving and loading of customer's data. See the
//! \ref ReDS_Storage class for the actual implementation of the input/output
//! interface
void Reality_DS::addSceneStorage() {
dzScene->addDataItem(new ReSceneBlock());
};
void Reality_DS::sceneLoadingStarted() {
RE_LOG_INFO() << "Loading a new scene...";
if (sceneLevel == 0) {
ReAcsel::getInstance()->startCaching();
}
sceneLevel++;
isSceneLoading = true;
// We assume that we merge the scenes. If we are not then the setNewScene()
// method will be called before any processing starts and that method
// will set the sceneIsMerging flag to false
sceneIsMerging = true;
}
void Reality_DS::sceneLoaded() {
// if (isSceneLoading) {
// RE_LOG_INFO() << " Merging Studio scenes";
// }
// else {
// RE_LOG_INFO() << " No scene merging needed";
// }
sceneLevel--;
if (sceneLevel == 0) {
dzApp->postEvent(this, new ReStudioEvent("addNode") );
isSceneLoading = false;
auto camID = getCurrentStudioCamera();
RealitySceneData->selectCamera(camID);
realityIPC->hostCameraSelected(camID);
// connect with the Reality IBL sphere, if present, to track changes
auto iblSphere = dzScene->findNodeByLabel(REALITY_IBL_SPHERE);
if (iblSphere) {
connect(iblSphere, SIGNAL(transformChanged()),
this, SLOT(changeIBLRotation()));
}
}
}
void Reality_DS::addNode( ReStudioEvent* reEvent ) {
RE_LOG_INFO() << "File or group finished loading";
int numNodes = nodeList.count();
for (int i = 0; i < numNodes; i++) {
addNode(nodeList[i]);
}
nodeList.clear();
// Add the monitors for objects loaded from the Studio scene for
// which Reality data was loaded.
numNodes = monitoringList.count();
for (int i = 0; i < numNodes; i++) {
monitorNode(dzScene->getNode(monitoringList[i]));
}
monitoringList.clear();
if ( reEvent->shouldCloseEventQueue() && sceneLevel == 0 ) {
isSceneLoading = false;
}
ReAcsel::getInstance()->stopCaching();
}
void Reality_DS::addNode( DzNode* node ) {
QString objID = makeObjectUID(node);
if (objID == ReGUID::InvalidGUID) {
return;
}
bool isLightNode = isLight(node);
bool isCameraNode = isCamera(node);
// Skip nodes that :
// - are parented and hidden, those are generally controllers
// - don't have geometry, unless they are instances
bool skip = false;
if (!isCameraNode && !isLightNode) {
skip = (node->parent() && node->isHidden()) ||
node->inherits("DzGroupNode");
if (!node->getObject()) {
if (!node->inherits("DzInstanceNode")) {
skip = true;
}
}
}
if (!skip) {
setGUIDForNode(node, objID);
if (isLightNode) {
lightAdded( static_cast<DzLight*>(node) );
}
else if ( isCameraNode ) {
cameraAdded(qobject_cast<DzCamera*>(node));
}
else {
addRealityObject(objID, node);
}
monitorNode(node);
}
else {
RE_LOG_INFO() << "Object " << node->getName()
<< " skipped."
<< QString(" - parented&hidden:%1, group: %2, no geom: %3, inst.: %4")
.arg((node->parent() && node->isHidden()))
.arg(node->inherits("DzGroupNode"))
.arg(node->getObject() == NULL)
.arg(node->inherits("DzInstanceNode"))
;
}
}
void Reality_DS::updateMaterial() {
ReAcsel::getInstance()->startCaching();
auto matConverter = ReDSMaterialConverter::getInstance();
QMutableHashIterator<QString, int> i(materialRefreshTable);
realityIPC->GUIPauseMatPreview();
while( i.hasNext() ) {
i.next();
QStringList key = i.key().split("::");
DzMaterial* mat= DzMaterial::getMaterial(i.value());
if (!mat) {
continue;
}
auto matInfo = matConverter->convertMaterial(mat);
RealitySceneData->updateMaterial(key[0], key[1], *matInfo);
auto reMat = RealitySceneData->getMaterial(key[0],key[1]);
flatMatList.storeMaterial(mat->getIndex(), reMat);
i.remove();
}
ReAcsel::getInstance()->stopCaching();
realityIPC->GUIResumeMatPreview();
}
void Reality_DS::updateMaterialList() {
int numMaterials = DzMaterial::getNumMaterials();
for (int i=0; i < numMaterials; i++) {
auto dsMat = DzMaterial::getMaterial(i);
if (!dsMat) {
continue;
}
auto shapes = dsMat->shapeListIterator();
while( shapes.hasNext() ) {
auto shape = shapes.next();
if (!shape) {
continue;
}
auto node = shape->getNode();
QString objID = ReGUID::getGUID(node);
auto reMat = RealitySceneData->getMaterial(objID, dsMat->getName());
if (!reMat.isNull()) {
flatMatList.storeMaterial(i, reMat);
}
}
}
}
bool Reality_DS::event( QEvent* e ) {
if (e->type() != ReStudioEvent::reEventType) {
return false;
}
auto reEvent = static_cast<ReStudioEvent*>(e);
QString eventDesc = reEvent->getDescription();
bool result = false;
// Adding a node
if ( eventDesc == "addNode" ) {
addNode(reEvent);
result = true;
}
// Material has changed
else if ( eventDesc == "materialChanged" ) {
if (materialRefreshTable.count()) {
updateMaterial();
}
result = true;
}
else if (eventDesc == "lightPos") {
auto light = boost::any_cast<DzLight*>(reEvent->getProperty("light"));
if (light) {
DzMatrix3 m = light->getWSTransform();
ReMatrix lightMatrix;
convertDzMatrix(m, lightMatrix);
RealitySceneData->setLightMatrix(ReGUID::getGUID(light), lightMatrix);
}
}
return result;
}
void Reality_DS::setNewScene() {
addSceneStorage();
flatMatList.clear();
sceneIsMerging = false;
// RE_LOG_INFO() << "New Studio scene";
if (isSceneLoading || dzApp->isClosing()) {
return;
}
isSceneLoading = false;
RealitySceneData->newScene();
realityIPC->setNewScene();
// RE_LOG_INFO() << " Reality scene cleared";
scanScene();
}
void Reality_DS::setFrameSize( const QSize& newSize ) {
RealitySceneData->setFrameSize(newSize.width(), newSize.height());
}
void Reality_DS::scanScene( const bool installMonitor ) {
QListIterator<DzCamera*> cameraIter = dzScene->cameraListIterator();
while( cameraIter.hasNext() ) {
DzCamera* dzCam = cameraIter.next();
cameraAdded(dzCam);
}
// Get the render options and install a monitor to track
// resolution changes
auto renderMgr = dzApp->getRenderMgr();
if (!renderMgr) {
return;
}
auto renderOpts = renderMgr->getRenderOptions();
setFrameSize(renderOpts->getImageSize());
if ( installMonitor ) {
connect( renderOpts, SIGNAL(imageSizeChanged(const QSize&)),
this, SLOT(setFrameSize(const QSize&)) );
}
}
void setCameraData( const DzCamera* dzCam, ReCameraPtr reCam ) {
reCam->setFocalLength(dzCam->getFocalLength());
reCam->setFocalDistance(dzCam->getFocalDistance()/100.0);
reCam->setName(dzCam->getLabel());
// Studio returns the FOV in radians, we use degrees
reCam->setFOV( dzCam->getFieldOfView()*180/PI );
DzMatrix3 m = dzCam->getWSTransform();
ReMatrix reMatrix;
convertDzMatrix(m, reMatrix);
reCam->setMatrix(reMatrix);
}
void Reality_DS::cameraAdded( DzCamera* dzCam ) {
// QString camID = dzCam->getAssetId();
QString camID = ReGUID::getGUID(dzCam);
if (camID == ReGUID::InvalidGUID) {
camID = makeObjectUID(dzCam);
setGUIDForNode(dzCam, camID);
}
ReCameraPtr cam = ReCameraPtr(
new ReCamera(dzCam->getLabel(), camID)
);
// set the parameters
setCameraData(dzCam, cam);
RealitySceneData->addCamera(cam);
// Store the camera data for caching
cameraData[camID] = cam->toString();
monitorCamera(dzCam);
};
void Reality_DS::cameraRemoved( DzCamera* camera ) {
if (shuttingDown) {
return;
}
auto camID = ReGUID::getGUID(camera);
RealitySceneData->removeCamera(camID);
// RE_LOG_INFO() << "Camera removed: " << camID;
cameraData.remove(camID);
camID = getCurrentStudioCamera();
if (camID != "") {
// RE_LOG_INFO() << "Studio current camera: " << camID;
RealitySceneData->selectCamera(camID);
realityIPC->hostCameraSelected(camID);
}
};
void Reality_DS::cameraRenamed( const QString& newLabel ) {
if (shuttingDown) {
return;
}
DzCamera* dsCam = static_cast<DzCamera*>(QObject::sender());
RealitySceneData->renameCamera(ReGUID::getGUID(dsCam), newLabel);
};
void Reality_DS::renderFrame( const QString& sceneFileName,
const unsigned int frameNo,
const bool runRenderer )
{
QStringList instances;
RealitySceneData->renderSceneStart(sceneFileName, frameNo);
auto exporter = new DS::ReGeometryExporter(&flatMatList);
auto objs = exporter->getNodes();
DS::ReGeometryExporter::NodeDictIterator nodeIter(objs);
DzProgress progressInd("Rendering", objs.count(), false, true);
realityIPC->exportStarted(objs.count());
while( nodeIter.hasNext() ) {
nodeIter.next();
QString objName = nodeIter.key();
RE_LOG_INFO() << "Exporting object " << objName;
auto obj = RealitySceneData->getObject(objName);
if (obj.isNull()) {
continue;
}
QString msg = QString("Exporting to LuxRender %1").arg(objName);
if (obj->isInstance()) {
instances.append(objName);
continue;
}
realityIPC->exportingObject(msg);
progressInd.setInfo(msg);
progressInd.step();
exporter->exportObject( objName, obj );
}
// Export the instances
int numInstances = instances.count();
for (int l = 0; l < numInstances; l++) {
QString objName = instances[l];
// We need to use the label to locate the object in the scene
auto node = dzScene->findNodeByLabel(
RealitySceneData->getObject(objName)->getName()
);
if (!node) {
continue;
}
auto target = static_cast<DzInstanceNode*>(node)->getTarget();
if (!target) {
continue;
}
auto tm = target->getWSTransform();
auto im = node->getWSTransform();
DzMatrix3 relMatrix = tm.inverse() * im;
ReMatrix reMatrix;
convertDzMatrix(relMatrix, reMatrix);
RealitySceneData->renderSceneExportInstance(objName, reMatrix, DAZStudio);
}
RealitySceneData->renderSceneFinish(runRenderer);
realityIPC->exportFinished();
delete exporter;
};
void Reality_DS::renderCurrentFrame( const QString& sceneFileName,
const unsigned int frameNo,
const bool runRenderer )
{
QTime t;
t.start();
ReRenderContext::getInstance()->init();
renderFrame(sceneFileName, frameNo, runRenderer);
RE_LOG_INFO() << "Elapsed Time: " << t.elapsed()/1000.0 << " sec.";
}
void Reality_DS::getAnimationRange( int& startFrame, int& endFrame, int& fps ) {
// Amount of clock "ticks" in a second, in Studio
unsigned int animDivisor = 4800.f;
auto animRange = dzScene->getAnimRange();
float frameDuration = dzScene->getTimeStep();
fps = animDivisor/frameDuration;
startFrame = animRange.getStart();
endFrame = animRange.getEnd()/frameDuration;
}
void Reality_DS::renderAnimation( const bool runRenderer,
int selectedStartFrame,
int selectedEndFrame )
{
int startFrame,
endFrame,
fps;
getAnimationRange(startFrame, endFrame, fps);
if (selectedStartFrame > 0) {
startFrame = selectedStartFrame;
}
if (selectedEndFrame != 0) {
endFrame = selectedEndFrame;
}
// Save the current frame for restoring it later
int currentFrame = dzScene->getFrame();
RE_LOG_INFO() << QString("Animation: start: %1, stop: %2, fps: %3")
.arg(startFrame).arg(endFrame).arg(fps);
QString sceneName = RealitySceneData->getSceneFileName();
QStringList renderQueue;
// Render the animation
QProgressDialog progress(dzApp->getInterface());
progress.setLabelText(tr("Reality is exporting your animation..."));
progress.setRange(startFrame, endFrame);
progress.setModal(true);
bool renderWasInterrupted = false;
for (int i = startFrame; i <= endFrame; i++) {
progress.setValue(i);
dzScene->setFrame(i);
dzApp->processEvents();
if (progress.wasCanceled()) {
renderWasInterrupted = true;
break;
}
updateCameraData();
QString fileName = expandFrameNumber(sceneName, i);
renderFrame(fileName, i, false);
renderQueue << fileName;
}
dzScene->setFrame(currentFrame);
updateCameraData();
if (renderWasInterrupted) {
return;
}
if (runRenderer) {
ReLuxRunner rr;
rr.runGuiLux( renderQueue,
RealitySceneData->getNumThreads(),
RealitySceneData->getLuxLogLevel() );
}
};
DzMaterial* findNodeMaterial( const DzNode* node, const QString& matName ) {
DzObject* obj = node->getObject();
if (!obj) {
RE_LOG_INFO() << "No object for node " << node->getName();
return NULL;
}
DzShape* shape = obj->getCurrentShape();
if (!shape) {
RE_LOG_INFO() << "No shapes available for node " << node->getName();
return NULL;
}
int numMats = shape->getNumAssemblyMaterials();
for ( int l = 0; l < numMats; l++) {
DzMaterial* theMat = shape->getAssemblyMaterial(l);
if (theMat->getName() == matName) {
return theMat;
}
}
return NULL;
}
void Reality_DS::processTimedEvents() {
//! Update the camera information
updateCameraData();
updateAnimationLimits();
// Check if there are commands pending from the GUI to us
RealityBase* rBase = RealityBase::getRealityBase();
while( rBase->getNumCommands() ) {
QString cmd = rBase->commandStackPop();
if (cmd == "changed") {
dzScene->markChanged();
}
else if (cmd == "render") {
QString runRender = rBase->commandStackPop();
renderCurrentFrame( "", 0, runRender == "1" );
}
else if (cmd == "renderAnim") {
QString runRender = rBase->commandStackPop();
int startFrame = rBase->commandStackPop().toInt();
int endFrame = rBase->commandStackPop().toInt();
renderAnimation( runRender == "1", startFrame, endFrame );
}
else if (cmd == "sip") {
// Set IBL Preview
QString mapName = rBase->commandStackPop();
setIBLPreviewMap(mapName);
}
else if (cmd == "save") {
auto sceneName = dzScene->getFilename();
if (sceneName == "") {
sceneName = dzScene->getAssetLoadPath();
};
auto mainWindow = dzApp->getInterface();
if (sceneName == "") {
mainWindow->doFileSaveAs();
}
else {
mainWindow->doFileSave();
}
}
else if (cmd == "smha") {
// Select material in host app
QString objectID = rBase->commandStackPop();
QString materialName = rBase->commandStackPop();
selectStudioMaterial(objectID, materialName);
}
}
}
void Reality_DS::updateCameraData() {
QListIterator<DzCamera*> cameraIter = dzScene->cameraListIterator();
while( cameraIter.hasNext() ) {
DzBasicCamera* dzCam = static_cast<DzBasicCamera*>(cameraIter.next());
// QString camID = dzCam->getAssetId();
QString camID = ReGUID::getGUID(dzCam);
ReCameraPtr cam = RealitySceneData->getCamera(camID);
if (cam) {
setCameraData(dzCam, cam);
QString camInfo = cam->toString();
if (camInfo != cameraData[camID]) {
cameraData[camID] = camInfo;
realityIPC->cameraDataChanged(camID);
}
}
}
}
void Reality_DS::updateAnimationLimits() {
int startFrame, endFrame, fps;
getAnimationRange(startFrame, endFrame, fps);
realityIPC->updateAnimationLimits(startFrame, endFrame, fps);
}
void Reality_DS::selectActiveCamera(DzCamera* dsCam) {
if (dzApp->isClosing()) {
return;
}
// auto camID = dsCam->getAssetId();
auto camID = ReGUID::getGUID(dsCam);
// RE_LOG_INFO() << "DS calls for camera change: " << camID;
RealitySceneData->selectCamera(camID);
realityIPC->hostCameraSelected(camID);
}
void getLightInfo( DzLight* light, QVariantMap& data ) {
QString lightID = ReGUID::getGUID(light);
if (lightID == ReGUID::InvalidGUID) {
lightID = makeObjectUID(light);
setGUIDForNode(light, lightID);
}
data["name"] = light->getLabel();
data["lightID"] = lightID;
data["on"] = light->isOn();
data["colorModel"] = ReLight::Temperature;
// Set the color data
QVariantMap color;
QVariantList theColor;
auto colorProp = qobject_cast<DzColorProperty*>(
light->findProperty(RE_DS_LIGHT_COLOR)
);
QColor lightColor;
if (colorProp) {
lightColor = colorProp->getColorValue();
if ( !isPureWhite(lightColor) ) {
data["colorModel"] = ReLight::RGB;
}
}
else {
lightColor = QColor(255,255,255);
}
theColor << QVariant(lightColor.redF())
<< QVariant(lightColor.greenF())
<< QVariant(lightColor.blueF());
color["color"] = theColor;
color["map"] = QVariant("");
data["color"] = color;
if (light->inherits("DzSpotLight")) {
data["type"] = SpotLight;
data["angle"] = (static_cast<const DzSpotLight*>(
light
))->getSpreadAngleControl()->getValue();
}
else if (light->inherits("DzPointLight")) {
data["type"] = PointLight;
}
else if (light->inherits("DzDistantLight")) {
data["type"] = InfiniteLight;
}
else if (light->inherits("DzShaderLight")) {
// Is this a fake spot
auto coneProp = qobject_cast<DzFloatProperty*>(
light->findProperty("Cone Inside")
);
if (coneProp) {
data["type"] = SpotLight;
}
else {
// Is this a fake pointlight?
auto pointProp = qobject_cast<DzFloatProperty*>(
light->findProperty("Decay")
);
if (pointProp) {
data["type"] = PointLight;
}
else {
data["type"] = InfiniteLight;
}
}
}
else if (light->isAreaLight()) {
data["type"] = MeshLight;
}
data["intensity"] = 1.0;
// Getting the intensity of the light
// All lights, except for "Bricklight", subclass DzDistantLight
if (light->inherits("DzDistantLight")) {
data["intensity"] = (static_cast<const DzDistantLight*>(light))->getIntensity();
}
else if (light->inherits("DzBrickLight")) {
data["intensity"] = (static_cast<const DzBrickLight*>(light))->getIntensity();
}
}
void Reality_DS::lightAdded( DzLight* light ) {
if (light->getName().startsWith(RE_DS_HEADLAMP_BLOCKER)) {
return;
}
QVariantMap data;
getLightInfo(light, data);
// Add the light to the scene and notify the UI
RE_LOG_INFO() << "Adding light with ID " << data.value("lightID").toString();
RealitySceneData->addLight(data.value("lightID").toString(), data);
// Set the initial matrix
DzMatrix3 m = light->getWSTransform();
ReMatrix lightMatrix;
convertDzMatrix(m, lightMatrix);
RealitySceneData->setLightMatrix(data.value("lightID").toString(),
lightMatrix);
monitorLight(light);
};
void Reality_DS::lightRemoved( DzLight* light ) {
RealitySceneData->deleteLight(ReGUID::getGUID(light));
};
void Reality_DS::lightRenamed( const QString& newLabel ) {
DzLight* dsLight = static_cast<DzLight*>(QObject::sender());
RealitySceneData->renameLight(ReGUID::getGUID(dsLight), newLabel);
};
void Reality_DS::updateLightPos() {
// Because Studio dispatches the events to plugins in the middle of their
// execution, there is at least one situation where asking for data about
// a light causes a crash in Studio. That happens when a light is set to
// point to an object, like a null, and then the object that it points to
// is deleted. If the DzLight::getWSTransform() method is called in the middle
// of processing the signal then Studio will crash. It seems that Studio
// fires the signal and then completes the update of the light after the
// signal is processed. Unfortunatelu the state of the light is such that
// retrieving its coordinates causes the crash.
//
// To avoid that issue we simply append an event to the app queue so that
// we return to this operation once Studio is done. See the event() method.
//
auto light = dynamic_cast<DzLight*>(QObject::sender());
auto reEvent = new ReStudioEvent("lightPos");
boost::any lightPtr = light;
reEvent->addProperty("light", lightPtr);
dzApp->postEvent(this, reEvent);
}
void Reality_DS::updateLightProperty() {
auto prop = qobject_cast<DzProperty*>(QObject::sender());
auto light = qobject_cast<DzLight*>(prop->getOwner());
QString propName = prop->getName();
QVariantMap data;
getLightInfo(light, data);
RealitySceneData->updateLight(ReGUID::getGUID(light), data);
}
void Reality_DS::selectStudioMaterial( const QString& objID,
const QString& materialName )
{
auto obj = RealitySceneData->getObject(objID);
if (obj.isNull()) {
return;
}
auto dsNode = dzScene->findNodeByLabel(obj->getName());
if (!dsNode) {
RE_LOG_WARN() << "Could nod find node " << dsNode->getName();
return;
}
DzObject* dsObj = dsNode->getObject();
if (!obj) {
RE_LOG_INFO() << "No object found!";
return;
}
DzShape* shape = dsObj->getCurrentShape();
if (!shape) {
RE_LOG_INFO() << "Object has no shape!";
return;
}
// The surface selection tool must be on or this will not work
auto vpMgr = dzApp->getInterface()->getViewportMgr();
auto sst = vpMgr->findTool("DzMaterialPickTool");
if (sst) {
vpMgr->setActiveTool(sst);
}
// Deselect any previously selected material
int numMats = DzMaterial::getNumMaterials();
for( int i = 0; i < numMats; i++ ) {
auto curMat = DzMaterial::getMaterial( i );
if( curMat && curMat->isSelected() )
curMat->select( false );
}
numMats = shape->getNumAssemblyMaterials();
for ( int l = 0; l < numMats; l++) {
DzMaterial* dsMat = shape->getAssemblyMaterial(l);
if (dsMat->getName() == materialName) {
dsMat->select(true);
}
}
};
void Reality_DS::nodeAdded( DzNode* node ) {
// RE_LOG_INFO() << "Studio added " << node->getLabel()
// << "/" << node->getName()
// << " of class: " << node->metaObject()->className()
// << (node->metaObject()->superClass() ?
// QString(" superclass: %1")
// .arg(node->metaObject()->superClass()->className())
// :
// "" )
// << ". Parented? " << (node->getNodeParent() != NULL)
// << " "
// << (node->getNodeParent() != NULL ? node->getNodeParent()->getName() : "");
// The following flag is used when we restore Reality data from the
// saved scene. In that case all the data is already there and
// we don't need to go through the process of adding nodes. We do
// need to set the monitoring for all objects involved, though, and that has
// to be delayed until Studio has completely created the node, which is not
// done at this stage.
if (!nodeAdditionActive) {
monitoringList << dzScene->findNodeIndex(node);
return;
}
bool shouldAddNode = true;
QString nodeClass = node->metaObject()->className();
// Lights are added by separate methods.
// Bones are not used anymore, they were used by DS3.
if (
node->inherits("DzMeasureMetricsNode") ||
node->inherits("DzRigidFollowNode") ||
nodeClass == "DzBone" ||
nodeClass == "DzIKNode" ||
// This includes DzDFormZone and
// DzDFormBase
nodeClass.startsWith("DzDForm") ||
!node->isVisible() ||
node->getName() == RE_DS_DATANODE_NAME ||
node->getName() == RE_DS_METADATA
)
{
shouldAddNode = false;
}
// // Add lights
// if ( shouldAddNode && isLight(node) ) {
// lightAdded( static_cast<DzLight*>(node) );
// return;
// }
// // Add cameras
// if ( shouldAddNode && isCamera(node) ) {
// cameraAdded(qobject_cast<DzCamera*>(node));
// return;
// }
// Check if the node is one of the primitives. If
// so we add the node
QString nodeName = node->getName();
if (
( nodeName.startsWith("plane") ||
nodeName.startsWith("torus") ||
nodeName.startsWith("sphere") ||
nodeName.startsWith("cone") ||
nodeName.startsWith("cylinder") ||
nodeName.startsWith("cube") ) && !isSceneLoading)
{
// Direct addition because primitives are not loaded from a scene
addNode(node);
return;
}
// If a group is added while the scene is not loading this means
// that any instance group has been created by the user.
// This kind of group behaves in a slightly different way than the
// a group coming from a loaded scene. So in this case, we fake
// the condition of the scene loading, and we push an event in the
// queue just to close the operation and reset the flag so that
// we return to the standard condition.
if (node->inherits("DzGroupNode") && !isSceneLoading) {
RE_LOG_INFO() << "Instance group";
isSceneLoading = true;
dzApp->postEvent( this, new ReStudioEvent("addNode",true) );
return;
}
if (shouldAddNode) {
if (isSceneLoading) {
nodeList.append(node);
}
else {
// This happens usually when the user undoes a deletion, with the
// result that the object is added back to the scene but there is
// no loading of a file, and so the isSceneLoading flag is not set
// if ( isCamera(node) ) {
// cameraAdded(qobject_cast<DzCamera*>(node));
// }
// else if ( isLight(node) ) {
// lightAdded( static_cast<DzLight*>(node) );
// }
// else {
addNode(node);
// }
}
}
};
void Reality_DS::nodeRemoved( DzNode* node ) {
if (shuttingDown) {
return;
}
// A lot of calls are for nodes of thime DzBone, which we don't add to the
// Reality database, so we can skip those right away.
QString className = node->metaObject()->className();
if ( className == "DzBone" || className.startsWith("DzDForm") ) {
return;
}
// RE_LOG_INFO() << "Asked to remove node: " << node->getName()
// << " class: " << node->metaObject()->className()
// << " with UID: " << ReGUID::getGUID(node);
int nodePos = nodeList.indexOf(node);
if (nodePos != -1) {
nodeList.removeAt(nodePos);
}
auto id = ReGUID::getGUID(node);
if (id != ReGUID::InvalidGUID) {
RealitySceneData->deleteObject(id);
}
};
void Reality_DS::nodeRenamed( const QString& newLabel ) {
DzNode* node = qobject_cast<DzNode*>(QObject::sender());
QString objID = ReGUID::getGUID(node);
if (RealitySceneData->hasObject(objID)) {
RealitySceneData->renameObject(objID, newLabel);
}
}
/*************************************************
* Material monitoring
*************************************************/
// Material definition changed
void Reality_DS::watchMaterial() {
if (dzApp->isClosing() || dzScene->isClearing()) {
return;
}
auto prop = qobject_cast<DzProperty*>(QObject::sender());
if (!prop) {
return;
}
auto propOwner = prop->getOwner();
if (propOwner->inherits("DzMaterial")) {
auto mat = qobject_cast<DzMaterial*>(propOwner);
auto i = mat->shapeListIterator();
while( i.hasNext() ) {
auto node = i.next()->getNode();
if (node) {
QString objID = ReGUID::getGUID(node);
QString matName = mat->getName();
// Get the Reality material to check of what type it is
auto reMat = RealitySceneData->getMaterial(objID, matName);
if (reMat && reMat->getType() == MatLight) {
// If the material has been previously changed to be a light
// then ignore the change int he host, it does not apply to our
// material.
return;
}
QString key = QString("%1::%2").arg(objID).arg(matName);
// See event()
materialRefreshTable[key] = mat->getIndex();
}
}
dzApp->postEvent( this, new ReStudioEvent("materialChanged") );
}
else {
RE_LOG_INFO() << QString(">> Property is of type: %1")
.arg(prop->metaObject()->className());
}
}
// Material is selected in Studio, we select in the Reality UI as well
void Reality_DS::materialSelected(DzMaterial *mat, bool onOff) {
if (onOff) {
DzShapeListIterator sli = mat->shapeListIterator();
DzNode* node = NULL;
while( sli.hasNext() ) {
auto shape = sli.next();
if (node = shape->getNode()) {
break;
}
}
if (node) {
realityIPC->materialSelected(ReGUID::getGUID(node), mat->getName());
}
}
}
void Reality_DS::visibilityChanged() {
auto node = qobject_cast<DzNode*>(QObject::sender());
auto objID = ReGUID::getGUID(node);
if (objID != ReGUID::InvalidGUID) {
RealitySceneData->setObjectVisible(objID, node->isVisible());
}
}
void Reality_DS::setIBLPreviewMap( const QString& mapFilename ) {
// Is the preview sphere already in the scene?
auto previewSphere = dzScene->findNodeByLabel(REALITY_IBL_SPHERE);
auto contentMgr = dzApp->getContentMgr();
if (!previewSphere) {
QString filePath = contentMgr->getAbsolutePath(
"/Props/Reality/Reality IBL Sphere.duf",
true
);
if (!filePath.isEmpty()) {
if (!contentMgr->openFile(filePath)) {
return;
}
// We need to be notified if the rotation of the sphere changes
// so that we can reflect that in the IBL settings
previewSphere = dzScene->findNodeByLabel(REALITY_IBL_SPHERE);
if (!previewSphere) {
return;
}
connect(previewSphere, SIGNAL(transformChanged()),
this, SLOT(changeIBLRotation()));
}
}
// If the sphere has been added successfully to the scene then we
// set the map for it and start tracking the changes to its rotation
if (!previewSphere) {
return;
}
auto obj = previewSphere->getObject();
if (!obj) {
return;
}
auto shape = obj->getCurrentShape();
if (!shape) {
return;
}
auto mat = qobject_cast<DzDefaultMaterial*>(shape->getMaterial(0));
if (mat) {
DzTexture* tex = dzApp->getImageMgr()->getImage(mapFilename);
mat->setColorMap(tex);
}
}
void Reality_DS::changeIBLRotation() {
DzNode* source = qobject_cast<DzNode*>(QObject::sender());
RealitySceneData->setIBLRotation(
source->getYRotControl()->getValue()
);
}
void Reality_DS::setIBLImage( const QString& mapFilename ) {
RealitySceneData->setIBLImage(mapFilename);
}
//! Proxy method to forward it to the one in ReSceneData
void Reality_DS::setLightIntensity( const QString& lightID, const float gain ) {
RealitySceneData->setLightIntensity(lightID, gain);
}
QString getGeometryFileName( const DzNode* node, const QString defaultName ) {
// Studio appends the number of vertices that an object has after
// the name of the object if that object is a prop or a Poser-style
// figure. The number of vertices is not part of the figure name if
// it's a triaxis figure, coming from a DUF file.
// On the other hand Reality needs to uniquely identify objects in
// the whole runtime, regardless of the scene. Some products use
// ambiguos names, like "pants" or "bra" and so it's likely to have
// collisions when those object names are used to identify ACSEL
// shaders.
//
// To make the product/object name unique we add the number of
// vertices all the time, even when it's not provided by Studio.
// The same is done by the Poser plugin so that the same object is
// identified in the same regardless of what application is used to
// create the scene, Poser or DS.
//
QString fileName = node->getAssetId();
// Find out if there is the number of vertices appended to the
// object name, as in FIG_12345
QString numVerts;
for (int i = fileName.length()-1; i >= 0; i--) {
auto ch = fileName[i];
if (ch >= '0' && ch <= '9') {
numVerts.prepend(ch);
}
else {
if (ch != '_') {
// Blanking the numVerts variable is used as a signal that
// the number of vertices was not found.
numVerts.clear();
}
break;
}
}
if (numVerts.isEmpty()) {
// Collect information about the node's geometry
DzObject* obj = node->getObject();
if (obj) {
DzShape* shape = obj->getCurrentShape();
if (shape) {
DzGeometry* geom = shape->getGeometry();
int numVerts;
if (!geom) {
numVerts = 0;
}
else{
numVerts = geom->getNumVertices();
};
fileName = QString("%1_%2").arg(fileName).arg(numVerts);
}
}
}
if ( fileName.isEmpty() ) {
fileName = defaultName;
}
return fileName;
}
/**
* Creates an object UID by taking the object name and adding a
* unique hash. The hash is created by using a GUID and then shortening it
* with a CRC function
*/
QString makeObjectUID( const DzNode* node ) {
// QString GUID = ReGUID::getGUID(node);
// if (GUID != "") {
// return GUID;
// }
QString GUID = ReGUID::getGUID();
return QString("%1-%2")
.arg(getGeometryFileName(node, node->getName()))
.arg( crcFast(GUID.toUtf8().data(), GUID.count()) );
}
/**
* Store the Reality GUID for a node in the node itself so that Studio
* will store it in its scene file and then will make it available to
* Reality whenever needed
*/
void setGUIDForNode( DzNode* node, const QString& GUID ) {
auto dataItem = qobject_cast<DzSimpleElementData*>(
node->findDataItem(RE_DS_NODE_GUID)
);
// There is no previously attached data
if (!dataItem) {
dataItem = new DzSimpleElementData(RE_DS_NODE_GUID, true);
node->addDataItem(dataItem);
}
auto settings = dataItem->getSettings();
settings->setStringValue(RE_DS_NODE_GUID, GUID);
// We use also a private property because the "Fit to..." operation, and possibly
// other Studio APIs, strip an object of the custom data once the conversion
// is done. At this time we duplicate the data to avoid breaking compatibility
// with the past versions of Reality which used the custom data.
DzStringProperty* customProp = new DzStringProperty(RE_DS_NODE_GUID, true);
customProp->setValue(GUID);
node->addPrivateProperty(customProp);
}
void Reality_DS::addRealityObject( const QString& objID,
const DzNode* node ) {
QString fileName = getGeometryFileName(node, objID);
if ( !RealitySceneData->addObject(node->getLabel(), objID, fileName) ) {
// if the addObject method return false it means that that object is already
// in the database and we don't need to do anything else
return;
}
if (node->getName().startsWith(RE_DS_UBER_LIGHT_PREFIX)) {
auto reMat = RealitySceneData->getObject(objID);
if (!reMat.isNull()) {
reMat->markAsLight(true);
}
}
// RE_LOG_INFO() << "Object " << objID << " added.";
// If this is an instance then set the link between the instance
// and its source object and get out of here.
if (node->inherits("DzInstanceNode")) {
DzNode* source = static_cast<const DzInstanceNode*>(node)->getTarget();
QString srcGUID = ReGUID::getGUID(source);
auto obj = RealitySceneData->getObject(objID);
obj->setInstanceSourceID(srcGUID);
realityIPC->objectAdded(objID);
return;
}
DzObject* obj = node->getObject();
if (!obj) {
RE_LOG_INFO() << "No object found! " << objID;
return;
}
DzShape* shape = obj->getCurrentShape();
if (!shape) {
RE_LOG_INFO() << "Object has no shape!";
return;
}
int numMats = shape->getNumAssemblyMaterials();
// Make sure that we cache the ACSEL database operations so to not
// slow-down the host
// ReAcsel::getInstance()->startCaching();
ReDSMaterialConverter* matConverter = ReDSMaterialConverter::getInstance();
for ( int l = 0; l < numMats; l++) {
DzMaterial* theMat = shape->getAssemblyMaterial(l);
QVariantMap* matInfo = matConverter->convertMaterial(theMat);
QString matName = theMat->getLabel();
RealitySceneData->addMaterial(objID, matName, *matInfo);
auto reMat = RealitySceneData->getMaterial(objID, matName);
flatMatList.storeMaterial(theMat->getIndex(), reMat);
}
// ReAcsel::getInstance()->stopCaching();
realityIPC->objectAdded(objID);
};
void Reality_DS::shapeSwitchHandler() {
RE_LOG_INFO() << "]! Shape switched!";
}
void setMonitorForMaterialProperties( const DzMaterial* mat, QObject* target) {
auto i = mat->propertyListIterator();
while( i.hasNext() ) {
auto prop = i.next();
// Get notifications when the material changes
if (prop->isHidden() || prop->isAlias()) {
continue;
}
QObject::connect(prop, SIGNAL(currentValueChanged()),
target, SLOT(watchMaterial()));
}
}
void Reality_DS::materialAdded( DzMaterial* dzMat ) {
auto src = qobject_cast<DzShape*>(QObject::sender());
if (!src) {
RE_LOG_INFO() << "materialAdded() called is not a shape";
return;
}
auto dzObj = qobject_cast<DzObject*>(src->getElementParent());
if (!dzObj) {
RE_LOG_INFO() << "Parent of shape instance is not a DzObject";
return;
}
auto dzNode = qobject_cast<DzNode*>(dzObj->getElementParent());
QString objID = ReGUID::getGUID(dzNode);
auto matConverter = ReDSMaterialConverter::getInstance();
auto matInfo = matConverter->convertMaterial(dzMat);
RealitySceneData->addMaterial(objID, dzMat->getLabel(), *matInfo);
realityIPC->objectDeleted(objID);
realityIPC->objectAdded(objID);
RE_LOG_INFO() << "Material added: "
<< src->getName()
<< "/"
<< objID
<< "::"
<< dzMat->getName();
}
void Reality_DS::materialRemoved( DzMaterial* dzMat ) {
auto src = qobject_cast<DzShape*>(QObject::sender());
if (!src) {
RE_LOG_INFO() << "materialAdded() called is not a shape";
return;
}
RE_LOG_INFO() << "Material removed: "
<< src->getName()
<< "/"
<< dzMat->getName()
<< " -- Nothing done!";
}
void Reality_DS::monitorCamera( const DzCamera* cam ) {
connect(cam, SIGNAL(labelChanged(const QString&)),
this, SLOT(cameraRenamed(const QString&)));
}
void Reality_DS::monitorLight( const DzLight* light ) {
// Make sure that Reality has the current label for the light
// This operation is actually required because lights being merged
// by Studio might receive a different label than the one that was
// stored in the Reality data saved with the scene
RealitySceneData->renameLight(ReGUID::getGUID(light), light->getLabel());
connect(light, SIGNAL(labelChanged(const QString&)),
this, SLOT(lightRenamed(const QString&)));
// Monitor the coordinates change
connect(light, SIGNAL(transformChanged()), this, SLOT(updateLightPos()));
// Monitor the change of properties
auto i = light->propertyListIterator();
while( i.hasNext() ) {
auto prop = i.next();
QString propName = prop->getName();
if ( propName == RE_DS_LIGHT_INTENSITY ||
propName == RE_DS_LIGHT_SPREAD_ANGLE ||
propName == RE_DS_LIGHT_COLOR ||
propName == RE_DS_LIGHT_ILLUMINATION)
{
connect( prop, SIGNAL(currentValueChanged()),
this, SLOT(updateLightProperty()));
}
}
}
void Reality_DS::monitorNode( const DzNode* node ) {
if (node) {
if (isCamera(node)) {
monitorCamera(static_cast<const DzCamera*>(node));
}
else if (isLight(node)) {
monitorLight(static_cast<const DzLight*>(node));
}
else {
// RE_LOG_INFO() << "Monitoring node " << node->getLabel();
// Ask for notifications when the node's label is renamed
connect(node, SIGNAL(labelChanged(const QString&)),
this, SLOT(nodeRenamed(const QString&)));
// Ask for notifications when the node changes visibility
connect(node, SIGNAL(visibilityChanged()), this, SLOT(visibilityChanged()));
DzObject* obj = node->getObject();
if (!obj) {
// RE_LOG_INFO() << "No object found!";
return;
}
DzShape* shape = obj->getCurrentShape();
if (!shape) {
// RE_LOG_INFO() << "Object has no shape!";
return;
}
//! Monitor the geometry switching
connect(obj, SIGNAL(currentShapeSwitched()), this, SLOT(shapeSwitchHandler()));
// Get notifications for material-level changes
connect(shape, SIGNAL(materialChanged()),this, SLOT(watchMaterial()));
// When materials are replaced by a preset the materialListChanged()
// signal is raised. In that case the old material is removed and a
// new material is instantiated. The materialRemoved() signal is not
// raised in that occasion and so it cannot be used reliably.
connect(shape, SIGNAL(materialListChanged()), this, SLOT(materialListChanged()));
// Get notifications when a material is added or removed
connect(shape, SIGNAL(materialAdded(DzMaterial*)),
this, SLOT(materialAdded(DzMaterial*)));
connect(shape, SIGNAL(materialRemoved(DzMaterial*)),
this, SLOT(materialRemoved(DzMaterial*)));
// Add a monitor for the material changes
// ReDSMaterialListIterator i(matList);
int numMats = shape->getNumAssemblyMaterials();
QString objID = ReGUID::getGUID(node);
for ( int l = 0; l < numMats; l++) {
DzMaterial* mat = shape->getAssemblyMaterial(l);
auto reMat = RealitySceneData->getMaterial(objID, mat->getName());
if (!reMat.isNull()) {
flatMatList.storeMaterial(mat->getIndex(), reMat);
}
// Get notifications when the material is selected
connect(mat, SIGNAL(selectionStateChanged (DzMaterial*, bool)),
this, SLOT(materialSelected(DzMaterial*, bool)));
// Scan the list of properties and monitor their changes
setMonitorForMaterialProperties(mat, this);
}
}
}
else {
RE_LOG_WARN() << "Node to be monitor is NULL";
}
}
void Reality_DS::materialListChanged() {
auto src = QObject::sender();
if (!src->inherits("DzShape")) {
return;
}
DzShape* shape = qobject_cast<DzShape*>(src);
if (!shape) {
return;
}
auto node = shape->getNode();
int numMats = shape->getNumAssemblyMaterials();
for ( int l = 0; l < numMats; l++) {
DzMaterial* theMat = shape->getAssemblyMaterial(l);
// Set the monitors for the new material because the old material
// has been removed at this point. A new material instance has been
// created by Studio.
setMonitorForMaterialProperties(theMat, this);
QString objID = ReGUID::getGUID(node);
QString key = QString("%1::%2").arg(objID).arg(theMat->getName());
auto reObj = RealitySceneData->getObject(objID);
if (!reObj.isNull()) {
auto reMat = reObj->getMaterial(theMat->getName());
if (!reMat.isNull()) {
flatMatList.storeMaterial(theMat->getIndex(), reMat);
}
}
materialRefreshTable[key] = theMat->getIndex();
}
}
|
/*
* Copyright (c) 2019-2020 Blue Zephyr
*
* This software may be modified and distributed under the terms
* of the MIT license. See the LICENSE file for details.
*
*/
#include <vector>
#include "Parser.h"
#include "Ast.h"
#include "CppUTest/TestHarness.h"
#include "CppUTest/CommandLineTestRunner.h"
struct TestTuple
{
std::string input;
std::string expectedResult;
int errors;
};
struct BooleanTestSetup
{
std::string input;
bool left;
const std::string& expectedOp;
bool right;
const std::string& expectedOutput;
};
TEST_GROUP(ParserTest)
{
void setup() override
{
lexer = nullptr;
}
void teardown() override
{
delete (lexer);
}
void checkLetStatement(const std::shared_ptr<Statement>& statement, const std::string& name) const
{
auto* letStatement = dynamic_cast<LetStatement *>(statement.get());
CHECK(letStatement->token != nullptr);
CHECK_EQUAL(Token::LET, (letStatement->token->type));
CHECK_EQUAL("let", *letStatement->token->literal);
CHECK(letStatement->identifier != nullptr);
CHECK_EQUAL(name, *letStatement->identifier->value);
}
void checkReturnStatement(const std::shared_ptr<Statement>& statement, std::string expected) const
{
auto* returnStatement = dynamic_cast<ReturnStatement *>(statement.get());
CHECK(returnStatement->token != nullptr);
CHECK_EQUAL(Token::RETURN, (returnStatement->token->type));
CHECK_EQUAL("return", *returnStatement->token->literal);
CHECK(returnStatement->expression != nullptr);
CHECK_EQUAL(expected, returnStatement->string());
}
void checkIntegerExpression(const std::shared_ptr<Expression>& expression, int64_t value) const
{
CHECK(expression != nullptr);
auto* integer = dynamic_cast<Integer*>(expression.get());
CHECK(integer != nullptr);
CHECK_EQUAL(value, integer->value);
CHECK_EQUAL(std::to_string(value), integer->string());
}
void checkBooleanExpression(const std::shared_ptr<Expression>& expression, bool value) const
{
CHECK(expression != nullptr);
auto boolean = dynamic_cast<Boolean*>(expression.get());
CHECK(boolean != nullptr);
CHECK_EQUAL(value, boolean->value);
if (value)
{
CHECK_EQUAL("true", boolean->string());
}
else
{
CHECK_EQUAL("false", boolean->string());
}
}
void checkInfixIntegerExpression(const char* input,
int left,
const std::string& expectedOp,
int right,
const std::string& expectedOutput)
{
auto parser = createParser(input);
auto program = parser.parseProgram();
CHECK_EQUAL_TEXT(0, parser.errors.size(), parser.errors[0].c_str());
CHECK_EQUAL(1, program.get()->statements.size());
std::shared_ptr<Expression> expression = getAndCheckExpressionStatement(program->statements.front());
auto* infix = dynamic_cast<InfixExpression*>(expression.get());
CHECK(infix != nullptr);
checkIntegerExpression(infix->left, left);
CHECK_EQUAL(expectedOp, infix->op);
checkIntegerExpression(infix->right, right);
CHECK_EQUAL(expectedOutput, infix->string());
}
static std::shared_ptr<Expression> getAndCheckExpressionStatement(const std::shared_ptr<Statement>& statement)
{
auto* expressionStatement = dynamic_cast<ExpressionStatement*>(statement.get());
CHECK(expressionStatement != nullptr);
CHECK(expressionStatement->expression != nullptr);
return expressionStatement->expression;
}
static void checkParserOutputOk(const TestTuple& test)
{
auto l = Lexer(test.input.c_str());
auto parser = Parser(l);
auto program = parser.parseProgram();
CHECK_EQUAL_TEXT(0, parser.errors.size(), parser.errors[0].c_str());
CHECK_EQUAL(test.expectedResult, program->string());
}
Parser createParser(const char* input)
{
lexer = new Lexer(input);
auto parser = Parser(*lexer);
return parser;
}
static std::shared_ptr<Program> parse(const std::string& input)
{
auto lexer = Lexer(input.c_str());
auto parser = Parser(lexer);
auto program = parser.parseProgram();
return program;
}
Lexer *lexer;
};
TEST(ParserTest, parseEmptyProgram)
{
auto parser = createParser("");
auto program = parser.parseProgram();
CHECK_TRUE(program.get()->statements.empty());
}
TEST(ParserTest, parseEmptyStatmentProgramNOK)
{
// Need to decide whether this is a valid program or not. For now, consider it to be not ok.
auto parser = createParser(";");
auto program = parser.parseProgram();
CHECK(program.get()->statements.empty());
CHECK_EQUAL(0, program.get()->statements.size());
}
TEST(ParserTest, parseSingleLetStatement)
{
auto parser = createParser("let x=5;");
auto program = parser.parseProgram();
CHECK_FALSE(program.get()->statements.empty());
checkLetStatement(program->statements.front(), "x");
}
TEST(ParserTest, parseLetStatements)
{
std::vector<std::string> identifiers = {"x", "y", "foobar"};
auto parser = createParser("let x=5;\n"
"let y=10;\n"
"let foobar = 423432\n");
auto program = parser.parseProgram();
CHECK_FALSE(program.get()->statements.empty());
CHECK_EQUAL(3, program.get()->statements.size());
int i=0;
for (auto const& statement : program->statements)
{
checkLetStatement(statement, identifiers[i]);
++i;
}
}
TEST(ParserTest, letStatementErrorMissingAssignment)
{
std::string message("Expected ASSIGN token. Got INT token (5)");
auto parser = createParser("let x 5;\n");
auto program = parser.parseProgram();
CHECK_TRUE(program.get()->statements.empty());
CHECK_EQUAL(1, parser.errors.size());
CHECK_EQUAL(message, parser.errors[0]);
}
TEST(ParserTest, letStatementErrorMissingIdentifier)
{
std::string message("Expected IDENTIFIER token. Got ASSIGN token (=)");
auto parser = createParser("let =10;\n");
auto program = parser.parseProgram();
CHECK_TRUE(program.get()->statements.empty());
CHECK_EQUAL(1, parser.errors.size());
CHECK_EQUAL(message, parser.errors[0]);
}
TEST(ParserTest, letStatementErrorNonValidIdentifier)
{
std::string message("Expected IDENTIFIER token. Got INT token (6777)");
auto parser = createParser("let 6777;\n");
auto program = parser.parseProgram();
CHECK_TRUE(program.get()->statements.empty());
CHECK_EQUAL(1, parser.errors.size());
CHECK_EQUAL(message, parser.errors[0]);
}
TEST(ParserTest, parseSingleReturnStatement)
{
auto program = parse("return 5;");
CHECK_FALSE(program.get()->statements.empty());
checkReturnStatement(program->statements.front(), "return 5;");
}
TEST(ParserTest, parseReturnStatements)
{
std::vector<std::string> expected = {"return 5;", "return 10;", "return 423432;"};
auto parser = createParser("return 5;\n"
"return 10;\n"
"return 423432\n");
auto program = parser.parseProgram();
CHECK_FALSE(program.get()->statements.empty());
CHECK_EQUAL(3, program.get()->statements.size());
auto i = 0;
for (auto const& statement : program->statements)
{
checkReturnStatement(statement, expected[i]);
++i;
}
}
TEST(ParserTest, parseIdentifierExpression)
{
auto parser = createParser("foobar;");
auto program = parser.parseProgram();
CHECK_EQUAL_TEXT(0, parser.errors.size(), parser.errors[0].c_str());
CHECK_EQUAL(1, program.get()->statements.size());
std::shared_ptr<Expression> expression = getAndCheckExpressionStatement(program->statements.front());
auto* identifier = dynamic_cast<Identifier*>(expression.get());
CHECK(identifier != nullptr);
CHECK_EQUAL(Token::IDENTIFIER, (identifier->token->type));
CHECK_EQUAL("foobar", *identifier->value);
CHECK_EQUAL("foobar", identifier->string());
}
TEST(ParserTest, parseIntegerLiteralExpression)
{
auto parser = createParser("5;");
auto program = parser.parseProgram();
CHECK_EQUAL_TEXT(0, parser.errors.size(), parser.errors[0].c_str());
CHECK_EQUAL(1, program.get()->statements.size());
std::shared_ptr<Expression> expression = getAndCheckExpressionStatement(program->statements.front());
checkIntegerExpression(expression, 5);
}
TEST(ParserTest, parseBangPrefixExpression)
{
auto parser = createParser("!5;");
auto program = parser.parseProgram();
CHECK_EQUAL_TEXT(0, parser.errors.size(), parser.errors[0].c_str());
CHECK_EQUAL(1, program.get()->statements.size());
std::shared_ptr<Expression> expression = getAndCheckExpressionStatement(program->statements.front());
auto* prefix = dynamic_cast<PrefixExpression*>(expression.get());
CHECK(prefix != nullptr);
CHECK_EQUAL("!", prefix->op);
checkIntegerExpression(prefix->right, 5);
CHECK_EQUAL("(!5)", prefix->string());
}
TEST(ParserTest, parseMinusPrefixExpression)
{
auto parser = createParser("-15");
auto program = parser.parseProgram();
CHECK_EQUAL_TEXT(0, parser.errors.size(), parser.errors[0].c_str());
CHECK_EQUAL(1, program.get()->statements.size());
std::shared_ptr<Expression> expression = getAndCheckExpressionStatement(program->statements.front());
auto* prefix = dynamic_cast<PrefixExpression*>(expression.get());
CHECK(prefix != nullptr);
CHECK_EQUAL("-", prefix->op);
checkIntegerExpression(prefix->right, 15);
CHECK_EQUAL("(-15)", prefix->string());
}
TEST(ParserTest, parsePlusInfixExpression)
{
checkInfixIntegerExpression("5+8;", 5, "+", 8, "(5 + 8)");
}
TEST(ParserTest, parseMinusInfixExpression)
{
checkInfixIntegerExpression("8-5;", 8, "-", 5, "(8 - 5)");
}
TEST(ParserTest, parseProductInfixExpression)
{
checkInfixIntegerExpression("3*7;", 3, "*", 7, "(3 * 7)");
}
TEST(ParserTest, parseDivisionInfixExpression)
{
checkInfixIntegerExpression("24 / 4;", 24, "/", 4, "(24 / 4)");
}
TEST(ParserTest, parseGreaterThanInfixExpression)
{
checkInfixIntegerExpression("5>4;", 5, ">", 4, "(5 > 4)");
}
TEST(ParserTest, parseLessThanInfixExpression)
{
checkInfixIntegerExpression("15 < 4;", 15, "<", 4, "(15 < 4)");
}
TEST(ParserTest, parseEqualInfixExpression)
{
checkInfixIntegerExpression("9 == 4;", 9, "==", 4, "(9 == 4)");
}
TEST(ParserTest, parseNotEqualInfixExpression)
{
checkInfixIntegerExpression("9 != 4;", 9, "!=", 4, "(9 != 4)");
}
TEST(ParserTest, parseBooleanExpressionTrue)
{
auto parser = createParser("true;");
auto program = parser.parseProgram();
CHECK_EQUAL_TEXT(0, parser.errors.size(), parser.errors[0].c_str());
CHECK_EQUAL(1, program.get()->statements.size());
std::shared_ptr<Expression> expression = getAndCheckExpressionStatement(program->statements.front());
checkBooleanExpression(expression, true);
}
TEST(ParserTest, parseBooleanExpressionFalse)
{
auto parser = createParser("false;");
auto program = parser.parseProgram();
CHECK_EQUAL_TEXT(0, parser.errors.size(), parser.errors[0].c_str());
CHECK_EQUAL(1, program.get()->statements.size());
std::shared_ptr<Expression> expression = getAndCheckExpressionStatement(program->statements.front());
checkBooleanExpression(expression, false);
}
TEST(ParserTest, parseBooleanInfixExpressions)
{
std::vector<BooleanTestSetup> tests
{
{"true == true", true, "==", true, "(true == true)"},
{"true != false", true, "!=", false, "(true != false)"},
{"false == false", false, "==", false, "(false == false)"},
};
for (auto test: tests)
{
auto l = Lexer(test.input.c_str());
auto parser = Parser(l);
auto program = parser.parseProgram();
CHECK_EQUAL_TEXT(0, parser.errors.size(), parser.errors[0].c_str());
CHECK_EQUAL(1, program.get()->statements.size());
std::shared_ptr<Expression> expression = getAndCheckExpressionStatement(program->statements.front());
auto* infix = dynamic_cast<InfixExpression*>(expression.get());
CHECK(infix != nullptr);
checkBooleanExpression(infix->left, test.left);
CHECK_EQUAL(test.expectedOp, infix->op);
checkBooleanExpression(infix->right, test.right);
CHECK_EQUAL(test.expectedOutput, infix->string());
}
}
TEST(ParserTest, parseBooleanPrefixExpressions)
{
std::vector<BooleanTestSetup> tests
{
// Note! Left operand is not used.
{"!true", false, "!", true, "(!true)"},
{"!false", false, "!", false, "(!false)"},
{"!(false)", false, "!", false, "(!false)"},
{"(!(true))", false, "!", true, "(!true)"},
};
for (auto test: tests)
{
auto l = Lexer(test.input.c_str());
auto parser = Parser(l);
auto program = parser.parseProgram();
CHECK_EQUAL_TEXT(0, parser.errors.size(), parser.errors[0].c_str());
CHECK_EQUAL(1, program.get()->statements.size());
std::shared_ptr<Expression> expression = getAndCheckExpressionStatement(program->statements.front());
auto *prefix = dynamic_cast<PrefixExpression *>(expression.get());
CHECK(prefix != nullptr);
CHECK_EQUAL(test.expectedOp, prefix->op);
checkBooleanExpression(prefix->right, test.right);
CHECK_EQUAL(test.expectedOutput, prefix->string());
}
}
TEST(ParserTest, checkOperatorPrecedenceParsing)
{
std::vector<TestTuple> tests
{
{"-a * b", "((-a) * b)\n"},
{"!-a", "(!(-a))\n"},
{"a + b + c", "((a + b) + c)\n"},
{"a + b - c", "((a + b) - c)\n"},
{"a * b * c", "((a * b) * c)\n"},
{"a * b / c", "((a * b) / c)\n"},
{"a + b / c", "(a + (b / c))\n"},
{"a + b * c + d / e - f", "(((a + (b * c)) + (d / e)) - f)\n"},
{"3 + 4; -5 * 5", "(3 + 4)\n((-5) * 5)\n"},
{"5 > 4 == 3 < 4", "((5 > 4) == (3 < 4))\n"},
{"5 < 4 != 3 > 4", "((5 < 4) != (3 > 4))\n"},
{"3 + 4 * 5 == 3 * 1 + 4 * 5", "((3 + (4 * 5)) == ((3 * 1) + (4 * 5)))\n"},
{"true", "true\n"},
{"false", "false\n"},
{"5 > 4 == true", "((5 > 4) == true)\n"},
{"5 < 4 == false", "((5 < 4) == false)\n"},
};
for (const auto& test: tests)
{
checkParserOutputOk(test);
}
}
TEST(ParserTest, checkGroupedPrecedenceParsing)
{
std::vector<TestTuple> tests
{
{"(4);", "4\n"},
{"(3 + 4);", "(3 + 4)\n"},
{"(3 + 4)", "(3 + 4)\n"},
{"(3 + 4);(-5 * 5)", "(3 + 4)\n((-5) * 5)\n"},
};
for (const auto& test: tests)
{
checkParserOutputOk(test);
}
}
TEST(ParserTest, unmatchedParenthesisError)
{
std::vector<TestTuple> tests
{
{"(3 + 4()", "Expected RPAREN token. Got EOF token (EOF)", 2},
{")", "No prefix parse function for RPAREN found", 2},
{"(4))", "No prefix parse function for RPAREN found", 2},
{"(4;", "Expected RPAREN token. Got SEMICOLON token (;)", 1},
{"((3+5)*(4)", "Expected RPAREN token. Got EOF token (EOF)", 2},
{"(((2));", "Expected RPAREN token. Got SEMICOLON token (;)", 1},
};
for (const auto& test: tests)
{
auto l = Lexer(test.input.c_str());
auto parser = Parser(l);
auto program = parser.parseProgram();
CHECK_EQUAL_TEXT(test.errors, parser.errors.size(), parser.errors[0].c_str());
CHECK_EQUAL(test.expectedResult, parser.errors[0]);
}
}
TEST(ParserTest, parseIfNoElseExpression)
{
auto parser = createParser("if (x < y) { x }");
auto program = parser.parseProgram();
CHECK_EQUAL_TEXT(0, parser.errors.size(), parser.errors[0].c_str());
CHECK_EQUAL(1, program.get()->statements.size());
std::shared_ptr<Expression> expression = getAndCheckExpressionStatement(program->statements.front());
auto* ifExpression = dynamic_cast<IfExpression*>(expression.get());
CHECK(ifExpression != nullptr);
CHECK(ifExpression->token != nullptr);
CHECK_EQUAL(Token::IF, (ifExpression->token->type));
CHECK_EQUAL("if", *ifExpression->token->literal);
CHECK(ifExpression->condition != nullptr);
CHECK_EQUAL("(x < y)", ifExpression->condition->string());
CHECK_EQUAL("x\n", ifExpression->consequence->string());
CHECK(ifExpression->alternative == nullptr);
CHECK_EQUAL("if (x < y) { x\n }\n", ifExpression->string());
}
TEST(ParserTest, parseIfWithElseExpression)
{
auto parser = createParser("if (x < y) { x } else { y }");
auto program = parser.parseProgram();
CHECK_EQUAL_TEXT(0, parser.errors.size(), parser.errors[0].c_str());
CHECK_EQUAL(1, program.get()->statements.size());
std::shared_ptr<Expression> expression = getAndCheckExpressionStatement(program->statements.front());
auto* ifExpression = dynamic_cast<IfExpression*>(expression.get());
CHECK(ifExpression != nullptr);
CHECK(ifExpression->token != nullptr);
CHECK_EQUAL(Token::IF, (ifExpression->token->type));
CHECK_EQUAL("if", *ifExpression->token->literal);
CHECK(ifExpression->condition != nullptr);
CHECK_EQUAL("(x < y)", ifExpression->condition->string());
CHECK_EQUAL("x\n", ifExpression->consequence->string());
CHECK_EQUAL("y\n", ifExpression->alternative->string());
CHECK_EQUAL("if (x < y) { x\n } else { y\n }\n", ifExpression->string());
}
TEST(ParserTest, parseFunctionLiteral)
{
auto parser = createParser("fn(x, y) { x + y; }");
auto program = parser.parseProgram();
CHECK_EQUAL_TEXT(0, parser.errors.size(), parser.errors[0].c_str());
CHECK_EQUAL(1, program.get()->statements.size());
std::shared_ptr<Expression> expression = getAndCheckExpressionStatement(program->statements.front());
auto* fnExpression = dynamic_cast<Function*>(expression.get());
CHECK(fnExpression != nullptr);
CHECK(fnExpression->token != nullptr);
CHECK_EQUAL(Token::FUNCTION, fnExpression->token->type);
CHECK(fnExpression->body != nullptr);
CHECK_EQUAL("(x + y)\n", fnExpression->body->string());
CHECK_EQUAL(2, fnExpression->parameters.size());
CHECK_EQUAL("x", *fnExpression->parameters[0]->value);
CHECK_EQUAL("y", *fnExpression->parameters[1]->value);
CHECK_EQUAL("fn(x, y) { (x + y)\n }", fnExpression->string());
}
TEST(ParserTest, parseFunctionLiteralNoParameters)
{
auto parser = createParser("fn() { return 10; }");
auto program = parser.parseProgram();
CHECK_EQUAL_TEXT(0, parser.errors.size(), parser.errors[0].c_str());
CHECK_EQUAL(1, program.get()->statements.size());
std::shared_ptr<Expression> expression = getAndCheckExpressionStatement(program->statements.front());
auto* fnExpression = dynamic_cast<Function*>(expression.get());
CHECK(fnExpression != nullptr);
CHECK(fnExpression->token != nullptr);
CHECK_EQUAL(Token::FUNCTION, fnExpression->token->type);
CHECK_EQUAL(0, fnExpression->parameters.size());
CHECK_EQUAL("fn() { return 10;\n }", fnExpression->string());
}
TEST(ParserTest, parseFunctionLiteralOneParameter)
{
auto parser = createParser("fn(x) { return 10*x; }");
auto program = parser.parseProgram();
CHECK_EQUAL_TEXT(0, parser.errors.size(), parser.errors[0].c_str());
CHECK_EQUAL(1, program.get()->statements.size());
std::shared_ptr<Expression> expression = getAndCheckExpressionStatement(program->statements.front());
auto* fnExpression = dynamic_cast<Function*>(expression.get());
CHECK(fnExpression != nullptr);
CHECK(fnExpression->token != nullptr);
CHECK_EQUAL(Token::FUNCTION, fnExpression->token->type);
CHECK_EQUAL(1, fnExpression->parameters.size());
CHECK_EQUAL(std::string("fn(x) { return (10 * x);\n }"), fnExpression->string());
}
TEST(ParserTest, parseCallExpressionNoArguments)
{
auto parser = createParser("add();");
auto program = parser.parseProgram();
CHECK_EQUAL_TEXT(0, parser.errors.size(), parser.errors[0].c_str());
CHECK_EQUAL(1, program.get()->statements.size());
std::shared_ptr<Expression> expression = getAndCheckExpressionStatement(program->statements.front());
auto* callExpression = dynamic_cast<CallExpression*>(expression.get());
CHECK(callExpression != nullptr);
CHECK_EQUAL(Token::LPAREN, callExpression->token->type);
auto* identifier = dynamic_cast<Identifier*>(callExpression->function.get());
CHECK(identifier != nullptr);
CHECK_EQUAL(Token::IDENTIFIER, (identifier->token->type));
CHECK_EQUAL(std::string("add"), *identifier->value);
CHECK_EQUAL(std::string("add()"), expression->string());
}
TEST(ParserTest, parseCallExpressionWithArguments)
{
auto parser = createParser("calculate(1, 2+3, 4*5);");
auto program = parser.parseProgram();
CHECK_EQUAL_TEXT(0, parser.errors.size(), parser.errors[0].c_str());
CHECK_EQUAL(1, program.get()->statements.size());
std::shared_ptr<Expression> expression = getAndCheckExpressionStatement(program->statements.front());
auto* callExpression = dynamic_cast<CallExpression*>(expression.get());
CHECK(callExpression != nullptr);
CHECK_EQUAL(Token::LPAREN, callExpression->token->type);
auto* identifier = dynamic_cast<Identifier*>(callExpression->function.get());
CHECK(identifier != nullptr);
CHECK_EQUAL(Token::IDENTIFIER, (identifier->token->type));
CHECK_EQUAL(std::string("calculate"), *identifier->value);
CHECK_EQUAL(3, callExpression->arguments.size());
checkIntegerExpression(callExpression->arguments[0], 1);
auto* infix = dynamic_cast<InfixExpression*>(callExpression->arguments[1].get());
CHECK(infix != nullptr);
checkIntegerExpression(infix->left, 2);
CHECK_EQUAL(std::string("+"), infix->op);
checkIntegerExpression(infix->right, 3);
CHECK_EQUAL(std::string("(2 + 3)"), infix->string());
infix = dynamic_cast<InfixExpression*>(callExpression->arguments[2].get());
CHECK(infix != nullptr);
checkIntegerExpression(infix->left, 4);
CHECK_EQUAL(std::string("*"), infix->op);
checkIntegerExpression(infix->right, 5);
CHECK_EQUAL(std::string("(4 * 5)"), infix->string());
CHECK_EQUAL(std::string("calculate(1, (2 + 3), (4 * 5))"), expression->string());
}
int main(int ac, char** av)
{
return CommandLineTestRunner::RunAllTests(ac, av);
}
|
/* (c) Magnus Auvinen. See licence.txt in the root of the distribution for more information. */
/* If you are missing that file, acquire a complete release at teeworlds.com. */
#include <base/math.h>
#include <engine/storage.h>
#include "filecollection.h"
bool CFileCollection::IsFilenameValid(const char *pFilename)
{
if(str_length(pFilename) != m_FileDescLength+TIMESTAMP_LENGTH+m_FileExtLength ||
str_comp_num(pFilename, m_aFileDesc, m_FileDescLength) ||
str_comp(pFilename+m_FileDescLength+TIMESTAMP_LENGTH, m_aFileExt))
return false;
pFilename += m_FileDescLength;
if(pFilename[0] == '_' &&
pFilename[1] >= '0' && pFilename[1] <= '9' &&
pFilename[2] >= '0' && pFilename[2] <= '9' &&
pFilename[3] >= '0' && pFilename[3] <= '9' &&
pFilename[4] >= '0' && pFilename[4] <= '9' &&
pFilename[5] == '-' &&
pFilename[6] >= '0' && pFilename[6] <= '9' &&
pFilename[7] >= '0' && pFilename[7] <= '9' &&
pFilename[8] == '-' &&
pFilename[9] >= '0' && pFilename[9] <= '9' &&
pFilename[10] >= '0' && pFilename[10] <= '9' &&
pFilename[11] == '_' &&
pFilename[12] >= '0' && pFilename[12] <= '9' &&
pFilename[13] >= '0' && pFilename[13] <= '9' &&
pFilename[14] == '-' &&
pFilename[15] >= '0' && pFilename[15] <= '9' &&
pFilename[16] >= '0' && pFilename[16] <= '9' &&
pFilename[17] == '-' &&
pFilename[18] >= '0' && pFilename[18] <= '9' &&
pFilename[19] >= '0' && pFilename[19] <= '9')
return true;
return false;
}
int64 CFileCollection::ExtractTimestamp(const char *pTimestring)
{
int64 Timestamp = pTimestring[0]-'0';
Timestamp <<= 4;
Timestamp += pTimestring[1]-'0';
Timestamp <<= 4;
Timestamp += pTimestring[2]-'0';
Timestamp <<= 4;
Timestamp += pTimestring[3]-'0';
Timestamp <<= 4;
Timestamp += pTimestring[5]-'0';
Timestamp <<= 4;
Timestamp += pTimestring[6]-'0';
Timestamp <<= 4;
Timestamp += pTimestring[8]-'0';
Timestamp <<= 4;
Timestamp += pTimestring[9]-'0';
Timestamp <<= 4;
Timestamp += pTimestring[11]-'0';
Timestamp <<= 4;
Timestamp += pTimestring[12]-'0';
Timestamp <<= 4;
Timestamp += pTimestring[14]-'0';
Timestamp <<= 4;
Timestamp += pTimestring[15]-'0';
Timestamp <<= 4;
Timestamp += pTimestring[17]-'0';
Timestamp <<= 4;
Timestamp += pTimestring[18]-'0';
return Timestamp;
}
void CFileCollection::BuildTimestring(int64 Timestamp, char *pTimestring)
{
pTimestring[19] = 0;
pTimestring[18] = (Timestamp&0xF)+'0';
Timestamp >>= 4;
pTimestring[17] = (Timestamp&0xF)+'0';
Timestamp >>= 4;
pTimestring[16] = '-';
pTimestring[15] = (Timestamp&0xF)+'0';
Timestamp >>= 4;
pTimestring[14] = (Timestamp&0xF)+'0';
Timestamp >>= 4;
pTimestring[13] = '-';
pTimestring[12] = (Timestamp&0xF)+'0';
Timestamp >>= 4;
pTimestring[11] = (Timestamp&0xF)+'0';
Timestamp >>= 4;
pTimestring[10] = '_';
pTimestring[9] = (Timestamp&0xF)+'0';
Timestamp >>= 4;
pTimestring[8] = (Timestamp&0xF)+'0';
Timestamp >>= 4;
pTimestring[7] = '-';
pTimestring[6] = (Timestamp&0xF)+'0';
Timestamp >>= 4;
pTimestring[5] = (Timestamp&0xF)+'0';
Timestamp >>= 4;
pTimestring[4] = '-';
pTimestring[3] = (Timestamp&0xF)+'0';
Timestamp >>= 4;
pTimestring[2] = (Timestamp&0xF)+'0';
Timestamp >>= 4;
pTimestring[1] = (Timestamp&0xF)+'0';
Timestamp >>= 4;
pTimestring[0] = (Timestamp&0xF)+'0';
}
void CFileCollection::Init(IStorage *pStorage, const char *pPath, const char *pFileDesc, const char *pFileExt, int MaxEntries)
{
mem_zero(m_aTimestamps, sizeof(m_aTimestamps));
m_NumTimestamps = 0;
m_MaxEntries = clamp(MaxEntries, 1, static_cast<int>(MAX_ENTRIES));
str_copy(m_aFileDesc, pFileDesc, sizeof(m_aFileDesc));
m_FileDescLength = str_length(m_aFileDesc);
str_copy(m_aFileExt, pFileExt, sizeof(m_aFileExt));
m_FileExtLength = str_length(m_aFileExt);
str_copy(m_aPath, pPath, sizeof(m_aPath));
m_pStorage = pStorage;
m_pStorage->ListDirectory(IStorage::TYPE_SAVE, m_aPath, FilelistCallback, this);
}
void CFileCollection::AddEntry(int64 Timestamp)
{
if(m_NumTimestamps == 0)
{
// empty list
m_aTimestamps[m_NumTimestamps++] = Timestamp;
}
else
{
// remove old file
if(m_NumTimestamps == m_MaxEntries)
{
char aBuf[512];
char aTimestring[TIMESTAMP_LENGTH];
BuildTimestring(m_aTimestamps[0], aTimestring);
str_format(aBuf, sizeof(aBuf), "%s/%s_%s%s", m_aPath, m_aFileDesc, aTimestring, m_aFileExt);
m_pStorage->RemoveFile(aBuf, IStorage::TYPE_SAVE);
}
// add entry to the sorted list
if(m_aTimestamps[0] > Timestamp)
{
// first entry
if(m_NumTimestamps < m_MaxEntries)
{
mem_move(m_aTimestamps+1, m_aTimestamps, m_NumTimestamps*sizeof(int64));
m_aTimestamps[0] = Timestamp;
++m_NumTimestamps;
}
}
else if(m_aTimestamps[m_NumTimestamps-1] <= Timestamp)
{
// last entry
if(m_NumTimestamps == m_MaxEntries)
{
mem_move(m_aTimestamps, m_aTimestamps+1, (m_NumTimestamps-1)*sizeof(int64));
m_aTimestamps[m_NumTimestamps-1] = Timestamp;
}
else
m_aTimestamps[m_NumTimestamps++] = Timestamp;
}
else
{
// middle entry
int Left = 0, Right = m_NumTimestamps-1;
while(Right-Left > 1)
{
int Mid = (Left+Right)/2;
if(m_aTimestamps[Mid] > Timestamp)
Right = Mid;
else
Left = Mid;
}
if(m_NumTimestamps == m_MaxEntries)
{
mem_move(m_aTimestamps, m_aTimestamps+1, (Right-1)*sizeof(int64));
m_aTimestamps[Right-1] = Timestamp;
}
else
{
mem_move(m_aTimestamps+Right+1, m_aTimestamps+Right, (m_NumTimestamps-Right)*sizeof(int64));
m_aTimestamps[Right] = Timestamp;
++m_NumTimestamps;
}
}
}
}
int CFileCollection::FilelistCallback(const char *pFilename, int IsDir, int StorageType, void *pUser)
{
CFileCollection *pThis = static_cast<CFileCollection *>(pUser);
// check for valid file name format
if(IsDir || !pThis->IsFilenameValid(pFilename))
return 0;
// extract the timestamp
int64 Timestamp = pThis->ExtractTimestamp(pFilename+pThis->m_FileDescLength+1);
// add the entry
pThis->AddEntry(Timestamp);
return 0;
}
|
; A008954: Final digit of triangular number n*(n+1)/2.
; 0,1,3,6,0,5,1,8,6,5,5,6,8,1,5,0,6,3,1,0,0,1,3,6,0,5,1,8,6,5,5,6,8,1,5,0,6,3,1,0,0,1,3,6,0,5,1,8,6,5,5,6,8,1,5,0,6,3,1,0,0,1,3,6,0,5,1,8,6,5,5,6,8,1,5,0,6,3,1,0,0,1,3,6,0,5,1,8,6,5,5,6,8,1,5,0,6,3,1,0
sub $1,$0
bin $1,2
mod $1,10
mov $0,$1
|
; Outputs a byte from a port
global outb
outb:
push ebp
mov ebp, esp
push ax
push dx
; dx = port, al = value
mov dx, word [ebp + 12]
mov al, byte [ebp + 8]
out dx, al
pop dx
pop ax
leave
ret
; Outputs a word from a port
global outw
outw:
push ebp
mov ebp, esp
push ax
push dx
; dx = port, ax = value
mov dx, word [ebp + 12]
mov ax, word [ebp + 8]
out dx, ax
pop dx
pop ax
leave
ret
; Receives a byte from a port
global inb
inb:
push ebp
mov ebp, esp
push dx
; dx = port, al = value
mov dx, word [ebp + 8]
in al, dx
pop dx
leave
ret
; Receives a word from a port
global inw
inw:
push ebp
mov ebp, esp
push dx
; dx = port, al = value
mov dx, word [ebp + 8]
in ax, dx
pop dx
leave
ret
|
// This file auto generated by plugin for ida pro. Generated code only for x64. Please, dont change manually
#pragma once
#include <common/common.h>
#include <ATL__CStringT.hpp>
#include <IStream.hpp>
START_ATF_NAMESPACE
#pragma pack(push, 8)
struct CStreamOnCString : IStream
{
ATL::CStringT<char> m_strStream;
ATL::CStringT<char> m_strAnsi;
unsigned int m_current_index;
};
#pragma pack(pop)
END_ATF_NAMESPACE
|
; Listing generated by Microsoft (R) Optimizing Compiler Version 19.28.29334.0
include listing.inc
INCLUDELIB MSVCRTD
INCLUDELIB OLDNAMES
msvcjmc SEGMENT
__2B31710D_vcruntime_new@h DB 01H
__09340588_corecrt_math@h DB 01H
__24E9E95F_stdlib@h DB 01H
__ACEB72CA_cstdlib DB 01H
__F66CEB67_corecrt_stdio_config@h DB 01H
__101834BA_corecrt_wstdio@h DB 01H
__AD6A91B7_stdio@h DB 01H
__367CC694_corecrt_memcpy_s@h DB 01H
__5467428D_corecrt_wconio@h DB 01H
__4442441F_corecrt_wio@h DB 01H
__DC9673E3_corecrt_wstring@h DB 01H
__45F4AF76_corecrt_wtime@h DB 01H
__186FF47F_stat@h DB 01H
__534C724A_wchar@h DB 01H
__0920A867_cstddef DB 01H
__D63D5DDA_limits DB 01H
__2D26A21E_type_traits DB 01H
__B0C4CEA9_malloc@h DB 01H
__49CBC5C5_vcruntime_exception@h DB 01H
__8B12B611_exception DB 01H
__35D7DDB3_corecrt_memory@h DB 01H
__A29A7DFB_string@h DB 01H
__F4CD6065_xutility DB 01H
__F1739482_xmemory DB 01H
__61DEF4C5_algorithm DB 01H
__B68D2755_vcruntime_typeinfo@h DB 01H
__8412937C_typeinfo DB 01H
__6A935154_memory DB 01H
__A298E223_tuple DB 01H
__B8402D15_xpolymorphic_allocator@h DB 01H
__85A0121E_xstring DB 01H
__025C8C4C_stdexcept DB 01H
__7242C389_ctype@h DB 01H
__1E40D7C8_string DB 01H
__04BBFB62_cmath DB 01H
__127BCABE_xcall_once@h DB 01H
__8AA3BE86_time@h DB 01H
__0E11DA62_xthreads@h DB 01H
__BD080118_atomic DB 01H
__AD26D89E_system_error DB 01H
__46D6065B_xfacet DB 01H
__9B9B70B4_xlocinfo DB 01H
__5A9E662F_xlocale DB 01H
__A27E07A7_xiosbase DB 01H
__C4190038_xlocnum DB 01H
__A1E1ADF7_ios DB 01H
__EF7B1500_xlocmon DB 01H
__3F86D9A6_xloctime DB 01H
__563C2410_any DB 01H
__0D920760_xtree DB 01H
__43313DD1_LoggerHandler@hpp DB 01H
__3559405B_PaymentHandler@cpp DB 01H
__9B902D3A_vector DB 01H
__2A5E89D1_istream DB 01H
__498EBCEB_ostream DB 01H
__00FC34F0_streambuf DB 01H
__E561D725_iterator DB 01H
__1AD4885C_iosfwd DB 01H
__9BE6F741_utility DB 01H
__6CF96053_xstddef DB 01H
__D69C4F83_iomanip DB 01H
__811E3AC7_xatomic@h DB 01H
msvcjmc ENDS
PUBLIC ?__empty_global_delete@@YAXPEAX@Z ; __empty_global_delete
PUBLIC ?__empty_global_delete@@YAXPEAX_K@Z ; __empty_global_delete
PUBLIC ?__empty_global_delete@@YAXPEAXW4align_val_t@std@@@Z ; __empty_global_delete
PUBLIC ?__empty_global_delete@@YAXPEAX_KW4align_val_t@std@@@Z ; __empty_global_delete
PUBLIC ??2@YAPEAX_KPEAX@Z ; operator new
PUBLIC wmemcpy
PUBLIC ?max@?$numeric_limits@_J@std@@SA_JXZ ; std::numeric_limits<__int64>::max
PUBLIC ??0exception@std@@QEAA@QEBDH@Z ; std::exception::exception
PUBLIC ??0exception@std@@QEAA@AEBV01@@Z ; std::exception::exception
PUBLIC ??1exception@std@@UEAA@XZ ; std::exception::~exception
PUBLIC ?what@exception@std@@UEBAPEBDXZ ; std::exception::what
PUBLIC ??_Gexception@std@@UEAAPEAXI@Z ; std::exception::`scalar deleting destructor'
PUBLIC ??0bad_alloc@std@@AEAA@QEBD@Z ; std::bad_alloc::bad_alloc
PUBLIC ??1bad_alloc@std@@UEAA@XZ ; std::bad_alloc::~bad_alloc
PUBLIC ??0bad_alloc@std@@QEAA@AEBV01@@Z ; std::bad_alloc::bad_alloc
PUBLIC ??_Gbad_alloc@std@@UEAAPEAXI@Z ; std::bad_alloc::`scalar deleting destructor'
PUBLIC ??0bad_array_new_length@std@@QEAA@XZ ; std::bad_array_new_length::bad_array_new_length
PUBLIC ??1bad_array_new_length@std@@UEAA@XZ ; std::bad_array_new_length::~bad_array_new_length
PUBLIC ??0bad_array_new_length@std@@QEAA@AEBV01@@Z ; std::bad_array_new_length::bad_array_new_length
PUBLIC ??_Gbad_array_new_length@std@@UEAAPEAXI@Z ; std::bad_array_new_length::`scalar deleting destructor'
PUBLIC ?_Throw_bad_array_new_length@std@@YAXXZ ; std::_Throw_bad_array_new_length
PUBLIC ?_Allocate@_Default_allocate_traits@std@@SAPEAX_K@Z ; std::_Default_allocate_traits::_Allocate
PUBLIC ?_Adjust_manually_vector_aligned@std@@YAXAEAPEAXAEA_K@Z ; std::_Adjust_manually_vector_aligned
PUBLIC ??0_Container_proxy@std@@QEAA@PEAU_Container_base12@1@@Z ; std::_Container_proxy::_Container_proxy
PUBLIC ??0_Container_base12@std@@QEAA@XZ ; std::_Container_base12::_Container_base12
PUBLIC ?_Orphan_all@_Container_base12@std@@QEAAXXZ ; std::_Container_base12::_Orphan_all
PUBLIC ??$_Construct_in_place@U_Container_proxy@std@@PEAU_Container_base12@2@@std@@YAXAEAU_Container_proxy@0@$$QEAPEAU_Container_base12@0@@Z ; std::_Construct_in_place<std::_Container_proxy,std::_Container_base12 *>
PUBLIC ??0?$allocator@D@std@@QEAA@XZ ; std::allocator<char>::allocator<char>
PUBLIC ?deallocate@?$allocator@D@std@@QEAAXQEAD_K@Z ; std::allocator<char>::deallocate
PUBLIC ?allocate@?$allocator@D@std@@QEAAPEAD_K@Z ; std::allocator<char>::allocate
PUBLIC ?copy@?$_Char_traits@DH@std@@SAPEADQEADQEBD_K@Z ; std::_Char_traits<char,int>::copy
PUBLIC ?move@?$_Char_traits@DH@std@@SAPEADQEADQEBD_K@Z ; std::_Char_traits<char,int>::move
PUBLIC ?compare@?$_Narrow_char_traits@DH@std@@SAHQEBD0_K@Z ; std::_Narrow_char_traits<char,int>::compare
PUBLIC ?length@?$_Narrow_char_traits@DH@std@@SA_KQEBD@Z ; std::_Narrow_char_traits<char,int>::length
PUBLIC ?assign@?$_Narrow_char_traits@DH@std@@SAXAEADAEBD@Z ; std::_Narrow_char_traits<char,int>::assign
PUBLIC ?eq_int_type@?$_Narrow_char_traits@DH@std@@SA_NAEBH0@Z ; std::_Narrow_char_traits<char,int>::eq_int_type
PUBLIC ?eof@?$_Narrow_char_traits@DH@std@@SAHXZ ; std::_Narrow_char_traits<char,int>::eof
PUBLIC ?_Xlen_string@std@@YAXXZ ; std::_Xlen_string
PUBLIC ?max_size@?$_Default_allocator_traits@V?$allocator@D@std@@@std@@SA_KAEBV?$allocator@D@2@@Z ; std::_Default_allocator_traits<std::allocator<char> >::max_size
PUBLIC ??0?$_String_val@U?$_Simple_types@D@std@@@std@@QEAA@XZ ; std::_String_val<std::_Simple_types<char> >::_String_val<std::_Simple_types<char> >
PUBLIC ?_Myptr@?$_String_val@U?$_Simple_types@D@std@@@std@@QEAAPEADXZ ; std::_String_val<std::_Simple_types<char> >::_Myptr
PUBLIC ?_Myptr@?$_String_val@U?$_Simple_types@D@std@@@std@@QEBAPEBDXZ ; std::_String_val<std::_Simple_types<char> >::_Myptr
PUBLIC ?_Large_string_engaged@?$_String_val@U?$_Simple_types@D@std@@@std@@QEBA_NXZ ; std::_String_val<std::_Simple_types<char> >::_Large_string_engaged
PUBLIC ??0_Bxty@?$_String_val@U?$_Simple_types@D@std@@@std@@QEAA@XZ ; std::_String_val<std::_Simple_types<char> >::_Bxty::_Bxty
PUBLIC ??1_Bxty@?$_String_val@U?$_Simple_types@D@std@@@std@@QEAA@XZ ; std::_String_val<std::_Simple_types<char> >::_Bxty::~_Bxty
PUBLIC ??1?$_String_val@U?$_Simple_types@D@std@@@std@@QEAA@XZ ; std::_String_val<std::_Simple_types<char> >::~_String_val<std::_Simple_types<char> >
PUBLIC ??0?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEAA@XZ ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::basic_string<char,std::char_traits<char>,std::allocator<char> >
PUBLIC ??1?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEAA@XZ ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::~basic_string<char,std::char_traits<char>,std::allocator<char> >
PUBLIC ?_Copy_assign@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@AEAAXAEBV12@U?$integral_constant@_N$0A@@2@@Z ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::_Copy_assign
PUBLIC ??4?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEAAAEAV01@AEBV01@@Z ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::operator=
PUBLIC ?assign@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEAAAEAV12@QEBD_K@Z ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::assign
PUBLIC ?data@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEBAPEBDXZ ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::data
PUBLIC ?size@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEBA_KXZ ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::size
PUBLIC ?max_size@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEBA_KXZ ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::max_size
PUBLIC ?_Equal@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEBA_NQEBD@Z ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::_Equal
PUBLIC ?_Calculate_growth@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@CA_K_K00@Z ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::_Calculate_growth
PUBLIC ?_Calculate_growth@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@AEBA_K_K@Z ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::_Calculate_growth
PUBLIC ?_Tidy_init@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@AEAAXXZ ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::_Tidy_init
PUBLIC ?_Tidy_deallocate@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@AEAAXXZ ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::_Tidy_deallocate
PUBLIC ?_Getal@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@AEAAAEAV?$allocator@D@2@XZ ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::_Getal
PUBLIC ?_Getal@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@AEBAAEBV?$allocator@D@2@XZ ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::_Getal
PUBLIC ?_Get_first@?$_Compressed_pair@V?$allocator@D@std@@V?$_String_val@U?$_Simple_types@D@std@@@2@$00@std@@QEAAAEAV?$allocator@D@2@XZ ; std::_Compressed_pair<std::allocator<char>,std::_String_val<std::_Simple_types<char> >,1>::_Get_first
PUBLIC ?_Get_first@?$_Compressed_pair@V?$allocator@D@std@@V?$_String_val@U?$_Simple_types@D@std@@@2@$00@std@@QEBAAEBV?$allocator@D@2@XZ ; std::_Compressed_pair<std::allocator<char>,std::_String_val<std::_Simple_types<char> >,1>::_Get_first
PUBLIC ??1?$_Compressed_pair@V?$allocator@D@std@@V?$_String_val@U?$_Simple_types@D@std@@@2@$00@std@@QEAA@XZ ; std::_Compressed_pair<std::allocator<char>,std::_String_val<std::_Simple_types<char> >,1>::~_Compressed_pair<std::allocator<char>,std::_String_val<std::_Simple_types<char> >,1>
PUBLIC ??$_Maklocstr@_W@std@@YAPEA_WPEBDPEA_WAEBU_Cvtvec@@@Z ; std::_Maklocstr<wchar_t>
PUBLIC ?_Maklocwcs@std@@YAPEA_WPEB_W@Z ; std::_Maklocwcs
PUBLIC ??$_Maklocstr@D@std@@YAPEADPEBDPEADAEBU_Cvtvec@@@Z ; std::_Maklocstr<char>
PUBLIC ??$_Getvals@_W@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@IEAAX_WAEBV_Locinfo@1@@Z ; std::time_get<char,std::istreambuf_iterator<char,std::char_traits<char> > >::_Getvals<wchar_t>
PUBLIC ??$_Getvals@_W@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@IEAAX_WAEBV_Locinfo@1@@Z ; std::time_get<wchar_t,std::istreambuf_iterator<wchar_t,std::char_traits<wchar_t> > >::_Getvals<wchar_t>
PUBLIC ??1PaymentOption@Persistence@TechnicalServices@@QEAA@XZ ; TechnicalServices::Persistence::PaymentOption::~PaymentOption
PUBLIC ??_GPaymentOption@Persistence@TechnicalServices@@QEAAPEAXI@Z ; TechnicalServices::Persistence::PaymentOption::`scalar deleting destructor'
PUBLIC ?PaySystemFactory@PaymentHandlerInterface@External@TechnicalServices@@SA?AV?$unique_ptr@VPaymentHandlerInterface@External@TechnicalServices@@U?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@@std@@XZ ; TechnicalServices::External::PaymentHandlerInterface::PaySystemFactory
PUBLIC ??1PaymentHandlerInterface@External@TechnicalServices@@UEAA@XZ ; TechnicalServices::External::PaymentHandlerInterface::~PaymentHandlerInterface
PUBLIC ??0PaymentHandlerInterface@External@TechnicalServices@@QEAA@XZ ; TechnicalServices::External::PaymentHandlerInterface::PaymentHandlerInterface
PUBLIC ??0CreditPayment@External@TechnicalServices@@QEAA@XZ ; TechnicalServices::External::CreditPayment::CreditPayment
PUBLIC ??1CreditPayment@External@TechnicalServices@@UEAA@XZ ; TechnicalServices::External::CreditPayment::~CreditPayment
PUBLIC ??_GCreditPayment@External@TechnicalServices@@UEAAPEAXI@Z ; TechnicalServices::External::CreditPayment::`scalar deleting destructor'
PUBLIC ??0DebitPayment@External@TechnicalServices@@QEAA@XZ ; TechnicalServices::External::DebitPayment::DebitPayment
PUBLIC ??1DebitPayment@External@TechnicalServices@@UEAA@XZ ; TechnicalServices::External::DebitPayment::~DebitPayment
PUBLIC ??_GDebitPayment@External@TechnicalServices@@UEAAPEAXI@Z ; TechnicalServices::External::DebitPayment::`scalar deleting destructor'
PUBLIC ??0GatewayPayment@External@TechnicalServices@@QEAA@XZ ; TechnicalServices::External::GatewayPayment::GatewayPayment
PUBLIC ??1GatewayPayment@External@TechnicalServices@@UEAA@XZ ; TechnicalServices::External::GatewayPayment::~GatewayPayment
PUBLIC ??_GGatewayPayment@External@TechnicalServices@@UEAAPEAXI@Z ; TechnicalServices::External::GatewayPayment::`scalar deleting destructor'
PUBLIC ?deallocate@?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@QEAAXQEAUPaymentOption@Persistence@TechnicalServices@@_K@Z ; std::allocator<TechnicalServices::Persistence::PaymentOption>::deallocate
PUBLIC ??1?$vector@UPaymentOption@Persistence@TechnicalServices@@V?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@@std@@QEAA@XZ ; std::vector<TechnicalServices::Persistence::PaymentOption,std::allocator<TechnicalServices::Persistence::PaymentOption> >::~vector<TechnicalServices::Persistence::PaymentOption,std::allocator<TechnicalServices::Persistence::PaymentOption> >
PUBLIC ?size@?$vector@UPaymentOption@Persistence@TechnicalServices@@V?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@@std@@QEBA_KXZ ; std::vector<TechnicalServices::Persistence::PaymentOption,std::allocator<TechnicalServices::Persistence::PaymentOption> >::size
PUBLIC ??A?$vector@UPaymentOption@Persistence@TechnicalServices@@V?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@@std@@QEAAAEAUPaymentOption@Persistence@TechnicalServices@@_K@Z ; std::vector<TechnicalServices::Persistence::PaymentOption,std::allocator<TechnicalServices::Persistence::PaymentOption> >::operator[]
PUBLIC ?_Destroy@?$vector@UPaymentOption@Persistence@TechnicalServices@@V?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@@std@@AEAAXPEAUPaymentOption@Persistence@TechnicalServices@@0@Z ; std::vector<TechnicalServices::Persistence::PaymentOption,std::allocator<TechnicalServices::Persistence::PaymentOption> >::_Destroy
PUBLIC ?_Tidy@?$vector@UPaymentOption@Persistence@TechnicalServices@@V?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@@std@@AEAAXXZ ; std::vector<TechnicalServices::Persistence::PaymentOption,std::allocator<TechnicalServices::Persistence::PaymentOption> >::_Tidy
PUBLIC ?_Getal@?$vector@UPaymentOption@Persistence@TechnicalServices@@V?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@@std@@AEAAAEAV?$allocator@UPaymentOption@Persistence@TechnicalServices@@@2@XZ ; std::vector<TechnicalServices::Persistence::PaymentOption,std::allocator<TechnicalServices::Persistence::PaymentOption> >::_Getal
PUBLIC ?_Get_first@?$_Compressed_pair@V?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@V?$_Vector_val@U?$_Simple_types@UPaymentOption@Persistence@TechnicalServices@@@std@@@2@$00@std@@QEAAAEAV?$allocator@UPaymentOption@Persistence@TechnicalServices@@@2@XZ ; std::_Compressed_pair<std::allocator<TechnicalServices::Persistence::PaymentOption>,std::_Vector_val<std::_Simple_types<TechnicalServices::Persistence::PaymentOption> >,1>::_Get_first
PUBLIC ?__autoclassinit2@?$vector@UPaymentOption@Persistence@TechnicalServices@@V?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@@std@@QEAAX_K@Z ; std::vector<TechnicalServices::Persistence::PaymentOption,std::allocator<TechnicalServices::Persistence::PaymentOption> >::__autoclassinit2
PUBLIC ??$?6U?$char_traits@D@std@@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@PEBD@Z ; std::operator<<<std::char_traits<char> >
PUBLIC ??$?6U?$char_traits@D@std@@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@D@Z ; std::operator<<<std::char_traits<char> >
PUBLIC ??$?6DU?$char_traits@D@std@@_J@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@AEBU?$_Smanip@_J@0@@Z ; std::operator<<<char,std::char_traits<char>,__int64>
PUBLIC ??$?6DU?$char_traits@D@std@@V?$allocator@D@1@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@AEBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@0@@Z ; std::operator<<<char,std::char_traits<char>,std::allocator<char> >
PUBLIC ??$?8DU?$char_traits@D@std@@V?$allocator@D@1@@std@@YA_NAEBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@0@QEBD@Z ; std::operator==<char,std::char_traits<char>,std::allocator<char> >
PUBLIC ??$make_unique@UCreditPayment@External@TechnicalServices@@$$V$0A@@std@@YA?AV?$unique_ptr@UCreditPayment@External@TechnicalServices@@U?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@@0@XZ ; std::make_unique<TechnicalServices::External::CreditPayment,0>
PUBLIC ??R?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@QEBAXPEAUCreditPayment@External@TechnicalServices@@@Z ; std::default_delete<TechnicalServices::External::CreditPayment>::operator()
PUBLIC ??1?$unique_ptr@UCreditPayment@External@TechnicalServices@@U?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@@std@@QEAA@XZ ; std::unique_ptr<TechnicalServices::External::CreditPayment,std::default_delete<TechnicalServices::External::CreditPayment> >::~unique_ptr<TechnicalServices::External::CreditPayment,std::default_delete<TechnicalServices::External::CreditPayment> >
PUBLIC ?get_deleter@?$unique_ptr@UCreditPayment@External@TechnicalServices@@U?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@@std@@QEAAAEAU?$default_delete@UCreditPayment@External@TechnicalServices@@@2@XZ ; std::unique_ptr<TechnicalServices::External::CreditPayment,std::default_delete<TechnicalServices::External::CreditPayment> >::get_deleter
PUBLIC ?release@?$unique_ptr@UCreditPayment@External@TechnicalServices@@U?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@@std@@QEAAPEAUCreditPayment@External@TechnicalServices@@XZ ; std::unique_ptr<TechnicalServices::External::CreditPayment,std::default_delete<TechnicalServices::External::CreditPayment> >::release
PUBLIC ?_Get_first@?$_Compressed_pair@U?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@PEAUCreditPayment@External@TechnicalServices@@$00@std@@QEAAAEAU?$default_delete@UCreditPayment@External@TechnicalServices@@@2@XZ ; std::_Compressed_pair<std::default_delete<TechnicalServices::External::CreditPayment>,TechnicalServices::External::CreditPayment *,1>::_Get_first
PUBLIC ??$?0UCreditPayment@External@TechnicalServices@@$0A@@?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@QEAA@AEBU?$default_delete@UCreditPayment@External@TechnicalServices@@@1@@Z ; std::default_delete<TechnicalServices::External::PaymentHandlerInterface>::default_delete<TechnicalServices::External::PaymentHandlerInterface><TechnicalServices::External::CreditPayment,0>
PUBLIC ??$?0UCreditPayment@External@TechnicalServices@@U?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@$0A@@?$unique_ptr@VPaymentHandlerInterface@External@TechnicalServices@@U?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@@std@@QEAA@$$QEAV?$unique_ptr@UCreditPayment@External@TechnicalServices@@U?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@@1@@Z ; std::unique_ptr<TechnicalServices::External::PaymentHandlerInterface,std::default_delete<TechnicalServices::External::PaymentHandlerInterface> >::unique_ptr<TechnicalServices::External::PaymentHandlerInterface,std::default_delete<TechnicalServices::External::PaymentHandlerInterface> ><TechnicalServices::External::CreditPayment,std::default_delete<TechnicalServices::External::CreditPayment>,0>
PUBLIC ??$make_unique@UDebitPayment@External@TechnicalServices@@$$V$0A@@std@@YA?AV?$unique_ptr@UDebitPayment@External@TechnicalServices@@U?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@@0@XZ ; std::make_unique<TechnicalServices::External::DebitPayment,0>
PUBLIC ??R?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@QEBAXPEAUDebitPayment@External@TechnicalServices@@@Z ; std::default_delete<TechnicalServices::External::DebitPayment>::operator()
PUBLIC ??1?$unique_ptr@UDebitPayment@External@TechnicalServices@@U?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@@std@@QEAA@XZ ; std::unique_ptr<TechnicalServices::External::DebitPayment,std::default_delete<TechnicalServices::External::DebitPayment> >::~unique_ptr<TechnicalServices::External::DebitPayment,std::default_delete<TechnicalServices::External::DebitPayment> >
PUBLIC ?get_deleter@?$unique_ptr@UDebitPayment@External@TechnicalServices@@U?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@@std@@QEAAAEAU?$default_delete@UDebitPayment@External@TechnicalServices@@@2@XZ ; std::unique_ptr<TechnicalServices::External::DebitPayment,std::default_delete<TechnicalServices::External::DebitPayment> >::get_deleter
PUBLIC ?release@?$unique_ptr@UDebitPayment@External@TechnicalServices@@U?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@@std@@QEAAPEAUDebitPayment@External@TechnicalServices@@XZ ; std::unique_ptr<TechnicalServices::External::DebitPayment,std::default_delete<TechnicalServices::External::DebitPayment> >::release
PUBLIC ?_Get_first@?$_Compressed_pair@U?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@PEAUDebitPayment@External@TechnicalServices@@$00@std@@QEAAAEAU?$default_delete@UDebitPayment@External@TechnicalServices@@@2@XZ ; std::_Compressed_pair<std::default_delete<TechnicalServices::External::DebitPayment>,TechnicalServices::External::DebitPayment *,1>::_Get_first
PUBLIC ??$?0UDebitPayment@External@TechnicalServices@@$0A@@?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@QEAA@AEBU?$default_delete@UDebitPayment@External@TechnicalServices@@@1@@Z ; std::default_delete<TechnicalServices::External::PaymentHandlerInterface>::default_delete<TechnicalServices::External::PaymentHandlerInterface><TechnicalServices::External::DebitPayment,0>
PUBLIC ??$?0UDebitPayment@External@TechnicalServices@@U?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@$0A@@?$unique_ptr@VPaymentHandlerInterface@External@TechnicalServices@@U?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@@std@@QEAA@$$QEAV?$unique_ptr@UDebitPayment@External@TechnicalServices@@U?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@@1@@Z ; std::unique_ptr<TechnicalServices::External::PaymentHandlerInterface,std::default_delete<TechnicalServices::External::PaymentHandlerInterface> >::unique_ptr<TechnicalServices::External::PaymentHandlerInterface,std::default_delete<TechnicalServices::External::PaymentHandlerInterface> ><TechnicalServices::External::DebitPayment,std::default_delete<TechnicalServices::External::DebitPayment>,0>
PUBLIC ??$make_unique@UGatewayPayment@External@TechnicalServices@@$$V$0A@@std@@YA?AV?$unique_ptr@UGatewayPayment@External@TechnicalServices@@U?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@@0@XZ ; std::make_unique<TechnicalServices::External::GatewayPayment,0>
PUBLIC ??R?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@QEBAXPEAUGatewayPayment@External@TechnicalServices@@@Z ; std::default_delete<TechnicalServices::External::GatewayPayment>::operator()
PUBLIC ??1?$unique_ptr@UGatewayPayment@External@TechnicalServices@@U?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@@std@@QEAA@XZ ; std::unique_ptr<TechnicalServices::External::GatewayPayment,std::default_delete<TechnicalServices::External::GatewayPayment> >::~unique_ptr<TechnicalServices::External::GatewayPayment,std::default_delete<TechnicalServices::External::GatewayPayment> >
PUBLIC ?get_deleter@?$unique_ptr@UGatewayPayment@External@TechnicalServices@@U?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@@std@@QEAAAEAU?$default_delete@UGatewayPayment@External@TechnicalServices@@@2@XZ ; std::unique_ptr<TechnicalServices::External::GatewayPayment,std::default_delete<TechnicalServices::External::GatewayPayment> >::get_deleter
PUBLIC ?release@?$unique_ptr@UGatewayPayment@External@TechnicalServices@@U?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@@std@@QEAAPEAUGatewayPayment@External@TechnicalServices@@XZ ; std::unique_ptr<TechnicalServices::External::GatewayPayment,std::default_delete<TechnicalServices::External::GatewayPayment> >::release
PUBLIC ?_Get_first@?$_Compressed_pair@U?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@PEAUGatewayPayment@External@TechnicalServices@@$00@std@@QEAAAEAU?$default_delete@UGatewayPayment@External@TechnicalServices@@@2@XZ ; std::_Compressed_pair<std::default_delete<TechnicalServices::External::GatewayPayment>,TechnicalServices::External::GatewayPayment *,1>::_Get_first
PUBLIC ??$?0UGatewayPayment@External@TechnicalServices@@$0A@@?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@QEAA@AEBU?$default_delete@UGatewayPayment@External@TechnicalServices@@@1@@Z ; std::default_delete<TechnicalServices::External::PaymentHandlerInterface>::default_delete<TechnicalServices::External::PaymentHandlerInterface><TechnicalServices::External::GatewayPayment,0>
PUBLIC ??$?0UGatewayPayment@External@TechnicalServices@@U?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@$0A@@?$unique_ptr@VPaymentHandlerInterface@External@TechnicalServices@@U?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@@std@@QEAA@$$QEAV?$unique_ptr@UGatewayPayment@External@TechnicalServices@@U?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@@1@@Z ; std::unique_ptr<TechnicalServices::External::PaymentHandlerInterface,std::default_delete<TechnicalServices::External::PaymentHandlerInterface> >::unique_ptr<TechnicalServices::External::PaymentHandlerInterface,std::default_delete<TechnicalServices::External::PaymentHandlerInterface> ><TechnicalServices::External::GatewayPayment,std::default_delete<TechnicalServices::External::GatewayPayment>,0>
PUBLIC ?allocate@?$allocator@U_Container_proxy@std@@@std@@QEAAPEAU_Container_proxy@2@_K@Z ; std::allocator<std::_Container_proxy>::allocate
PUBLIC ??$?0UPaymentOption@Persistence@TechnicalServices@@@?$allocator@U_Container_proxy@std@@@std@@QEAA@AEBV?$allocator@UPaymentOption@Persistence@TechnicalServices@@@1@@Z ; std::allocator<std::_Container_proxy>::allocator<std::_Container_proxy><TechnicalServices::Persistence::PaymentOption>
PUBLIC ??$exchange@PEAU_Container_proxy@std@@$$T@std@@YAPEAU_Container_proxy@0@AEAPEAU10@$$QEA$$T@Z ; std::exchange<std::_Container_proxy *,std::nullptr_t>
PUBLIC ??$_Delete_plain_internal@V?$allocator@U_Container_proxy@std@@@std@@@std@@YAXAEAV?$allocator@U_Container_proxy@std@@@0@QEAU_Container_proxy@0@@Z ; std::_Delete_plain_internal<std::allocator<std::_Container_proxy> >
PUBLIC ??0_Sentry_base@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAA@AEAV12@@Z ; std::basic_ostream<char,std::char_traits<char> >::_Sentry_base::_Sentry_base
PUBLIC ??1_Sentry_base@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAA@XZ ; std::basic_ostream<char,std::char_traits<char> >::_Sentry_base::~_Sentry_base
PUBLIC ??0sentry@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAA@AEAV12@@Z ; std::basic_ostream<char,std::char_traits<char> >::sentry::sentry
PUBLIC ??1sentry@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAA@XZ ; std::basic_ostream<char,std::char_traits<char> >::sentry::~sentry
PUBLIC ??Bsentry@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEBA_NXZ ; std::basic_ostream<char,std::char_traits<char> >::sentry::operator bool
PUBLIC ??$min@_K@std@@YAAEB_KAEB_K0@Z ; std::min<unsigned __int64>
PUBLIC ??$_Alloc_proxy@V?$allocator@U_Container_proxy@std@@@std@@@_Container_base12@std@@QEAAX$$QEAV?$allocator@U_Container_proxy@std@@@1@@Z ; std::_Container_base12::_Alloc_proxy<std::allocator<std::_Container_proxy> >
PUBLIC ??$addressof@$$CBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@@std@@YAPEBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@0@AEBV10@@Z ; std::addressof<std::basic_string<char,std::char_traits<char>,std::allocator<char> > const >
PUBLIC ??$?0D@?$allocator@U_Container_proxy@std@@@std@@QEAA@AEBV?$allocator@D@1@@Z ; std::allocator<std::_Container_proxy>::allocator<std::_Container_proxy><char>
PUBLIC ??$?0$$V@?$_Compressed_pair@V?$allocator@D@std@@V?$_String_val@U?$_Simple_types@D@std@@@2@$00@std@@QEAA@U_Zero_then_variadic_args_t@1@@Z ; std::_Compressed_pair<std::allocator<char>,std::_String_val<std::_Simple_types<char> >,1>::_Compressed_pair<std::allocator<char>,std::_String_val<std::_Simple_types<char> >,1><>
PUBLIC ??$_Unfancy@U_Container_proxy@std@@@std@@YAPEAU_Container_proxy@0@PEAU10@@Z ; std::_Unfancy<std::_Container_proxy>
PUBLIC ??$_Destroy_in_place@PEAD@std@@YAXAEAPEAD@Z ; std::_Destroy_in_place<char *>
PUBLIC ??R<lambda_66f57f934f28d61049862f64df852ff0>@@QEBA@QEAD_KQEBD@Z ; <lambda_66f57f934f28d61049862f64df852ff0>::operator()
PUBLIC ??$_Reallocate_for@V<lambda_66f57f934f28d61049862f64df852ff0>@@PEBD@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@AEAAAEAV01@_KV<lambda_66f57f934f28d61049862f64df852ff0>@@PEBD@Z ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::_Reallocate_for<<lambda_66f57f934f28d61049862f64df852ff0>,char const *>
PUBLIC ??$_Pocca@V?$allocator@D@std@@@std@@YAXAEAV?$allocator@D@0@AEBV10@@Z ; std::_Pocca<std::allocator<char> >
PUBLIC ??$_Construct_in_place@PEADAEBQEAD@std@@YAXAEAPEADAEBQEAD@Z ; std::_Construct_in_place<char *,char * const &>
PUBLIC ??$_Unfancy@D@std@@YAPEADPEAD@Z ; std::_Unfancy<char>
PUBLIC ??$max@_K@std@@YAAEB_KAEB_K0@Z ; std::max<unsigned __int64>
PUBLIC ??$_Get_size_of_n@$0BA@@std@@YA_K_K@Z ; std::_Get_size_of_n<16>
PUBLIC ??$_Allocate@$0BA@U_Default_allocate_traits@std@@$0A@@std@@YAPEAX_K@Z ; std::_Allocate<16,std::_Default_allocate_traits,0>
PUBLIC ??$_Destroy_range@V?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@@std@@YAXPEAUPaymentOption@Persistence@TechnicalServices@@QEAU123@AEAV?$allocator@UPaymentOption@Persistence@TechnicalServices@@@0@@Z ; std::_Destroy_range<std::allocator<TechnicalServices::Persistence::PaymentOption> >
PUBLIC ??$_Deallocate@$0BA@$0A@@std@@YAXPEAX_K@Z ; std::_Deallocate<16,0>
PUBLIC ??$_Get_size_of_n@$00@std@@YA_K_K@Z ; std::_Get_size_of_n<1>
PUBLIC ??$addressof@U_Container_proxy@std@@@std@@YAPEAU_Container_proxy@0@AEAU10@@Z ; std::addressof<std::_Container_proxy>
PUBLIC ??$forward@PEAU_Container_base12@std@@@std@@YA$$QEAPEAU_Container_base12@0@AEAPEAU10@@Z ; std::forward<std::_Container_base12 *>
PUBLIC ??$_Insert_string@DU?$char_traits@D@std@@_K@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@QEBD_K@Z ; std::_Insert_string<char,std::char_traits<char>,unsigned __int64>
PUBLIC ??$?0U?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@$0A@@?$unique_ptr@UCreditPayment@External@TechnicalServices@@U?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@@std@@QEAA@PEAUCreditPayment@External@TechnicalServices@@@Z ; std::unique_ptr<TechnicalServices::External::CreditPayment,std::default_delete<TechnicalServices::External::CreditPayment> >::unique_ptr<TechnicalServices::External::CreditPayment,std::default_delete<TechnicalServices::External::CreditPayment> ><std::default_delete<TechnicalServices::External::CreditPayment>,0>
PUBLIC ??$forward@U?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@@std@@YA$$QEAU?$default_delete@UCreditPayment@External@TechnicalServices@@@0@AEAU10@@Z ; std::forward<std::default_delete<TechnicalServices::External::CreditPayment> >
PUBLIC ??$?0U?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@PEAUCreditPayment@External@TechnicalServices@@@?$_Compressed_pair@U?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@PEAVPaymentHandlerInterface@External@TechnicalServices@@$00@std@@QEAA@U_One_then_variadic_args_t@1@$$QEAU?$default_delete@UCreditPayment@External@TechnicalServices@@@1@$$QEAPEAUCreditPayment@External@TechnicalServices@@@Z ; std::_Compressed_pair<std::default_delete<TechnicalServices::External::PaymentHandlerInterface>,TechnicalServices::External::PaymentHandlerInterface *,1>::_Compressed_pair<std::default_delete<TechnicalServices::External::PaymentHandlerInterface>,TechnicalServices::External::PaymentHandlerInterface *,1><std::default_delete<TechnicalServices::External::CreditPayment>,TechnicalServices::External::CreditPayment *>
PUBLIC ??$?0U?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@$0A@@?$unique_ptr@UDebitPayment@External@TechnicalServices@@U?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@@std@@QEAA@PEAUDebitPayment@External@TechnicalServices@@@Z ; std::unique_ptr<TechnicalServices::External::DebitPayment,std::default_delete<TechnicalServices::External::DebitPayment> >::unique_ptr<TechnicalServices::External::DebitPayment,std::default_delete<TechnicalServices::External::DebitPayment> ><std::default_delete<TechnicalServices::External::DebitPayment>,0>
PUBLIC ??$forward@U?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@@std@@YA$$QEAU?$default_delete@UDebitPayment@External@TechnicalServices@@@0@AEAU10@@Z ; std::forward<std::default_delete<TechnicalServices::External::DebitPayment> >
PUBLIC ??$?0U?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@PEAUDebitPayment@External@TechnicalServices@@@?$_Compressed_pair@U?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@PEAVPaymentHandlerInterface@External@TechnicalServices@@$00@std@@QEAA@U_One_then_variadic_args_t@1@$$QEAU?$default_delete@UDebitPayment@External@TechnicalServices@@@1@$$QEAPEAUDebitPayment@External@TechnicalServices@@@Z ; std::_Compressed_pair<std::default_delete<TechnicalServices::External::PaymentHandlerInterface>,TechnicalServices::External::PaymentHandlerInterface *,1>::_Compressed_pair<std::default_delete<TechnicalServices::External::PaymentHandlerInterface>,TechnicalServices::External::PaymentHandlerInterface *,1><std::default_delete<TechnicalServices::External::DebitPayment>,TechnicalServices::External::DebitPayment *>
PUBLIC ??$?0U?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@$0A@@?$unique_ptr@UGatewayPayment@External@TechnicalServices@@U?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@@std@@QEAA@PEAUGatewayPayment@External@TechnicalServices@@@Z ; std::unique_ptr<TechnicalServices::External::GatewayPayment,std::default_delete<TechnicalServices::External::GatewayPayment> >::unique_ptr<TechnicalServices::External::GatewayPayment,std::default_delete<TechnicalServices::External::GatewayPayment> ><std::default_delete<TechnicalServices::External::GatewayPayment>,0>
PUBLIC ??$forward@U?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@@std@@YA$$QEAU?$default_delete@UGatewayPayment@External@TechnicalServices@@@0@AEAU10@@Z ; std::forward<std::default_delete<TechnicalServices::External::GatewayPayment> >
PUBLIC ??$?0U?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@PEAUGatewayPayment@External@TechnicalServices@@@?$_Compressed_pair@U?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@PEAVPaymentHandlerInterface@External@TechnicalServices@@$00@std@@QEAA@U_One_then_variadic_args_t@1@$$QEAU?$default_delete@UGatewayPayment@External@TechnicalServices@@@1@$$QEAPEAUGatewayPayment@External@TechnicalServices@@@Z ; std::_Compressed_pair<std::default_delete<TechnicalServices::External::PaymentHandlerInterface>,TechnicalServices::External::PaymentHandlerInterface *,1>::_Compressed_pair<std::default_delete<TechnicalServices::External::PaymentHandlerInterface>,TechnicalServices::External::PaymentHandlerInterface *,1><std::default_delete<TechnicalServices::External::GatewayPayment>,TechnicalServices::External::GatewayPayment *>
PUBLIC ??$_Deallocate_plain@V?$allocator@U_Container_proxy@std@@@std@@@std@@YAXAEAV?$allocator@U_Container_proxy@std@@@0@QEAU_Container_proxy@0@@Z ; std::_Deallocate_plain<std::allocator<std::_Container_proxy> >
PUBLIC ??$addressof@PEAD@std@@YAPEAPEADAEAPEAD@Z ; std::addressof<char *>
PUBLIC ??$forward@AEBQEAD@std@@YAAEBQEADAEBQEAD@Z ; std::forward<char * const &>
PUBLIC ??$_Allocate_manually_vector_aligned@U_Default_allocate_traits@std@@@std@@YAPEAX_K@Z ; std::_Allocate_manually_vector_aligned<std::_Default_allocate_traits>
PUBLIC ??$_Unfancy@UPaymentOption@Persistence@TechnicalServices@@@std@@YAPEAUPaymentOption@Persistence@TechnicalServices@@PEAU123@@Z ; std::_Unfancy<TechnicalServices::Persistence::PaymentOption>
PUBLIC ??$destroy@UPaymentOption@Persistence@TechnicalServices@@@?$_Default_allocator_traits@V?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@@std@@SAXAEAV?$allocator@UPaymentOption@Persistence@TechnicalServices@@@1@QEAUPaymentOption@Persistence@TechnicalServices@@@Z ; std::_Default_allocator_traits<std::allocator<TechnicalServices::Persistence::PaymentOption> >::destroy<TechnicalServices::Persistence::PaymentOption>
PUBLIC ??$exchange@PEAUGatewayPayment@External@TechnicalServices@@PEAU123@@std@@YAPEAUGatewayPayment@External@TechnicalServices@@AEAPEAU123@$$QEAPEAU123@@Z ; std::exchange<TechnicalServices::External::GatewayPayment *,TechnicalServices::External::GatewayPayment *>
PUBLIC ??$exchange@PEAUDebitPayment@External@TechnicalServices@@PEAU123@@std@@YAPEAUDebitPayment@External@TechnicalServices@@AEAPEAU123@$$QEAPEAU123@@Z ; std::exchange<TechnicalServices::External::DebitPayment *,TechnicalServices::External::DebitPayment *>
PUBLIC ??$exchange@PEAUCreditPayment@External@TechnicalServices@@PEAU123@@std@@YAPEAUCreditPayment@External@TechnicalServices@@AEAPEAU123@$$QEAPEAU123@@Z ; std::exchange<TechnicalServices::External::CreditPayment *,TechnicalServices::External::CreditPayment *>
PUBLIC ??$_Traits_equal@U?$char_traits@D@std@@@std@@YA_NQEBD_K01@Z ; std::_Traits_equal<std::char_traits<char> >
PUBLIC ??$?0AEAPEAUCreditPayment@External@TechnicalServices@@@?$_Compressed_pair@U?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@PEAUCreditPayment@External@TechnicalServices@@$00@std@@QEAA@U_Zero_then_variadic_args_t@1@AEAPEAUCreditPayment@External@TechnicalServices@@@Z ; std::_Compressed_pair<std::default_delete<TechnicalServices::External::CreditPayment>,TechnicalServices::External::CreditPayment *,1>::_Compressed_pair<std::default_delete<TechnicalServices::External::CreditPayment>,TechnicalServices::External::CreditPayment *,1><TechnicalServices::External::CreditPayment * &>
PUBLIC ??$forward@PEAUCreditPayment@External@TechnicalServices@@@std@@YA$$QEAPEAUCreditPayment@External@TechnicalServices@@AEAPEAU123@@Z ; std::forward<TechnicalServices::External::CreditPayment *>
PUBLIC ??$?0AEAPEAUDebitPayment@External@TechnicalServices@@@?$_Compressed_pair@U?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@PEAUDebitPayment@External@TechnicalServices@@$00@std@@QEAA@U_Zero_then_variadic_args_t@1@AEAPEAUDebitPayment@External@TechnicalServices@@@Z ; std::_Compressed_pair<std::default_delete<TechnicalServices::External::DebitPayment>,TechnicalServices::External::DebitPayment *,1>::_Compressed_pair<std::default_delete<TechnicalServices::External::DebitPayment>,TechnicalServices::External::DebitPayment *,1><TechnicalServices::External::DebitPayment * &>
PUBLIC ??$forward@PEAUDebitPayment@External@TechnicalServices@@@std@@YA$$QEAPEAUDebitPayment@External@TechnicalServices@@AEAPEAU123@@Z ; std::forward<TechnicalServices::External::DebitPayment *>
PUBLIC ??$?0AEAPEAUGatewayPayment@External@TechnicalServices@@@?$_Compressed_pair@U?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@PEAUGatewayPayment@External@TechnicalServices@@$00@std@@QEAA@U_Zero_then_variadic_args_t@1@AEAPEAUGatewayPayment@External@TechnicalServices@@@Z ; std::_Compressed_pair<std::default_delete<TechnicalServices::External::GatewayPayment>,TechnicalServices::External::GatewayPayment *,1>::_Compressed_pair<std::default_delete<TechnicalServices::External::GatewayPayment>,TechnicalServices::External::GatewayPayment *,1><TechnicalServices::External::GatewayPayment * &>
PUBLIC ??$forward@PEAUGatewayPayment@External@TechnicalServices@@@std@@YA$$QEAPEAUGatewayPayment@External@TechnicalServices@@AEAPEAU123@@Z ; std::forward<TechnicalServices::External::GatewayPayment *>
PUBLIC ?deallocate@?$_Default_allocator_traits@V?$allocator@U_Container_proxy@std@@@std@@@std@@SAXAEAV?$allocator@U_Container_proxy@std@@@2@QEAU_Container_proxy@2@_K@Z ; std::_Default_allocator_traits<std::allocator<std::_Container_proxy> >::deallocate
PUBLIC ??$forward@AEAPEAUCreditPayment@External@TechnicalServices@@@std@@YAAEAPEAUCreditPayment@External@TechnicalServices@@AEAPEAU123@@Z ; std::forward<TechnicalServices::External::CreditPayment * &>
PUBLIC ??$forward@AEAPEAUDebitPayment@External@TechnicalServices@@@std@@YAAEAPEAUDebitPayment@External@TechnicalServices@@AEAPEAU123@@Z ; std::forward<TechnicalServices::External::DebitPayment * &>
PUBLIC ??$forward@AEAPEAUGatewayPayment@External@TechnicalServices@@@std@@YAAEAPEAUGatewayPayment@External@TechnicalServices@@AEAPEAU123@@Z ; std::forward<TechnicalServices::External::GatewayPayment * &>
PUBLIC __JustMyCode_Default
PUBLIC ??_7exception@std@@6B@ ; std::exception::`vftable'
PUBLIC ??_C@_0BC@EOODALEL@Unknown?5exception@ ; `string'
PUBLIC ??_7bad_alloc@std@@6B@ ; std::bad_alloc::`vftable'
PUBLIC ??_7bad_array_new_length@std@@6B@ ; std::bad_array_new_length::`vftable'
PUBLIC ??_C@_0BF@KINCDENJ@bad?5array?5new?5length@ ; `string'
PUBLIC _TI3?AVbad_array_new_length@std@@
PUBLIC _CTA3?AVbad_array_new_length@std@@
PUBLIC ??_R0?AVbad_array_new_length@std@@@8 ; std::bad_array_new_length `RTTI Type Descriptor'
PUBLIC _CT??_R0?AVbad_array_new_length@std@@@8??0bad_array_new_length@std@@QEAA@AEBV01@@Z24
PUBLIC ??_R0?AVbad_alloc@std@@@8 ; std::bad_alloc `RTTI Type Descriptor'
PUBLIC _CT??_R0?AVbad_alloc@std@@@8??0bad_alloc@std@@QEAA@AEBV01@@Z24
PUBLIC ??_R0?AVexception@std@@@8 ; std::exception `RTTI Type Descriptor'
PUBLIC _CT??_R0?AVexception@std@@@8??0exception@std@@QEAA@AEBV01@@Z24
PUBLIC ?__LINE__Var@?0??_Adjust_manually_vector_aligned@std@@YAXAEAPEAXAEA_K@Z@4JA ; `std::_Adjust_manually_vector_aligned'::`1'::__LINE__Var
PUBLIC ??_C@_0BB@FCMFBGOM@invalid?5argument@ ; `string'
PUBLIC ??_C@_02DKCKIIND@?$CFs@ ; `string'
PUBLIC ??_C@_0GI@CLKHGMEI@C?3?2Program?5Files?5?$CIx86?$CJ?2Microsof@ ; `string'
PUBLIC ??_C@_1NA@PDNNFCLD@?$AAC?$AA?3?$AA?2?$AAP?$AAr?$AAo?$AAg?$AAr?$AAa?$AAm?$AA?5?$AAF?$AAi?$AAl?$AAe@ ; `string'
PUBLIC ??_C@_1EK@NIFDJFDG@?$AAs?$AAt?$AAd?$AA?3?$AA?3?$AA_?$AAA?$AAd?$AAj?$AAu?$AAs?$AAt?$AA_?$AAm?$AAa@ ; `string'
PUBLIC ??_C@_1CG@JNLFBNGN@?$AA?$CC?$AAi?$AAn?$AAv?$AAa?$AAl?$AAi?$AAd?$AA?5?$AAa?$AAr?$AAg?$AAu?$AAm?$AAe@ ; `string'
PUBLIC ??_C@_0BA@JFNIOLAK@string?5too?5long@ ; `string'
PUBLIC ??_C@_0GI@IDGLFOOP@C?3?2Program?5Files?5?$CIx86?$CJ?2Microsof@ ; `string'
PUBLIC ?__LINE__Var@?0??_Maklocwcs@std@@YAPEA_WPEB_W@Z@4JA ; `std::_Maklocwcs'::`1'::__LINE__Var
PUBLIC ??_C@_0GI@CGFMEO@C?3?2Program?5Files?5?$CIx86?$CJ?2Microsof@ ; `string'
PUBLIC ??_7PaymentHandlerInterface@External@TechnicalServices@@6B@ ; TechnicalServices::External::PaymentHandlerInterface::`vftable'
PUBLIC ??_7CreditPayment@External@TechnicalServices@@6B@ ; TechnicalServices::External::CreditPayment::`vftable'
PUBLIC ??_7DebitPayment@External@TechnicalServices@@6B@ ; TechnicalServices::External::DebitPayment::`vftable'
PUBLIC ??_7GatewayPayment@External@TechnicalServices@@6B@ ; TechnicalServices::External::GatewayPayment::`vftable'
PUBLIC ??_C@_03NLJIHOMM@?5?9?5@ ; `string'
PUBLIC ??_C@_03LPPJIELD@?$CJ?3?5@ ; `string'
PUBLIC ??_C@_0N@HNKDLDDO@?5?5action?5?$CI0?9@ ; `string'
PUBLIC ??_C@_06LIFJDHJL@Credit@ ; `string'
PUBLIC ??_C@_05BGFMJNMO@Debit@ ; `string'
PUBLIC ??_C@_07LEBHEPGK@GateWay@ ; `string'
PUBLIC ??_C@_0BO@PFKOHNJC@vector?5subscript?5out?5of?5range@ ; `string'
PUBLIC ??_C@_0GH@CENCAHKH@C?3?2Program?5Files?5?$CIx86?$CJ?2Microsof@ ; `string'
PUBLIC ??_C@_1MO@BFNDGJJP@?$AAC?$AA?3?$AA?2?$AAP?$AAr?$AAo?$AAg?$AAr?$AAa?$AAm?$AA?5?$AAF?$AAi?$AAl?$AAe@ ; `string'
PUBLIC ??_C@_1BDG@KBAFNKDI@?$AAs?$AAt?$AAd?$AA?3?$AA?3?$AAv?$AAe?$AAc?$AAt?$AAo?$AAr?$AA?$DM?$AAs?$AAt?$AAr@ ; `string'
PUBLIC ??_C@_1EA@LEKOKFNB@?$AA?$CC?$AAv?$AAe?$AAc?$AAt?$AAo?$AAr?$AA?5?$AAs?$AAu?$AAb?$AAs?$AAc?$AAr?$AAi@ ; `string'
PUBLIC ??_C@_0N@LPFKKEBD@?3AM?3am?3PM?3pm@ ; `string'
PUBLIC ??_C@_1BK@MHIKGOKE@?$AA?3?$AAA?$AAM?$AA?3?$AAa?$AAm?$AA?3?$AAP?$AAM?$AA?3?$AAp?$AAm@ ; `string'
PUBLIC ??_C@_1EO@GFNCMDLA@?$AAs?$AAt?$AAd?$AA?3?$AA?3?$AA_?$AAA?$AAl?$AAl?$AAo?$AAc?$AAa?$AAt?$AAe?$AA_@ ; `string'
PUBLIC ??_R4exception@std@@6B@ ; std::exception::`RTTI Complete Object Locator'
PUBLIC ??_R3exception@std@@8 ; std::exception::`RTTI Class Hierarchy Descriptor'
PUBLIC ??_R2exception@std@@8 ; std::exception::`RTTI Base Class Array'
PUBLIC ??_R1A@?0A@EA@exception@std@@8 ; std::exception::`RTTI Base Class Descriptor at (0,-1,0,64)'
PUBLIC ??_R4bad_alloc@std@@6B@ ; std::bad_alloc::`RTTI Complete Object Locator'
PUBLIC ??_R3bad_alloc@std@@8 ; std::bad_alloc::`RTTI Class Hierarchy Descriptor'
PUBLIC ??_R2bad_alloc@std@@8 ; std::bad_alloc::`RTTI Base Class Array'
PUBLIC ??_R1A@?0A@EA@bad_alloc@std@@8 ; std::bad_alloc::`RTTI Base Class Descriptor at (0,-1,0,64)'
PUBLIC ??_R4bad_array_new_length@std@@6B@ ; std::bad_array_new_length::`RTTI Complete Object Locator'
PUBLIC ??_R3bad_array_new_length@std@@8 ; std::bad_array_new_length::`RTTI Class Hierarchy Descriptor'
PUBLIC ??_R2bad_array_new_length@std@@8 ; std::bad_array_new_length::`RTTI Base Class Array'
PUBLIC ??_R1A@?0A@EA@bad_array_new_length@std@@8 ; std::bad_array_new_length::`RTTI Base Class Descriptor at (0,-1,0,64)'
PUBLIC ??_R4PaymentHandlerInterface@External@TechnicalServices@@6B@ ; TechnicalServices::External::PaymentHandlerInterface::`RTTI Complete Object Locator'
PUBLIC ??_R0?AVPaymentHandlerInterface@External@TechnicalServices@@@8 ; TechnicalServices::External::PaymentHandlerInterface `RTTI Type Descriptor'
PUBLIC ??_R3PaymentHandlerInterface@External@TechnicalServices@@8 ; TechnicalServices::External::PaymentHandlerInterface::`RTTI Class Hierarchy Descriptor'
PUBLIC ??_R2PaymentHandlerInterface@External@TechnicalServices@@8 ; TechnicalServices::External::PaymentHandlerInterface::`RTTI Base Class Array'
PUBLIC ??_R1A@?0A@EA@PaymentHandlerInterface@External@TechnicalServices@@8 ; TechnicalServices::External::PaymentHandlerInterface::`RTTI Base Class Descriptor at (0,-1,0,64)'
PUBLIC ??_R4CreditPayment@External@TechnicalServices@@6B@ ; TechnicalServices::External::CreditPayment::`RTTI Complete Object Locator'
PUBLIC ??_R0?AUCreditPayment@External@TechnicalServices@@@8 ; TechnicalServices::External::CreditPayment `RTTI Type Descriptor'
PUBLIC ??_R3CreditPayment@External@TechnicalServices@@8 ; TechnicalServices::External::CreditPayment::`RTTI Class Hierarchy Descriptor'
PUBLIC ??_R2CreditPayment@External@TechnicalServices@@8 ; TechnicalServices::External::CreditPayment::`RTTI Base Class Array'
PUBLIC ??_R1A@?0A@EA@CreditPayment@External@TechnicalServices@@8 ; TechnicalServices::External::CreditPayment::`RTTI Base Class Descriptor at (0,-1,0,64)'
PUBLIC ??_R4DebitPayment@External@TechnicalServices@@6B@ ; TechnicalServices::External::DebitPayment::`RTTI Complete Object Locator'
PUBLIC ??_R0?AUDebitPayment@External@TechnicalServices@@@8 ; TechnicalServices::External::DebitPayment `RTTI Type Descriptor'
PUBLIC ??_R3DebitPayment@External@TechnicalServices@@8 ; TechnicalServices::External::DebitPayment::`RTTI Class Hierarchy Descriptor'
PUBLIC ??_R2DebitPayment@External@TechnicalServices@@8 ; TechnicalServices::External::DebitPayment::`RTTI Base Class Array'
PUBLIC ??_R1A@?0A@EA@DebitPayment@External@TechnicalServices@@8 ; TechnicalServices::External::DebitPayment::`RTTI Base Class Descriptor at (0,-1,0,64)'
PUBLIC ??_R4GatewayPayment@External@TechnicalServices@@6B@ ; TechnicalServices::External::GatewayPayment::`RTTI Complete Object Locator'
PUBLIC ??_R0?AUGatewayPayment@External@TechnicalServices@@@8 ; TechnicalServices::External::GatewayPayment `RTTI Type Descriptor'
PUBLIC ??_R3GatewayPayment@External@TechnicalServices@@8 ; TechnicalServices::External::GatewayPayment::`RTTI Class Hierarchy Descriptor'
PUBLIC ??_R2GatewayPayment@External@TechnicalServices@@8 ; TechnicalServices::External::GatewayPayment::`RTTI Base Class Array'
PUBLIC ??_R1A@?0A@EA@GatewayPayment@External@TechnicalServices@@8 ; TechnicalServices::External::GatewayPayment::`RTTI Base Class Descriptor at (0,-1,0,64)'
EXTRN _purecall:PROC
EXTRN ??2@YAPEAX_K@Z:PROC ; operator new
EXTRN ??3@YAXPEAX_K@Z:PROC ; operator delete
EXTRN __imp__invalid_parameter:PROC
EXTRN __imp__calloc_dbg:PROC
EXTRN __imp__CrtDbgReport:PROC
EXTRN __imp_??0_Lockit@std@@QEAA@H@Z:PROC
EXTRN __imp_??1_Lockit@std@@QEAA@XZ:PROC
EXTRN memcpy:PROC
EXTRN memmove:PROC
EXTRN __imp_wcslen:PROC
EXTRN ?uncaught_exception@std@@YA_NXZ:PROC ; std::uncaught_exception
EXTRN __std_exception_copy:PROC
EXTRN __std_exception_destroy:PROC
EXTRN ??_Eexception@std@@UEAAPEAXI@Z:PROC ; std::exception::`vector deleting destructor'
EXTRN ??_Ebad_alloc@std@@UEAAPEAXI@Z:PROC ; std::bad_alloc::`vector deleting destructor'
EXTRN ??_Ebad_array_new_length@std@@UEAAPEAXI@Z:PROC ; std::bad_array_new_length::`vector deleting destructor'
EXTRN strlen:PROC
EXTRN ?_Xbad_alloc@std@@YAXXZ:PROC ; std::_Xbad_alloc
EXTRN ?_Xlength_error@std@@YAXPEBD@Z:PROC ; std::_Xlength_error
EXTRN _Mbrtowc:PROC
EXTRN __imp_?_Getcvt@_Locinfo@std@@QEBA?AU_Cvtvec@@XZ:PROC
EXTRN __imp_?_Getdays@_Locinfo@std@@QEBAPEBDXZ:PROC
EXTRN __imp_?_Getmonths@_Locinfo@std@@QEBAPEBDXZ:PROC
EXTRN __imp_?_W_Getdays@_Locinfo@std@@QEBAPEBGXZ:PROC
EXTRN __imp_?_W_Getmonths@_Locinfo@std@@QEBAPEBGXZ:PROC
EXTRN __imp_?good@ios_base@std@@QEBA_NXZ:PROC
EXTRN __imp_?flags@ios_base@std@@QEBAHXZ:PROC
EXTRN __imp_?width@ios_base@std@@QEBA_JXZ:PROC
EXTRN __imp_?width@ios_base@std@@QEAA_J_J@Z:PROC
EXTRN __imp_?sputc@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QEAAHD@Z:PROC
EXTRN __imp_?sputn@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QEAA_JPEBD_J@Z:PROC
EXTRN __imp_?setstate@?$basic_ios@DU?$char_traits@D@std@@@std@@QEAAXH_N@Z:PROC
EXTRN __imp_?tie@?$basic_ios@DU?$char_traits@D@std@@@std@@QEBAPEAV?$basic_ostream@DU?$char_traits@D@std@@@2@XZ:PROC
EXTRN __imp_?rdbuf@?$basic_ios@DU?$char_traits@D@std@@@std@@QEBAPEAV?$basic_streambuf@DU?$char_traits@D@std@@@2@XZ:PROC
EXTRN __imp_?fill@?$basic_ios@DU?$char_traits@D@std@@@std@@QEBADXZ:PROC
EXTRN __imp_?_Osfx@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAAXXZ:PROC
EXTRN __imp_??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@I@Z:PROC
EXTRN __imp_??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@_K@Z:PROC
EXTRN __imp_?flush@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAAAEAV12@XZ:PROC
EXTRN __imp_??5?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@AEAI@Z:PROC
EXTRN ?setw@std@@YA?AU?$_Smanip@_J@1@_J@Z:PROC ; std::setw
EXTRN ?instance@PersistenceHandler@Persistence@TechnicalServices@@SAAEAV123@XZ:PROC ; TechnicalServices::Persistence::PersistenceHandler::instance
EXTRN ?PayMethod@CreditPayment@External@TechnicalServices@@UEAA?AV?$unique_ptr@VPayment@External@TechnicalServices@@U?$default_delete@VPayment@External@TechnicalServices@@@std@@@std@@AEAV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@5@@Z:PROC ; TechnicalServices::External::CreditPayment::PayMethod
EXTRN ??_ECreditPayment@External@TechnicalServices@@UEAAPEAXI@Z:PROC ; TechnicalServices::External::CreditPayment::`vector deleting destructor'
EXTRN ?PayMethod@DebitPayment@External@TechnicalServices@@UEAA?AV?$unique_ptr@VPayment@External@TechnicalServices@@U?$default_delete@VPayment@External@TechnicalServices@@@std@@@std@@AEAV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@5@@Z:PROC ; TechnicalServices::External::DebitPayment::PayMethod
EXTRN ??_EDebitPayment@External@TechnicalServices@@UEAAPEAXI@Z:PROC ; TechnicalServices::External::DebitPayment::`vector deleting destructor'
EXTRN ?PayMethod@GatewayPayment@External@TechnicalServices@@UEAA?AV?$unique_ptr@VPayment@External@TechnicalServices@@U?$default_delete@VPayment@External@TechnicalServices@@@std@@@std@@AEAV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@5@@Z:PROC ; TechnicalServices::External::GatewayPayment::PayMethod
EXTRN ??_EGatewayPayment@External@TechnicalServices@@UEAAPEAXI@Z:PROC ; TechnicalServices::External::GatewayPayment::`vector deleting destructor'
EXTRN _CxxThrowException:PROC
EXTRN _RTC_CheckStackVars:PROC
EXTRN _RTC_InitBase:PROC
EXTRN _RTC_Shutdown:PROC
EXTRN __CheckForDebuggerJustMyCode:PROC
EXTRN __CxxFrameHandler4:PROC
EXTRN __GSHandlerCheck:PROC
EXTRN __GSHandlerCheck_EH4:PROC
EXTRN __security_check_cookie:PROC
EXTRN memcmp:PROC
EXTRN ??_7type_info@@6B@:BYTE ; type_info::`vftable'
EXTRN __imp_?cin@std@@3V?$basic_istream@DU?$char_traits@D@std@@@1@A:BYTE
EXTRN __imp_?cout@std@@3V?$basic_ostream@DU?$char_traits@D@std@@@1@A:BYTE
EXTRN __security_cookie:QWORD
; COMDAT pdata
pdata SEGMENT
$pdata$?__empty_global_delete@@YAXPEAX@Z DD imagerel $LN3
DD imagerel $LN3+64
DD imagerel $unwind$?__empty_global_delete@@YAXPEAX@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$?__empty_global_delete@@YAXPEAX_K@Z DD imagerel $LN3
DD imagerel $LN3+69
DD imagerel $unwind$?__empty_global_delete@@YAXPEAX_K@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$?__empty_global_delete@@YAXPEAXW4align_val_t@std@@@Z DD imagerel $LN3
DD imagerel $LN3+69
DD imagerel $unwind$?__empty_global_delete@@YAXPEAXW4align_val_t@std@@@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$?__empty_global_delete@@YAXPEAX_KW4align_val_t@std@@@Z DD imagerel $LN3
DD imagerel $LN3+74
DD imagerel $unwind$?__empty_global_delete@@YAXPEAX_KW4align_val_t@std@@@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??2@YAPEAX_KPEAX@Z DD imagerel $LN3
DD imagerel $LN3+76
DD imagerel $unwind$??2@YAPEAX_KPEAX@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$wmemcpy DD imagerel $LN3
DD imagerel $LN3+106
DD imagerel $unwind$wmemcpy
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$?max@?$numeric_limits@_J@std@@SA_JXZ DD imagerel $LN3
DD imagerel $LN3+62
DD imagerel $unwind$?max@?$numeric_limits@_J@std@@SA_JXZ
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??0exception@std@@QEAA@QEBDH@Z DD imagerel $LN3
DD imagerel $LN3+139
DD imagerel $unwind$??0exception@std@@QEAA@QEBDH@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??0exception@std@@QEAA@AEBV01@@Z DD imagerel $LN3
DD imagerel $LN3+146
DD imagerel $unwind$??0exception@std@@QEAA@AEBV01@@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??1exception@std@@UEAA@XZ DD imagerel $LN3
DD imagerel $LN3+100
DD imagerel $unwind$??1exception@std@@UEAA@XZ
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$?what@exception@std@@UEBAPEBDXZ DD imagerel $LN5
DD imagerel $LN5+119
DD imagerel $unwind$?what@exception@std@@UEBAPEBDXZ
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??_Gexception@std@@UEAAPEAXI@Z DD imagerel $LN4
DD imagerel $LN4+105
DD imagerel $unwind$??_Gexception@std@@UEAAPEAXI@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??0bad_alloc@std@@AEAA@QEBD@Z DD imagerel $LN3
DD imagerel $LN3+118
DD imagerel $unwind$??0bad_alloc@std@@AEAA@QEBD@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??1bad_alloc@std@@UEAA@XZ DD imagerel $LN3
DD imagerel $LN3+64
DD imagerel $unwind$??1bad_alloc@std@@UEAA@XZ
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??0bad_alloc@std@@QEAA@AEBV01@@Z DD imagerel $LN3
DD imagerel $LN3+100
DD imagerel $unwind$??0bad_alloc@std@@QEAA@AEBV01@@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??_Gbad_alloc@std@@UEAAPEAXI@Z DD imagerel $LN4
DD imagerel $LN4+105
DD imagerel $unwind$??_Gbad_alloc@std@@UEAAPEAXI@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??0bad_array_new_length@std@@QEAA@XZ DD imagerel $LN3
DD imagerel $LN3+107
DD imagerel $unwind$??0bad_array_new_length@std@@QEAA@XZ
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??1bad_array_new_length@std@@UEAA@XZ DD imagerel $LN3
DD imagerel $LN3+64
DD imagerel $unwind$??1bad_array_new_length@std@@UEAA@XZ
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??0bad_array_new_length@std@@QEAA@AEBV01@@Z DD imagerel $LN3
DD imagerel $LN3+100
DD imagerel $unwind$??0bad_array_new_length@std@@QEAA@AEBV01@@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??_Gbad_array_new_length@std@@UEAAPEAXI@Z DD imagerel $LN4
DD imagerel $LN4+105
DD imagerel $unwind$??_Gbad_array_new_length@std@@UEAAPEAXI@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$?_Throw_bad_array_new_length@std@@YAXXZ DD imagerel $LN3
DD imagerel $LN3+83
DD imagerel $unwind$?_Throw_bad_array_new_length@std@@YAXXZ
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$?_Allocate@_Default_allocate_traits@std@@SAPEAX_K@Z DD imagerel $LN3
DD imagerel $LN3+76
DD imagerel $unwind$?_Allocate@_Default_allocate_traits@std@@SAPEAX_K@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$?_Adjust_manually_vector_aligned@std@@YAXAEAPEAXAEA_K@Z DD imagerel $LN21
DD imagerel $LN21+476
DD imagerel $unwind$?_Adjust_manually_vector_aligned@std@@YAXAEAPEAXAEA_K@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??0_Container_proxy@std@@QEAA@PEAU_Container_base12@1@@Z DD imagerel $LN3
DD imagerel $LN3+108
DD imagerel $unwind$??0_Container_proxy@std@@QEAA@PEAU_Container_base12@1@@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??0_Container_base12@std@@QEAA@XZ DD imagerel $LN3
DD imagerel $LN3+85
DD imagerel $unwind$??0_Container_base12@std@@QEAA@XZ
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$?_Orphan_all@_Container_base12@std@@QEAAXXZ DD imagerel $LN7
DD imagerel $LN7+232
DD imagerel $unwind$?_Orphan_all@_Container_base12@std@@QEAAXXZ
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??$_Construct_in_place@U_Container_proxy@std@@PEAU_Container_base12@2@@std@@YAXAEAU_Container_proxy@0@$$QEAPEAU_Container_base12@0@@Z DD imagerel $LN3
DD imagerel $LN3+142
DD imagerel $unwind$??$_Construct_in_place@U_Container_proxy@std@@PEAU_Container_base12@2@@std@@YAXAEAU_Container_proxy@0@$$QEAPEAU_Container_base12@0@@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??0?$allocator@D@std@@QEAA@XZ DD imagerel $LN3
DD imagerel $LN3+71
DD imagerel $unwind$??0?$allocator@D@std@@QEAA@XZ
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$?deallocate@?$allocator@D@std@@QEAAXQEAD_K@Z DD imagerel $LN3
DD imagerel $LN3+93
DD imagerel $unwind$?deallocate@?$allocator@D@std@@QEAAXQEAD_K@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$?allocate@?$allocator@D@std@@QEAAPEAD_K@Z DD imagerel $LN3
DD imagerel $LN3+89
DD imagerel $unwind$?allocate@?$allocator@D@std@@QEAAPEAD_K@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$?copy@?$_Char_traits@DH@std@@SAPEADQEADQEBD_K@Z DD imagerel $LN3
DD imagerel $LN3+107
DD imagerel $unwind$?copy@?$_Char_traits@DH@std@@SAPEADQEADQEBD_K@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$?move@?$_Char_traits@DH@std@@SAPEADQEADQEBD_K@Z DD imagerel $LN3
DD imagerel $LN3+107
DD imagerel $unwind$?move@?$_Char_traits@DH@std@@SAPEADQEADQEBD_K@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$?compare@?$_Narrow_char_traits@DH@std@@SAHQEBD0_K@Z DD imagerel $LN3
DD imagerel $LN3+100
DD imagerel $unwind$?compare@?$_Narrow_char_traits@DH@std@@SAHQEBD0_K@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$?length@?$_Narrow_char_traits@DH@std@@SA_KQEBD@Z DD imagerel $LN4
DD imagerel $LN4+123
DD imagerel $unwind$?length@?$_Narrow_char_traits@DH@std@@SA_KQEBD@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$?assign@?$_Narrow_char_traits@DH@std@@SAXAEADAEBD@Z DD imagerel $LN3
DD imagerel $LN3+88
DD imagerel $unwind$?assign@?$_Narrow_char_traits@DH@std@@SAXAEADAEBD@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$?eq_int_type@?$_Narrow_char_traits@DH@std@@SA_NAEBH0@Z DD imagerel $LN5
DD imagerel $LN5+118
DD imagerel $unwind$?eq_int_type@?$_Narrow_char_traits@DH@std@@SA_NAEBH0@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$?eof@?$_Narrow_char_traits@DH@std@@SAHXZ DD imagerel $LN3
DD imagerel $LN3+57
DD imagerel $unwind$?eof@?$_Narrow_char_traits@DH@std@@SAHXZ
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$?_Xlen_string@std@@YAXXZ DD imagerel $LN3
DD imagerel $LN3+64
DD imagerel $unwind$?_Xlen_string@std@@YAXXZ
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$?max_size@?$_Default_allocator_traits@V?$allocator@D@std@@@std@@SA_KAEBV?$allocator@D@2@@Z DD imagerel $LN3
DD imagerel $LN3+71
DD imagerel $unwind$?max_size@?$_Default_allocator_traits@V?$allocator@D@std@@@std@@SA_KAEBV?$allocator@D@2@@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??0?$_String_val@U?$_Simple_types@D@std@@@std@@QEAA@XZ DD imagerel $LN3
DD imagerel $LN3+132
DD imagerel $unwind$??0?$_String_val@U?$_Simple_types@D@std@@@std@@QEAA@XZ
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$?_Myptr@?$_String_val@U?$_Simple_types@D@std@@@std@@QEAAPEADXZ DD imagerel $LN4
DD imagerel $LN4+122
DD imagerel $unwind$?_Myptr@?$_String_val@U?$_Simple_types@D@std@@@std@@QEAAPEADXZ
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$?_Myptr@?$_String_val@U?$_Simple_types@D@std@@@std@@QEBAPEBDXZ DD imagerel $LN4
DD imagerel $LN4+122
DD imagerel $unwind$?_Myptr@?$_String_val@U?$_Simple_types@D@std@@@std@@QEBAPEBDXZ
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$?_Large_string_engaged@?$_String_val@U?$_Simple_types@D@std@@@std@@QEBA_NXZ DD imagerel $LN5
DD imagerel $LN5+107
DD imagerel $unwind$?_Large_string_engaged@?$_String_val@U?$_Simple_types@D@std@@@std@@QEBA_NXZ
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??0_Bxty@?$_String_val@U?$_Simple_types@D@std@@@std@@QEAA@XZ DD imagerel $LN3
DD imagerel $LN3+71
DD imagerel $unwind$??0_Bxty@?$_String_val@U?$_Simple_types@D@std@@@std@@QEAA@XZ
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??1_Bxty@?$_String_val@U?$_Simple_types@D@std@@@std@@QEAA@XZ DD imagerel $LN3
DD imagerel $LN3+64
DD imagerel $unwind$??1_Bxty@?$_String_val@U?$_Simple_types@D@std@@@std@@QEAA@XZ
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??1?$_String_val@U?$_Simple_types@D@std@@@std@@QEAA@XZ DD imagerel $LN3
DD imagerel $LN3+71
DD imagerel $unwind$??1?$_String_val@U?$_Simple_types@D@std@@@std@@QEAA@XZ
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??0?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEAA@XZ DD imagerel $LN3
DD imagerel $LN3+172
DD imagerel $unwind$??0?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEAA@XZ
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??1?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEAA@XZ DD imagerel $LN3
DD imagerel $LN3+212
DD imagerel $unwind$??1?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEAA@XZ
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$?_Copy_assign@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@AEAAXAEBV12@U?$integral_constant@_N$0A@@2@@Z DD imagerel $LN3
DD imagerel $LN3+197
DD imagerel $unwind$?_Copy_assign@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@AEAAXAEBV12@U?$integral_constant@_N$0A@@2@@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??4?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEAAAEAV01@AEBV01@@Z DD imagerel $LN4
DD imagerel $LN4+143
DD imagerel $unwind$??4?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEAAAEAV01@AEBV01@@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$?assign@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEAAAEAV12@QEBD_K@Z DD imagerel $LN4
DD imagerel $LN4+255
DD imagerel $unwind$?assign@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEAAAEAV12@QEBD_K@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$?data@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEBAPEBDXZ DD imagerel $LN3
DD imagerel $LN3+79
DD imagerel $unwind$?data@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEBAPEBDXZ
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$?size@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEBA_KXZ DD imagerel $LN3
DD imagerel $LN3+75
DD imagerel $unwind$?size@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEBA_KXZ
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$?max_size@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEBA_KXZ DD imagerel $LN3
DD imagerel $LN3+224
DD imagerel $unwind$?max_size@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEBA_KXZ
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$?_Equal@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEBA_NQEBD@Z DD imagerel $LN3
DD imagerel $LN3+161
DD imagerel $unwind$?_Equal@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEBA_NQEBD@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$?_Calculate_growth@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@CA_K_K00@Z DD imagerel $LN5
DD imagerel $LN5+269
DD imagerel $unwind$?_Calculate_growth@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@CA_K_K00@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$?_Calculate_growth@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@AEBA_K_K@Z DD imagerel $LN3
DD imagerel $LN3+132
DD imagerel $unwind$?_Calculate_growth@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@AEBA_K_K@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$?_Tidy_init@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@AEAAXXZ DD imagerel $LN3
DD imagerel $LN3+137
DD imagerel $unwind$?_Tidy_init@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@AEAAXXZ
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$?_Tidy_deallocate@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@AEAAXXZ DD imagerel $LN4
DD imagerel $LN4+255
DD imagerel $unwind$?_Tidy_deallocate@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@AEAAXXZ
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$?_Getal@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@AEAAAEAV?$allocator@D@2@XZ DD imagerel $LN3
DD imagerel $LN3+79
DD imagerel $unwind$?_Getal@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@AEAAAEAV?$allocator@D@2@XZ
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$?_Getal@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@AEBAAEBV?$allocator@D@2@XZ DD imagerel $LN3
DD imagerel $LN3+79
DD imagerel $unwind$?_Getal@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@AEBAAEBV?$allocator@D@2@XZ
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$?_Get_first@?$_Compressed_pair@V?$allocator@D@std@@V?$_String_val@U?$_Simple_types@D@std@@@2@$00@std@@QEAAAEAV?$allocator@D@2@XZ DD imagerel $LN3
DD imagerel $LN3+71
DD imagerel $unwind$?_Get_first@?$_Compressed_pair@V?$allocator@D@std@@V?$_String_val@U?$_Simple_types@D@std@@@2@$00@std@@QEAAAEAV?$allocator@D@2@XZ
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$?_Get_first@?$_Compressed_pair@V?$allocator@D@std@@V?$_String_val@U?$_Simple_types@D@std@@@2@$00@std@@QEBAAEBV?$allocator@D@2@XZ DD imagerel $LN3
DD imagerel $LN3+71
DD imagerel $unwind$?_Get_first@?$_Compressed_pair@V?$allocator@D@std@@V?$_String_val@U?$_Simple_types@D@std@@@2@$00@std@@QEBAAEBV?$allocator@D@2@XZ
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??1?$_Compressed_pair@V?$allocator@D@std@@V?$_String_val@U?$_Simple_types@D@std@@@2@$00@std@@QEAA@XZ DD imagerel $LN3
DD imagerel $LN3+67
DD imagerel $unwind$??1?$_Compressed_pair@V?$allocator@D@std@@V?$_String_val@U?$_Simple_types@D@std@@@2@$00@std@@QEAA@XZ
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??$_Maklocstr@_W@std@@YAPEA_WPEBDPEA_WAEBU_Cvtvec@@@Z DD imagerel $LN12
DD imagerel $LN12+584
DD imagerel $unwind$??$_Maklocstr@_W@std@@YAPEA_WPEBDPEA_WAEBU_Cvtvec@@@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$?_Maklocwcs@std@@YAPEA_WPEB_W@Z DD imagerel $LN4
DD imagerel $LN4+165
DD imagerel $unwind$?_Maklocwcs@std@@YAPEA_WPEB_W@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??$_Maklocstr@D@std@@YAPEADPEBDPEADAEBU_Cvtvec@@@Z DD imagerel $LN7
DD imagerel $LN7+223
DD imagerel $unwind$??$_Maklocstr@D@std@@YAPEADPEBDPEADAEBU_Cvtvec@@@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??$_Getvals@_W@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@IEAAX_WAEBV_Locinfo@1@@Z DD imagerel $LN5
DD imagerel $LN5+379
DD imagerel $unwind$??$_Getvals@_W@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@IEAAX_WAEBV_Locinfo@1@@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??$_Getvals@_W@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@IEAAX_WAEBV_Locinfo@1@@Z DD imagerel $LN5
DD imagerel $LN5+379
DD imagerel $unwind$??$_Getvals@_W@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@IEAAX_WAEBV_Locinfo@1@@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??1PaymentOption@Persistence@TechnicalServices@@QEAA@XZ DD imagerel $LN3
DD imagerel $LN3+71
DD imagerel $unwind$??1PaymentOption@Persistence@TechnicalServices@@QEAA@XZ
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??_GPaymentOption@Persistence@TechnicalServices@@QEAAPEAXI@Z DD imagerel $LN4
DD imagerel $LN4+105
DD imagerel $unwind$??_GPaymentOption@Persistence@TechnicalServices@@QEAAPEAXI@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$?PaySystemFactory@PaymentHandlerInterface@External@TechnicalServices@@SA?AV?$unique_ptr@VPaymentHandlerInterface@External@TechnicalServices@@U?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@@std@@XZ DD imagerel $LN19
DD imagerel $LN19+969
DD imagerel $unwind$?PaySystemFactory@PaymentHandlerInterface@External@TechnicalServices@@SA?AV?$unique_ptr@VPaymentHandlerInterface@External@TechnicalServices@@U?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@@std@@XZ
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$?dtor$0@?0??PaySystemFactory@PaymentHandlerInterface@External@TechnicalServices@@SA?AV?$unique_ptr@VPaymentHandlerInterface@External@TechnicalServices@@U?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@@std@@XZ@4HA DD imagerel ?dtor$0@?0??PaySystemFactory@PaymentHandlerInterface@External@TechnicalServices@@SA?AV?$unique_ptr@VPaymentHandlerInterface@External@TechnicalServices@@U?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@@std@@XZ@4HA
DD imagerel ?dtor$0@?0??PaySystemFactory@PaymentHandlerInterface@External@TechnicalServices@@SA?AV?$unique_ptr@VPaymentHandlerInterface@External@TechnicalServices@@U?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@@std@@XZ@4HA+36
DD imagerel $unwind$?dtor$0@?0??PaySystemFactory@PaymentHandlerInterface@External@TechnicalServices@@SA?AV?$unique_ptr@VPaymentHandlerInterface@External@TechnicalServices@@U?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@@std@@XZ@4HA
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$?dtor$1@?0??PaySystemFactory@PaymentHandlerInterface@External@TechnicalServices@@SA?AV?$unique_ptr@VPaymentHandlerInterface@External@TechnicalServices@@U?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@@std@@XZ@4HA DD imagerel ?dtor$1@?0??PaySystemFactory@PaymentHandlerInterface@External@TechnicalServices@@SA?AV?$unique_ptr@VPaymentHandlerInterface@External@TechnicalServices@@U?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@@std@@XZ@4HA
DD imagerel ?dtor$1@?0??PaySystemFactory@PaymentHandlerInterface@External@TechnicalServices@@SA?AV?$unique_ptr@VPaymentHandlerInterface@External@TechnicalServices@@U?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@@std@@XZ@4HA+36
DD imagerel $unwind$?dtor$1@?0??PaySystemFactory@PaymentHandlerInterface@External@TechnicalServices@@SA?AV?$unique_ptr@VPaymentHandlerInterface@External@TechnicalServices@@U?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@@std@@XZ@4HA
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??1PaymentHandlerInterface@External@TechnicalServices@@UEAA@XZ DD imagerel $LN3
DD imagerel $LN3+81
DD imagerel $unwind$??1PaymentHandlerInterface@External@TechnicalServices@@UEAA@XZ
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??0PaymentHandlerInterface@External@TechnicalServices@@QEAA@XZ DD imagerel $LN3
DD imagerel $LN3+74
DD imagerel $unwind$??0PaymentHandlerInterface@External@TechnicalServices@@QEAA@XZ
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??0CreditPayment@External@TechnicalServices@@QEAA@XZ DD imagerel $LN3
DD imagerel $LN3+88
DD imagerel $unwind$??0CreditPayment@External@TechnicalServices@@QEAA@XZ
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??1CreditPayment@External@TechnicalServices@@UEAA@XZ DD imagerel $LN3
DD imagerel $LN3+64
DD imagerel $unwind$??1CreditPayment@External@TechnicalServices@@UEAA@XZ
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??_GCreditPayment@External@TechnicalServices@@UEAAPEAXI@Z DD imagerel $LN4
DD imagerel $LN4+105
DD imagerel $unwind$??_GCreditPayment@External@TechnicalServices@@UEAAPEAXI@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??0DebitPayment@External@TechnicalServices@@QEAA@XZ DD imagerel $LN3
DD imagerel $LN3+88
DD imagerel $unwind$??0DebitPayment@External@TechnicalServices@@QEAA@XZ
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??1DebitPayment@External@TechnicalServices@@UEAA@XZ DD imagerel $LN3
DD imagerel $LN3+64
DD imagerel $unwind$??1DebitPayment@External@TechnicalServices@@UEAA@XZ
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??_GDebitPayment@External@TechnicalServices@@UEAAPEAXI@Z DD imagerel $LN4
DD imagerel $LN4+105
DD imagerel $unwind$??_GDebitPayment@External@TechnicalServices@@UEAAPEAXI@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??0GatewayPayment@External@TechnicalServices@@QEAA@XZ DD imagerel $LN3
DD imagerel $LN3+88
DD imagerel $unwind$??0GatewayPayment@External@TechnicalServices@@QEAA@XZ
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??1GatewayPayment@External@TechnicalServices@@UEAA@XZ DD imagerel $LN3
DD imagerel $LN3+64
DD imagerel $unwind$??1GatewayPayment@External@TechnicalServices@@UEAA@XZ
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??_GGatewayPayment@External@TechnicalServices@@UEAAPEAXI@Z DD imagerel $LN4
DD imagerel $LN4+105
DD imagerel $unwind$??_GGatewayPayment@External@TechnicalServices@@UEAAPEAXI@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$?deallocate@?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@QEAAXQEAUPaymentOption@Persistence@TechnicalServices@@_K@Z DD imagerel $LN3
DD imagerel $LN3+97
DD imagerel $unwind$?deallocate@?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@QEAAXQEAUPaymentOption@Persistence@TechnicalServices@@_K@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??1?$vector@UPaymentOption@Persistence@TechnicalServices@@V?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@@std@@QEAA@XZ DD imagerel $LN3
DD imagerel $LN3+201
DD imagerel $unwind$??1?$vector@UPaymentOption@Persistence@TechnicalServices@@V?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@@std@@QEAA@XZ
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$?size@?$vector@UPaymentOption@Persistence@TechnicalServices@@V?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@@std@@QEBA_KXZ DD imagerel $LN3
DD imagerel $LN3+104
DD imagerel $unwind$?size@?$vector@UPaymentOption@Persistence@TechnicalServices@@V?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@@std@@QEBA_KXZ
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??A?$vector@UPaymentOption@Persistence@TechnicalServices@@V?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@@std@@QEAAAEAUPaymentOption@Persistence@TechnicalServices@@_K@Z DD imagerel $LN12
DD imagerel $LN12+253
DD imagerel $unwind$??A?$vector@UPaymentOption@Persistence@TechnicalServices@@V?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@@std@@QEAAAEAUPaymentOption@Persistence@TechnicalServices@@_K@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$?_Destroy@?$vector@UPaymentOption@Persistence@TechnicalServices@@V?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@@std@@AEAAXPEAUPaymentOption@Persistence@TechnicalServices@@0@Z DD imagerel $LN3
DD imagerel $LN3+108
DD imagerel $unwind$?_Destroy@?$vector@UPaymentOption@Persistence@TechnicalServices@@V?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@@std@@AEAAXPEAUPaymentOption@Persistence@TechnicalServices@@0@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$?_Tidy@?$vector@UPaymentOption@Persistence@TechnicalServices@@V?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@@std@@AEAAXXZ DD imagerel $LN4
DD imagerel $LN4+286
DD imagerel $unwind$?_Tidy@?$vector@UPaymentOption@Persistence@TechnicalServices@@V?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@@std@@AEAAXXZ
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$?_Getal@?$vector@UPaymentOption@Persistence@TechnicalServices@@V?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@@std@@AEAAAEAV?$allocator@UPaymentOption@Persistence@TechnicalServices@@@2@XZ DD imagerel $LN3
DD imagerel $LN3+79
DD imagerel $unwind$?_Getal@?$vector@UPaymentOption@Persistence@TechnicalServices@@V?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@@std@@AEAAAEAV?$allocator@UPaymentOption@Persistence@TechnicalServices@@@2@XZ
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$?_Get_first@?$_Compressed_pair@V?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@V?$_Vector_val@U?$_Simple_types@UPaymentOption@Persistence@TechnicalServices@@@std@@@2@$00@std@@QEAAAEAV?$allocator@UPaymentOption@Persistence@TechnicalServices@@@2@XZ DD imagerel $LN3
DD imagerel $LN3+71
DD imagerel $unwind$?_Get_first@?$_Compressed_pair@V?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@V?$_Vector_val@U?$_Simple_types@UPaymentOption@Persistence@TechnicalServices@@@std@@@2@$00@std@@QEAAAEAV?$allocator@UPaymentOption@Persistence@TechnicalServices@@@2@XZ
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$?__autoclassinit2@?$vector@UPaymentOption@Persistence@TechnicalServices@@V?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@@std@@QEAAX_K@Z DD imagerel $LN3
DD imagerel $LN3+73
DD imagerel $unwind$?__autoclassinit2@?$vector@UPaymentOption@Persistence@TechnicalServices@@V?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@@std@@QEAAX_K@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??$?6U?$char_traits@D@std@@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@PEBD@Z DD imagerel $LN25
DD imagerel $LN25+1124
DD imagerel $unwind$??$?6U?$char_traits@D@std@@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@PEBD@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$?dtor$0@?0???$?6U?$char_traits@D@std@@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@PEBD@Z@4HA DD imagerel ?dtor$0@?0???$?6U?$char_traits@D@std@@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@PEBD@Z@4HA
DD imagerel ?dtor$0@?0???$?6U?$char_traits@D@std@@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@PEBD@Z@4HA+36
DD imagerel $unwind$?dtor$0@?0???$?6U?$char_traits@D@std@@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@PEBD@Z@4HA
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$?catch$1@?0???$?6U?$char_traits@D@std@@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@PEBD@Z@4HA DD imagerel ?catch$1@?0???$?6U?$char_traits@D@std@@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@PEBD@Z@4HA
DD imagerel ?catch$1@?0???$?6U?$char_traits@D@std@@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@PEBD@Z@4HA+91
DD imagerel $unwind$?catch$1@?0???$?6U?$char_traits@D@std@@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@PEBD@Z@4HA
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??$?6U?$char_traits@D@std@@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@D@Z DD imagerel $LN23
DD imagerel $LN23+1095
DD imagerel $unwind$??$?6U?$char_traits@D@std@@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@D@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$?dtor$0@?0???$?6U?$char_traits@D@std@@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@D@Z@4HA DD imagerel ?dtor$0@?0???$?6U?$char_traits@D@std@@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@D@Z@4HA
DD imagerel ?dtor$0@?0???$?6U?$char_traits@D@std@@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@D@Z@4HA+36
DD imagerel $unwind$?dtor$0@?0???$?6U?$char_traits@D@std@@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@D@Z@4HA
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$?catch$1@?0???$?6U?$char_traits@D@std@@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@D@Z@4HA DD imagerel ?catch$1@?0???$?6U?$char_traits@D@std@@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@D@Z@4HA
DD imagerel ?catch$1@?0???$?6U?$char_traits@D@std@@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@D@Z@4HA+91
DD imagerel $unwind$?catch$1@?0???$?6U?$char_traits@D@std@@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@D@Z@4HA
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??$?6DU?$char_traits@D@std@@_J@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@AEBU?$_Smanip@_J@0@@Z DD imagerel $LN3
DD imagerel $LN3+140
DD imagerel $unwind$??$?6DU?$char_traits@D@std@@_J@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@AEBU?$_Smanip@_J@0@@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??$?6DU?$char_traits@D@std@@V?$allocator@D@1@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@AEBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@0@@Z DD imagerel $LN3
DD imagerel $LN3+133
DD imagerel $unwind$??$?6DU?$char_traits@D@std@@V?$allocator@D@1@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@AEBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@0@@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??$?8DU?$char_traits@D@std@@V?$allocator@D@1@@std@@YA_NAEBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@0@QEBD@Z DD imagerel $LN3
DD imagerel $LN3+88
DD imagerel $unwind$??$?8DU?$char_traits@D@std@@V?$allocator@D@1@@std@@YA_NAEBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@0@QEBD@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??$make_unique@UCreditPayment@External@TechnicalServices@@$$V$0A@@std@@YA?AV?$unique_ptr@UCreditPayment@External@TechnicalServices@@U?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@@0@XZ DD imagerel $LN7
DD imagerel $LN7+190
DD imagerel $unwind$??$make_unique@UCreditPayment@External@TechnicalServices@@$$V$0A@@std@@YA?AV?$unique_ptr@UCreditPayment@External@TechnicalServices@@U?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@@0@XZ
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??R?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@QEBAXPEAUCreditPayment@External@TechnicalServices@@@Z DD imagerel $LN5
DD imagerel $LN5+152
DD imagerel $unwind$??R?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@QEBAXPEAUCreditPayment@External@TechnicalServices@@@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??1?$unique_ptr@UCreditPayment@External@TechnicalServices@@U?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@@std@@QEAA@XZ DD imagerel $LN4
DD imagerel $LN4+135
DD imagerel $unwind$??1?$unique_ptr@UCreditPayment@External@TechnicalServices@@U?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@@std@@QEAA@XZ
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$?get_deleter@?$unique_ptr@UCreditPayment@External@TechnicalServices@@U?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@@std@@QEAAAEAU?$default_delete@UCreditPayment@External@TechnicalServices@@@2@XZ DD imagerel $LN3
DD imagerel $LN3+79
DD imagerel $unwind$?get_deleter@?$unique_ptr@UCreditPayment@External@TechnicalServices@@U?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@@std@@QEAAAEAU?$default_delete@UCreditPayment@External@TechnicalServices@@@2@XZ
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$?release@?$unique_ptr@UCreditPayment@External@TechnicalServices@@U?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@@std@@QEAAPEAUCreditPayment@External@TechnicalServices@@XZ DD imagerel $LN3
DD imagerel $LN3+97
DD imagerel $unwind$?release@?$unique_ptr@UCreditPayment@External@TechnicalServices@@U?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@@std@@QEAAPEAUCreditPayment@External@TechnicalServices@@XZ
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$?_Get_first@?$_Compressed_pair@U?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@PEAUCreditPayment@External@TechnicalServices@@$00@std@@QEAAAEAU?$default_delete@UCreditPayment@External@TechnicalServices@@@2@XZ DD imagerel $LN3
DD imagerel $LN3+71
DD imagerel $unwind$?_Get_first@?$_Compressed_pair@U?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@PEAUCreditPayment@External@TechnicalServices@@$00@std@@QEAAAEAU?$default_delete@UCreditPayment@External@TechnicalServices@@@2@XZ
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??$?0UCreditPayment@External@TechnicalServices@@$0A@@?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@QEAA@AEBU?$default_delete@UCreditPayment@External@TechnicalServices@@@1@@Z DD imagerel $LN3
DD imagerel $LN3+76
DD imagerel $unwind$??$?0UCreditPayment@External@TechnicalServices@@$0A@@?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@QEAA@AEBU?$default_delete@UCreditPayment@External@TechnicalServices@@@1@@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??$?0UCreditPayment@External@TechnicalServices@@U?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@$0A@@?$unique_ptr@VPaymentHandlerInterface@External@TechnicalServices@@U?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@@std@@QEAA@$$QEAV?$unique_ptr@UCreditPayment@External@TechnicalServices@@U?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@@1@@Z DD imagerel $LN3
DD imagerel $LN3+182
DD imagerel $unwind$??$?0UCreditPayment@External@TechnicalServices@@U?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@$0A@@?$unique_ptr@VPaymentHandlerInterface@External@TechnicalServices@@U?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@@std@@QEAA@$$QEAV?$unique_ptr@UCreditPayment@External@TechnicalServices@@U?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@@1@@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??$make_unique@UDebitPayment@External@TechnicalServices@@$$V$0A@@std@@YA?AV?$unique_ptr@UDebitPayment@External@TechnicalServices@@U?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@@0@XZ DD imagerel $LN7
DD imagerel $LN7+190
DD imagerel $unwind$??$make_unique@UDebitPayment@External@TechnicalServices@@$$V$0A@@std@@YA?AV?$unique_ptr@UDebitPayment@External@TechnicalServices@@U?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@@0@XZ
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??R?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@QEBAXPEAUDebitPayment@External@TechnicalServices@@@Z DD imagerel $LN5
DD imagerel $LN5+152
DD imagerel $unwind$??R?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@QEBAXPEAUDebitPayment@External@TechnicalServices@@@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??1?$unique_ptr@UDebitPayment@External@TechnicalServices@@U?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@@std@@QEAA@XZ DD imagerel $LN4
DD imagerel $LN4+135
DD imagerel $unwind$??1?$unique_ptr@UDebitPayment@External@TechnicalServices@@U?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@@std@@QEAA@XZ
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$?get_deleter@?$unique_ptr@UDebitPayment@External@TechnicalServices@@U?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@@std@@QEAAAEAU?$default_delete@UDebitPayment@External@TechnicalServices@@@2@XZ DD imagerel $LN3
DD imagerel $LN3+79
DD imagerel $unwind$?get_deleter@?$unique_ptr@UDebitPayment@External@TechnicalServices@@U?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@@std@@QEAAAEAU?$default_delete@UDebitPayment@External@TechnicalServices@@@2@XZ
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$?release@?$unique_ptr@UDebitPayment@External@TechnicalServices@@U?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@@std@@QEAAPEAUDebitPayment@External@TechnicalServices@@XZ DD imagerel $LN3
DD imagerel $LN3+97
DD imagerel $unwind$?release@?$unique_ptr@UDebitPayment@External@TechnicalServices@@U?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@@std@@QEAAPEAUDebitPayment@External@TechnicalServices@@XZ
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$?_Get_first@?$_Compressed_pair@U?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@PEAUDebitPayment@External@TechnicalServices@@$00@std@@QEAAAEAU?$default_delete@UDebitPayment@External@TechnicalServices@@@2@XZ DD imagerel $LN3
DD imagerel $LN3+71
DD imagerel $unwind$?_Get_first@?$_Compressed_pair@U?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@PEAUDebitPayment@External@TechnicalServices@@$00@std@@QEAAAEAU?$default_delete@UDebitPayment@External@TechnicalServices@@@2@XZ
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??$?0UDebitPayment@External@TechnicalServices@@$0A@@?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@QEAA@AEBU?$default_delete@UDebitPayment@External@TechnicalServices@@@1@@Z DD imagerel $LN3
DD imagerel $LN3+76
DD imagerel $unwind$??$?0UDebitPayment@External@TechnicalServices@@$0A@@?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@QEAA@AEBU?$default_delete@UDebitPayment@External@TechnicalServices@@@1@@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??$?0UDebitPayment@External@TechnicalServices@@U?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@$0A@@?$unique_ptr@VPaymentHandlerInterface@External@TechnicalServices@@U?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@@std@@QEAA@$$QEAV?$unique_ptr@UDebitPayment@External@TechnicalServices@@U?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@@1@@Z DD imagerel $LN3
DD imagerel $LN3+182
DD imagerel $unwind$??$?0UDebitPayment@External@TechnicalServices@@U?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@$0A@@?$unique_ptr@VPaymentHandlerInterface@External@TechnicalServices@@U?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@@std@@QEAA@$$QEAV?$unique_ptr@UDebitPayment@External@TechnicalServices@@U?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@@1@@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??$make_unique@UGatewayPayment@External@TechnicalServices@@$$V$0A@@std@@YA?AV?$unique_ptr@UGatewayPayment@External@TechnicalServices@@U?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@@0@XZ DD imagerel $LN7
DD imagerel $LN7+190
DD imagerel $unwind$??$make_unique@UGatewayPayment@External@TechnicalServices@@$$V$0A@@std@@YA?AV?$unique_ptr@UGatewayPayment@External@TechnicalServices@@U?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@@0@XZ
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??R?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@QEBAXPEAUGatewayPayment@External@TechnicalServices@@@Z DD imagerel $LN5
DD imagerel $LN5+152
DD imagerel $unwind$??R?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@QEBAXPEAUGatewayPayment@External@TechnicalServices@@@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??1?$unique_ptr@UGatewayPayment@External@TechnicalServices@@U?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@@std@@QEAA@XZ DD imagerel $LN4
DD imagerel $LN4+135
DD imagerel $unwind$??1?$unique_ptr@UGatewayPayment@External@TechnicalServices@@U?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@@std@@QEAA@XZ
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$?get_deleter@?$unique_ptr@UGatewayPayment@External@TechnicalServices@@U?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@@std@@QEAAAEAU?$default_delete@UGatewayPayment@External@TechnicalServices@@@2@XZ DD imagerel $LN3
DD imagerel $LN3+79
DD imagerel $unwind$?get_deleter@?$unique_ptr@UGatewayPayment@External@TechnicalServices@@U?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@@std@@QEAAAEAU?$default_delete@UGatewayPayment@External@TechnicalServices@@@2@XZ
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$?release@?$unique_ptr@UGatewayPayment@External@TechnicalServices@@U?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@@std@@QEAAPEAUGatewayPayment@External@TechnicalServices@@XZ DD imagerel $LN3
DD imagerel $LN3+97
DD imagerel $unwind$?release@?$unique_ptr@UGatewayPayment@External@TechnicalServices@@U?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@@std@@QEAAPEAUGatewayPayment@External@TechnicalServices@@XZ
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$?_Get_first@?$_Compressed_pair@U?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@PEAUGatewayPayment@External@TechnicalServices@@$00@std@@QEAAAEAU?$default_delete@UGatewayPayment@External@TechnicalServices@@@2@XZ DD imagerel $LN3
DD imagerel $LN3+71
DD imagerel $unwind$?_Get_first@?$_Compressed_pair@U?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@PEAUGatewayPayment@External@TechnicalServices@@$00@std@@QEAAAEAU?$default_delete@UGatewayPayment@External@TechnicalServices@@@2@XZ
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??$?0UGatewayPayment@External@TechnicalServices@@$0A@@?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@QEAA@AEBU?$default_delete@UGatewayPayment@External@TechnicalServices@@@1@@Z DD imagerel $LN3
DD imagerel $LN3+76
DD imagerel $unwind$??$?0UGatewayPayment@External@TechnicalServices@@$0A@@?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@QEAA@AEBU?$default_delete@UGatewayPayment@External@TechnicalServices@@@1@@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??$?0UGatewayPayment@External@TechnicalServices@@U?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@$0A@@?$unique_ptr@VPaymentHandlerInterface@External@TechnicalServices@@U?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@@std@@QEAA@$$QEAV?$unique_ptr@UGatewayPayment@External@TechnicalServices@@U?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@@1@@Z DD imagerel $LN3
DD imagerel $LN3+182
DD imagerel $unwind$??$?0UGatewayPayment@External@TechnicalServices@@U?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@$0A@@?$unique_ptr@VPaymentHandlerInterface@External@TechnicalServices@@U?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@@std@@QEAA@$$QEAV?$unique_ptr@UGatewayPayment@External@TechnicalServices@@U?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@@1@@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$?allocate@?$allocator@U_Container_proxy@std@@@std@@QEAAPEAU_Container_proxy@2@_K@Z DD imagerel $LN3
DD imagerel $LN3+89
DD imagerel $unwind$?allocate@?$allocator@U_Container_proxy@std@@@std@@QEAAPEAU_Container_proxy@2@_K@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??$?0UPaymentOption@Persistence@TechnicalServices@@@?$allocator@U_Container_proxy@std@@@std@@QEAA@AEBV?$allocator@UPaymentOption@Persistence@TechnicalServices@@@1@@Z DD imagerel $LN3
DD imagerel $LN3+76
DD imagerel $unwind$??$?0UPaymentOption@Persistence@TechnicalServices@@@?$allocator@U_Container_proxy@std@@@std@@QEAA@AEBV?$allocator@UPaymentOption@Persistence@TechnicalServices@@@1@@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??$exchange@PEAU_Container_proxy@std@@$$T@std@@YAPEAU_Container_proxy@0@AEAPEAU10@$$QEA$$T@Z DD imagerel $LN3
DD imagerel $LN3+107
DD imagerel $unwind$??$exchange@PEAU_Container_proxy@std@@$$T@std@@YAPEAU_Container_proxy@0@AEAPEAU10@$$QEA$$T@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??$_Delete_plain_internal@V?$allocator@U_Container_proxy@std@@@std@@@std@@YAXAEAV?$allocator@U_Container_proxy@std@@@0@QEAU_Container_proxy@0@@Z DD imagerel $LN3
DD imagerel $LN3+88
DD imagerel $unwind$??$_Delete_plain_internal@V?$allocator@U_Container_proxy@std@@@std@@@std@@YAXAEAV?$allocator@U_Container_proxy@std@@@0@QEAU_Container_proxy@0@@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??0_Sentry_base@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAA@AEAV12@@Z DD imagerel $LN4
DD imagerel $LN4+171
DD imagerel $unwind$??0_Sentry_base@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAA@AEAV12@@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??1_Sentry_base@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAA@XZ DD imagerel $LN4
DD imagerel $LN4+143
DD imagerel $unwind$??1_Sentry_base@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAA@XZ
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??0sentry@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAA@AEAV12@@Z DD imagerel $LN7
DD imagerel $LN7+284
DD imagerel $unwind$??0sentry@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAA@AEAV12@@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$?dtor$0@?0???0sentry@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAA@AEAV12@@Z@4HA DD imagerel ?dtor$0@?0???0sentry@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAA@AEAV12@@Z@4HA
DD imagerel ?dtor$0@?0???0sentry@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAA@AEAV12@@Z@4HA+39
DD imagerel $unwind$?dtor$0@?0???0sentry@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAA@AEAV12@@Z@4HA
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??1sentry@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAA@XZ DD imagerel $LN6
DD imagerel $LN6+139
DD imagerel $unwind$??1sentry@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAA@XZ
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??Bsentry@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEBA_NXZ DD imagerel $LN3
DD imagerel $LN3+75
DD imagerel $unwind$??Bsentry@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEBA_NXZ
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??$min@_K@std@@YAAEB_KAEB_K0@Z DD imagerel $LN5
DD imagerel $LN5+142
DD imagerel $unwind$??$min@_K@std@@YAAEB_KAEB_K0@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??$_Alloc_proxy@V?$allocator@U_Container_proxy@std@@@std@@@_Container_base12@std@@QEAAX$$QEAV?$allocator@U_Container_proxy@std@@@1@@Z DD imagerel $LN3
DD imagerel $LN3+156
DD imagerel $unwind$??$_Alloc_proxy@V?$allocator@U_Container_proxy@std@@@std@@@_Container_base12@std@@QEAAX$$QEAV?$allocator@U_Container_proxy@std@@@1@@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??$addressof@$$CBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@@std@@YAPEBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@0@AEBV10@@Z DD imagerel $LN3
DD imagerel $LN3+71
DD imagerel $unwind$??$addressof@$$CBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@@std@@YAPEBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@0@AEBV10@@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??$?0D@?$allocator@U_Container_proxy@std@@@std@@QEAA@AEBV?$allocator@D@1@@Z DD imagerel $LN3
DD imagerel $LN3+76
DD imagerel $unwind$??$?0D@?$allocator@U_Container_proxy@std@@@std@@QEAA@AEBV?$allocator@D@1@@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??$?0$$V@?$_Compressed_pair@V?$allocator@D@std@@V?$_String_val@U?$_Simple_types@D@std@@@2@$00@std@@QEAA@U_Zero_then_variadic_args_t@1@@Z DD imagerel $LN3
DD imagerel $LN3+102
DD imagerel $unwind$??$?0$$V@?$_Compressed_pair@V?$allocator@D@std@@V?$_String_val@U?$_Simple_types@D@std@@@2@$00@std@@QEAA@U_Zero_then_variadic_args_t@1@@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??$_Unfancy@U_Container_proxy@std@@@std@@YAPEAU_Container_proxy@0@PEAU10@@Z DD imagerel $LN3
DD imagerel $LN3+71
DD imagerel $unwind$??$_Unfancy@U_Container_proxy@std@@@std@@YAPEAU_Container_proxy@0@PEAU10@@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??$_Destroy_in_place@PEAD@std@@YAXAEAPEAD@Z DD imagerel $LN3
DD imagerel $LN3+64
DD imagerel $unwind$??$_Destroy_in_place@PEAD@std@@YAXAEAPEAD@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??R<lambda_66f57f934f28d61049862f64df852ff0>@@QEBA@QEAD_KQEBD@Z DD imagerel $LN3
DD imagerel $LN3+147
DD imagerel $unwind$??R<lambda_66f57f934f28d61049862f64df852ff0>@@QEBA@QEAD_KQEBD@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??$_Reallocate_for@V<lambda_66f57f934f28d61049862f64df852ff0>@@PEBD@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@AEAAAEAV01@_KV<lambda_66f57f934f28d61049862f64df852ff0>@@PEBD@Z DD imagerel $LN6
DD imagerel $LN6+418
DD imagerel $unwind$??$_Reallocate_for@V<lambda_66f57f934f28d61049862f64df852ff0>@@PEBD@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@AEAAAEAV01@_KV<lambda_66f57f934f28d61049862f64df852ff0>@@PEBD@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??$_Pocca@V?$allocator@D@std@@@std@@YAXAEAV?$allocator@D@0@AEBV10@@Z DD imagerel $LN3
DD imagerel $LN3+69
DD imagerel $unwind$??$_Pocca@V?$allocator@D@std@@@std@@YAXAEAV?$allocator@D@0@AEBV10@@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??$_Construct_in_place@PEADAEBQEAD@std@@YAXAEAPEADAEBQEAD@Z DD imagerel $LN3
DD imagerel $LN3+126
DD imagerel $unwind$??$_Construct_in_place@PEADAEBQEAD@std@@YAXAEAPEADAEBQEAD@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??$_Unfancy@D@std@@YAPEADPEAD@Z DD imagerel $LN3
DD imagerel $LN3+71
DD imagerel $unwind$??$_Unfancy@D@std@@YAPEADPEAD@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??$max@_K@std@@YAAEB_KAEB_K0@Z DD imagerel $LN5
DD imagerel $LN5+142
DD imagerel $unwind$??$max@_K@std@@YAAEB_KAEB_K0@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??$_Get_size_of_n@$0BA@@std@@YA_K_K@Z DD imagerel $LN4
DD imagerel $LN4+114
DD imagerel $unwind$??$_Get_size_of_n@$0BA@@std@@YA_K_K@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??$_Allocate@$0BA@U_Default_allocate_traits@std@@$0A@@std@@YAPEAX_K@Z DD imagerel $LN5
DD imagerel $LN5+117
DD imagerel $unwind$??$_Allocate@$0BA@U_Default_allocate_traits@std@@$0A@@std@@YAPEAX_K@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??$_Destroy_range@V?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@@std@@YAXPEAUPaymentOption@Persistence@TechnicalServices@@QEAU123@AEAV?$allocator@UPaymentOption@Persistence@TechnicalServices@@@0@@Z DD imagerel $LN6
DD imagerel $LN6+139
DD imagerel $unwind$??$_Destroy_range@V?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@@std@@YAXPEAUPaymentOption@Persistence@TechnicalServices@@QEAU123@AEAV?$allocator@UPaymentOption@Persistence@TechnicalServices@@@0@@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??$_Deallocate@$0BA@$0A@@std@@YAXPEAX_K@Z DD imagerel $LN4
DD imagerel $LN4+121
DD imagerel $unwind$??$_Deallocate@$0BA@$0A@@std@@YAXPEAX_K@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??$_Get_size_of_n@$00@std@@YA_K_K@Z DD imagerel $LN3
DD imagerel $LN3+75
DD imagerel $unwind$??$_Get_size_of_n@$00@std@@YA_K_K@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??$addressof@U_Container_proxy@std@@@std@@YAPEAU_Container_proxy@0@AEAU10@@Z DD imagerel $LN3
DD imagerel $LN3+71
DD imagerel $unwind$??$addressof@U_Container_proxy@std@@@std@@YAPEAU_Container_proxy@0@AEAU10@@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??$forward@PEAU_Container_base12@std@@@std@@YA$$QEAPEAU_Container_base12@0@AEAPEAU10@@Z DD imagerel $LN3
DD imagerel $LN3+71
DD imagerel $unwind$??$forward@PEAU_Container_base12@std@@@std@@YA$$QEAPEAU_Container_base12@0@AEAPEAU10@@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??$_Insert_string@DU?$char_traits@D@std@@_K@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@QEBD_K@Z DD imagerel $LN26
DD imagerel $LN26+1103
DD imagerel $unwind$??$_Insert_string@DU?$char_traits@D@std@@_K@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@QEBD_K@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$?dtor$0@?0???$_Insert_string@DU?$char_traits@D@std@@_K@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@QEBD_K@Z@4HA DD imagerel ?dtor$0@?0???$_Insert_string@DU?$char_traits@D@std@@_K@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@QEBD_K@Z@4HA
DD imagerel ?dtor$0@?0???$_Insert_string@DU?$char_traits@D@std@@_K@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@QEBD_K@Z@4HA+36
DD imagerel $unwind$?dtor$0@?0???$_Insert_string@DU?$char_traits@D@std@@_K@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@QEBD_K@Z@4HA
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$?catch$1@?0???$_Insert_string@DU?$char_traits@D@std@@_K@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@QEBD_K@Z@4HA DD imagerel ?catch$1@?0???$_Insert_string@DU?$char_traits@D@std@@_K@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@QEBD_K@Z@4HA
DD imagerel ?catch$1@?0???$_Insert_string@DU?$char_traits@D@std@@_K@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@QEBD_K@Z@4HA+91
DD imagerel $unwind$?catch$1@?0???$_Insert_string@DU?$char_traits@D@std@@_K@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@QEBD_K@Z@4HA
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??$?0U?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@$0A@@?$unique_ptr@UCreditPayment@External@TechnicalServices@@U?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@@std@@QEAA@PEAUCreditPayment@External@TechnicalServices@@@Z DD imagerel $LN3
DD imagerel $LN3+116
DD imagerel $unwind$??$?0U?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@$0A@@?$unique_ptr@UCreditPayment@External@TechnicalServices@@U?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@@std@@QEAA@PEAUCreditPayment@External@TechnicalServices@@@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??$forward@U?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@@std@@YA$$QEAU?$default_delete@UCreditPayment@External@TechnicalServices@@@0@AEAU10@@Z DD imagerel $LN3
DD imagerel $LN3+71
DD imagerel $unwind$??$forward@U?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@@std@@YA$$QEAU?$default_delete@UCreditPayment@External@TechnicalServices@@@0@AEAU10@@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??$?0U?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@PEAUCreditPayment@External@TechnicalServices@@@?$_Compressed_pair@U?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@PEAVPaymentHandlerInterface@External@TechnicalServices@@$00@std@@QEAA@U_One_then_variadic_args_t@1@$$QEAU?$default_delete@UCreditPayment@External@TechnicalServices@@@1@$$QEAPEAUCreditPayment@External@TechnicalServices@@@Z DD imagerel $LN3
DD imagerel $LN3+137
DD imagerel $unwind$??$?0U?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@PEAUCreditPayment@External@TechnicalServices@@@?$_Compressed_pair@U?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@PEAVPaymentHandlerInterface@External@TechnicalServices@@$00@std@@QEAA@U_One_then_variadic_args_t@1@$$QEAU?$default_delete@UCreditPayment@External@TechnicalServices@@@1@$$QEAPEAUCreditPayment@External@TechnicalServices@@@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??$?0U?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@$0A@@?$unique_ptr@UDebitPayment@External@TechnicalServices@@U?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@@std@@QEAA@PEAUDebitPayment@External@TechnicalServices@@@Z DD imagerel $LN3
DD imagerel $LN3+116
DD imagerel $unwind$??$?0U?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@$0A@@?$unique_ptr@UDebitPayment@External@TechnicalServices@@U?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@@std@@QEAA@PEAUDebitPayment@External@TechnicalServices@@@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??$forward@U?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@@std@@YA$$QEAU?$default_delete@UDebitPayment@External@TechnicalServices@@@0@AEAU10@@Z DD imagerel $LN3
DD imagerel $LN3+71
DD imagerel $unwind$??$forward@U?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@@std@@YA$$QEAU?$default_delete@UDebitPayment@External@TechnicalServices@@@0@AEAU10@@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??$?0U?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@PEAUDebitPayment@External@TechnicalServices@@@?$_Compressed_pair@U?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@PEAVPaymentHandlerInterface@External@TechnicalServices@@$00@std@@QEAA@U_One_then_variadic_args_t@1@$$QEAU?$default_delete@UDebitPayment@External@TechnicalServices@@@1@$$QEAPEAUDebitPayment@External@TechnicalServices@@@Z DD imagerel $LN3
DD imagerel $LN3+137
DD imagerel $unwind$??$?0U?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@PEAUDebitPayment@External@TechnicalServices@@@?$_Compressed_pair@U?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@PEAVPaymentHandlerInterface@External@TechnicalServices@@$00@std@@QEAA@U_One_then_variadic_args_t@1@$$QEAU?$default_delete@UDebitPayment@External@TechnicalServices@@@1@$$QEAPEAUDebitPayment@External@TechnicalServices@@@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??$?0U?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@$0A@@?$unique_ptr@UGatewayPayment@External@TechnicalServices@@U?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@@std@@QEAA@PEAUGatewayPayment@External@TechnicalServices@@@Z DD imagerel $LN3
DD imagerel $LN3+116
DD imagerel $unwind$??$?0U?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@$0A@@?$unique_ptr@UGatewayPayment@External@TechnicalServices@@U?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@@std@@QEAA@PEAUGatewayPayment@External@TechnicalServices@@@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??$forward@U?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@@std@@YA$$QEAU?$default_delete@UGatewayPayment@External@TechnicalServices@@@0@AEAU10@@Z DD imagerel $LN3
DD imagerel $LN3+71
DD imagerel $unwind$??$forward@U?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@@std@@YA$$QEAU?$default_delete@UGatewayPayment@External@TechnicalServices@@@0@AEAU10@@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??$?0U?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@PEAUGatewayPayment@External@TechnicalServices@@@?$_Compressed_pair@U?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@PEAVPaymentHandlerInterface@External@TechnicalServices@@$00@std@@QEAA@U_One_then_variadic_args_t@1@$$QEAU?$default_delete@UGatewayPayment@External@TechnicalServices@@@1@$$QEAPEAUGatewayPayment@External@TechnicalServices@@@Z DD imagerel $LN3
DD imagerel $LN3+137
DD imagerel $unwind$??$?0U?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@PEAUGatewayPayment@External@TechnicalServices@@@?$_Compressed_pair@U?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@PEAVPaymentHandlerInterface@External@TechnicalServices@@$00@std@@QEAA@U_One_then_variadic_args_t@1@$$QEAU?$default_delete@UGatewayPayment@External@TechnicalServices@@@1@$$QEAPEAUGatewayPayment@External@TechnicalServices@@@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??$_Deallocate_plain@V?$allocator@U_Container_proxy@std@@@std@@@std@@YAXAEAV?$allocator@U_Container_proxy@std@@@0@QEAU_Container_proxy@0@@Z DD imagerel $LN3
DD imagerel $LN3+95
DD imagerel $unwind$??$_Deallocate_plain@V?$allocator@U_Container_proxy@std@@@std@@@std@@YAXAEAV?$allocator@U_Container_proxy@std@@@0@QEAU_Container_proxy@0@@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??$addressof@PEAD@std@@YAPEAPEADAEAPEAD@Z DD imagerel $LN3
DD imagerel $LN3+71
DD imagerel $unwind$??$addressof@PEAD@std@@YAPEAPEADAEAPEAD@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??$forward@AEBQEAD@std@@YAAEBQEADAEBQEAD@Z DD imagerel $LN3
DD imagerel $LN3+71
DD imagerel $unwind$??$forward@AEBQEAD@std@@YAAEBQEADAEBQEAD@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??$_Allocate_manually_vector_aligned@U_Default_allocate_traits@std@@@std@@YAPEAX_K@Z DD imagerel $LN13
DD imagerel $LN13+300
DD imagerel $unwind$??$_Allocate_manually_vector_aligned@U_Default_allocate_traits@std@@@std@@YAPEAX_K@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??$_Unfancy@UPaymentOption@Persistence@TechnicalServices@@@std@@YAPEAUPaymentOption@Persistence@TechnicalServices@@PEAU123@@Z DD imagerel $LN3
DD imagerel $LN3+71
DD imagerel $unwind$??$_Unfancy@UPaymentOption@Persistence@TechnicalServices@@@std@@YAPEAUPaymentOption@Persistence@TechnicalServices@@PEAU123@@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??$destroy@UPaymentOption@Persistence@TechnicalServices@@@?$_Default_allocator_traits@V?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@@std@@SAXAEAV?$allocator@UPaymentOption@Persistence@TechnicalServices@@@1@QEAUPaymentOption@Persistence@TechnicalServices@@@Z DD imagerel $LN3
DD imagerel $LN3+83
DD imagerel $unwind$??$destroy@UPaymentOption@Persistence@TechnicalServices@@@?$_Default_allocator_traits@V?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@@std@@SAXAEAV?$allocator@UPaymentOption@Persistence@TechnicalServices@@@1@QEAUPaymentOption@Persistence@TechnicalServices@@@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??$exchange@PEAUGatewayPayment@External@TechnicalServices@@PEAU123@@std@@YAPEAUGatewayPayment@External@TechnicalServices@@AEAPEAU123@$$QEAPEAU123@@Z DD imagerel $LN3
DD imagerel $LN3+107
DD imagerel $unwind$??$exchange@PEAUGatewayPayment@External@TechnicalServices@@PEAU123@@std@@YAPEAUGatewayPayment@External@TechnicalServices@@AEAPEAU123@$$QEAPEAU123@@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??$exchange@PEAUDebitPayment@External@TechnicalServices@@PEAU123@@std@@YAPEAUDebitPayment@External@TechnicalServices@@AEAPEAU123@$$QEAPEAU123@@Z DD imagerel $LN3
DD imagerel $LN3+107
DD imagerel $unwind$??$exchange@PEAUDebitPayment@External@TechnicalServices@@PEAU123@@std@@YAPEAUDebitPayment@External@TechnicalServices@@AEAPEAU123@$$QEAPEAU123@@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??$exchange@PEAUCreditPayment@External@TechnicalServices@@PEAU123@@std@@YAPEAUCreditPayment@External@TechnicalServices@@AEAPEAU123@$$QEAPEAU123@@Z DD imagerel $LN3
DD imagerel $LN3+107
DD imagerel $unwind$??$exchange@PEAUCreditPayment@External@TechnicalServices@@PEAU123@@std@@YAPEAUCreditPayment@External@TechnicalServices@@AEAPEAU123@$$QEAPEAU123@@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??$_Traits_equal@U?$char_traits@D@std@@@std@@YA_NQEBD_K01@Z DD imagerel $LN5
DD imagerel $LN5+154
DD imagerel $unwind$??$_Traits_equal@U?$char_traits@D@std@@@std@@YA_NQEBD_K01@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??$?0AEAPEAUCreditPayment@External@TechnicalServices@@@?$_Compressed_pair@U?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@PEAUCreditPayment@External@TechnicalServices@@$00@std@@QEAA@U_Zero_then_variadic_args_t@1@AEAPEAUCreditPayment@External@TechnicalServices@@@Z DD imagerel $LN3
DD imagerel $LN3+105
DD imagerel $unwind$??$?0AEAPEAUCreditPayment@External@TechnicalServices@@@?$_Compressed_pair@U?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@PEAUCreditPayment@External@TechnicalServices@@$00@std@@QEAA@U_Zero_then_variadic_args_t@1@AEAPEAUCreditPayment@External@TechnicalServices@@@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??$forward@PEAUCreditPayment@External@TechnicalServices@@@std@@YA$$QEAPEAUCreditPayment@External@TechnicalServices@@AEAPEAU123@@Z DD imagerel $LN3
DD imagerel $LN3+71
DD imagerel $unwind$??$forward@PEAUCreditPayment@External@TechnicalServices@@@std@@YA$$QEAPEAUCreditPayment@External@TechnicalServices@@AEAPEAU123@@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??$?0AEAPEAUDebitPayment@External@TechnicalServices@@@?$_Compressed_pair@U?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@PEAUDebitPayment@External@TechnicalServices@@$00@std@@QEAA@U_Zero_then_variadic_args_t@1@AEAPEAUDebitPayment@External@TechnicalServices@@@Z DD imagerel $LN3
DD imagerel $LN3+105
DD imagerel $unwind$??$?0AEAPEAUDebitPayment@External@TechnicalServices@@@?$_Compressed_pair@U?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@PEAUDebitPayment@External@TechnicalServices@@$00@std@@QEAA@U_Zero_then_variadic_args_t@1@AEAPEAUDebitPayment@External@TechnicalServices@@@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??$forward@PEAUDebitPayment@External@TechnicalServices@@@std@@YA$$QEAPEAUDebitPayment@External@TechnicalServices@@AEAPEAU123@@Z DD imagerel $LN3
DD imagerel $LN3+71
DD imagerel $unwind$??$forward@PEAUDebitPayment@External@TechnicalServices@@@std@@YA$$QEAPEAUDebitPayment@External@TechnicalServices@@AEAPEAU123@@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??$?0AEAPEAUGatewayPayment@External@TechnicalServices@@@?$_Compressed_pair@U?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@PEAUGatewayPayment@External@TechnicalServices@@$00@std@@QEAA@U_Zero_then_variadic_args_t@1@AEAPEAUGatewayPayment@External@TechnicalServices@@@Z DD imagerel $LN3
DD imagerel $LN3+105
DD imagerel $unwind$??$?0AEAPEAUGatewayPayment@External@TechnicalServices@@@?$_Compressed_pair@U?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@PEAUGatewayPayment@External@TechnicalServices@@$00@std@@QEAA@U_Zero_then_variadic_args_t@1@AEAPEAUGatewayPayment@External@TechnicalServices@@@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??$forward@PEAUGatewayPayment@External@TechnicalServices@@@std@@YA$$QEAPEAUGatewayPayment@External@TechnicalServices@@AEAPEAU123@@Z DD imagerel $LN3
DD imagerel $LN3+71
DD imagerel $unwind$??$forward@PEAUGatewayPayment@External@TechnicalServices@@@std@@YA$$QEAPEAUGatewayPayment@External@TechnicalServices@@AEAPEAU123@@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$?deallocate@?$_Default_allocator_traits@V?$allocator@U_Container_proxy@std@@@std@@@std@@SAXAEAV?$allocator@U_Container_proxy@std@@@2@QEAU_Container_proxy@2@_K@Z DD imagerel $LN3
DD imagerel $LN3+97
DD imagerel $unwind$?deallocate@?$_Default_allocator_traits@V?$allocator@U_Container_proxy@std@@@std@@@std@@SAXAEAV?$allocator@U_Container_proxy@std@@@2@QEAU_Container_proxy@2@_K@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??$forward@AEAPEAUCreditPayment@External@TechnicalServices@@@std@@YAAEAPEAUCreditPayment@External@TechnicalServices@@AEAPEAU123@@Z DD imagerel $LN3
DD imagerel $LN3+71
DD imagerel $unwind$??$forward@AEAPEAUCreditPayment@External@TechnicalServices@@@std@@YAAEAPEAUCreditPayment@External@TechnicalServices@@AEAPEAU123@@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??$forward@AEAPEAUDebitPayment@External@TechnicalServices@@@std@@YAAEAPEAUDebitPayment@External@TechnicalServices@@AEAPEAU123@@Z DD imagerel $LN3
DD imagerel $LN3+71
DD imagerel $unwind$??$forward@AEAPEAUDebitPayment@External@TechnicalServices@@@std@@YAAEAPEAUDebitPayment@External@TechnicalServices@@AEAPEAU123@@Z
pdata ENDS
; COMDAT pdata
pdata SEGMENT
$pdata$??$forward@AEAPEAUGatewayPayment@External@TechnicalServices@@@std@@YAAEAPEAUGatewayPayment@External@TechnicalServices@@AEAPEAU123@@Z DD imagerel $LN3
DD imagerel $LN3+71
DD imagerel $unwind$??$forward@AEAPEAUGatewayPayment@External@TechnicalServices@@@std@@YAAEAPEAUGatewayPayment@External@TechnicalServices@@AEAPEAU123@@Z
pdata ENDS
; COMDAT rtc$TMZ
rtc$TMZ SEGMENT
_RTC_Shutdown.rtc$TMZ DQ FLAT:_RTC_Shutdown
rtc$TMZ ENDS
; COMDAT rtc$IMZ
rtc$IMZ SEGMENT
_RTC_InitBase.rtc$IMZ DQ FLAT:_RTC_InitBase
rtc$IMZ ENDS
; COMDAT ??_R1A@?0A@EA@GatewayPayment@External@TechnicalServices@@8
rdata$r SEGMENT
??_R1A@?0A@EA@GatewayPayment@External@TechnicalServices@@8 DD imagerel ??_R0?AUGatewayPayment@External@TechnicalServices@@@8 ; TechnicalServices::External::GatewayPayment::`RTTI Base Class Descriptor at (0,-1,0,64)'
DD 01H
DD 00H
DD 0ffffffffH
DD 00H
DD 040H
DD imagerel ??_R3GatewayPayment@External@TechnicalServices@@8
rdata$r ENDS
; COMDAT ??_R2GatewayPayment@External@TechnicalServices@@8
rdata$r SEGMENT
??_R2GatewayPayment@External@TechnicalServices@@8 DD imagerel ??_R1A@?0A@EA@GatewayPayment@External@TechnicalServices@@8 ; TechnicalServices::External::GatewayPayment::`RTTI Base Class Array'
DD imagerel ??_R1A@?0A@EA@PaymentHandlerInterface@External@TechnicalServices@@8
ORG $+3
rdata$r ENDS
; COMDAT ??_R3GatewayPayment@External@TechnicalServices@@8
rdata$r SEGMENT
??_R3GatewayPayment@External@TechnicalServices@@8 DD 00H ; TechnicalServices::External::GatewayPayment::`RTTI Class Hierarchy Descriptor'
DD 00H
DD 02H
DD imagerel ??_R2GatewayPayment@External@TechnicalServices@@8
rdata$r ENDS
; COMDAT ??_R0?AUGatewayPayment@External@TechnicalServices@@@8
data$rs SEGMENT
??_R0?AUGatewayPayment@External@TechnicalServices@@@8 DQ FLAT:??_7type_info@@6B@ ; TechnicalServices::External::GatewayPayment `RTTI Type Descriptor'
DQ 0000000000000000H
DB '.?AUGatewayPayment@External@TechnicalServices@@', 00H
data$rs ENDS
; COMDAT ??_R4GatewayPayment@External@TechnicalServices@@6B@
rdata$r SEGMENT
??_R4GatewayPayment@External@TechnicalServices@@6B@ DD 01H ; TechnicalServices::External::GatewayPayment::`RTTI Complete Object Locator'
DD 00H
DD 00H
DD imagerel ??_R0?AUGatewayPayment@External@TechnicalServices@@@8
DD imagerel ??_R3GatewayPayment@External@TechnicalServices@@8
DD imagerel ??_R4GatewayPayment@External@TechnicalServices@@6B@
rdata$r ENDS
; COMDAT ??_R1A@?0A@EA@DebitPayment@External@TechnicalServices@@8
rdata$r SEGMENT
??_R1A@?0A@EA@DebitPayment@External@TechnicalServices@@8 DD imagerel ??_R0?AUDebitPayment@External@TechnicalServices@@@8 ; TechnicalServices::External::DebitPayment::`RTTI Base Class Descriptor at (0,-1,0,64)'
DD 01H
DD 00H
DD 0ffffffffH
DD 00H
DD 040H
DD imagerel ??_R3DebitPayment@External@TechnicalServices@@8
rdata$r ENDS
; COMDAT ??_R2DebitPayment@External@TechnicalServices@@8
rdata$r SEGMENT
??_R2DebitPayment@External@TechnicalServices@@8 DD imagerel ??_R1A@?0A@EA@DebitPayment@External@TechnicalServices@@8 ; TechnicalServices::External::DebitPayment::`RTTI Base Class Array'
DD imagerel ??_R1A@?0A@EA@PaymentHandlerInterface@External@TechnicalServices@@8
ORG $+3
rdata$r ENDS
; COMDAT ??_R3DebitPayment@External@TechnicalServices@@8
rdata$r SEGMENT
??_R3DebitPayment@External@TechnicalServices@@8 DD 00H ; TechnicalServices::External::DebitPayment::`RTTI Class Hierarchy Descriptor'
DD 00H
DD 02H
DD imagerel ??_R2DebitPayment@External@TechnicalServices@@8
rdata$r ENDS
; COMDAT ??_R0?AUDebitPayment@External@TechnicalServices@@@8
data$rs SEGMENT
??_R0?AUDebitPayment@External@TechnicalServices@@@8 DQ FLAT:??_7type_info@@6B@ ; TechnicalServices::External::DebitPayment `RTTI Type Descriptor'
DQ 0000000000000000H
DB '.?AUDebitPayment@External@TechnicalServices@@', 00H
data$rs ENDS
; COMDAT ??_R4DebitPayment@External@TechnicalServices@@6B@
rdata$r SEGMENT
??_R4DebitPayment@External@TechnicalServices@@6B@ DD 01H ; TechnicalServices::External::DebitPayment::`RTTI Complete Object Locator'
DD 00H
DD 00H
DD imagerel ??_R0?AUDebitPayment@External@TechnicalServices@@@8
DD imagerel ??_R3DebitPayment@External@TechnicalServices@@8
DD imagerel ??_R4DebitPayment@External@TechnicalServices@@6B@
rdata$r ENDS
; COMDAT ??_R1A@?0A@EA@CreditPayment@External@TechnicalServices@@8
rdata$r SEGMENT
??_R1A@?0A@EA@CreditPayment@External@TechnicalServices@@8 DD imagerel ??_R0?AUCreditPayment@External@TechnicalServices@@@8 ; TechnicalServices::External::CreditPayment::`RTTI Base Class Descriptor at (0,-1,0,64)'
DD 01H
DD 00H
DD 0ffffffffH
DD 00H
DD 040H
DD imagerel ??_R3CreditPayment@External@TechnicalServices@@8
rdata$r ENDS
; COMDAT ??_R2CreditPayment@External@TechnicalServices@@8
rdata$r SEGMENT
??_R2CreditPayment@External@TechnicalServices@@8 DD imagerel ??_R1A@?0A@EA@CreditPayment@External@TechnicalServices@@8 ; TechnicalServices::External::CreditPayment::`RTTI Base Class Array'
DD imagerel ??_R1A@?0A@EA@PaymentHandlerInterface@External@TechnicalServices@@8
ORG $+3
rdata$r ENDS
; COMDAT ??_R3CreditPayment@External@TechnicalServices@@8
rdata$r SEGMENT
??_R3CreditPayment@External@TechnicalServices@@8 DD 00H ; TechnicalServices::External::CreditPayment::`RTTI Class Hierarchy Descriptor'
DD 00H
DD 02H
DD imagerel ??_R2CreditPayment@External@TechnicalServices@@8
rdata$r ENDS
; COMDAT ??_R0?AUCreditPayment@External@TechnicalServices@@@8
data$rs SEGMENT
??_R0?AUCreditPayment@External@TechnicalServices@@@8 DQ FLAT:??_7type_info@@6B@ ; TechnicalServices::External::CreditPayment `RTTI Type Descriptor'
DQ 0000000000000000H
DB '.?AUCreditPayment@External@TechnicalServices@@', 00H
data$rs ENDS
; COMDAT ??_R4CreditPayment@External@TechnicalServices@@6B@
rdata$r SEGMENT
??_R4CreditPayment@External@TechnicalServices@@6B@ DD 01H ; TechnicalServices::External::CreditPayment::`RTTI Complete Object Locator'
DD 00H
DD 00H
DD imagerel ??_R0?AUCreditPayment@External@TechnicalServices@@@8
DD imagerel ??_R3CreditPayment@External@TechnicalServices@@8
DD imagerel ??_R4CreditPayment@External@TechnicalServices@@6B@
rdata$r ENDS
; COMDAT ??_R1A@?0A@EA@PaymentHandlerInterface@External@TechnicalServices@@8
rdata$r SEGMENT
??_R1A@?0A@EA@PaymentHandlerInterface@External@TechnicalServices@@8 DD imagerel ??_R0?AVPaymentHandlerInterface@External@TechnicalServices@@@8 ; TechnicalServices::External::PaymentHandlerInterface::`RTTI Base Class Descriptor at (0,-1,0,64)'
DD 00H
DD 00H
DD 0ffffffffH
DD 00H
DD 040H
DD imagerel ??_R3PaymentHandlerInterface@External@TechnicalServices@@8
rdata$r ENDS
; COMDAT ??_R2PaymentHandlerInterface@External@TechnicalServices@@8
rdata$r SEGMENT
??_R2PaymentHandlerInterface@External@TechnicalServices@@8 DD imagerel ??_R1A@?0A@EA@PaymentHandlerInterface@External@TechnicalServices@@8 ; TechnicalServices::External::PaymentHandlerInterface::`RTTI Base Class Array'
ORG $+3
rdata$r ENDS
; COMDAT ??_R3PaymentHandlerInterface@External@TechnicalServices@@8
rdata$r SEGMENT
??_R3PaymentHandlerInterface@External@TechnicalServices@@8 DD 00H ; TechnicalServices::External::PaymentHandlerInterface::`RTTI Class Hierarchy Descriptor'
DD 00H
DD 01H
DD imagerel ??_R2PaymentHandlerInterface@External@TechnicalServices@@8
rdata$r ENDS
; COMDAT ??_R0?AVPaymentHandlerInterface@External@TechnicalServices@@@8
data$rs SEGMENT
??_R0?AVPaymentHandlerInterface@External@TechnicalServices@@@8 DQ FLAT:??_7type_info@@6B@ ; TechnicalServices::External::PaymentHandlerInterface `RTTI Type Descriptor'
DQ 0000000000000000H
DB '.?AVPaymentHandlerInterface@External@TechnicalServices@@'
DB 00H
data$rs ENDS
; COMDAT ??_R4PaymentHandlerInterface@External@TechnicalServices@@6B@
rdata$r SEGMENT
??_R4PaymentHandlerInterface@External@TechnicalServices@@6B@ DD 01H ; TechnicalServices::External::PaymentHandlerInterface::`RTTI Complete Object Locator'
DD 00H
DD 00H
DD imagerel ??_R0?AVPaymentHandlerInterface@External@TechnicalServices@@@8
DD imagerel ??_R3PaymentHandlerInterface@External@TechnicalServices@@8
DD imagerel ??_R4PaymentHandlerInterface@External@TechnicalServices@@6B@
rdata$r ENDS
; COMDAT ??_R1A@?0A@EA@bad_array_new_length@std@@8
rdata$r SEGMENT
??_R1A@?0A@EA@bad_array_new_length@std@@8 DD imagerel ??_R0?AVbad_array_new_length@std@@@8 ; std::bad_array_new_length::`RTTI Base Class Descriptor at (0,-1,0,64)'
DD 02H
DD 00H
DD 0ffffffffH
DD 00H
DD 040H
DD imagerel ??_R3bad_array_new_length@std@@8
rdata$r ENDS
; COMDAT ??_R2bad_array_new_length@std@@8
rdata$r SEGMENT
??_R2bad_array_new_length@std@@8 DD imagerel ??_R1A@?0A@EA@bad_array_new_length@std@@8 ; std::bad_array_new_length::`RTTI Base Class Array'
DD imagerel ??_R1A@?0A@EA@bad_alloc@std@@8
DD imagerel ??_R1A@?0A@EA@exception@std@@8
ORG $+3
rdata$r ENDS
; COMDAT ??_R3bad_array_new_length@std@@8
rdata$r SEGMENT
??_R3bad_array_new_length@std@@8 DD 00H ; std::bad_array_new_length::`RTTI Class Hierarchy Descriptor'
DD 00H
DD 03H
DD imagerel ??_R2bad_array_new_length@std@@8
rdata$r ENDS
; COMDAT ??_R4bad_array_new_length@std@@6B@
rdata$r SEGMENT
??_R4bad_array_new_length@std@@6B@ DD 01H ; std::bad_array_new_length::`RTTI Complete Object Locator'
DD 00H
DD 00H
DD imagerel ??_R0?AVbad_array_new_length@std@@@8
DD imagerel ??_R3bad_array_new_length@std@@8
DD imagerel ??_R4bad_array_new_length@std@@6B@
rdata$r ENDS
; COMDAT ??_R1A@?0A@EA@bad_alloc@std@@8
rdata$r SEGMENT
??_R1A@?0A@EA@bad_alloc@std@@8 DD imagerel ??_R0?AVbad_alloc@std@@@8 ; std::bad_alloc::`RTTI Base Class Descriptor at (0,-1,0,64)'
DD 01H
DD 00H
DD 0ffffffffH
DD 00H
DD 040H
DD imagerel ??_R3bad_alloc@std@@8
rdata$r ENDS
; COMDAT ??_R2bad_alloc@std@@8
rdata$r SEGMENT
??_R2bad_alloc@std@@8 DD imagerel ??_R1A@?0A@EA@bad_alloc@std@@8 ; std::bad_alloc::`RTTI Base Class Array'
DD imagerel ??_R1A@?0A@EA@exception@std@@8
ORG $+3
rdata$r ENDS
; COMDAT ??_R3bad_alloc@std@@8
rdata$r SEGMENT
??_R3bad_alloc@std@@8 DD 00H ; std::bad_alloc::`RTTI Class Hierarchy Descriptor'
DD 00H
DD 02H
DD imagerel ??_R2bad_alloc@std@@8
rdata$r ENDS
; COMDAT ??_R4bad_alloc@std@@6B@
rdata$r SEGMENT
??_R4bad_alloc@std@@6B@ DD 01H ; std::bad_alloc::`RTTI Complete Object Locator'
DD 00H
DD 00H
DD imagerel ??_R0?AVbad_alloc@std@@@8
DD imagerel ??_R3bad_alloc@std@@8
DD imagerel ??_R4bad_alloc@std@@6B@
rdata$r ENDS
; COMDAT ??_R1A@?0A@EA@exception@std@@8
rdata$r SEGMENT
??_R1A@?0A@EA@exception@std@@8 DD imagerel ??_R0?AVexception@std@@@8 ; std::exception::`RTTI Base Class Descriptor at (0,-1,0,64)'
DD 00H
DD 00H
DD 0ffffffffH
DD 00H
DD 040H
DD imagerel ??_R3exception@std@@8
rdata$r ENDS
; COMDAT ??_R2exception@std@@8
rdata$r SEGMENT
??_R2exception@std@@8 DD imagerel ??_R1A@?0A@EA@exception@std@@8 ; std::exception::`RTTI Base Class Array'
ORG $+3
rdata$r ENDS
; COMDAT ??_R3exception@std@@8
rdata$r SEGMENT
??_R3exception@std@@8 DD 00H ; std::exception::`RTTI Class Hierarchy Descriptor'
DD 00H
DD 01H
DD imagerel ??_R2exception@std@@8
rdata$r ENDS
; COMDAT ??_R4exception@std@@6B@
rdata$r SEGMENT
??_R4exception@std@@6B@ DD 01H ; std::exception::`RTTI Complete Object Locator'
DD 00H
DD 00H
DD imagerel ??_R0?AVexception@std@@@8
DD imagerel ??_R3exception@std@@8
DD imagerel ??_R4exception@std@@6B@
rdata$r ENDS
; COMDAT ??_C@_1EO@GFNCMDLA@?$AAs?$AAt?$AAd?$AA?3?$AA?3?$AA_?$AAA?$AAl?$AAl?$AAo?$AAc?$AAa?$AAt?$AAe?$AA_@
CONST SEGMENT
??_C@_1EO@GFNCMDLA@?$AAs?$AAt?$AAd?$AA?3?$AA?3?$AA_?$AAA?$AAl?$AAl?$AAo?$AAc?$AAa?$AAt?$AAe?$AA_@ DB 's'
DB 00H, 't', 00H, 'd', 00H, ':', 00H, ':', 00H, '_', 00H, 'A', 00H
DB 'l', 00H, 'l', 00H, 'o', 00H, 'c', 00H, 'a', 00H, 't', 00H, 'e'
DB 00H, '_', 00H, 'm', 00H, 'a', 00H, 'n', 00H, 'u', 00H, 'a', 00H
DB 'l', 00H, 'l', 00H, 'y', 00H, '_', 00H, 'v', 00H, 'e', 00H, 'c'
DB 00H, 't', 00H, 'o', 00H, 'r', 00H, '_', 00H, 'a', 00H, 'l', 00H
DB 'i', 00H, 'g', 00H, 'n', 00H, 'e', 00H, 'd', 00H, 00H, 00H ; `string'
CONST ENDS
; COMDAT ??_C@_1BK@MHIKGOKE@?$AA?3?$AAA?$AAM?$AA?3?$AAa?$AAm?$AA?3?$AAP?$AAM?$AA?3?$AAp?$AAm@
CONST SEGMENT
??_C@_1BK@MHIKGOKE@?$AA?3?$AAA?$AAM?$AA?3?$AAa?$AAm?$AA?3?$AAP?$AAM?$AA?3?$AAp?$AAm@ DB ':'
DB 00H, 'A', 00H, 'M', 00H, ':', 00H, 'a', 00H, 'm', 00H, ':', 00H
DB 'P', 00H, 'M', 00H, ':', 00H, 'p', 00H, 'm', 00H, 00H, 00H ; `string'
CONST ENDS
; COMDAT ??_C@_0N@LPFKKEBD@?3AM?3am?3PM?3pm@
CONST SEGMENT
??_C@_0N@LPFKKEBD@?3AM?3am?3PM?3pm@ DB ':AM:am:PM:pm', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_1EA@LEKOKFNB@?$AA?$CC?$AAv?$AAe?$AAc?$AAt?$AAo?$AAr?$AA?5?$AAs?$AAu?$AAb?$AAs?$AAc?$AAr?$AAi@
CONST SEGMENT
??_C@_1EA@LEKOKFNB@?$AA?$CC?$AAv?$AAe?$AAc?$AAt?$AAo?$AAr?$AA?5?$AAs?$AAu?$AAb?$AAs?$AAc?$AAr?$AAi@ DB '"'
DB 00H, 'v', 00H, 'e', 00H, 'c', 00H, 't', 00H, 'o', 00H, 'r', 00H
DB ' ', 00H, 's', 00H, 'u', 00H, 'b', 00H, 's', 00H, 'c', 00H, 'r'
DB 00H, 'i', 00H, 'p', 00H, 't', 00H, ' ', 00H, 'o', 00H, 'u', 00H
DB 't', 00H, ' ', 00H, 'o', 00H, 'f', 00H, ' ', 00H, 'r', 00H, 'a'
DB 00H, 'n', 00H, 'g', 00H, 'e', 00H, '"', 00H, 00H, 00H ; `string'
CONST ENDS
; COMDAT ??_C@_1BDG@KBAFNKDI@?$AAs?$AAt?$AAd?$AA?3?$AA?3?$AAv?$AAe?$AAc?$AAt?$AAo?$AAr?$AA?$DM?$AAs?$AAt?$AAr@
CONST SEGMENT
??_C@_1BDG@KBAFNKDI@?$AAs?$AAt?$AAd?$AA?3?$AA?3?$AAv?$AAe?$AAc?$AAt?$AAo?$AAr?$AA?$DM?$AAs?$AAt?$AAr@ DB 's'
DB 00H, 't', 00H, 'd', 00H, ':', 00H, ':', 00H, 'v', 00H, 'e', 00H
DB 'c', 00H, 't', 00H, 'o', 00H, 'r', 00H, '<', 00H, 's', 00H, 't'
DB 00H, 'r', 00H, 'u', 00H, 'c', 00H, 't', 00H, ' ', 00H, 'T', 00H
DB 'e', 00H, 'c', 00H, 'h', 00H, 'n', 00H, 'i', 00H, 'c', 00H, 'a'
DB 00H, 'l', 00H, 'S', 00H, 'e', 00H, 'r', 00H, 'v', 00H, 'i', 00H
DB 'c', 00H, 'e', 00H, 's', 00H, ':', 00H, ':', 00H, 'P', 00H, 'e'
DB 00H, 'r', 00H, 's', 00H, 'i', 00H, 's', 00H, 't', 00H, 'e', 00H
DB 'n', 00H, 'c', 00H, 'e', 00H, ':', 00H, ':', 00H, 'P', 00H, 'a'
DB 00H, 'y', 00H, 'm', 00H, 'e', 00H, 'n', 00H, 't', 00H, 'O', 00H
DB 'p', 00H, 't', 00H, 'i', 00H, 'o', 00H, 'n', 00H, ',', 00H, 'c'
DB 00H, 'l', 00H, 'a', 00H, 's', 00H, 's', 00H, ' ', 00H, 's', 00H
DB 't', 00H, 'd', 00H, ':', 00H, ':', 00H, 'a', 00H, 'l', 00H, 'l'
DB 00H, 'o', 00H, 'c', 00H, 'a', 00H, 't', 00H, 'o', 00H, 'r', 00H
DB '<', 00H, 's', 00H, 't', 00H, 'r', 00H, 'u', 00H, 'c', 00H, 't'
DB 00H, ' ', 00H, 'T', 00H, 'e', 00H, 'c', 00H, 'h', 00H, 'n', 00H
DB 'i', 00H, 'c', 00H, 'a', 00H, 'l', 00H, 'S', 00H, 'e', 00H, 'r'
DB 00H, 'v', 00H, 'i', 00H, 'c', 00H, 'e', 00H, 's', 00H, ':', 00H
DB ':', 00H, 'P', 00H, 'e', 00H, 'r', 00H, 's', 00H, 'i', 00H, 's'
DB 00H, 't', 00H, 'e', 00H, 'n', 00H, 'c', 00H, 'e', 00H, ':', 00H
DB ':', 00H, 'P', 00H, 'a', 00H, 'y', 00H, 'm', 00H, 'e', 00H, 'n'
DB 00H, 't', 00H, 'O', 00H, 'p', 00H, 't', 00H, 'i', 00H, 'o', 00H
DB 'n', 00H, '>', 00H, ' ', 00H, '>', 00H, ':', 00H, ':', 00H, 'o'
DB 00H, 'p', 00H, 'e', 00H, 'r', 00H, 'a', 00H, 't', 00H, 'o', 00H
DB 'r', 00H, ' ', 00H, '[', 00H, ']', 00H, 00H, 00H ; `string'
CONST ENDS
; COMDAT ??_C@_1MO@BFNDGJJP@?$AAC?$AA?3?$AA?2?$AAP?$AAr?$AAo?$AAg?$AAr?$AAa?$AAm?$AA?5?$AAF?$AAi?$AAl?$AAe@
CONST SEGMENT
??_C@_1MO@BFNDGJJP@?$AAC?$AA?3?$AA?2?$AAP?$AAr?$AAo?$AAg?$AAr?$AAa?$AAm?$AA?5?$AAF?$AAi?$AAl?$AAe@ DB 'C'
DB 00H, ':', 00H, '\', 00H, 'P', 00H, 'r', 00H, 'o', 00H, 'g', 00H
DB 'r', 00H, 'a', 00H, 'm', 00H, ' ', 00H, 'F', 00H, 'i', 00H, 'l'
DB 00H, 'e', 00H, 's', 00H, ' ', 00H, '(', 00H, 'x', 00H, '8', 00H
DB '6', 00H, ')', 00H, '\', 00H, 'M', 00H, 'i', 00H, 'c', 00H, 'r'
DB 00H, 'o', 00H, 's', 00H, 'o', 00H, 'f', 00H, 't', 00H, ' ', 00H
DB 'V', 00H, 'i', 00H, 's', 00H, 'u', 00H, 'a', 00H, 'l', 00H, ' '
DB 00H, 'S', 00H, 't', 00H, 'u', 00H, 'd', 00H, 'i', 00H, 'o', 00H
DB '\', 00H, '2', 00H, '0', 00H, '1', 00H, '9', 00H, '\', 00H, 'C'
DB 00H, 'o', 00H, 'm', 00H, 'm', 00H, 'u', 00H, 'n', 00H, 'i', 00H
DB 't', 00H, 'y', 00H, '\', 00H, 'V', 00H, 'C', 00H, '\', 00H, 'T'
DB 00H, 'o', 00H, 'o', 00H, 'l', 00H, 's', 00H, '\', 00H, 'M', 00H
DB 'S', 00H, 'V', 00H, 'C', 00H, '\', 00H, '1', 00H, '4', 00H, '.'
DB 00H, '2', 00H, '8', 00H, '.', 00H, '2', 00H, '9', 00H, '3', 00H
DB '3', 00H, '3', 00H, '\', 00H, 'i', 00H, 'n', 00H, 'c', 00H, 'l'
DB 00H, 'u', 00H, 'd', 00H, 'e', 00H, '\', 00H, 'v', 00H, 'e', 00H
DB 'c', 00H, 't', 00H, 'o', 00H, 'r', 00H, 00H, 00H ; `string'
CONST ENDS
; COMDAT ??_C@_0GH@CENCAHKH@C?3?2Program?5Files?5?$CIx86?$CJ?2Microsof@
CONST SEGMENT
??_C@_0GH@CENCAHKH@C?3?2Program?5Files?5?$CIx86?$CJ?2Microsof@ DB 'C:\Pro'
DB 'gram Files (x86)\Microsoft Visual Studio\2019\Community\VC\To'
DB 'ols\MSVC\14.28.29333\include\vector', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_0BO@PFKOHNJC@vector?5subscript?5out?5of?5range@
CONST SEGMENT
??_C@_0BO@PFKOHNJC@vector?5subscript?5out?5of?5range@ DB 'vector subscrip'
DB 't out of range', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_07LEBHEPGK@GateWay@
CONST SEGMENT
??_C@_07LEBHEPGK@GateWay@ DB 'GateWay', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_05BGFMJNMO@Debit@
CONST SEGMENT
??_C@_05BGFMJNMO@Debit@ DB 'Debit', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_06LIFJDHJL@Credit@
CONST SEGMENT
??_C@_06LIFJDHJL@Credit@ DB 'Credit', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_0N@HNKDLDDO@?5?5action?5?$CI0?9@
CONST SEGMENT
??_C@_0N@HNKDLDDO@?5?5action?5?$CI0?9@ DB ' action (0-', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_03LPPJIELD@?$CJ?3?5@
CONST SEGMENT
??_C@_03LPPJIELD@?$CJ?3?5@ DB '): ', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_03NLJIHOMM@?5?9?5@
CONST SEGMENT
??_C@_03NLJIHOMM@?5?9?5@ DB ' - ', 00H ; `string'
CONST ENDS
; COMDAT ??_7GatewayPayment@External@TechnicalServices@@6B@
CONST SEGMENT
??_7GatewayPayment@External@TechnicalServices@@6B@ DQ FLAT:??_R4GatewayPayment@External@TechnicalServices@@6B@ ; TechnicalServices::External::GatewayPayment::`vftable'
DQ FLAT:?PayMethod@GatewayPayment@External@TechnicalServices@@UEAA?AV?$unique_ptr@VPayment@External@TechnicalServices@@U?$default_delete@VPayment@External@TechnicalServices@@@std@@@std@@AEAV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@5@@Z
DQ FLAT:??_EGatewayPayment@External@TechnicalServices@@UEAAPEAXI@Z
CONST ENDS
; COMDAT ??_7DebitPayment@External@TechnicalServices@@6B@
CONST SEGMENT
??_7DebitPayment@External@TechnicalServices@@6B@ DQ FLAT:??_R4DebitPayment@External@TechnicalServices@@6B@ ; TechnicalServices::External::DebitPayment::`vftable'
DQ FLAT:?PayMethod@DebitPayment@External@TechnicalServices@@UEAA?AV?$unique_ptr@VPayment@External@TechnicalServices@@U?$default_delete@VPayment@External@TechnicalServices@@@std@@@std@@AEAV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@5@@Z
DQ FLAT:??_EDebitPayment@External@TechnicalServices@@UEAAPEAXI@Z
CONST ENDS
; COMDAT ??_7CreditPayment@External@TechnicalServices@@6B@
CONST SEGMENT
??_7CreditPayment@External@TechnicalServices@@6B@ DQ FLAT:??_R4CreditPayment@External@TechnicalServices@@6B@ ; TechnicalServices::External::CreditPayment::`vftable'
DQ FLAT:?PayMethod@CreditPayment@External@TechnicalServices@@UEAA?AV?$unique_ptr@VPayment@External@TechnicalServices@@U?$default_delete@VPayment@External@TechnicalServices@@@std@@@std@@AEAV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@5@@Z
DQ FLAT:??_ECreditPayment@External@TechnicalServices@@UEAAPEAXI@Z
CONST ENDS
; COMDAT ??_7PaymentHandlerInterface@External@TechnicalServices@@6B@
CONST SEGMENT
??_7PaymentHandlerInterface@External@TechnicalServices@@6B@ DQ FLAT:??_R4PaymentHandlerInterface@External@TechnicalServices@@6B@ ; TechnicalServices::External::PaymentHandlerInterface::`vftable'
DQ FLAT:_purecall
DQ FLAT:_purecall
CONST ENDS
; COMDAT ??_C@_0GI@CGFMEO@C?3?2Program?5Files?5?$CIx86?$CJ?2Microsof@
CONST SEGMENT
??_C@_0GI@CGFMEO@C?3?2Program?5Files?5?$CIx86?$CJ?2Microsof@ DB 'C:\Progr'
DB 'am Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tool'
DB 's\MSVC\14.28.29333\include\xlocnum', 00H ; `string'
CONST ENDS
; COMDAT ?__LINE__Var@?0??_Maklocwcs@std@@YAPEA_WPEB_W@Z@4JA
_DATA SEGMENT
?__LINE__Var@?0??_Maklocwcs@std@@YAPEA_WPEB_W@Z@4JA DD 05aH ; `std::_Maklocwcs'::`1'::__LINE__Var
_DATA ENDS
; COMDAT ??_C@_0GI@IDGLFOOP@C?3?2Program?5Files?5?$CIx86?$CJ?2Microsof@
CONST SEGMENT
??_C@_0GI@IDGLFOOP@C?3?2Program?5Files?5?$CIx86?$CJ?2Microsof@ DB 'C:\Pro'
DB 'gram Files (x86)\Microsoft Visual Studio\2019\Community\VC\To'
DB 'ols\MSVC\14.28.29333\include\xlocale', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_0BA@JFNIOLAK@string?5too?5long@
CONST SEGMENT
??_C@_0BA@JFNIOLAK@string?5too?5long@ DB 'string too long', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_1CG@JNLFBNGN@?$AA?$CC?$AAi?$AAn?$AAv?$AAa?$AAl?$AAi?$AAd?$AA?5?$AAa?$AAr?$AAg?$AAu?$AAm?$AAe@
CONST SEGMENT
??_C@_1CG@JNLFBNGN@?$AA?$CC?$AAi?$AAn?$AAv?$AAa?$AAl?$AAi?$AAd?$AA?5?$AAa?$AAr?$AAg?$AAu?$AAm?$AAe@ DB '"'
DB 00H, 'i', 00H, 'n', 00H, 'v', 00H, 'a', 00H, 'l', 00H, 'i', 00H
DB 'd', 00H, ' ', 00H, 'a', 00H, 'r', 00H, 'g', 00H, 'u', 00H, 'm'
DB 00H, 'e', 00H, 'n', 00H, 't', 00H, '"', 00H, 00H, 00H ; `string'
CONST ENDS
; COMDAT ??_C@_1EK@NIFDJFDG@?$AAs?$AAt?$AAd?$AA?3?$AA?3?$AA_?$AAA?$AAd?$AAj?$AAu?$AAs?$AAt?$AA_?$AAm?$AAa@
CONST SEGMENT
??_C@_1EK@NIFDJFDG@?$AAs?$AAt?$AAd?$AA?3?$AA?3?$AA_?$AAA?$AAd?$AAj?$AAu?$AAs?$AAt?$AA_?$AAm?$AAa@ DB 's'
DB 00H, 't', 00H, 'd', 00H, ':', 00H, ':', 00H, '_', 00H, 'A', 00H
DB 'd', 00H, 'j', 00H, 'u', 00H, 's', 00H, 't', 00H, '_', 00H, 'm'
DB 00H, 'a', 00H, 'n', 00H, 'u', 00H, 'a', 00H, 'l', 00H, 'l', 00H
DB 'y', 00H, '_', 00H, 'v', 00H, 'e', 00H, 'c', 00H, 't', 00H, 'o'
DB 00H, 'r', 00H, '_', 00H, 'a', 00H, 'l', 00H, 'i', 00H, 'g', 00H
DB 'n', 00H, 'e', 00H, 'd', 00H, 00H, 00H ; `string'
CONST ENDS
; COMDAT ??_C@_1NA@PDNNFCLD@?$AAC?$AA?3?$AA?2?$AAP?$AAr?$AAo?$AAg?$AAr?$AAa?$AAm?$AA?5?$AAF?$AAi?$AAl?$AAe@
CONST SEGMENT
??_C@_1NA@PDNNFCLD@?$AAC?$AA?3?$AA?2?$AAP?$AAr?$AAo?$AAg?$AAr?$AAa?$AAm?$AA?5?$AAF?$AAi?$AAl?$AAe@ DB 'C'
DB 00H, ':', 00H, '\', 00H, 'P', 00H, 'r', 00H, 'o', 00H, 'g', 00H
DB 'r', 00H, 'a', 00H, 'm', 00H, ' ', 00H, 'F', 00H, 'i', 00H, 'l'
DB 00H, 'e', 00H, 's', 00H, ' ', 00H, '(', 00H, 'x', 00H, '8', 00H
DB '6', 00H, ')', 00H, '\', 00H, 'M', 00H, 'i', 00H, 'c', 00H, 'r'
DB 00H, 'o', 00H, 's', 00H, 'o', 00H, 'f', 00H, 't', 00H, ' ', 00H
DB 'V', 00H, 'i', 00H, 's', 00H, 'u', 00H, 'a', 00H, 'l', 00H, ' '
DB 00H, 'S', 00H, 't', 00H, 'u', 00H, 'd', 00H, 'i', 00H, 'o', 00H
DB '\', 00H, '2', 00H, '0', 00H, '1', 00H, '9', 00H, '\', 00H, 'C'
DB 00H, 'o', 00H, 'm', 00H, 'm', 00H, 'u', 00H, 'n', 00H, 'i', 00H
DB 't', 00H, 'y', 00H, '\', 00H, 'V', 00H, 'C', 00H, '\', 00H, 'T'
DB 00H, 'o', 00H, 'o', 00H, 'l', 00H, 's', 00H, '\', 00H, 'M', 00H
DB 'S', 00H, 'V', 00H, 'C', 00H, '\', 00H, '1', 00H, '4', 00H, '.'
DB 00H, '2', 00H, '8', 00H, '.', 00H, '2', 00H, '9', 00H, '3', 00H
DB '3', 00H, '3', 00H, '\', 00H, 'i', 00H, 'n', 00H, 'c', 00H, 'l'
DB 00H, 'u', 00H, 'd', 00H, 'e', 00H, '\', 00H, 'x', 00H, 'm', 00H
DB 'e', 00H, 'm', 00H, 'o', 00H, 'r', 00H, 'y', 00H, 00H, 00H ; `string'
CONST ENDS
; COMDAT ??_C@_0GI@CLKHGMEI@C?3?2Program?5Files?5?$CIx86?$CJ?2Microsof@
CONST SEGMENT
??_C@_0GI@CLKHGMEI@C?3?2Program?5Files?5?$CIx86?$CJ?2Microsof@ DB 'C:\Pro'
DB 'gram Files (x86)\Microsoft Visual Studio\2019\Community\VC\To'
DB 'ols\MSVC\14.28.29333\include\xmemory', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_02DKCKIIND@?$CFs@
CONST SEGMENT
??_C@_02DKCKIIND@?$CFs@ DB '%s', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_0BB@FCMFBGOM@invalid?5argument@
CONST SEGMENT
??_C@_0BB@FCMFBGOM@invalid?5argument@ DB 'invalid argument', 00H ; `string'
CONST ENDS
; COMDAT ?__LINE__Var@?0??_Adjust_manually_vector_aligned@std@@YAXAEAPEAXAEA_K@Z@4JA
_DATA SEGMENT
?__LINE__Var@?0??_Adjust_manually_vector_aligned@std@@YAXAEAPEAXAEA_K@Z@4JA DD 084H ; `std::_Adjust_manually_vector_aligned'::`1'::__LINE__Var
_DATA ENDS
; COMDAT _CT??_R0?AVexception@std@@@8??0exception@std@@QEAA@AEBV01@@Z24
xdata$x SEGMENT
_CT??_R0?AVexception@std@@@8??0exception@std@@QEAA@AEBV01@@Z24 DD 00H
DD imagerel ??_R0?AVexception@std@@@8
DD 00H
DD 0ffffffffH
ORG $+4
DD 018H
DD imagerel ??0exception@std@@QEAA@AEBV01@@Z
xdata$x ENDS
; COMDAT ??_R0?AVexception@std@@@8
data$r SEGMENT
??_R0?AVexception@std@@@8 DQ FLAT:??_7type_info@@6B@ ; std::exception `RTTI Type Descriptor'
DQ 0000000000000000H
DB '.?AVexception@std@@', 00H
data$r ENDS
; COMDAT _CT??_R0?AVbad_alloc@std@@@8??0bad_alloc@std@@QEAA@AEBV01@@Z24
xdata$x SEGMENT
_CT??_R0?AVbad_alloc@std@@@8??0bad_alloc@std@@QEAA@AEBV01@@Z24 DD 010H
DD imagerel ??_R0?AVbad_alloc@std@@@8
DD 00H
DD 0ffffffffH
ORG $+4
DD 018H
DD imagerel ??0bad_alloc@std@@QEAA@AEBV01@@Z
xdata$x ENDS
; COMDAT ??_R0?AVbad_alloc@std@@@8
data$r SEGMENT
??_R0?AVbad_alloc@std@@@8 DQ FLAT:??_7type_info@@6B@ ; std::bad_alloc `RTTI Type Descriptor'
DQ 0000000000000000H
DB '.?AVbad_alloc@std@@', 00H
data$r ENDS
; COMDAT _CT??_R0?AVbad_array_new_length@std@@@8??0bad_array_new_length@std@@QEAA@AEBV01@@Z24
xdata$x SEGMENT
_CT??_R0?AVbad_array_new_length@std@@@8??0bad_array_new_length@std@@QEAA@AEBV01@@Z24 DD 00H
DD imagerel ??_R0?AVbad_array_new_length@std@@@8
DD 00H
DD 0ffffffffH
ORG $+4
DD 018H
DD imagerel ??0bad_array_new_length@std@@QEAA@AEBV01@@Z
xdata$x ENDS
; COMDAT ??_R0?AVbad_array_new_length@std@@@8
data$r SEGMENT
??_R0?AVbad_array_new_length@std@@@8 DQ FLAT:??_7type_info@@6B@ ; std::bad_array_new_length `RTTI Type Descriptor'
DQ 0000000000000000H
DB '.?AVbad_array_new_length@std@@', 00H
data$r ENDS
; COMDAT _CTA3?AVbad_array_new_length@std@@
xdata$x SEGMENT
_CTA3?AVbad_array_new_length@std@@ DD 03H
DD imagerel _CT??_R0?AVbad_array_new_length@std@@@8??0bad_array_new_length@std@@QEAA@AEBV01@@Z24
DD imagerel _CT??_R0?AVbad_alloc@std@@@8??0bad_alloc@std@@QEAA@AEBV01@@Z24
DD imagerel _CT??_R0?AVexception@std@@@8??0exception@std@@QEAA@AEBV01@@Z24
xdata$x ENDS
; COMDAT _TI3?AVbad_array_new_length@std@@
xdata$x SEGMENT
_TI3?AVbad_array_new_length@std@@ DD 00H
DD imagerel ??1bad_array_new_length@std@@UEAA@XZ
DD 00H
DD imagerel _CTA3?AVbad_array_new_length@std@@
xdata$x ENDS
; COMDAT ??_C@_0BF@KINCDENJ@bad?5array?5new?5length@
CONST SEGMENT
??_C@_0BF@KINCDENJ@bad?5array?5new?5length@ DB 'bad array new length', 00H ; `string'
CONST ENDS
; COMDAT ??_7bad_array_new_length@std@@6B@
CONST SEGMENT
??_7bad_array_new_length@std@@6B@ DQ FLAT:??_R4bad_array_new_length@std@@6B@ ; std::bad_array_new_length::`vftable'
DQ FLAT:??_Ebad_array_new_length@std@@UEAAPEAXI@Z
DQ FLAT:?what@exception@std@@UEBAPEBDXZ
CONST ENDS
; COMDAT ??_7bad_alloc@std@@6B@
CONST SEGMENT
??_7bad_alloc@std@@6B@ DQ FLAT:??_R4bad_alloc@std@@6B@ ; std::bad_alloc::`vftable'
DQ FLAT:??_Ebad_alloc@std@@UEAAPEAXI@Z
DQ FLAT:?what@exception@std@@UEBAPEBDXZ
CONST ENDS
; COMDAT ??_C@_0BC@EOODALEL@Unknown?5exception@
CONST SEGMENT
??_C@_0BC@EOODALEL@Unknown?5exception@ DB 'Unknown exception', 00H ; `string'
CONST ENDS
; COMDAT ??_7exception@std@@6B@
CONST SEGMENT
??_7exception@std@@6B@ DQ FLAT:??_R4exception@std@@6B@ ; std::exception::`vftable'
DQ FLAT:??_Eexception@std@@UEAAPEAXI@Z
DQ FLAT:?what@exception@std@@UEBAPEBDXZ
CONST ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??$forward@AEAPEAUGatewayPayment@External@TechnicalServices@@@std@@YAAEAPEAUGatewayPayment@External@TechnicalServices@@AEAPEAU123@@Z DD 025052a01H
DD 010e2313H
DD 07007001dH
DD 05006H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??$forward@AEAPEAUDebitPayment@External@TechnicalServices@@@std@@YAAEAPEAUDebitPayment@External@TechnicalServices@@AEAPEAU123@@Z DD 025052a01H
DD 010e2313H
DD 07007001dH
DD 05006H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??$forward@AEAPEAUCreditPayment@External@TechnicalServices@@@std@@YAAEAPEAUCreditPayment@External@TechnicalServices@@AEAPEAU123@@Z DD 025052a01H
DD 010e2313H
DD 07007001dH
DD 05006H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$?deallocate@?$_Default_allocator_traits@V?$allocator@U_Container_proxy@std@@@std@@@std@@SAXAEAV?$allocator@U_Container_proxy@std@@@2@QEAU_Container_proxy@2@_K@Z DD 025053401H
DD 0118231dH
DD 07011001dH
DD 05010H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??$forward@PEAUGatewayPayment@External@TechnicalServices@@@std@@YA$$QEAPEAUGatewayPayment@External@TechnicalServices@@AEAPEAU123@@Z DD 025052a01H
DD 010e2313H
DD 07007001dH
DD 05006H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??$?0AEAPEAUGatewayPayment@External@TechnicalServices@@@?$_Compressed_pair@U?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@PEAUGatewayPayment@External@TechnicalServices@@$00@std@@QEAA@U_Zero_then_variadic_args_t@1@AEAPEAUGatewayPayment@External@TechnicalServices@@@Z DD 025053301H
DD 0117231cH
DD 07010001dH
DD 0500fH
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??$forward@PEAUDebitPayment@External@TechnicalServices@@@std@@YA$$QEAPEAUDebitPayment@External@TechnicalServices@@AEAPEAU123@@Z DD 025052a01H
DD 010e2313H
DD 07007001dH
DD 05006H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??$?0AEAPEAUDebitPayment@External@TechnicalServices@@@?$_Compressed_pair@U?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@PEAUDebitPayment@External@TechnicalServices@@$00@std@@QEAA@U_Zero_then_variadic_args_t@1@AEAPEAUDebitPayment@External@TechnicalServices@@@Z DD 025053301H
DD 0117231cH
DD 07010001dH
DD 0500fH
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??$forward@PEAUCreditPayment@External@TechnicalServices@@@std@@YA$$QEAPEAUCreditPayment@External@TechnicalServices@@AEAPEAU123@@Z DD 025052a01H
DD 010e2313H
DD 07007001dH
DD 05006H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??$?0AEAPEAUCreditPayment@External@TechnicalServices@@@?$_Compressed_pair@U?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@PEAUCreditPayment@External@TechnicalServices@@$00@std@@QEAA@U_Zero_then_variadic_args_t@1@AEAPEAUCreditPayment@External@TechnicalServices@@@Z DD 025053301H
DD 0117231cH
DD 07010001dH
DD 0500fH
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??$_Traits_equal@U?$char_traits@D@std@@@std@@YA_NQEBD_K01@Z DD 025053901H
DD 011d2322H
DD 07016001fH
DD 05015H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??$exchange@PEAUCreditPayment@External@TechnicalServices@@PEAU123@@std@@YAPEAUCreditPayment@External@TechnicalServices@@AEAPEAU123@$$QEAPEAU123@@Z DD 025052f01H
DD 01132318H
DD 0700c0021H
DD 0500bH
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??$exchange@PEAUDebitPayment@External@TechnicalServices@@PEAU123@@std@@YAPEAUDebitPayment@External@TechnicalServices@@AEAPEAU123@$$QEAPEAU123@@Z DD 025052f01H
DD 01132318H
DD 0700c0021H
DD 0500bH
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??$exchange@PEAUGatewayPayment@External@TechnicalServices@@PEAU123@@std@@YAPEAUGatewayPayment@External@TechnicalServices@@AEAPEAU123@$$QEAPEAU123@@Z DD 025052f01H
DD 01132318H
DD 0700c0021H
DD 0500bH
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??$destroy@UPaymentOption@Persistence@TechnicalServices@@@?$_Default_allocator_traits@V?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@@std@@SAXAEAV?$allocator@UPaymentOption@Persistence@TechnicalServices@@@1@QEAUPaymentOption@Persistence@TechnicalServices@@@Z DD 025052f01H
DD 01132318H
DD 0700c001dH
DD 0500bH
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??$_Unfancy@UPaymentOption@Persistence@TechnicalServices@@@std@@YAPEAUPaymentOption@Persistence@TechnicalServices@@PEAU123@@Z DD 025052a01H
DD 010e2313H
DD 07007001dH
DD 05006H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??$_Allocate_manually_vector_aligned@U_Default_allocate_traits@std@@@std@@YAPEAX_K@Z DD 035052a01H
DD 010e3313H
DD 07007002bH
DD 05006H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??$forward@AEBQEAD@std@@YAAEBQEADAEBQEAD@Z DD 025052a01H
DD 010e2313H
DD 07007001dH
DD 05006H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??$addressof@PEAD@std@@YAPEAPEADAEAPEAD@Z DD 025052a01H
DD 010e2313H
DD 07007001dH
DD 05006H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$ip2state$??$_Deallocate_plain@V?$allocator@U_Container_proxy@std@@@std@@@std@@YAXAEAV?$allocator@U_Container_proxy@std@@@0@QEAU_Container_proxy@0@@Z DB 02H
DB 00H
DB 00H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$cppxdata$??$_Deallocate_plain@V?$allocator@U_Container_proxy@std@@@std@@@std@@YAXAEAV?$allocator@U_Container_proxy@std@@@0@QEAU_Container_proxy@0@@Z DB 060H
DD imagerel $ip2state$??$_Deallocate_plain@V?$allocator@U_Container_proxy@std@@@std@@@std@@YAXAEAV?$allocator@U_Container_proxy@std@@@0@QEAU_Container_proxy@0@@Z
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??$_Deallocate_plain@V?$allocator@U_Container_proxy@std@@@std@@@std@@YAXAEAV?$allocator@U_Container_proxy@std@@@0@QEAU_Container_proxy@0@@Z DD 025052f19H
DD 01132318H
DD 0700c001dH
DD 0500bH
DD imagerel __CxxFrameHandler4
DD imagerel $cppxdata$??$_Deallocate_plain@V?$allocator@U_Container_proxy@std@@@std@@@std@@YAXAEAV?$allocator@U_Container_proxy@std@@@0@QEAU_Container_proxy@0@@Z
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??$?0U?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@PEAUGatewayPayment@External@TechnicalServices@@@?$_Compressed_pair@U?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@PEAVPaymentHandlerInterface@External@TechnicalServices@@$00@std@@QEAA@U_One_then_variadic_args_t@1@$$QEAU?$default_delete@UGatewayPayment@External@TechnicalServices@@@1@$$QEAPEAUGatewayPayment@External@TechnicalServices@@@Z DD 025053801H
DD 011c2321H
DD 07015001dH
DD 05014H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??$forward@U?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@@std@@YA$$QEAU?$default_delete@UGatewayPayment@External@TechnicalServices@@@0@AEAU10@@Z DD 025052a01H
DD 010e2313H
DD 07007001dH
DD 05006H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??$?0U?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@$0A@@?$unique_ptr@UGatewayPayment@External@TechnicalServices@@U?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@@std@@QEAA@PEAUGatewayPayment@External@TechnicalServices@@@Z DD 025052f01H
DD 01132318H
DD 0700c0021H
DD 0500bH
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??$?0U?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@PEAUDebitPayment@External@TechnicalServices@@@?$_Compressed_pair@U?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@PEAVPaymentHandlerInterface@External@TechnicalServices@@$00@std@@QEAA@U_One_then_variadic_args_t@1@$$QEAU?$default_delete@UDebitPayment@External@TechnicalServices@@@1@$$QEAPEAUDebitPayment@External@TechnicalServices@@@Z DD 025053801H
DD 011c2321H
DD 07015001dH
DD 05014H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??$forward@U?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@@std@@YA$$QEAU?$default_delete@UDebitPayment@External@TechnicalServices@@@0@AEAU10@@Z DD 025052a01H
DD 010e2313H
DD 07007001dH
DD 05006H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??$?0U?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@$0A@@?$unique_ptr@UDebitPayment@External@TechnicalServices@@U?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@@std@@QEAA@PEAUDebitPayment@External@TechnicalServices@@@Z DD 025052f01H
DD 01132318H
DD 0700c0021H
DD 0500bH
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??$?0U?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@PEAUCreditPayment@External@TechnicalServices@@@?$_Compressed_pair@U?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@PEAVPaymentHandlerInterface@External@TechnicalServices@@$00@std@@QEAA@U_One_then_variadic_args_t@1@$$QEAU?$default_delete@UCreditPayment@External@TechnicalServices@@@1@$$QEAPEAUCreditPayment@External@TechnicalServices@@@Z DD 025053801H
DD 011c2321H
DD 07015001dH
DD 05014H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??$forward@U?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@@std@@YA$$QEAU?$default_delete@UCreditPayment@External@TechnicalServices@@@0@AEAU10@@Z DD 025052a01H
DD 010e2313H
DD 07007001dH
DD 05006H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??$?0U?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@$0A@@?$unique_ptr@UCreditPayment@External@TechnicalServices@@U?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@@std@@QEAA@PEAUCreditPayment@External@TechnicalServices@@@Z DD 025052f01H
DD 01132318H
DD 0700c0021H
DD 0500bH
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$?catch$1@?0???$_Insert_string@DU?$char_traits@D@std@@_K@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@QEBD_K@Z@4HA DD 031001H
DD 0700c4210H
DD 0500bH
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$?dtor$0@?0???$_Insert_string@DU?$char_traits@D@std@@_K@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@QEBD_K@Z@4HA DD 031001H
DD 0700c4210H
DD 0500bH
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$ip2state$??$_Insert_string@DU?$char_traits@D@std@@_K@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@QEBD_K@Z DB 0aH
DB 00H
DB 00H
DB 0e1H, 03H
DB 02H
DB '<'
DB 04H
DB 0d5H, 0aH
DB 02H
DB 08aH
DB 00H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$handlerMap$??$_Insert_string@DU?$char_traits@D@std@@_K@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@QEBD_K@Z DB 02H
DB 01H
DB 080H
DD imagerel ?catch$1@?0???$_Insert_string@DU?$char_traits@D@std@@_K@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@QEBD_K@Z@4HA
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$tryMap$??$_Insert_string@DU?$char_traits@D@std@@_K@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@QEBD_K@Z DB 02H
DB 02H
DB 02H
DB 04H
DD imagerel $handlerMap$??$_Insert_string@DU?$char_traits@D@std@@_K@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@QEBD_K@Z
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$stateUnwindMap$??$_Insert_string@DU?$char_traits@D@std@@_K@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@QEBD_K@Z DB 06H
DB 0eH
DD imagerel ?dtor$0@?0???$_Insert_string@DU?$char_traits@D@std@@_K@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@QEBD_K@Z@4HA
DB 028H
DB 030H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$cppxdata$??$_Insert_string@DU?$char_traits@D@std@@_K@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@QEBD_K@Z DB 038H
DD imagerel $stateUnwindMap$??$_Insert_string@DU?$char_traits@D@std@@_K@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@QEBD_K@Z
DD imagerel $tryMap$??$_Insert_string@DU?$char_traits@D@std@@_K@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@QEBD_K@Z
DD imagerel $ip2state$??$_Insert_string@DU?$char_traits@D@std@@_K@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@QEBD_K@Z
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??$_Insert_string@DU?$char_traits@D@std@@_K@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@QEBD_K@Z DD 025054519H
DD 0118231dH
DD 070110043H
DD 05010H
DD imagerel __GSHandlerCheck_EH4
DD imagerel $cppxdata$??$_Insert_string@DU?$char_traits@D@std@@_K@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@QEBD_K@Z
DD 0203H
xdata ENDS
; COMDAT CONST
CONST SEGMENT
??$_Insert_string@DU?$char_traits@D@std@@_K@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@QEBD_K@Z$rtcName$0 DB 05fH ; std::_Insert_string<char,std::char_traits<char>,unsigned __int64>
DB 04fH
DB 06bH
DB 00H
ORG $+12
??$_Insert_string@DU?$char_traits@D@std@@_K@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@QEBD_K@Z$rtcVarDesc DD 068H ; std::_Insert_string<char,std::char_traits<char>,unsigned __int64>
DD 010H
DQ FLAT:??$_Insert_string@DU?$char_traits@D@std@@_K@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@QEBD_K@Z$rtcName$0
ORG $+48
??$_Insert_string@DU?$char_traits@D@std@@_K@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@QEBD_K@Z$rtcFrameData DD 01H ; std::_Insert_string<char,std::char_traits<char>,unsigned __int64>
DD 00H
DQ FLAT:??$_Insert_string@DU?$char_traits@D@std@@_K@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@QEBD_K@Z$rtcVarDesc
CONST ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??$forward@PEAU_Container_base12@std@@@std@@YA$$QEAPEAU_Container_base12@0@AEAPEAU10@@Z DD 025052a01H
DD 010e2313H
DD 07007001dH
DD 05006H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??$addressof@U_Container_proxy@std@@@std@@YAPEAU_Container_proxy@0@AEAU10@@Z DD 025052a01H
DD 010e2313H
DD 07007001dH
DD 05006H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??$_Get_size_of_n@$00@std@@YA_K_K@Z DD 025052a01H
DD 010e2313H
DD 070070021H
DD 05006H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$ip2state$??$_Deallocate@$0BA@$0A@@std@@YAXPEAX_K@Z DB 02H
DB 00H
DB 00H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$cppxdata$??$_Deallocate@$0BA@$0A@@std@@YAXPEAX_K@Z DB 060H
DD imagerel $ip2state$??$_Deallocate@$0BA@$0A@@std@@YAXPEAX_K@Z
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??$_Deallocate@$0BA@$0A@@std@@YAXPEAX_K@Z DD 025052f19H
DD 01132318H
DD 0700c001dH
DD 0500bH
DD imagerel __CxxFrameHandler4
DD imagerel $cppxdata$??$_Deallocate@$0BA@$0A@@std@@YAXPEAX_K@Z
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$ip2state$??$_Destroy_range@V?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@@std@@YAXPEAUPaymentOption@Persistence@TechnicalServices@@QEAU123@AEAV?$allocator@UPaymentOption@Persistence@TechnicalServices@@@0@@Z DB 02H
DB 00H
DB 00H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$cppxdata$??$_Destroy_range@V?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@@std@@YAXPEAUPaymentOption@Persistence@TechnicalServices@@QEAU123@AEAV?$allocator@UPaymentOption@Persistence@TechnicalServices@@@0@@Z DB 060H
DD imagerel $ip2state$??$_Destroy_range@V?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@@std@@YAXPEAUPaymentOption@Persistence@TechnicalServices@@QEAU123@AEAV?$allocator@UPaymentOption@Persistence@TechnicalServices@@@0@@Z
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??$_Destroy_range@V?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@@std@@YAXPEAUPaymentOption@Persistence@TechnicalServices@@QEAU123@AEAV?$allocator@UPaymentOption@Persistence@TechnicalServices@@@0@@Z DD 025053419H
DD 0118231dH
DD 07011001dH
DD 05010H
DD imagerel __CxxFrameHandler4
DD imagerel $cppxdata$??$_Destroy_range@V?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@@std@@YAXPEAUPaymentOption@Persistence@TechnicalServices@@QEAU123@AEAV?$allocator@UPaymentOption@Persistence@TechnicalServices@@@0@@Z
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??$_Allocate@$0BA@U_Default_allocate_traits@std@@$0A@@std@@YAPEAX_K@Z DD 025052a01H
DD 010e2313H
DD 07007001dH
DD 05006H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??$_Get_size_of_n@$0BA@@std@@YA_K_K@Z DD 025052a01H
DD 010e2313H
DD 070070025H
DD 05006H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??$max@_K@std@@YAAEB_KAEB_K0@Z DD 025052f01H
DD 01132318H
DD 0700c0021H
DD 0500bH
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??$_Unfancy@D@std@@YAPEADPEAD@Z DD 025052a01H
DD 010e2313H
DD 07007001dH
DD 05006H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??$_Construct_in_place@PEADAEBQEAD@std@@YAXAEAPEADAEBQEAD@Z DD 025052f01H
DD 01132318H
DD 0700c0021H
DD 0500bH
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??$_Pocca@V?$allocator@D@std@@@std@@YAXAEAV?$allocator@D@0@AEBV10@@Z DD 025052f01H
DD 01132318H
DD 0700c001dH
DD 0500bH
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??$_Reallocate_for@V<lambda_66f57f934f28d61049862f64df852ff0>@@PEBD@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@AEAAAEAV01@_KV<lambda_66f57f934f28d61049862f64df852ff0>@@PEBD@Z DD 025054a19H
DD 011d2322H
DD 07016002dH
DD 05015H
DD imagerel __GSHandlerCheck
DD 0158H
xdata ENDS
; COMDAT CONST
CONST SEGMENT
??$_Reallocate_for@V<lambda_66f57f934f28d61049862f64df852ff0>@@PEBD@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@AEAAAEAV01@_KV<lambda_66f57f934f28d61049862f64df852ff0>@@PEBD@Z$rtcName$0 DB 05fH ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::_Reallocate_for<<lambda_66f57f934f28d61049862f64df852ff0>,char const *>
DB 04eH
DB 065H
DB 077H
DB 05fH
DB 070H
DB 074H
DB 072H
DB 00H
ORG $+7
??$_Reallocate_for@V<lambda_66f57f934f28d61049862f64df852ff0>@@PEBD@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@AEAAAEAV01@_KV<lambda_66f57f934f28d61049862f64df852ff0>@@PEBD@Z$rtcVarDesc DD 088H ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::_Reallocate_for<<lambda_66f57f934f28d61049862f64df852ff0>,char const *>
DD 08H
DQ FLAT:??$_Reallocate_for@V<lambda_66f57f934f28d61049862f64df852ff0>@@PEBD@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@AEAAAEAV01@_KV<lambda_66f57f934f28d61049862f64df852ff0>@@PEBD@Z$rtcName$0
ORG $+48
??$_Reallocate_for@V<lambda_66f57f934f28d61049862f64df852ff0>@@PEBD@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@AEAAAEAV01@_KV<lambda_66f57f934f28d61049862f64df852ff0>@@PEBD@Z$rtcFrameData DD 01H ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::_Reallocate_for<<lambda_66f57f934f28d61049862f64df852ff0>,char const *>
DD 00H
DQ FLAT:??$_Reallocate_for@V<lambda_66f57f934f28d61049862f64df852ff0>@@PEBD@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@AEAAAEAV01@_KV<lambda_66f57f934f28d61049862f64df852ff0>@@PEBD@Z$rtcVarDesc
CONST ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??R<lambda_66f57f934f28d61049862f64df852ff0>@@QEBA@QEAD_KQEBD@Z DD 025053901H
DD 011d2322H
DD 070160021H
DD 05015H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??$_Destroy_in_place@PEAD@std@@YAXAEAPEAD@Z DD 025052a01H
DD 010e2313H
DD 07007001dH
DD 05006H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??$_Unfancy@U_Container_proxy@std@@@std@@YAPEAU_Container_proxy@0@PEAU10@@Z DD 025052a01H
DD 010e2313H
DD 07007001dH
DD 05006H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??$?0$$V@?$_Compressed_pair@V?$allocator@D@std@@V?$_String_val@U?$_Simple_types@D@std@@@2@$00@std@@QEAA@U_Zero_then_variadic_args_t@1@@Z DD 025052e01H
DD 01122317H
DD 0700b001dH
DD 0500aH
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??$?0D@?$allocator@U_Container_proxy@std@@@std@@QEAA@AEBV?$allocator@D@1@@Z DD 025052f01H
DD 01132318H
DD 0700c001dH
DD 0500bH
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??$addressof@$$CBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@@std@@YAPEBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@0@AEBV10@@Z DD 025052a01H
DD 010e2313H
DD 07007001dH
DD 05006H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??$_Alloc_proxy@V?$allocator@U_Container_proxy@std@@@std@@@_Container_base12@std@@QEAAX$$QEAV?$allocator@U_Container_proxy@std@@@1@@Z DD 025052f01H
DD 01132318H
DD 0700c0025H
DD 0500bH
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??$min@_K@std@@YAAEB_KAEB_K0@Z DD 025052f01H
DD 01132318H
DD 0700c0021H
DD 0500bH
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??Bsentry@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEBA_NXZ DD 025052a01H
DD 010e2313H
DD 07007001dH
DD 05006H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$ip2state$??1sentry@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAA@XZ DB 02H
DB 00H
DB 00H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$cppxdata$??1sentry@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAA@XZ DB 060H
DD imagerel $ip2state$??1sentry@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAA@XZ
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??1sentry@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAA@XZ DD 025052a19H
DD 010e2313H
DD 070070021H
DD 05006H
DD imagerel __CxxFrameHandler4
DD imagerel $cppxdata$??1sentry@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAA@XZ
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$?dtor$0@?0???0sentry@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAA@AEAV12@@Z@4HA DD 031001H
DD 0700c4210H
DD 0500bH
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$ip2state$??0sentry@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAA@AEAV12@@Z DB 06H
DB 00H
DB 00H
DB 09eH
DB 02H
DB 0f1H, 02H
DB 00H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$stateUnwindMap$??0sentry@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAA@AEAV12@@Z DB 02H
DB 0eH
DD imagerel ?dtor$0@?0???0sentry@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAA@AEAV12@@Z@4HA
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$cppxdata$??0sentry@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAA@AEAV12@@Z DB 028H
DD imagerel $stateUnwindMap$??0sentry@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAA@AEAV12@@Z
DD imagerel $ip2state$??0sentry@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAA@AEAV12@@Z
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??0sentry@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAA@AEAV12@@Z DD 025052f11H
DD 01132318H
DD 0700c0021H
DD 0500bH
DD imagerel __CxxFrameHandler4
DD imagerel $cppxdata$??0sentry@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAA@AEAV12@@Z
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$ip2state$??1_Sentry_base@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAA@XZ DB 02H
DB 00H
DB 00H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$cppxdata$??1_Sentry_base@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAA@XZ DB 060H
DD imagerel $ip2state$??1_Sentry_base@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAA@XZ
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??1_Sentry_base@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAA@XZ DD 025052a19H
DD 010e2313H
DD 070070021H
DD 05006H
DD imagerel __CxxFrameHandler4
DD imagerel $cppxdata$??1_Sentry_base@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAA@XZ
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??0_Sentry_base@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAA@AEAV12@@Z DD 025052f01H
DD 01132318H
DD 0700c0021H
DD 0500bH
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??$_Delete_plain_internal@V?$allocator@U_Container_proxy@std@@@std@@@std@@YAXAEAV?$allocator@U_Container_proxy@std@@@0@QEAU_Container_proxy@0@@Z DD 025052f01H
DD 01132318H
DD 0700c001dH
DD 0500bH
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??$exchange@PEAU_Container_proxy@std@@$$T@std@@YAPEAU_Container_proxy@0@AEAPEAU10@$$QEA$$T@Z DD 025052f01H
DD 01132318H
DD 0700c0021H
DD 0500bH
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??$?0UPaymentOption@Persistence@TechnicalServices@@@?$allocator@U_Container_proxy@std@@@std@@QEAA@AEBV?$allocator@UPaymentOption@Persistence@TechnicalServices@@@1@@Z DD 025052f01H
DD 01132318H
DD 0700c001dH
DD 0500bH
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$?allocate@?$allocator@U_Container_proxy@std@@@std@@QEAAPEAU_Container_proxy@2@_K@Z DD 025052f01H
DD 01132318H
DD 0700c001dH
DD 0500bH
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??$?0UGatewayPayment@External@TechnicalServices@@U?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@$0A@@?$unique_ptr@VPaymentHandlerInterface@External@TechnicalServices@@U?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@@std@@QEAA@$$QEAV?$unique_ptr@UGatewayPayment@External@TechnicalServices@@U?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@@1@@Z DD 025052f01H
DD 01132318H
DD 0700c002bH
DD 0500bH
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??$?0UGatewayPayment@External@TechnicalServices@@$0A@@?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@QEAA@AEBU?$default_delete@UGatewayPayment@External@TechnicalServices@@@1@@Z DD 025052f01H
DD 01132318H
DD 0700c001dH
DD 0500bH
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$?_Get_first@?$_Compressed_pair@U?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@PEAUGatewayPayment@External@TechnicalServices@@$00@std@@QEAAAEAU?$default_delete@UGatewayPayment@External@TechnicalServices@@@2@XZ DD 025052a01H
DD 010e2313H
DD 07007001dH
DD 05006H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$?release@?$unique_ptr@UGatewayPayment@External@TechnicalServices@@U?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@@std@@QEAAPEAUGatewayPayment@External@TechnicalServices@@XZ DD 025052a01H
DD 010e2313H
DD 070070021H
DD 05006H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$?get_deleter@?$unique_ptr@UGatewayPayment@External@TechnicalServices@@U?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@@std@@QEAAAEAU?$default_delete@UGatewayPayment@External@TechnicalServices@@@2@XZ DD 025052a01H
DD 010e2313H
DD 07007001dH
DD 05006H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??1?$unique_ptr@UGatewayPayment@External@TechnicalServices@@U?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@@std@@QEAA@XZ DD 025052a01H
DD 010e2313H
DD 07007001fH
DD 05006H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??R?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@QEBAXPEAUGatewayPayment@External@TechnicalServices@@@Z DD 025052f01H
DD 01132318H
DD 0700c0023H
DD 0500bH
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??$make_unique@UGatewayPayment@External@TechnicalServices@@$$V$0A@@std@@YA?AV?$unique_ptr@UGatewayPayment@External@TechnicalServices@@U?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@@0@XZ DD 025052a01H
DD 010e2313H
DD 070070025H
DD 05006H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??$?0UDebitPayment@External@TechnicalServices@@U?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@$0A@@?$unique_ptr@VPaymentHandlerInterface@External@TechnicalServices@@U?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@@std@@QEAA@$$QEAV?$unique_ptr@UDebitPayment@External@TechnicalServices@@U?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@@1@@Z DD 025052f01H
DD 01132318H
DD 0700c002bH
DD 0500bH
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??$?0UDebitPayment@External@TechnicalServices@@$0A@@?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@QEAA@AEBU?$default_delete@UDebitPayment@External@TechnicalServices@@@1@@Z DD 025052f01H
DD 01132318H
DD 0700c001dH
DD 0500bH
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$?_Get_first@?$_Compressed_pair@U?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@PEAUDebitPayment@External@TechnicalServices@@$00@std@@QEAAAEAU?$default_delete@UDebitPayment@External@TechnicalServices@@@2@XZ DD 025052a01H
DD 010e2313H
DD 07007001dH
DD 05006H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$?release@?$unique_ptr@UDebitPayment@External@TechnicalServices@@U?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@@std@@QEAAPEAUDebitPayment@External@TechnicalServices@@XZ DD 025052a01H
DD 010e2313H
DD 070070021H
DD 05006H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$?get_deleter@?$unique_ptr@UDebitPayment@External@TechnicalServices@@U?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@@std@@QEAAAEAU?$default_delete@UDebitPayment@External@TechnicalServices@@@2@XZ DD 025052a01H
DD 010e2313H
DD 07007001dH
DD 05006H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??1?$unique_ptr@UDebitPayment@External@TechnicalServices@@U?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@@std@@QEAA@XZ DD 025052a01H
DD 010e2313H
DD 07007001fH
DD 05006H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??R?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@QEBAXPEAUDebitPayment@External@TechnicalServices@@@Z DD 025052f01H
DD 01132318H
DD 0700c0023H
DD 0500bH
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??$make_unique@UDebitPayment@External@TechnicalServices@@$$V$0A@@std@@YA?AV?$unique_ptr@UDebitPayment@External@TechnicalServices@@U?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@@0@XZ DD 025052a01H
DD 010e2313H
DD 070070025H
DD 05006H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??$?0UCreditPayment@External@TechnicalServices@@U?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@$0A@@?$unique_ptr@VPaymentHandlerInterface@External@TechnicalServices@@U?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@@std@@QEAA@$$QEAV?$unique_ptr@UCreditPayment@External@TechnicalServices@@U?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@@1@@Z DD 025052f01H
DD 01132318H
DD 0700c002bH
DD 0500bH
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??$?0UCreditPayment@External@TechnicalServices@@$0A@@?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@QEAA@AEBU?$default_delete@UCreditPayment@External@TechnicalServices@@@1@@Z DD 025052f01H
DD 01132318H
DD 0700c001dH
DD 0500bH
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$?_Get_first@?$_Compressed_pair@U?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@PEAUCreditPayment@External@TechnicalServices@@$00@std@@QEAAAEAU?$default_delete@UCreditPayment@External@TechnicalServices@@@2@XZ DD 025052a01H
DD 010e2313H
DD 07007001dH
DD 05006H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$?release@?$unique_ptr@UCreditPayment@External@TechnicalServices@@U?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@@std@@QEAAPEAUCreditPayment@External@TechnicalServices@@XZ DD 025052a01H
DD 010e2313H
DD 070070021H
DD 05006H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$?get_deleter@?$unique_ptr@UCreditPayment@External@TechnicalServices@@U?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@@std@@QEAAAEAU?$default_delete@UCreditPayment@External@TechnicalServices@@@2@XZ DD 025052a01H
DD 010e2313H
DD 07007001dH
DD 05006H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??1?$unique_ptr@UCreditPayment@External@TechnicalServices@@U?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@@std@@QEAA@XZ DD 025052a01H
DD 010e2313H
DD 07007001fH
DD 05006H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??R?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@QEBAXPEAUCreditPayment@External@TechnicalServices@@@Z DD 025052f01H
DD 01132318H
DD 0700c0023H
DD 0500bH
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??$make_unique@UCreditPayment@External@TechnicalServices@@$$V$0A@@std@@YA?AV?$unique_ptr@UCreditPayment@External@TechnicalServices@@U?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@@0@XZ DD 025052a01H
DD 010e2313H
DD 070070025H
DD 05006H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??$?8DU?$char_traits@D@std@@V?$allocator@D@1@@std@@YA_NAEBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@0@QEBD@Z DD 025052f01H
DD 01132318H
DD 0700c001dH
DD 0500bH
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??$?6DU?$char_traits@D@std@@V?$allocator@D@1@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@AEBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@0@@Z DD 025052f01H
DD 01132318H
DD 0700c001fH
DD 0500bH
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??$?6DU?$char_traits@D@std@@_J@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@AEBU?$_Smanip@_J@0@@Z DD 025052f01H
DD 01132318H
DD 0700c001fH
DD 0500bH
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$?catch$1@?0???$?6U?$char_traits@D@std@@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@D@Z@4HA DD 031001H
DD 0700c4210H
DD 0500bH
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$?dtor$0@?0???$?6U?$char_traits@D@std@@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@D@Z@4HA DD 031001H
DD 0700c4210H
DD 0500bH
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$ip2state$??$?6U?$char_traits@D@std@@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@D@Z DB 0aH
DB 00H
DB 00H
DB 0c6H
DB 02H
DB 011H, 02H
DB 04H
DB 0adH, 0aH
DB 02H
DB 0ecH
DB 00H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$handlerMap$??$?6U?$char_traits@D@std@@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@D@Z DB 02H
DB 01H
DB 080H
DD imagerel ?catch$1@?0???$?6U?$char_traits@D@std@@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@D@Z@4HA
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$tryMap$??$?6U?$char_traits@D@std@@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@D@Z DB 02H
DB 02H
DB 02H
DB 04H
DD imagerel $handlerMap$??$?6U?$char_traits@D@std@@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@D@Z
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$stateUnwindMap$??$?6U?$char_traits@D@std@@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@D@Z DB 06H
DB 0eH
DD imagerel ?dtor$0@?0???$?6U?$char_traits@D@std@@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@D@Z@4HA
DB 028H
DB 030H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$cppxdata$??$?6U?$char_traits@D@std@@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@D@Z DB 038H
DD imagerel $stateUnwindMap$??$?6U?$char_traits@D@std@@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@D@Z
DD imagerel $tryMap$??$?6U?$char_traits@D@std@@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@D@Z
DD imagerel $ip2state$??$?6U?$char_traits@D@std@@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@D@Z
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??$?6U?$char_traits@D@std@@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@D@Z DD 025053f19H
DD 01122317H
DD 0700b004bH
DD 0500aH
DD imagerel __GSHandlerCheck_EH4
DD imagerel $cppxdata$??$?6U?$char_traits@D@std@@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@D@Z
DD 0243H
xdata ENDS
; COMDAT CONST
CONST SEGMENT
??$?6U?$char_traits@D@std@@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@D@Z$rtcName$0 DB 05fH ; std::operator<<<std::char_traits<char> >
DB 04fH
DB 06bH
DB 00H
ORG $+12
??$?6U?$char_traits@D@std@@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@D@Z$rtcVarDesc DD 048H ; std::operator<<<std::char_traits<char> >
DD 010H
DQ FLAT:??$?6U?$char_traits@D@std@@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@D@Z$rtcName$0
ORG $+48
??$?6U?$char_traits@D@std@@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@D@Z$rtcFrameData DD 01H ; std::operator<<<std::char_traits<char> >
DD 00H
DQ FLAT:??$?6U?$char_traits@D@std@@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@D@Z$rtcVarDesc
CONST ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$?catch$1@?0???$?6U?$char_traits@D@std@@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@PEBD@Z@4HA DD 031001H
DD 0700c4210H
DD 0500bH
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$?dtor$0@?0???$?6U?$char_traits@D@std@@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@PEBD@Z@4HA DD 031001H
DD 0700c4210H
DD 0500bH
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$ip2state$??$?6U?$char_traits@D@std@@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@PEBD@Z DB 0aH
DB 00H
DB 00H
DB '9', 04H
DB 02H
DB '<'
DB 04H
DB 0d1H, 0aH
DB 02H
DB 08aH
DB 00H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$handlerMap$??$?6U?$char_traits@D@std@@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@PEBD@Z DB 02H
DB 01H
DB 080H
DD imagerel ?catch$1@?0???$?6U?$char_traits@D@std@@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@PEBD@Z@4HA
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$tryMap$??$?6U?$char_traits@D@std@@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@PEBD@Z DB 02H
DB 02H
DB 02H
DB 04H
DD imagerel $handlerMap$??$?6U?$char_traits@D@std@@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@PEBD@Z
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$stateUnwindMap$??$?6U?$char_traits@D@std@@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@PEBD@Z DB 06H
DB 0eH
DD imagerel ?dtor$0@?0???$?6U?$char_traits@D@std@@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@PEBD@Z@4HA
DB 028H
DB 030H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$cppxdata$??$?6U?$char_traits@D@std@@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@PEBD@Z DB 038H
DD imagerel $stateUnwindMap$??$?6U?$char_traits@D@std@@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@PEBD@Z
DD imagerel $tryMap$??$?6U?$char_traits@D@std@@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@PEBD@Z
DD imagerel $ip2state$??$?6U?$char_traits@D@std@@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@PEBD@Z
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??$?6U?$char_traits@D@std@@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@PEBD@Z DD 025054019H
DD 01132318H
DD 0700c0047H
DD 0500bH
DD imagerel __GSHandlerCheck_EH4
DD imagerel $cppxdata$??$?6U?$char_traits@D@std@@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@PEBD@Z
DD 0223H
xdata ENDS
; COMDAT CONST
CONST SEGMENT
??$?6U?$char_traits@D@std@@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@PEBD@Z$rtcName$0 DB 05fH ; std::operator<<<std::char_traits<char> >
DB 04fH
DB 06bH
DB 00H
ORG $+12
??$?6U?$char_traits@D@std@@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@PEBD@Z$rtcVarDesc DD 088H ; std::operator<<<std::char_traits<char> >
DD 010H
DQ FLAT:??$?6U?$char_traits@D@std@@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@PEBD@Z$rtcName$0
ORG $+48
??$?6U?$char_traits@D@std@@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@PEBD@Z$rtcFrameData DD 01H ; std::operator<<<std::char_traits<char> >
DD 00H
DQ FLAT:??$?6U?$char_traits@D@std@@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@PEBD@Z$rtcVarDesc
CONST ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$?__autoclassinit2@?$vector@UPaymentOption@Persistence@TechnicalServices@@V?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@@std@@QEAAX_K@Z DD 05052d01H
DD 01130316H
DD 0700c0019H
DD 0500bH
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$?_Get_first@?$_Compressed_pair@V?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@V?$_Vector_val@U?$_Simple_types@UPaymentOption@Persistence@TechnicalServices@@@std@@@2@$00@std@@QEAAAEAV?$allocator@UPaymentOption@Persistence@TechnicalServices@@@2@XZ DD 025052a01H
DD 010e2313H
DD 07007001dH
DD 05006H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$?_Getal@?$vector@UPaymentOption@Persistence@TechnicalServices@@V?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@@std@@AEAAAEAV?$allocator@UPaymentOption@Persistence@TechnicalServices@@@2@XZ DD 025052a01H
DD 010e2313H
DD 07007001dH
DD 05006H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$ip2state$?_Tidy@?$vector@UPaymentOption@Persistence@TechnicalServices@@V?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@@std@@AEAAXXZ DB 02H
DB 00H
DB 00H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$cppxdata$?_Tidy@?$vector@UPaymentOption@Persistence@TechnicalServices@@V?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@@std@@AEAAXXZ DB 060H
DD imagerel $ip2state$?_Tidy@?$vector@UPaymentOption@Persistence@TechnicalServices@@V?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@@std@@AEAAXXZ
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$?_Tidy@?$vector@UPaymentOption@Persistence@TechnicalServices@@V?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@@std@@AEAAXXZ DD 025052a19H
DD 010e2313H
DD 07007002fH
DD 05006H
DD imagerel __CxxFrameHandler4
DD imagerel $cppxdata$?_Tidy@?$vector@UPaymentOption@Persistence@TechnicalServices@@V?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@@std@@AEAAXXZ
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$?_Destroy@?$vector@UPaymentOption@Persistence@TechnicalServices@@V?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@@std@@AEAAXPEAUPaymentOption@Persistence@TechnicalServices@@0@Z DD 025053401H
DD 0118231dH
DD 07011001dH
DD 05010H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??A?$vector@UPaymentOption@Persistence@TechnicalServices@@V?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@@std@@QEAAAEAUPaymentOption@Persistence@TechnicalServices@@_K@Z DD 035052f01H
DD 01133318H
DD 0700c0023H
DD 0500bH
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$?size@?$vector@UPaymentOption@Persistence@TechnicalServices@@V?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@@std@@QEBA_KXZ DD 025052a01H
DD 010e2313H
DD 070070021H
DD 05006H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??1?$vector@UPaymentOption@Persistence@TechnicalServices@@V?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@@std@@QEAA@XZ DD 025053b19H
DD 010e2313H
DD 070070029H
DD 05006H
DD imagerel __GSHandlerCheck
DD 0138H
xdata ENDS
; COMDAT CONST
CONST SEGMENT
??1?$vector@UPaymentOption@Persistence@TechnicalServices@@V?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@@std@@QEAA@XZ$rtcName$0 DB 024H ; std::vector<TechnicalServices::Persistence::PaymentOption,std::allocator<TechnicalServices::Persistence::PaymentOption> >::~vector<TechnicalServices::Persistence::PaymentOption,std::allocator<TechnicalServices::Persistence::PaymentOption> >
DB 053H
DB 031H
DB 00H
ORG $+12
??1?$vector@UPaymentOption@Persistence@TechnicalServices@@V?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@@std@@QEAA@XZ$rtcVarDesc DD 044H ; std::vector<TechnicalServices::Persistence::PaymentOption,std::allocator<TechnicalServices::Persistence::PaymentOption> >::~vector<TechnicalServices::Persistence::PaymentOption,std::allocator<TechnicalServices::Persistence::PaymentOption> >
DD 01H
DQ FLAT:??1?$vector@UPaymentOption@Persistence@TechnicalServices@@V?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@@std@@QEAA@XZ$rtcName$0
ORG $+48
??1?$vector@UPaymentOption@Persistence@TechnicalServices@@V?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@@std@@QEAA@XZ$rtcFrameData DD 01H ; std::vector<TechnicalServices::Persistence::PaymentOption,std::allocator<TechnicalServices::Persistence::PaymentOption> >::~vector<TechnicalServices::Persistence::PaymentOption,std::allocator<TechnicalServices::Persistence::PaymentOption> >
DD 00H
DQ FLAT:??1?$vector@UPaymentOption@Persistence@TechnicalServices@@V?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@@std@@QEAA@XZ$rtcVarDesc
CONST ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$?deallocate@?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@QEAAXQEAUPaymentOption@Persistence@TechnicalServices@@_K@Z DD 025053401H
DD 0118231dH
DD 07011001dH
DD 05010H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??_GGatewayPayment@External@TechnicalServices@@UEAAPEAXI@Z DD 025052e01H
DD 01122317H
DD 0700b001dH
DD 0500aH
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??1GatewayPayment@External@TechnicalServices@@UEAA@XZ DD 025052a01H
DD 010e2313H
DD 07007001dH
DD 05006H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??0GatewayPayment@External@TechnicalServices@@QEAA@XZ DD 025052a01H
DD 010e2313H
DD 07007001dH
DD 05006H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??_GDebitPayment@External@TechnicalServices@@UEAAPEAXI@Z DD 025052e01H
DD 01122317H
DD 0700b001dH
DD 0500aH
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??1DebitPayment@External@TechnicalServices@@UEAA@XZ DD 025052a01H
DD 010e2313H
DD 07007001dH
DD 05006H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??0DebitPayment@External@TechnicalServices@@QEAA@XZ DD 025052a01H
DD 010e2313H
DD 07007001dH
DD 05006H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??_GCreditPayment@External@TechnicalServices@@UEAAPEAXI@Z DD 025052e01H
DD 01122317H
DD 0700b001dH
DD 0500aH
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??1CreditPayment@External@TechnicalServices@@UEAA@XZ DD 025052a01H
DD 010e2313H
DD 07007001dH
DD 05006H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??0CreditPayment@External@TechnicalServices@@QEAA@XZ DD 025052a01H
DD 010e2313H
DD 07007001dH
DD 05006H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??0PaymentHandlerInterface@External@TechnicalServices@@QEAA@XZ DD 05052801H
DD 010e0311H
DD 070070019H
DD 05006H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??1PaymentHandlerInterface@External@TechnicalServices@@UEAA@XZ DD 025052a01H
DD 010e2313H
DD 07007001dH
DD 05006H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$?dtor$1@?0??PaySystemFactory@PaymentHandlerInterface@External@TechnicalServices@@SA?AV?$unique_ptr@VPaymentHandlerInterface@External@TechnicalServices@@U?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@@std@@XZ@4HA DD 031001H
DD 0700c4210H
DD 0500bH
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$?dtor$0@?0??PaySystemFactory@PaymentHandlerInterface@External@TechnicalServices@@SA?AV?$unique_ptr@VPaymentHandlerInterface@External@TechnicalServices@@U?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@@std@@XZ@4HA DD 031001H
DD 0700c4210H
DD 0500bH
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$ip2state$?PaySystemFactory@PaymentHandlerInterface@External@TechnicalServices@@SA?AV?$unique_ptr@VPaymentHandlerInterface@External@TechnicalServices@@U?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@@std@@XZ DB 01aH
DB 00H
DB 00H
DB '%', 02H
DB 02H
DB 014H
DB 04H
DB 0a1H, 07H
DB 02H
DB 014H
DB 00H
DB '*'
DB 04H
DB 0b2H
DB 02H
DB 014H
DB 00H
DB '*'
DB 04H
DB 0b2H
DB 02H
DB 014H
DB 00H
DB '$'
DB 02H
DB 014H
DB 00H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$stateUnwindMap$?PaySystemFactory@PaymentHandlerInterface@External@TechnicalServices@@SA?AV?$unique_ptr@VPaymentHandlerInterface@External@TechnicalServices@@U?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@@std@@XZ DB 04H
DB 0eH
DD imagerel ?dtor$0@?0??PaySystemFactory@PaymentHandlerInterface@External@TechnicalServices@@SA?AV?$unique_ptr@VPaymentHandlerInterface@External@TechnicalServices@@U?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@@std@@XZ@4HA
DB 02eH
DD imagerel ?dtor$1@?0??PaySystemFactory@PaymentHandlerInterface@External@TechnicalServices@@SA?AV?$unique_ptr@VPaymentHandlerInterface@External@TechnicalServices@@U?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@@std@@XZ@4HA
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$cppxdata$?PaySystemFactory@PaymentHandlerInterface@External@TechnicalServices@@SA?AV?$unique_ptr@VPaymentHandlerInterface@External@TechnicalServices@@U?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@@std@@XZ DB 028H
DD imagerel $stateUnwindMap$?PaySystemFactory@PaymentHandlerInterface@External@TechnicalServices@@SA?AV?$unique_ptr@VPaymentHandlerInterface@External@TechnicalServices@@U?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@@std@@XZ
DD imagerel $ip2state$?PaySystemFactory@PaymentHandlerInterface@External@TechnicalServices@@SA?AV?$unique_ptr@VPaymentHandlerInterface@External@TechnicalServices@@U?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@@std@@XZ
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$?PaySystemFactory@PaymentHandlerInterface@External@TechnicalServices@@SA?AV?$unique_ptr@VPaymentHandlerInterface@External@TechnicalServices@@U?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@@std@@XZ DD 025053b19H
DD 010e2313H
DD 070070055H
DD 05006H
DD imagerel __GSHandlerCheck_EH4
DD imagerel $cppxdata$?PaySystemFactory@PaymentHandlerInterface@External@TechnicalServices@@SA?AV?$unique_ptr@VPaymentHandlerInterface@External@TechnicalServices@@U?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@@std@@XZ
DD 0292H
xdata ENDS
; COMDAT CONST
CONST SEGMENT
?PaySystemFactory@PaymentHandlerInterface@External@TechnicalServices@@SA?AV?$unique_ptr@VPaymentHandlerInterface@External@TechnicalServices@@U?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@@std@@XZ$rtcName$0 DB 050H ; TechnicalServices::External::PaymentHandlerInterface::PaySystemFactory
DB 061H
DB 079H
DB 04fH
DB 070H
DB 073H
DB 00H
ORG $+1
?PaySystemFactory@PaymentHandlerInterface@External@TechnicalServices@@SA?AV?$unique_ptr@VPaymentHandlerInterface@External@TechnicalServices@@U?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@@std@@XZ$rtcName$1 DB 073H ; TechnicalServices::External::PaymentHandlerInterface::PaySystemFactory
DB 065H
DB 06cH
DB 065H
DB 063H
DB 074H
DB 065H
DB 064H
DB 050H
DB 061H
DB 079H
DB 06dH
DB 065H
DB 074H
DB 068H
DB 06fH
DB 064H
DB 00H
ORG $+6
?PaySystemFactory@PaymentHandlerInterface@External@TechnicalServices@@SA?AV?$unique_ptr@VPaymentHandlerInterface@External@TechnicalServices@@U?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@@std@@XZ$rtcName$2 DB 06dH ; TechnicalServices::External::PaymentHandlerInterface::PaySystemFactory
DB 065H
DB 06eH
DB 075H
DB 050H
DB 061H
DB 079H
DB 053H
DB 065H
DB 06cH
DB 065H
DB 063H
DB 074H
DB 069H
DB 06fH
DB 06eH
DB 00H
ORG $+15
?PaySystemFactory@PaymentHandlerInterface@External@TechnicalServices@@SA?AV?$unique_ptr@VPaymentHandlerInterface@External@TechnicalServices@@U?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@@std@@XZ$rtcVarDesc DD 0c4H ; TechnicalServices::External::PaymentHandlerInterface::PaySystemFactory
DD 04H
DQ FLAT:?PaySystemFactory@PaymentHandlerInterface@External@TechnicalServices@@SA?AV?$unique_ptr@VPaymentHandlerInterface@External@TechnicalServices@@U?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@@std@@XZ$rtcName$2
DD 088H
DD 028H
DQ FLAT:?PaySystemFactory@PaymentHandlerInterface@External@TechnicalServices@@SA?AV?$unique_ptr@VPaymentHandlerInterface@External@TechnicalServices@@U?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@@std@@XZ$rtcName$1
DD 048H
DD 020H
DQ FLAT:?PaySystemFactory@PaymentHandlerInterface@External@TechnicalServices@@SA?AV?$unique_ptr@VPaymentHandlerInterface@External@TechnicalServices@@U?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@@std@@XZ$rtcName$0
ORG $+144
?PaySystemFactory@PaymentHandlerInterface@External@TechnicalServices@@SA?AV?$unique_ptr@VPaymentHandlerInterface@External@TechnicalServices@@U?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@@std@@XZ$rtcFrameData DD 03H ; TechnicalServices::External::PaymentHandlerInterface::PaySystemFactory
DD 00H
DQ FLAT:?PaySystemFactory@PaymentHandlerInterface@External@TechnicalServices@@SA?AV?$unique_ptr@VPaymentHandlerInterface@External@TechnicalServices@@U?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@@std@@XZ$rtcVarDesc
CONST ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??_GPaymentOption@Persistence@TechnicalServices@@QEAAPEAXI@Z DD 025052e01H
DD 01122317H
DD 0700b001dH
DD 0500aH
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??1PaymentOption@Persistence@TechnicalServices@@QEAA@XZ DD 025052a01H
DD 010e2313H
DD 07007001dH
DD 05006H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??$_Getvals@_W@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@IEAAX_WAEBV_Locinfo@1@@Z DD 025063501H
DD 0119231eH
DD 070120026H
DD 050106011H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??$_Getvals@_W@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@IEAAX_WAEBV_Locinfo@1@@Z DD 025063501H
DD 0119231eH
DD 070120026H
DD 050106011H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??$_Maklocstr@D@std@@YAPEADPEBDPEADAEBU_Cvtvec@@@Z DD 035053401H
DD 0118331dH
DD 07011002bH
DD 05010H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$?_Maklocwcs@std@@YAPEA_WPEB_W@Z DD 035052a01H
DD 010e3313H
DD 070070027H
DD 05006H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??$_Maklocstr@_W@std@@YAPEA_WPEBDPEA_WAEBU_Cvtvec@@@Z DD 035054519H
DD 0118331dH
DD 070110047H
DD 05010H
DD imagerel __GSHandlerCheck
DD 0228H
xdata ENDS
; COMDAT CONST
CONST SEGMENT
??$_Maklocstr@_W@std@@YAPEA_WPEBDPEA_WAEBU_Cvtvec@@@Z$rtcName$0 DB 05fH ; std::_Maklocstr<wchar_t>
DB 057H
DB 063H
DB 00H
??$_Maklocstr@_W@std@@YAPEA_WPEBDPEA_WAEBU_Cvtvec@@@Z$rtcName$1 DB 05fH ; std::_Maklocstr<wchar_t>
DB 04dH
DB 062H
DB 073H
DB 074H
DB 031H
DB 00H
ORG $+1
??$_Maklocstr@_W@std@@YAPEA_WPEBDPEA_WAEBU_Cvtvec@@@Z$rtcName$2 DB 05fH ; std::_Maklocstr<wchar_t>
DB 04dH
DB 062H
DB 073H
DB 074H
DB 032H
DB 00H
ORG $+13
??$_Maklocstr@_W@std@@YAPEA_WPEBDPEA_WAEBU_Cvtvec@@@Z$rtcVarDesc DD 0158H ; std::_Maklocstr<wchar_t>
DD 08H
DQ FLAT:??$_Maklocstr@_W@std@@YAPEA_WPEBDPEA_WAEBU_Cvtvec@@@Z$rtcName$2
DD 0f8H
DD 08H
DQ FLAT:??$_Maklocstr@_W@std@@YAPEA_WPEBDPEA_WAEBU_Cvtvec@@@Z$rtcName$1
DD 0d4H
DD 02H
DQ FLAT:??$_Maklocstr@_W@std@@YAPEA_WPEBDPEA_WAEBU_Cvtvec@@@Z$rtcName$0
ORG $+144
??$_Maklocstr@_W@std@@YAPEA_WPEBDPEA_WAEBU_Cvtvec@@@Z$rtcFrameData DD 03H ; std::_Maklocstr<wchar_t>
DD 00H
DQ FLAT:??$_Maklocstr@_W@std@@YAPEA_WPEBDPEA_WAEBU_Cvtvec@@@Z$rtcVarDesc
CONST ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??1?$_Compressed_pair@V?$allocator@D@std@@V?$_String_val@U?$_Simple_types@D@std@@@2@$00@std@@QEAA@XZ DD 025052a01H
DD 010e2313H
DD 07007001dH
DD 05006H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$?_Get_first@?$_Compressed_pair@V?$allocator@D@std@@V?$_String_val@U?$_Simple_types@D@std@@@2@$00@std@@QEBAAEBV?$allocator@D@2@XZ DD 025052a01H
DD 010e2313H
DD 07007001dH
DD 05006H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$?_Get_first@?$_Compressed_pair@V?$allocator@D@std@@V?$_String_val@U?$_Simple_types@D@std@@@2@$00@std@@QEAAAEAV?$allocator@D@2@XZ DD 025052a01H
DD 010e2313H
DD 07007001dH
DD 05006H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$?_Getal@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@AEBAAEBV?$allocator@D@2@XZ DD 025052a01H
DD 010e2313H
DD 07007001dH
DD 05006H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$?_Getal@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@AEAAAEAV?$allocator@D@2@XZ DD 025052a01H
DD 010e2313H
DD 07007001dH
DD 05006H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$ip2state$?_Tidy_deallocate@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@AEAAXXZ DB 02H
DB 00H
DB 00H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$cppxdata$?_Tidy_deallocate@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@AEAAXXZ DB 060H
DD imagerel $ip2state$?_Tidy_deallocate@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@AEAAXXZ
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$?_Tidy_deallocate@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@AEAAXXZ DD 025052a19H
DD 010e2313H
DD 070070029H
DD 05006H
DD imagerel __CxxFrameHandler4
DD imagerel $cppxdata$?_Tidy_deallocate@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@AEAAXXZ
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$?_Tidy_init@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@AEAAXXZ DD 025052a01H
DD 010e2313H
DD 070070021H
DD 05006H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$?_Calculate_growth@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@AEBA_K_K@Z DD 025052f01H
DD 01132318H
DD 0700c001fH
DD 0500bH
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$?_Calculate_growth@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@CA_K_K00@Z DD 025054519H
DD 0118231dH
DD 070110025H
DD 05010H
DD imagerel __GSHandlerCheck
DD 0118H
xdata ENDS
; COMDAT CONST
CONST SEGMENT
?_Calculate_growth@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@CA_K_K00@Z$rtcName$0 DB 05fH ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::_Calculate_growth
DB 04dH
DB 061H
DB 073H
DB 06bH
DB 065H
DB 064H
DB 00H
ORG $+8
?_Calculate_growth@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@CA_K_K00@Z$rtcVarDesc DD 028H ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::_Calculate_growth
DD 08H
DQ FLAT:?_Calculate_growth@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@CA_K_K00@Z$rtcName$0
ORG $+48
?_Calculate_growth@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@CA_K_K00@Z$rtcFrameData DD 01H ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::_Calculate_growth
DD 00H
DQ FLAT:?_Calculate_growth@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@CA_K_K00@Z$rtcVarDesc
CONST ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$?_Equal@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEBA_NQEBD@Z DD 025052f01H
DD 01132318H
DD 0700c0021H
DD 0500bH
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$?max_size@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEBA_KXZ DD 025053b19H
DD 010e2313H
DD 070070031H
DD 05006H
DD imagerel __GSHandlerCheck
DD 0178H
xdata ENDS
; COMDAT CONST
CONST SEGMENT
?max_size@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEBA_KXZ$rtcName$0 DB 05fH ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::max_size
DB 041H
DB 06cH
DB 06cH
DB 06fH
DB 063H
DB 05fH
DB 06dH
DB 061H
DB 078H
DB 00H
ORG $+5
?max_size@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEBA_KXZ$rtcVarDesc DD 028H ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::max_size
DD 08H
DQ FLAT:?max_size@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEBA_KXZ$rtcName$0
ORG $+48
?max_size@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEBA_KXZ$rtcFrameData DD 01H ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::max_size
DD 00H
DQ FLAT:?max_size@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEBA_KXZ$rtcVarDesc
CONST ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$?size@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEBA_KXZ DD 025052a01H
DD 010e2313H
DD 07007001dH
DD 05006H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$?data@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEBAPEBDXZ DD 025052a01H
DD 010e2313H
DD 07007001dH
DD 05006H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$?assign@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEAAAEAV12@QEBD_K@Z DD 025053401H
DD 0118231dH
DD 070110029H
DD 05010H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??4?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEAAAEAV01@AEBV01@@Z DD 025052f01H
DD 01132318H
DD 0700c0021H
DD 0500bH
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$?_Copy_assign@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@AEAAXAEBV12@U?$integral_constant@_N$0A@@2@@Z DD 025053401H
DD 0118231dH
DD 07011001fH
DD 05010H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??1?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEAA@XZ DD 025053b19H
DD 010e2313H
DD 070070029H
DD 05006H
DD imagerel __GSHandlerCheck
DD 0138H
xdata ENDS
; COMDAT CONST
CONST SEGMENT
??1?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEAA@XZ$rtcName$0 DB 024H ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::~basic_string<char,std::char_traits<char>,std::allocator<char> >
DB 053H
DB 039H
DB 00H
ORG $+12
??1?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEAA@XZ$rtcVarDesc DD 044H ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::~basic_string<char,std::char_traits<char>,std::allocator<char> >
DD 01H
DQ FLAT:??1?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEAA@XZ$rtcName$0
ORG $+48
??1?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEAA@XZ$rtcFrameData DD 01H ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::~basic_string<char,std::char_traits<char>,std::allocator<char> >
DD 00H
DQ FLAT:??1?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEAA@XZ$rtcVarDesc
CONST ENDS
; COMDAT xdata
xdata SEGMENT
$ip2state$??0?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEAA@XZ DB 02H
DB 00H
DB 00H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$cppxdata$??0?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEAA@XZ DB 060H
DD imagerel $ip2state$??0?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEAA@XZ
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??0?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEAA@XZ DD 025052a19H
DD 010e2313H
DD 070070025H
DD 05006H
DD imagerel __CxxFrameHandler4
DD imagerel $cppxdata$??0?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEAA@XZ
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??1?$_String_val@U?$_Simple_types@D@std@@@std@@QEAA@XZ DD 025052a01H
DD 010e2313H
DD 07007001dH
DD 05006H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??1_Bxty@?$_String_val@U?$_Simple_types@D@std@@@std@@QEAA@XZ DD 025052a01H
DD 010e2313H
DD 07007001dH
DD 05006H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??0_Bxty@?$_String_val@U?$_Simple_types@D@std@@@std@@QEAA@XZ DD 025052a01H
DD 010e2313H
DD 07007001dH
DD 05006H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$?_Large_string_engaged@?$_String_val@U?$_Simple_types@D@std@@@std@@QEBA_NXZ DD 025052a01H
DD 010e2313H
DD 07007001fH
DD 05006H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$?_Myptr@?$_String_val@U?$_Simple_types@D@std@@@std@@QEBAPEBDXZ DD 025052a01H
DD 010e2313H
DD 070070021H
DD 05006H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$?_Myptr@?$_String_val@U?$_Simple_types@D@std@@@std@@QEAAPEADXZ DD 025052a01H
DD 010e2313H
DD 070070021H
DD 05006H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??0?$_String_val@U?$_Simple_types@D@std@@@std@@QEAA@XZ DD 025052a01H
DD 010e2313H
DD 07007001dH
DD 05006H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$?max_size@?$_Default_allocator_traits@V?$allocator@D@std@@@std@@SA_KAEBV?$allocator@D@2@@Z DD 025052a01H
DD 010e2313H
DD 07007001dH
DD 05006H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$?_Xlen_string@std@@YAXXZ DD 025051e01H
DD 010a230fH
DD 07003001dH
DD 05002H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$?eof@?$_Narrow_char_traits@DH@std@@SAHXZ DD 025051e01H
DD 010a230fH
DD 07003001dH
DD 05002H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$?eq_int_type@?$_Narrow_char_traits@DH@std@@SA_NAEBH0@Z DD 025052f01H
DD 01132318H
DD 0700c001fH
DD 0500bH
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$?assign@?$_Narrow_char_traits@DH@std@@SAXAEADAEBD@Z DD 025052f01H
DD 01132318H
DD 0700c001dH
DD 0500bH
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$?length@?$_Narrow_char_traits@DH@std@@SA_KQEBD@Z DD 025052a01H
DD 010e2313H
DD 07007001fH
DD 05006H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$?compare@?$_Narrow_char_traits@DH@std@@SAHQEBD0_K@Z DD 025053401H
DD 0118231dH
DD 07011001dH
DD 05010H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$?move@?$_Char_traits@DH@std@@SAPEADQEADQEBD_K@Z DD 025053401H
DD 0118231dH
DD 07011001dH
DD 05010H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$?copy@?$_Char_traits@DH@std@@SAPEADQEADQEBD_K@Z DD 025053401H
DD 0118231dH
DD 07011001dH
DD 05010H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$?allocate@?$allocator@D@std@@QEAAPEAD_K@Z DD 025052f01H
DD 01132318H
DD 0700c001dH
DD 0500bH
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$?deallocate@?$allocator@D@std@@QEAAXQEAD_K@Z DD 025053401H
DD 0118231dH
DD 07011001dH
DD 05010H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??0?$allocator@D@std@@QEAA@XZ DD 025052a01H
DD 010e2313H
DD 07007001dH
DD 05006H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??$_Construct_in_place@U_Container_proxy@std@@PEAU_Container_base12@2@@std@@YAXAEAU_Container_proxy@0@$$QEAPEAU_Container_base12@0@@Z DD 025052f01H
DD 01132318H
DD 0700c0021H
DD 0500bH
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$?_Orphan_all@_Container_base12@std@@QEAAXXZ DD 025053b19H
DD 010e2313H
DD 070070025H
DD 05006H
DD imagerel __GSHandlerCheck
DD 0118H
xdata ENDS
; COMDAT CONST
CONST SEGMENT
?_Orphan_all@_Container_base12@std@@QEAAXXZ$rtcName$0 DB 05fH ; std::_Container_base12::_Orphan_all
DB 04cH
DB 06fH
DB 063H
DB 06bH
DB 00H
ORG $+10
?_Orphan_all@_Container_base12@std@@QEAAXXZ$rtcVarDesc DD 024H ; std::_Container_base12::_Orphan_all
DD 04H
DQ FLAT:?_Orphan_all@_Container_base12@std@@QEAAXXZ$rtcName$0
ORG $+48
?_Orphan_all@_Container_base12@std@@QEAAXXZ$rtcFrameData DD 01H ; std::_Container_base12::_Orphan_all
DD 00H
DQ FLAT:?_Orphan_all@_Container_base12@std@@QEAAXXZ$rtcVarDesc
CONST ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??0_Container_base12@std@@QEAA@XZ DD 025052a01H
DD 010e2313H
DD 07007001dH
DD 05006H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??0_Container_proxy@std@@QEAA@PEAU_Container_base12@1@@Z DD 025052f01H
DD 01132318H
DD 0700c001dH
DD 0500bH
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$?_Adjust_manually_vector_aligned@std@@YAXAEAPEAXAEA_K@Z DD 035052f01H
DD 01133318H
DD 0700c002fH
DD 0500bH
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$?_Allocate@_Default_allocate_traits@std@@SAPEAX_K@Z DD 025052a01H
DD 010e2313H
DD 07007001dH
DD 05006H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$?_Throw_bad_array_new_length@std@@YAXXZ DD 025051e01H
DD 010a230fH
DD 070030023H
DD 05002H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??_Gbad_array_new_length@std@@UEAAPEAXI@Z DD 025052e01H
DD 01122317H
DD 0700b001dH
DD 0500aH
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??0bad_array_new_length@std@@QEAA@AEBV01@@Z DD 025052f01H
DD 01132318H
DD 0700c001dH
DD 0500bH
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??1bad_array_new_length@std@@UEAA@XZ DD 025052a01H
DD 010e2313H
DD 07007001dH
DD 05006H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??0bad_array_new_length@std@@QEAA@XZ DD 025052a01H
DD 010e2313H
DD 07007001dH
DD 05006H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??_Gbad_alloc@std@@UEAAPEAXI@Z DD 025052e01H
DD 01122317H
DD 0700b001dH
DD 0500aH
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??0bad_alloc@std@@QEAA@AEBV01@@Z DD 025052f01H
DD 01132318H
DD 0700c001dH
DD 0500bH
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??1bad_alloc@std@@UEAA@XZ DD 025052a01H
DD 010e2313H
DD 07007001dH
DD 05006H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??0bad_alloc@std@@AEAA@QEBD@Z DD 025052f01H
DD 01132318H
DD 0700c001dH
DD 0500bH
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??_Gexception@std@@UEAAPEAXI@Z DD 025052e01H
DD 01122317H
DD 0700b001dH
DD 0500aH
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$?what@exception@std@@UEBAPEBDXZ DD 025052a01H
DD 010e2313H
DD 07007001fH
DD 05006H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??1exception@std@@UEAA@XZ DD 025052a01H
DD 010e2313H
DD 07007001dH
DD 05006H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??0exception@std@@QEAA@AEBV01@@Z DD 025052f01H
DD 01132318H
DD 0700c001dH
DD 0500bH
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??0exception@std@@QEAA@QEBDH@Z DD 025053401H
DD 0118231dH
DD 07011001dH
DD 05010H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$?max@?$numeric_limits@_J@std@@SA_JXZ DD 025051e01H
DD 010a230fH
DD 07003001dH
DD 05002H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$wmemcpy DD 025053401H
DD 0118231dH
DD 07011001dH
DD 05010H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$??2@YAPEAX_KPEAX@Z DD 025052f01H
DD 01132318H
DD 0700c001dH
DD 0500bH
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$?__empty_global_delete@@YAXPEAX_KW4align_val_t@std@@@Z DD 025053401H
DD 0118231dH
DD 07011001dH
DD 05010H
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$?__empty_global_delete@@YAXPEAXW4align_val_t@std@@@Z DD 025052f01H
DD 01132318H
DD 0700c001dH
DD 0500bH
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$?__empty_global_delete@@YAXPEAX_K@Z DD 025052f01H
DD 01132318H
DD 0700c001dH
DD 0500bH
xdata ENDS
; COMDAT xdata
xdata SEGMENT
$unwind$?__empty_global_delete@@YAXPEAX@Z DD 025052a01H
DD 010e2313H
DD 07007001dH
DD 05006H
xdata ENDS
; Function compile flags: /Odt
; COMDAT __JustMyCode_Default
_TEXT SEGMENT
__JustMyCode_Default PROC ; COMDAT
ret 0
__JustMyCode_Default ENDP
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\type_traits
; COMDAT ??$forward@AEAPEAUGatewayPayment@External@TechnicalServices@@@std@@YAAEAPEAUGatewayPayment@External@TechnicalServices@@AEAPEAU123@@Z
_TEXT SEGMENT
_Arg$ = 224
??$forward@AEAPEAUGatewayPayment@External@TechnicalServices@@@std@@YAAEAPEAUGatewayPayment@External@TechnicalServices@@AEAPEAU123@@Z PROC ; std::forward<TechnicalServices::External::GatewayPayment * &>, COMDAT
; 1442 : remove_reference_t<_Ty>& _Arg) noexcept { // forward an lvalue as either an lvalue or an rvalue
$LN3:
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+264]
lea rcx, OFFSET FLAT:__2D26A21E_type_traits
call __CheckForDebuggerJustMyCode
; 1443 : return static_cast<_Ty&&>(_Arg);
mov rax, QWORD PTR _Arg$[rbp]
; 1444 : }
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
??$forward@AEAPEAUGatewayPayment@External@TechnicalServices@@@std@@YAAEAPEAUGatewayPayment@External@TechnicalServices@@AEAPEAU123@@Z ENDP ; std::forward<TechnicalServices::External::GatewayPayment * &>
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\type_traits
; COMDAT ??$forward@AEAPEAUDebitPayment@External@TechnicalServices@@@std@@YAAEAPEAUDebitPayment@External@TechnicalServices@@AEAPEAU123@@Z
_TEXT SEGMENT
_Arg$ = 224
??$forward@AEAPEAUDebitPayment@External@TechnicalServices@@@std@@YAAEAPEAUDebitPayment@External@TechnicalServices@@AEAPEAU123@@Z PROC ; std::forward<TechnicalServices::External::DebitPayment * &>, COMDAT
; 1442 : remove_reference_t<_Ty>& _Arg) noexcept { // forward an lvalue as either an lvalue or an rvalue
$LN3:
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+264]
lea rcx, OFFSET FLAT:__2D26A21E_type_traits
call __CheckForDebuggerJustMyCode
; 1443 : return static_cast<_Ty&&>(_Arg);
mov rax, QWORD PTR _Arg$[rbp]
; 1444 : }
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
??$forward@AEAPEAUDebitPayment@External@TechnicalServices@@@std@@YAAEAPEAUDebitPayment@External@TechnicalServices@@AEAPEAU123@@Z ENDP ; std::forward<TechnicalServices::External::DebitPayment * &>
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\type_traits
; COMDAT ??$forward@AEAPEAUCreditPayment@External@TechnicalServices@@@std@@YAAEAPEAUCreditPayment@External@TechnicalServices@@AEAPEAU123@@Z
_TEXT SEGMENT
_Arg$ = 224
??$forward@AEAPEAUCreditPayment@External@TechnicalServices@@@std@@YAAEAPEAUCreditPayment@External@TechnicalServices@@AEAPEAU123@@Z PROC ; std::forward<TechnicalServices::External::CreditPayment * &>, COMDAT
; 1442 : remove_reference_t<_Ty>& _Arg) noexcept { // forward an lvalue as either an lvalue or an rvalue
$LN3:
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+264]
lea rcx, OFFSET FLAT:__2D26A21E_type_traits
call __CheckForDebuggerJustMyCode
; 1443 : return static_cast<_Ty&&>(_Arg);
mov rax, QWORD PTR _Arg$[rbp]
; 1444 : }
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
??$forward@AEAPEAUCreditPayment@External@TechnicalServices@@@std@@YAAEAPEAUCreditPayment@External@TechnicalServices@@AEAPEAU123@@Z ENDP ; std::forward<TechnicalServices::External::CreditPayment * &>
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\xmemory
; COMDAT ?deallocate@?$_Default_allocator_traits@V?$allocator@U_Container_proxy@std@@@std@@@std@@SAXAEAV?$allocator@U_Container_proxy@std@@@2@QEAU_Container_proxy@2@_K@Z
_TEXT SEGMENT
__formal$ = 224
_Ptr$ = 232
_Count$ = 240
?deallocate@?$_Default_allocator_traits@V?$allocator@U_Container_proxy@std@@@std@@@std@@SAXAEAV?$allocator@U_Container_proxy@std@@@2@QEAU_Container_proxy@2@_K@Z PROC ; std::_Default_allocator_traits<std::allocator<std::_Container_proxy> >::deallocate, COMDAT
; 694 : static void deallocate(_Alloc&, const pointer _Ptr, const size_type _Count) {
$LN3:
mov QWORD PTR [rsp+24], r8
mov QWORD PTR [rsp+16], rdx
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+264]
lea rcx, OFFSET FLAT:__F1739482_xmemory
call __CheckForDebuggerJustMyCode
; 695 : // no overflow check on the following multiply; we assume _Allocate did that check
; 696 : _Deallocate<_New_alignof<value_type>>(_Ptr, sizeof(value_type) * _Count);
imul rax, QWORD PTR _Count$[rbp], 16
mov rdx, rax
mov rcx, QWORD PTR _Ptr$[rbp]
call ??$_Deallocate@$0BA@$0A@@std@@YAXPEAX_K@Z ; std::_Deallocate<16,0>
; 697 : }
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
?deallocate@?$_Default_allocator_traits@V?$allocator@U_Container_proxy@std@@@std@@@std@@SAXAEAV?$allocator@U_Container_proxy@std@@@2@QEAU_Container_proxy@2@_K@Z ENDP ; std::_Default_allocator_traits<std::allocator<std::_Container_proxy> >::deallocate
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\type_traits
; COMDAT ??$forward@PEAUGatewayPayment@External@TechnicalServices@@@std@@YA$$QEAPEAUGatewayPayment@External@TechnicalServices@@AEAPEAU123@@Z
_TEXT SEGMENT
_Arg$ = 224
??$forward@PEAUGatewayPayment@External@TechnicalServices@@@std@@YA$$QEAPEAUGatewayPayment@External@TechnicalServices@@AEAPEAU123@@Z PROC ; std::forward<TechnicalServices::External::GatewayPayment *>, COMDAT
; 1442 : remove_reference_t<_Ty>& _Arg) noexcept { // forward an lvalue as either an lvalue or an rvalue
$LN3:
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+264]
lea rcx, OFFSET FLAT:__2D26A21E_type_traits
call __CheckForDebuggerJustMyCode
; 1443 : return static_cast<_Ty&&>(_Arg);
mov rax, QWORD PTR _Arg$[rbp]
; 1444 : }
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
??$forward@PEAUGatewayPayment@External@TechnicalServices@@@std@@YA$$QEAPEAUGatewayPayment@External@TechnicalServices@@AEAPEAU123@@Z ENDP ; std::forward<TechnicalServices::External::GatewayPayment *>
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\xmemory
; COMDAT ??$?0AEAPEAUGatewayPayment@External@TechnicalServices@@@?$_Compressed_pair@U?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@PEAUGatewayPayment@External@TechnicalServices@@$00@std@@QEAA@U_Zero_then_variadic_args_t@1@AEAPEAUGatewayPayment@External@TechnicalServices@@@Z
_TEXT SEGMENT
this$ = 224
__formal$ = 232
<_Val2_0>$ = 240
??$?0AEAPEAUGatewayPayment@External@TechnicalServices@@@?$_Compressed_pair@U?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@PEAUGatewayPayment@External@TechnicalServices@@$00@std@@QEAA@U_Zero_then_variadic_args_t@1@AEAPEAUGatewayPayment@External@TechnicalServices@@@Z PROC ; std::_Compressed_pair<std::default_delete<TechnicalServices::External::GatewayPayment>,TechnicalServices::External::GatewayPayment *,1>::_Compressed_pair<std::default_delete<TechnicalServices::External::GatewayPayment>,TechnicalServices::External::GatewayPayment *,1><TechnicalServices::External::GatewayPayment * &>, COMDAT
; 1339 : : _Ty1(), _Myval2(_STD forward<_Other2>(_Val2)...) {}
$LN3:
mov QWORD PTR [rsp+24], r8
mov BYTE PTR [rsp+16], dl
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+264]
lea rcx, OFFSET FLAT:__F1739482_xmemory
call __CheckForDebuggerJustMyCode
mov rcx, QWORD PTR <_Val2_0>$[rbp]
call ??$forward@AEAPEAUGatewayPayment@External@TechnicalServices@@@std@@YAAEAPEAUGatewayPayment@External@TechnicalServices@@AEAPEAU123@@Z ; std::forward<TechnicalServices::External::GatewayPayment * &>
mov rcx, QWORD PTR this$[rbp]
mov rax, QWORD PTR [rax]
mov QWORD PTR [rcx], rax
mov rax, QWORD PTR this$[rbp]
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
??$?0AEAPEAUGatewayPayment@External@TechnicalServices@@@?$_Compressed_pair@U?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@PEAUGatewayPayment@External@TechnicalServices@@$00@std@@QEAA@U_Zero_then_variadic_args_t@1@AEAPEAUGatewayPayment@External@TechnicalServices@@@Z ENDP ; std::_Compressed_pair<std::default_delete<TechnicalServices::External::GatewayPayment>,TechnicalServices::External::GatewayPayment *,1>::_Compressed_pair<std::default_delete<TechnicalServices::External::GatewayPayment>,TechnicalServices::External::GatewayPayment *,1><TechnicalServices::External::GatewayPayment * &>
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\type_traits
; COMDAT ??$forward@PEAUDebitPayment@External@TechnicalServices@@@std@@YA$$QEAPEAUDebitPayment@External@TechnicalServices@@AEAPEAU123@@Z
_TEXT SEGMENT
_Arg$ = 224
??$forward@PEAUDebitPayment@External@TechnicalServices@@@std@@YA$$QEAPEAUDebitPayment@External@TechnicalServices@@AEAPEAU123@@Z PROC ; std::forward<TechnicalServices::External::DebitPayment *>, COMDAT
; 1442 : remove_reference_t<_Ty>& _Arg) noexcept { // forward an lvalue as either an lvalue or an rvalue
$LN3:
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+264]
lea rcx, OFFSET FLAT:__2D26A21E_type_traits
call __CheckForDebuggerJustMyCode
; 1443 : return static_cast<_Ty&&>(_Arg);
mov rax, QWORD PTR _Arg$[rbp]
; 1444 : }
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
??$forward@PEAUDebitPayment@External@TechnicalServices@@@std@@YA$$QEAPEAUDebitPayment@External@TechnicalServices@@AEAPEAU123@@Z ENDP ; std::forward<TechnicalServices::External::DebitPayment *>
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\xmemory
; COMDAT ??$?0AEAPEAUDebitPayment@External@TechnicalServices@@@?$_Compressed_pair@U?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@PEAUDebitPayment@External@TechnicalServices@@$00@std@@QEAA@U_Zero_then_variadic_args_t@1@AEAPEAUDebitPayment@External@TechnicalServices@@@Z
_TEXT SEGMENT
this$ = 224
__formal$ = 232
<_Val2_0>$ = 240
??$?0AEAPEAUDebitPayment@External@TechnicalServices@@@?$_Compressed_pair@U?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@PEAUDebitPayment@External@TechnicalServices@@$00@std@@QEAA@U_Zero_then_variadic_args_t@1@AEAPEAUDebitPayment@External@TechnicalServices@@@Z PROC ; std::_Compressed_pair<std::default_delete<TechnicalServices::External::DebitPayment>,TechnicalServices::External::DebitPayment *,1>::_Compressed_pair<std::default_delete<TechnicalServices::External::DebitPayment>,TechnicalServices::External::DebitPayment *,1><TechnicalServices::External::DebitPayment * &>, COMDAT
; 1339 : : _Ty1(), _Myval2(_STD forward<_Other2>(_Val2)...) {}
$LN3:
mov QWORD PTR [rsp+24], r8
mov BYTE PTR [rsp+16], dl
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+264]
lea rcx, OFFSET FLAT:__F1739482_xmemory
call __CheckForDebuggerJustMyCode
mov rcx, QWORD PTR <_Val2_0>$[rbp]
call ??$forward@AEAPEAUDebitPayment@External@TechnicalServices@@@std@@YAAEAPEAUDebitPayment@External@TechnicalServices@@AEAPEAU123@@Z ; std::forward<TechnicalServices::External::DebitPayment * &>
mov rcx, QWORD PTR this$[rbp]
mov rax, QWORD PTR [rax]
mov QWORD PTR [rcx], rax
mov rax, QWORD PTR this$[rbp]
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
??$?0AEAPEAUDebitPayment@External@TechnicalServices@@@?$_Compressed_pair@U?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@PEAUDebitPayment@External@TechnicalServices@@$00@std@@QEAA@U_Zero_then_variadic_args_t@1@AEAPEAUDebitPayment@External@TechnicalServices@@@Z ENDP ; std::_Compressed_pair<std::default_delete<TechnicalServices::External::DebitPayment>,TechnicalServices::External::DebitPayment *,1>::_Compressed_pair<std::default_delete<TechnicalServices::External::DebitPayment>,TechnicalServices::External::DebitPayment *,1><TechnicalServices::External::DebitPayment * &>
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\type_traits
; COMDAT ??$forward@PEAUCreditPayment@External@TechnicalServices@@@std@@YA$$QEAPEAUCreditPayment@External@TechnicalServices@@AEAPEAU123@@Z
_TEXT SEGMENT
_Arg$ = 224
??$forward@PEAUCreditPayment@External@TechnicalServices@@@std@@YA$$QEAPEAUCreditPayment@External@TechnicalServices@@AEAPEAU123@@Z PROC ; std::forward<TechnicalServices::External::CreditPayment *>, COMDAT
; 1442 : remove_reference_t<_Ty>& _Arg) noexcept { // forward an lvalue as either an lvalue or an rvalue
$LN3:
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+264]
lea rcx, OFFSET FLAT:__2D26A21E_type_traits
call __CheckForDebuggerJustMyCode
; 1443 : return static_cast<_Ty&&>(_Arg);
mov rax, QWORD PTR _Arg$[rbp]
; 1444 : }
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
??$forward@PEAUCreditPayment@External@TechnicalServices@@@std@@YA$$QEAPEAUCreditPayment@External@TechnicalServices@@AEAPEAU123@@Z ENDP ; std::forward<TechnicalServices::External::CreditPayment *>
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\xmemory
; COMDAT ??$?0AEAPEAUCreditPayment@External@TechnicalServices@@@?$_Compressed_pair@U?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@PEAUCreditPayment@External@TechnicalServices@@$00@std@@QEAA@U_Zero_then_variadic_args_t@1@AEAPEAUCreditPayment@External@TechnicalServices@@@Z
_TEXT SEGMENT
this$ = 224
__formal$ = 232
<_Val2_0>$ = 240
??$?0AEAPEAUCreditPayment@External@TechnicalServices@@@?$_Compressed_pair@U?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@PEAUCreditPayment@External@TechnicalServices@@$00@std@@QEAA@U_Zero_then_variadic_args_t@1@AEAPEAUCreditPayment@External@TechnicalServices@@@Z PROC ; std::_Compressed_pair<std::default_delete<TechnicalServices::External::CreditPayment>,TechnicalServices::External::CreditPayment *,1>::_Compressed_pair<std::default_delete<TechnicalServices::External::CreditPayment>,TechnicalServices::External::CreditPayment *,1><TechnicalServices::External::CreditPayment * &>, COMDAT
; 1339 : : _Ty1(), _Myval2(_STD forward<_Other2>(_Val2)...) {}
$LN3:
mov QWORD PTR [rsp+24], r8
mov BYTE PTR [rsp+16], dl
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+264]
lea rcx, OFFSET FLAT:__F1739482_xmemory
call __CheckForDebuggerJustMyCode
mov rcx, QWORD PTR <_Val2_0>$[rbp]
call ??$forward@AEAPEAUCreditPayment@External@TechnicalServices@@@std@@YAAEAPEAUCreditPayment@External@TechnicalServices@@AEAPEAU123@@Z ; std::forward<TechnicalServices::External::CreditPayment * &>
mov rcx, QWORD PTR this$[rbp]
mov rax, QWORD PTR [rax]
mov QWORD PTR [rcx], rax
mov rax, QWORD PTR this$[rbp]
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
??$?0AEAPEAUCreditPayment@External@TechnicalServices@@@?$_Compressed_pair@U?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@PEAUCreditPayment@External@TechnicalServices@@$00@std@@QEAA@U_Zero_then_variadic_args_t@1@AEAPEAUCreditPayment@External@TechnicalServices@@@Z ENDP ; std::_Compressed_pair<std::default_delete<TechnicalServices::External::CreditPayment>,TechnicalServices::External::CreditPayment *,1>::_Compressed_pair<std::default_delete<TechnicalServices::External::CreditPayment>,TechnicalServices::External::CreditPayment *,1><TechnicalServices::External::CreditPayment * &>
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\xstring
; COMDAT ??$_Traits_equal@U?$char_traits@D@std@@@std@@YA_NQEBD_K01@Z
_TEXT SEGMENT
tv70 = 192
_Left$ = 240
_Left_size$ = 248
_Right$ = 256
_Right_size$ = 264
??$_Traits_equal@U?$char_traits@D@std@@@std@@YA_NQEBD_K01@Z PROC ; std::_Traits_equal<std::char_traits<char> >, COMDAT
; 559 : _In_reads_(_Right_size) const _Traits_ptr_t<_Traits> _Right, const size_t _Right_size) noexcept {
$LN5:
mov QWORD PTR [rsp+32], r9
mov QWORD PTR [rsp+24], r8
mov QWORD PTR [rsp+16], rdx
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 248 ; 000000f8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 62 ; 0000003eH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+280]
lea rcx, OFFSET FLAT:__85A0121E_xstring
call __CheckForDebuggerJustMyCode
; 560 : // compare [_Left, _Left + _Left_size) to [_Right, _Right + _Right_size) for equality using _Traits
; 561 : return _Left_size == _Right_size && _Traits::compare(_Left, _Right, _Left_size) == 0;
mov rax, QWORD PTR _Right_size$[rbp]
cmp QWORD PTR _Left_size$[rbp], rax
jne SHORT $LN3@Traits_equ
mov r8, QWORD PTR _Left_size$[rbp]
mov rdx, QWORD PTR _Right$[rbp]
mov rcx, QWORD PTR _Left$[rbp]
call ?compare@?$_Narrow_char_traits@DH@std@@SAHQEBD0_K@Z ; std::_Narrow_char_traits<char,int>::compare
test eax, eax
jne SHORT $LN3@Traits_equ
mov DWORD PTR tv70[rbp], 1
jmp SHORT $LN4@Traits_equ
$LN3@Traits_equ:
mov DWORD PTR tv70[rbp], 0
$LN4@Traits_equ:
movzx eax, BYTE PTR tv70[rbp]
; 562 : }
lea rsp, QWORD PTR [rbp+216]
pop rdi
pop rbp
ret 0
??$_Traits_equal@U?$char_traits@D@std@@@std@@YA_NQEBD_K01@Z ENDP ; std::_Traits_equal<std::char_traits<char> >
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\utility
; COMDAT ??$exchange@PEAUCreditPayment@External@TechnicalServices@@PEAU123@@std@@YAPEAUCreditPayment@External@TechnicalServices@@AEAPEAU123@$$QEAPEAU123@@Z
_TEXT SEGMENT
_Old_val$ = 8
_Val$ = 256
_New_val$ = 264
??$exchange@PEAUCreditPayment@External@TechnicalServices@@PEAU123@@std@@YAPEAUCreditPayment@External@TechnicalServices@@AEAPEAU123@$$QEAPEAU123@@Z PROC ; std::exchange<TechnicalServices::External::CreditPayment *,TechnicalServices::External::CreditPayment *>, COMDAT
; 596 : conjunction_v<is_nothrow_move_constructible<_Ty>, is_nothrow_assignable<_Ty&, _Other>>) /* strengthened */ {
$LN3:
mov QWORD PTR [rsp+16], rdx
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 264 ; 00000108H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 66 ; 00000042H
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+296]
lea rcx, OFFSET FLAT:__9BE6F741_utility
call __CheckForDebuggerJustMyCode
; 597 : // assign _New_val to _Val, return previous _Val
; 598 : _Ty _Old_val = static_cast<_Ty&&>(_Val);
mov rax, QWORD PTR _Val$[rbp]
mov rax, QWORD PTR [rax]
mov QWORD PTR _Old_val$[rbp], rax
; 599 : _Val = static_cast<_Other&&>(_New_val);
mov rax, QWORD PTR _Val$[rbp]
mov rcx, QWORD PTR _New_val$[rbp]
mov rcx, QWORD PTR [rcx]
mov QWORD PTR [rax], rcx
; 600 : return _Old_val;
mov rax, QWORD PTR _Old_val$[rbp]
; 601 : }
lea rsp, QWORD PTR [rbp+232]
pop rdi
pop rbp
ret 0
??$exchange@PEAUCreditPayment@External@TechnicalServices@@PEAU123@@std@@YAPEAUCreditPayment@External@TechnicalServices@@AEAPEAU123@$$QEAPEAU123@@Z ENDP ; std::exchange<TechnicalServices::External::CreditPayment *,TechnicalServices::External::CreditPayment *>
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\utility
; COMDAT ??$exchange@PEAUDebitPayment@External@TechnicalServices@@PEAU123@@std@@YAPEAUDebitPayment@External@TechnicalServices@@AEAPEAU123@$$QEAPEAU123@@Z
_TEXT SEGMENT
_Old_val$ = 8
_Val$ = 256
_New_val$ = 264
??$exchange@PEAUDebitPayment@External@TechnicalServices@@PEAU123@@std@@YAPEAUDebitPayment@External@TechnicalServices@@AEAPEAU123@$$QEAPEAU123@@Z PROC ; std::exchange<TechnicalServices::External::DebitPayment *,TechnicalServices::External::DebitPayment *>, COMDAT
; 596 : conjunction_v<is_nothrow_move_constructible<_Ty>, is_nothrow_assignable<_Ty&, _Other>>) /* strengthened */ {
$LN3:
mov QWORD PTR [rsp+16], rdx
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 264 ; 00000108H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 66 ; 00000042H
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+296]
lea rcx, OFFSET FLAT:__9BE6F741_utility
call __CheckForDebuggerJustMyCode
; 597 : // assign _New_val to _Val, return previous _Val
; 598 : _Ty _Old_val = static_cast<_Ty&&>(_Val);
mov rax, QWORD PTR _Val$[rbp]
mov rax, QWORD PTR [rax]
mov QWORD PTR _Old_val$[rbp], rax
; 599 : _Val = static_cast<_Other&&>(_New_val);
mov rax, QWORD PTR _Val$[rbp]
mov rcx, QWORD PTR _New_val$[rbp]
mov rcx, QWORD PTR [rcx]
mov QWORD PTR [rax], rcx
; 600 : return _Old_val;
mov rax, QWORD PTR _Old_val$[rbp]
; 601 : }
lea rsp, QWORD PTR [rbp+232]
pop rdi
pop rbp
ret 0
??$exchange@PEAUDebitPayment@External@TechnicalServices@@PEAU123@@std@@YAPEAUDebitPayment@External@TechnicalServices@@AEAPEAU123@$$QEAPEAU123@@Z ENDP ; std::exchange<TechnicalServices::External::DebitPayment *,TechnicalServices::External::DebitPayment *>
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\utility
; COMDAT ??$exchange@PEAUGatewayPayment@External@TechnicalServices@@PEAU123@@std@@YAPEAUGatewayPayment@External@TechnicalServices@@AEAPEAU123@$$QEAPEAU123@@Z
_TEXT SEGMENT
_Old_val$ = 8
_Val$ = 256
_New_val$ = 264
??$exchange@PEAUGatewayPayment@External@TechnicalServices@@PEAU123@@std@@YAPEAUGatewayPayment@External@TechnicalServices@@AEAPEAU123@$$QEAPEAU123@@Z PROC ; std::exchange<TechnicalServices::External::GatewayPayment *,TechnicalServices::External::GatewayPayment *>, COMDAT
; 596 : conjunction_v<is_nothrow_move_constructible<_Ty>, is_nothrow_assignable<_Ty&, _Other>>) /* strengthened */ {
$LN3:
mov QWORD PTR [rsp+16], rdx
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 264 ; 00000108H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 66 ; 00000042H
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+296]
lea rcx, OFFSET FLAT:__9BE6F741_utility
call __CheckForDebuggerJustMyCode
; 597 : // assign _New_val to _Val, return previous _Val
; 598 : _Ty _Old_val = static_cast<_Ty&&>(_Val);
mov rax, QWORD PTR _Val$[rbp]
mov rax, QWORD PTR [rax]
mov QWORD PTR _Old_val$[rbp], rax
; 599 : _Val = static_cast<_Other&&>(_New_val);
mov rax, QWORD PTR _Val$[rbp]
mov rcx, QWORD PTR _New_val$[rbp]
mov rcx, QWORD PTR [rcx]
mov QWORD PTR [rax], rcx
; 600 : return _Old_val;
mov rax, QWORD PTR _Old_val$[rbp]
; 601 : }
lea rsp, QWORD PTR [rbp+232]
pop rdi
pop rbp
ret 0
??$exchange@PEAUGatewayPayment@External@TechnicalServices@@PEAU123@@std@@YAPEAUGatewayPayment@External@TechnicalServices@@AEAPEAU123@$$QEAPEAU123@@Z ENDP ; std::exchange<TechnicalServices::External::GatewayPayment *,TechnicalServices::External::GatewayPayment *>
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\xmemory
; COMDAT ??$destroy@UPaymentOption@Persistence@TechnicalServices@@@?$_Default_allocator_traits@V?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@@std@@SAXAEAV?$allocator@UPaymentOption@Persistence@TechnicalServices@@@1@QEAUPaymentOption@Persistence@TechnicalServices@@@Z
_TEXT SEGMENT
__formal$ = 224
_Ptr$ = 232
??$destroy@UPaymentOption@Persistence@TechnicalServices@@@?$_Default_allocator_traits@V?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@@std@@SAXAEAV?$allocator@UPaymentOption@Persistence@TechnicalServices@@@1@QEAUPaymentOption@Persistence@TechnicalServices@@@Z PROC ; std::_Default_allocator_traits<std::allocator<TechnicalServices::Persistence::PaymentOption> >::destroy<TechnicalServices::Persistence::PaymentOption>, COMDAT
; 705 : static void destroy(_Alloc&, _Uty* const _Ptr) {
$LN3:
mov QWORD PTR [rsp+16], rdx
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+264]
lea rcx, OFFSET FLAT:__F1739482_xmemory
call __CheckForDebuggerJustMyCode
; 706 : _Ptr->~_Uty();
xor edx, edx
mov rcx, QWORD PTR _Ptr$[rbp]
call ??_GPaymentOption@Persistence@TechnicalServices@@QEAAPEAXI@Z
; 707 : }
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
??$destroy@UPaymentOption@Persistence@TechnicalServices@@@?$_Default_allocator_traits@V?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@@std@@SAXAEAV?$allocator@UPaymentOption@Persistence@TechnicalServices@@@1@QEAUPaymentOption@Persistence@TechnicalServices@@@Z ENDP ; std::_Default_allocator_traits<std::allocator<TechnicalServices::Persistence::PaymentOption> >::destroy<TechnicalServices::Persistence::PaymentOption>
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\xstddef
; COMDAT ??$_Unfancy@UPaymentOption@Persistence@TechnicalServices@@@std@@YAPEAUPaymentOption@Persistence@TechnicalServices@@PEAU123@@Z
_TEXT SEGMENT
_Ptr$ = 224
??$_Unfancy@UPaymentOption@Persistence@TechnicalServices@@@std@@YAPEAUPaymentOption@Persistence@TechnicalServices@@PEAU123@@Z PROC ; std::_Unfancy<TechnicalServices::Persistence::PaymentOption>, COMDAT
; 288 : _NODISCARD constexpr _Ty* _Unfancy(_Ty* _Ptr) noexcept { // do nothing for plain pointers
$LN3:
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+264]
lea rcx, OFFSET FLAT:__6CF96053_xstddef
call __CheckForDebuggerJustMyCode
; 289 : return _Ptr;
mov rax, QWORD PTR _Ptr$[rbp]
; 290 : }
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
??$_Unfancy@UPaymentOption@Persistence@TechnicalServices@@@std@@YAPEAUPaymentOption@Persistence@TechnicalServices@@PEAU123@@Z ENDP ; std::_Unfancy<TechnicalServices::Persistence::PaymentOption>
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\xmemory
; COMDAT ??$_Allocate_manually_vector_aligned@U_Default_allocate_traits@std@@@std@@YAPEAX_K@Z
_TEXT SEGMENT
_Block_size$ = 8
_Ptr_container$ = 40
_Ptr$ = 72
_Bytes$ = 320
??$_Allocate_manually_vector_aligned@U_Default_allocate_traits@std@@@std@@YAPEAX_K@Z PROC ; std::_Allocate_manually_vector_aligned<std::_Default_allocate_traits>, COMDAT
; 113 : __declspec(allocator) void* _Allocate_manually_vector_aligned(const size_t _Bytes) {
$LN13:
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 344 ; 00000158H
lea rbp, QWORD PTR [rsp+48]
mov rdi, rsp
mov ecx, 86 ; 00000056H
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+376]
lea rcx, OFFSET FLAT:__F1739482_xmemory
call __CheckForDebuggerJustMyCode
; 114 : // allocate _Bytes manually aligned to at least _Big_allocation_alignment
; 115 : const size_t _Block_size = _Non_user_size + _Bytes;
mov rax, QWORD PTR _Bytes$[rbp]
add rax, 47 ; 0000002fH
mov QWORD PTR _Block_size$[rbp], rax
; 116 : if (_Block_size <= _Bytes) {
mov rax, QWORD PTR _Bytes$[rbp]
cmp QWORD PTR _Block_size$[rbp], rax
ja SHORT $LN8@Allocate_m
; 117 : _Throw_bad_array_new_length(); // add overflow
call ?_Throw_bad_array_new_length@std@@YAXXZ ; std::_Throw_bad_array_new_length
$LN8@Allocate_m:
; 118 : }
; 119 :
; 120 : const uintptr_t _Ptr_container = reinterpret_cast<uintptr_t>(_Traits::_Allocate(_Block_size));
mov rcx, QWORD PTR _Block_size$[rbp]
call ?_Allocate@_Default_allocate_traits@std@@SAPEAX_K@Z ; std::_Default_allocate_traits::_Allocate
mov QWORD PTR _Ptr_container$[rbp], rax
$LN4@Allocate_m:
; 121 : _STL_VERIFY(_Ptr_container != 0, "invalid argument"); // validate even in release since we're doing p[-1]
cmp QWORD PTR _Ptr_container$[rbp], 0
je SHORT $LN9@Allocate_m
jmp SHORT $LN10@Allocate_m
$LN9@Allocate_m:
$LN7@Allocate_m:
lea rax, OFFSET FLAT:??_C@_0BB@FCMFBGOM@invalid?5argument@
mov QWORD PTR [rsp+40], rax
lea rax, OFFSET FLAT:??_C@_02DKCKIIND@?$CFs@
mov QWORD PTR [rsp+32], rax
xor r9d, r9d
mov r8d, 121 ; 00000079H
lea rdx, OFFSET FLAT:??_C@_0GI@CLKHGMEI@C?3?2Program?5Files?5?$CIx86?$CJ?2Microsof@
mov ecx, 2
call QWORD PTR __imp__CrtDbgReport
cmp eax, 1
jne SHORT $LN12@Allocate_m
int 3
xor eax, eax
$LN12@Allocate_m:
mov QWORD PTR [rsp+32], 0
mov r9d, 121 ; 00000079H
lea r8, OFFSET FLAT:??_C@_1NA@PDNNFCLD@?$AAC?$AA?3?$AA?2?$AAP?$AAr?$AAo?$AAg?$AAr?$AAa?$AAm?$AA?5?$AAF?$AAi?$AAl?$AAe@
lea rdx, OFFSET FLAT:??_C@_1EO@GFNCMDLA@?$AAs?$AAt?$AAd?$AA?3?$AA?3?$AA_?$AAA?$AAl?$AAl?$AAo?$AAc?$AAa?$AAt?$AAe?$AA_@
lea rcx, OFFSET FLAT:??_C@_1CG@JNLFBNGN@?$AA?$CC?$AAi?$AAn?$AAv?$AAa?$AAl?$AAi?$AAd?$AA?5?$AAa?$AAr?$AAg?$AAu?$AAm?$AAe@
call QWORD PTR __imp__invalid_parameter
xor eax, eax
test eax, eax
jne SHORT $LN7@Allocate_m
$LN10@Allocate_m:
xor eax, eax
test eax, eax
jne SHORT $LN4@Allocate_m
; 122 : void* const _Ptr = reinterpret_cast<void*>((_Ptr_container + _Non_user_size) & ~(_Big_allocation_alignment - 1));
mov rax, QWORD PTR _Ptr_container$[rbp]
add rax, 47 ; 0000002fH
and rax, -32 ; ffffffffffffffe0H
mov QWORD PTR _Ptr$[rbp], rax
; 123 : static_cast<uintptr_t*>(_Ptr)[-1] = _Ptr_container;
mov eax, 8
imul rax, rax, -1
mov rcx, QWORD PTR _Ptr$[rbp]
mov rdx, QWORD PTR _Ptr_container$[rbp]
mov QWORD PTR [rcx+rax], rdx
; 124 :
; 125 : #ifdef _DEBUG
; 126 : static_cast<uintptr_t*>(_Ptr)[-2] = _Big_allocation_sentinel;
mov eax, 8
imul rax, rax, -2
mov rcx, QWORD PTR _Ptr$[rbp]
mov rdx, -361700864190383366 ; fafafafafafafafaH
mov QWORD PTR [rcx+rax], rdx
; 127 : #endif // _DEBUG
; 128 : return _Ptr;
mov rax, QWORD PTR _Ptr$[rbp]
$LN11@Allocate_m:
; 129 : }
lea rsp, QWORD PTR [rbp+296]
pop rdi
pop rbp
ret 0
??$_Allocate_manually_vector_aligned@U_Default_allocate_traits@std@@@std@@YAPEAX_K@Z ENDP ; std::_Allocate_manually_vector_aligned<std::_Default_allocate_traits>
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\type_traits
; COMDAT ??$forward@AEBQEAD@std@@YAAEBQEADAEBQEAD@Z
_TEXT SEGMENT
_Arg$ = 224
??$forward@AEBQEAD@std@@YAAEBQEADAEBQEAD@Z PROC ; std::forward<char * const &>, COMDAT
; 1442 : remove_reference_t<_Ty>& _Arg) noexcept { // forward an lvalue as either an lvalue or an rvalue
$LN3:
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+264]
lea rcx, OFFSET FLAT:__2D26A21E_type_traits
call __CheckForDebuggerJustMyCode
; 1443 : return static_cast<_Ty&&>(_Arg);
mov rax, QWORD PTR _Arg$[rbp]
; 1444 : }
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
??$forward@AEBQEAD@std@@YAAEBQEADAEBQEAD@Z ENDP ; std::forward<char * const &>
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\xstddef
; COMDAT ??$addressof@PEAD@std@@YAPEAPEADAEAPEAD@Z
_TEXT SEGMENT
_Val$ = 224
??$addressof@PEAD@std@@YAPEAPEADAEAPEAD@Z PROC ; std::addressof<char *>, COMDAT
; 274 : _NODISCARD constexpr _Ty* addressof(_Ty& _Val) noexcept {
$LN3:
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+264]
lea rcx, OFFSET FLAT:__6CF96053_xstddef
call __CheckForDebuggerJustMyCode
; 275 : return __builtin_addressof(_Val);
mov rax, QWORD PTR _Val$[rbp]
; 276 : }
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
??$addressof@PEAD@std@@YAPEAPEADAEAPEAD@Z ENDP ; std::addressof<char *>
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\xmemory
; COMDAT ??$_Deallocate_plain@V?$allocator@U_Container_proxy@std@@@std@@@std@@YAXAEAV?$allocator@U_Container_proxy@std@@@0@QEAU_Container_proxy@0@@Z
_TEXT SEGMENT
_Al$ = 224
_Ptr$ = 232
??$_Deallocate_plain@V?$allocator@U_Container_proxy@std@@@std@@@std@@YAXAEAV?$allocator@U_Container_proxy@std@@@0@QEAU_Container_proxy@0@@Z PROC ; std::_Deallocate_plain<std::allocator<std::_Container_proxy> >, COMDAT
; 1003 : void _Deallocate_plain(_Alloc& _Al, typename _Alloc::value_type* const _Ptr) noexcept {
$LN3:
mov QWORD PTR [rsp+16], rdx
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+264]
lea rcx, OFFSET FLAT:__F1739482_xmemory
call __CheckForDebuggerJustMyCode
; 1004 : // deallocate a plain pointer using an allocator
; 1005 : using _Alloc_traits = allocator_traits<_Alloc>;
; 1006 : if constexpr (is_same_v<_Alloc_ptr_t<_Alloc>, typename _Alloc::value_type*>) {
; 1007 : _Alloc_traits::deallocate(_Al, _Ptr, 1);
mov r8d, 1
mov rdx, QWORD PTR _Ptr$[rbp]
mov rcx, QWORD PTR _Al$[rbp]
call ?deallocate@?$_Default_allocator_traits@V?$allocator@U_Container_proxy@std@@@std@@@std@@SAXAEAV?$allocator@U_Container_proxy@std@@@2@QEAU_Container_proxy@2@_K@Z ; std::_Default_allocator_traits<std::allocator<std::_Container_proxy> >::deallocate
npad 1
; 1008 : } else {
; 1009 : using _Ptr_traits = pointer_traits<_Alloc_ptr_t<_Alloc>>;
; 1010 : _Alloc_traits::deallocate(_Al, _Ptr_traits::pointer_to(*_Ptr), 1);
; 1011 : }
; 1012 : }
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
??$_Deallocate_plain@V?$allocator@U_Container_proxy@std@@@std@@@std@@YAXAEAV?$allocator@U_Container_proxy@std@@@0@QEAU_Container_proxy@0@@Z ENDP ; std::_Deallocate_plain<std::allocator<std::_Container_proxy> >
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\xmemory
; COMDAT ??$?0U?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@PEAUGatewayPayment@External@TechnicalServices@@@?$_Compressed_pair@U?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@PEAVPaymentHandlerInterface@External@TechnicalServices@@$00@std@@QEAA@U_One_then_variadic_args_t@1@$$QEAU?$default_delete@UGatewayPayment@External@TechnicalServices@@@1@$$QEAPEAUGatewayPayment@External@TechnicalServices@@@Z
_TEXT SEGMENT
this$ = 224
__formal$ = 232
_Val1$ = 240
<_Val2_0>$ = 248
??$?0U?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@PEAUGatewayPayment@External@TechnicalServices@@@?$_Compressed_pair@U?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@PEAVPaymentHandlerInterface@External@TechnicalServices@@$00@std@@QEAA@U_One_then_variadic_args_t@1@$$QEAU?$default_delete@UGatewayPayment@External@TechnicalServices@@@1@$$QEAPEAUGatewayPayment@External@TechnicalServices@@@Z PROC ; std::_Compressed_pair<std::default_delete<TechnicalServices::External::PaymentHandlerInterface>,TechnicalServices::External::PaymentHandlerInterface *,1>::_Compressed_pair<std::default_delete<TechnicalServices::External::PaymentHandlerInterface>,TechnicalServices::External::PaymentHandlerInterface *,1><std::default_delete<TechnicalServices::External::GatewayPayment>,TechnicalServices::External::GatewayPayment *>, COMDAT
; 1344 : : _Ty1(_STD forward<_Other1>(_Val1)), _Myval2(_STD forward<_Other2>(_Val2)...) {}
$LN3:
mov QWORD PTR [rsp+32], r9
mov QWORD PTR [rsp+24], r8
mov BYTE PTR [rsp+16], dl
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+264]
lea rcx, OFFSET FLAT:__F1739482_xmemory
call __CheckForDebuggerJustMyCode
mov rcx, QWORD PTR _Val1$[rbp]
call ??$forward@U?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@@std@@YA$$QEAU?$default_delete@UGatewayPayment@External@TechnicalServices@@@0@AEAU10@@Z ; std::forward<std::default_delete<TechnicalServices::External::GatewayPayment> >
mov rdx, rax
mov rcx, QWORD PTR this$[rbp]
call ??$?0UGatewayPayment@External@TechnicalServices@@$0A@@?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@QEAA@AEBU?$default_delete@UGatewayPayment@External@TechnicalServices@@@1@@Z ; std::default_delete<TechnicalServices::External::PaymentHandlerInterface>::default_delete<TechnicalServices::External::PaymentHandlerInterface><TechnicalServices::External::GatewayPayment,0>
mov rcx, QWORD PTR <_Val2_0>$[rbp]
call ??$forward@PEAUGatewayPayment@External@TechnicalServices@@@std@@YA$$QEAPEAUGatewayPayment@External@TechnicalServices@@AEAPEAU123@@Z ; std::forward<TechnicalServices::External::GatewayPayment *>
mov rcx, QWORD PTR this$[rbp]
mov rax, QWORD PTR [rax]
mov QWORD PTR [rcx], rax
mov rax, QWORD PTR this$[rbp]
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
??$?0U?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@PEAUGatewayPayment@External@TechnicalServices@@@?$_Compressed_pair@U?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@PEAVPaymentHandlerInterface@External@TechnicalServices@@$00@std@@QEAA@U_One_then_variadic_args_t@1@$$QEAU?$default_delete@UGatewayPayment@External@TechnicalServices@@@1@$$QEAPEAUGatewayPayment@External@TechnicalServices@@@Z ENDP ; std::_Compressed_pair<std::default_delete<TechnicalServices::External::PaymentHandlerInterface>,TechnicalServices::External::PaymentHandlerInterface *,1>::_Compressed_pair<std::default_delete<TechnicalServices::External::PaymentHandlerInterface>,TechnicalServices::External::PaymentHandlerInterface *,1><std::default_delete<TechnicalServices::External::GatewayPayment>,TechnicalServices::External::GatewayPayment *>
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\type_traits
; COMDAT ??$forward@U?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@@std@@YA$$QEAU?$default_delete@UGatewayPayment@External@TechnicalServices@@@0@AEAU10@@Z
_TEXT SEGMENT
_Arg$ = 224
??$forward@U?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@@std@@YA$$QEAU?$default_delete@UGatewayPayment@External@TechnicalServices@@@0@AEAU10@@Z PROC ; std::forward<std::default_delete<TechnicalServices::External::GatewayPayment> >, COMDAT
; 1442 : remove_reference_t<_Ty>& _Arg) noexcept { // forward an lvalue as either an lvalue or an rvalue
$LN3:
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+264]
lea rcx, OFFSET FLAT:__2D26A21E_type_traits
call __CheckForDebuggerJustMyCode
; 1443 : return static_cast<_Ty&&>(_Arg);
mov rax, QWORD PTR _Arg$[rbp]
; 1444 : }
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
??$forward@U?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@@std@@YA$$QEAU?$default_delete@UGatewayPayment@External@TechnicalServices@@@0@AEAU10@@Z ENDP ; std::forward<std::default_delete<TechnicalServices::External::GatewayPayment> >
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\memory
; COMDAT ??$?0U?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@$0A@@?$unique_ptr@UGatewayPayment@External@TechnicalServices@@U?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@@std@@QEAA@PEAUGatewayPayment@External@TechnicalServices@@@Z
_TEXT SEGMENT
$T1 = 196
tv70 = 216
this$ = 256
_Ptr$ = 264
??$?0U?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@$0A@@?$unique_ptr@UGatewayPayment@External@TechnicalServices@@U?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@@std@@QEAA@PEAUGatewayPayment@External@TechnicalServices@@@Z PROC ; std::unique_ptr<TechnicalServices::External::GatewayPayment,std::default_delete<TechnicalServices::External::GatewayPayment> >::unique_ptr<TechnicalServices::External::GatewayPayment,std::default_delete<TechnicalServices::External::GatewayPayment> ><std::default_delete<TechnicalServices::External::GatewayPayment>,0>, COMDAT
; 2590 : explicit unique_ptr(pointer _Ptr) noexcept : _Mypair(_Zero_then_variadic_args_t{}, _Ptr) {}
$LN3:
mov QWORD PTR [rsp+16], rdx
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 264 ; 00000108H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 66 ; 00000042H
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+296]
lea rcx, OFFSET FLAT:__6A935154_memory
call __CheckForDebuggerJustMyCode
mov rax, QWORD PTR this$[rbp]
mov QWORD PTR tv70[rbp], rax
lea r8, QWORD PTR _Ptr$[rbp]
movzx edx, BYTE PTR $T1[rbp]
mov rcx, QWORD PTR tv70[rbp]
call ??$?0AEAPEAUGatewayPayment@External@TechnicalServices@@@?$_Compressed_pair@U?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@PEAUGatewayPayment@External@TechnicalServices@@$00@std@@QEAA@U_Zero_then_variadic_args_t@1@AEAPEAUGatewayPayment@External@TechnicalServices@@@Z ; std::_Compressed_pair<std::default_delete<TechnicalServices::External::GatewayPayment>,TechnicalServices::External::GatewayPayment *,1>::_Compressed_pair<std::default_delete<TechnicalServices::External::GatewayPayment>,TechnicalServices::External::GatewayPayment *,1><TechnicalServices::External::GatewayPayment * &>
mov rax, QWORD PTR this$[rbp]
lea rsp, QWORD PTR [rbp+232]
pop rdi
pop rbp
ret 0
??$?0U?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@$0A@@?$unique_ptr@UGatewayPayment@External@TechnicalServices@@U?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@@std@@QEAA@PEAUGatewayPayment@External@TechnicalServices@@@Z ENDP ; std::unique_ptr<TechnicalServices::External::GatewayPayment,std::default_delete<TechnicalServices::External::GatewayPayment> >::unique_ptr<TechnicalServices::External::GatewayPayment,std::default_delete<TechnicalServices::External::GatewayPayment> ><std::default_delete<TechnicalServices::External::GatewayPayment>,0>
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\xmemory
; COMDAT ??$?0U?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@PEAUDebitPayment@External@TechnicalServices@@@?$_Compressed_pair@U?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@PEAVPaymentHandlerInterface@External@TechnicalServices@@$00@std@@QEAA@U_One_then_variadic_args_t@1@$$QEAU?$default_delete@UDebitPayment@External@TechnicalServices@@@1@$$QEAPEAUDebitPayment@External@TechnicalServices@@@Z
_TEXT SEGMENT
this$ = 224
__formal$ = 232
_Val1$ = 240
<_Val2_0>$ = 248
??$?0U?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@PEAUDebitPayment@External@TechnicalServices@@@?$_Compressed_pair@U?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@PEAVPaymentHandlerInterface@External@TechnicalServices@@$00@std@@QEAA@U_One_then_variadic_args_t@1@$$QEAU?$default_delete@UDebitPayment@External@TechnicalServices@@@1@$$QEAPEAUDebitPayment@External@TechnicalServices@@@Z PROC ; std::_Compressed_pair<std::default_delete<TechnicalServices::External::PaymentHandlerInterface>,TechnicalServices::External::PaymentHandlerInterface *,1>::_Compressed_pair<std::default_delete<TechnicalServices::External::PaymentHandlerInterface>,TechnicalServices::External::PaymentHandlerInterface *,1><std::default_delete<TechnicalServices::External::DebitPayment>,TechnicalServices::External::DebitPayment *>, COMDAT
; 1344 : : _Ty1(_STD forward<_Other1>(_Val1)), _Myval2(_STD forward<_Other2>(_Val2)...) {}
$LN3:
mov QWORD PTR [rsp+32], r9
mov QWORD PTR [rsp+24], r8
mov BYTE PTR [rsp+16], dl
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+264]
lea rcx, OFFSET FLAT:__F1739482_xmemory
call __CheckForDebuggerJustMyCode
mov rcx, QWORD PTR _Val1$[rbp]
call ??$forward@U?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@@std@@YA$$QEAU?$default_delete@UDebitPayment@External@TechnicalServices@@@0@AEAU10@@Z ; std::forward<std::default_delete<TechnicalServices::External::DebitPayment> >
mov rdx, rax
mov rcx, QWORD PTR this$[rbp]
call ??$?0UDebitPayment@External@TechnicalServices@@$0A@@?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@QEAA@AEBU?$default_delete@UDebitPayment@External@TechnicalServices@@@1@@Z ; std::default_delete<TechnicalServices::External::PaymentHandlerInterface>::default_delete<TechnicalServices::External::PaymentHandlerInterface><TechnicalServices::External::DebitPayment,0>
mov rcx, QWORD PTR <_Val2_0>$[rbp]
call ??$forward@PEAUDebitPayment@External@TechnicalServices@@@std@@YA$$QEAPEAUDebitPayment@External@TechnicalServices@@AEAPEAU123@@Z ; std::forward<TechnicalServices::External::DebitPayment *>
mov rcx, QWORD PTR this$[rbp]
mov rax, QWORD PTR [rax]
mov QWORD PTR [rcx], rax
mov rax, QWORD PTR this$[rbp]
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
??$?0U?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@PEAUDebitPayment@External@TechnicalServices@@@?$_Compressed_pair@U?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@PEAVPaymentHandlerInterface@External@TechnicalServices@@$00@std@@QEAA@U_One_then_variadic_args_t@1@$$QEAU?$default_delete@UDebitPayment@External@TechnicalServices@@@1@$$QEAPEAUDebitPayment@External@TechnicalServices@@@Z ENDP ; std::_Compressed_pair<std::default_delete<TechnicalServices::External::PaymentHandlerInterface>,TechnicalServices::External::PaymentHandlerInterface *,1>::_Compressed_pair<std::default_delete<TechnicalServices::External::PaymentHandlerInterface>,TechnicalServices::External::PaymentHandlerInterface *,1><std::default_delete<TechnicalServices::External::DebitPayment>,TechnicalServices::External::DebitPayment *>
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\type_traits
; COMDAT ??$forward@U?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@@std@@YA$$QEAU?$default_delete@UDebitPayment@External@TechnicalServices@@@0@AEAU10@@Z
_TEXT SEGMENT
_Arg$ = 224
??$forward@U?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@@std@@YA$$QEAU?$default_delete@UDebitPayment@External@TechnicalServices@@@0@AEAU10@@Z PROC ; std::forward<std::default_delete<TechnicalServices::External::DebitPayment> >, COMDAT
; 1442 : remove_reference_t<_Ty>& _Arg) noexcept { // forward an lvalue as either an lvalue or an rvalue
$LN3:
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+264]
lea rcx, OFFSET FLAT:__2D26A21E_type_traits
call __CheckForDebuggerJustMyCode
; 1443 : return static_cast<_Ty&&>(_Arg);
mov rax, QWORD PTR _Arg$[rbp]
; 1444 : }
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
??$forward@U?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@@std@@YA$$QEAU?$default_delete@UDebitPayment@External@TechnicalServices@@@0@AEAU10@@Z ENDP ; std::forward<std::default_delete<TechnicalServices::External::DebitPayment> >
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\memory
; COMDAT ??$?0U?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@$0A@@?$unique_ptr@UDebitPayment@External@TechnicalServices@@U?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@@std@@QEAA@PEAUDebitPayment@External@TechnicalServices@@@Z
_TEXT SEGMENT
$T1 = 196
tv70 = 216
this$ = 256
_Ptr$ = 264
??$?0U?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@$0A@@?$unique_ptr@UDebitPayment@External@TechnicalServices@@U?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@@std@@QEAA@PEAUDebitPayment@External@TechnicalServices@@@Z PROC ; std::unique_ptr<TechnicalServices::External::DebitPayment,std::default_delete<TechnicalServices::External::DebitPayment> >::unique_ptr<TechnicalServices::External::DebitPayment,std::default_delete<TechnicalServices::External::DebitPayment> ><std::default_delete<TechnicalServices::External::DebitPayment>,0>, COMDAT
; 2590 : explicit unique_ptr(pointer _Ptr) noexcept : _Mypair(_Zero_then_variadic_args_t{}, _Ptr) {}
$LN3:
mov QWORD PTR [rsp+16], rdx
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 264 ; 00000108H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 66 ; 00000042H
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+296]
lea rcx, OFFSET FLAT:__6A935154_memory
call __CheckForDebuggerJustMyCode
mov rax, QWORD PTR this$[rbp]
mov QWORD PTR tv70[rbp], rax
lea r8, QWORD PTR _Ptr$[rbp]
movzx edx, BYTE PTR $T1[rbp]
mov rcx, QWORD PTR tv70[rbp]
call ??$?0AEAPEAUDebitPayment@External@TechnicalServices@@@?$_Compressed_pair@U?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@PEAUDebitPayment@External@TechnicalServices@@$00@std@@QEAA@U_Zero_then_variadic_args_t@1@AEAPEAUDebitPayment@External@TechnicalServices@@@Z ; std::_Compressed_pair<std::default_delete<TechnicalServices::External::DebitPayment>,TechnicalServices::External::DebitPayment *,1>::_Compressed_pair<std::default_delete<TechnicalServices::External::DebitPayment>,TechnicalServices::External::DebitPayment *,1><TechnicalServices::External::DebitPayment * &>
mov rax, QWORD PTR this$[rbp]
lea rsp, QWORD PTR [rbp+232]
pop rdi
pop rbp
ret 0
??$?0U?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@$0A@@?$unique_ptr@UDebitPayment@External@TechnicalServices@@U?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@@std@@QEAA@PEAUDebitPayment@External@TechnicalServices@@@Z ENDP ; std::unique_ptr<TechnicalServices::External::DebitPayment,std::default_delete<TechnicalServices::External::DebitPayment> >::unique_ptr<TechnicalServices::External::DebitPayment,std::default_delete<TechnicalServices::External::DebitPayment> ><std::default_delete<TechnicalServices::External::DebitPayment>,0>
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\xmemory
; COMDAT ??$?0U?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@PEAUCreditPayment@External@TechnicalServices@@@?$_Compressed_pair@U?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@PEAVPaymentHandlerInterface@External@TechnicalServices@@$00@std@@QEAA@U_One_then_variadic_args_t@1@$$QEAU?$default_delete@UCreditPayment@External@TechnicalServices@@@1@$$QEAPEAUCreditPayment@External@TechnicalServices@@@Z
_TEXT SEGMENT
this$ = 224
__formal$ = 232
_Val1$ = 240
<_Val2_0>$ = 248
??$?0U?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@PEAUCreditPayment@External@TechnicalServices@@@?$_Compressed_pair@U?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@PEAVPaymentHandlerInterface@External@TechnicalServices@@$00@std@@QEAA@U_One_then_variadic_args_t@1@$$QEAU?$default_delete@UCreditPayment@External@TechnicalServices@@@1@$$QEAPEAUCreditPayment@External@TechnicalServices@@@Z PROC ; std::_Compressed_pair<std::default_delete<TechnicalServices::External::PaymentHandlerInterface>,TechnicalServices::External::PaymentHandlerInterface *,1>::_Compressed_pair<std::default_delete<TechnicalServices::External::PaymentHandlerInterface>,TechnicalServices::External::PaymentHandlerInterface *,1><std::default_delete<TechnicalServices::External::CreditPayment>,TechnicalServices::External::CreditPayment *>, COMDAT
; 1344 : : _Ty1(_STD forward<_Other1>(_Val1)), _Myval2(_STD forward<_Other2>(_Val2)...) {}
$LN3:
mov QWORD PTR [rsp+32], r9
mov QWORD PTR [rsp+24], r8
mov BYTE PTR [rsp+16], dl
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+264]
lea rcx, OFFSET FLAT:__F1739482_xmemory
call __CheckForDebuggerJustMyCode
mov rcx, QWORD PTR _Val1$[rbp]
call ??$forward@U?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@@std@@YA$$QEAU?$default_delete@UCreditPayment@External@TechnicalServices@@@0@AEAU10@@Z ; std::forward<std::default_delete<TechnicalServices::External::CreditPayment> >
mov rdx, rax
mov rcx, QWORD PTR this$[rbp]
call ??$?0UCreditPayment@External@TechnicalServices@@$0A@@?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@QEAA@AEBU?$default_delete@UCreditPayment@External@TechnicalServices@@@1@@Z ; std::default_delete<TechnicalServices::External::PaymentHandlerInterface>::default_delete<TechnicalServices::External::PaymentHandlerInterface><TechnicalServices::External::CreditPayment,0>
mov rcx, QWORD PTR <_Val2_0>$[rbp]
call ??$forward@PEAUCreditPayment@External@TechnicalServices@@@std@@YA$$QEAPEAUCreditPayment@External@TechnicalServices@@AEAPEAU123@@Z ; std::forward<TechnicalServices::External::CreditPayment *>
mov rcx, QWORD PTR this$[rbp]
mov rax, QWORD PTR [rax]
mov QWORD PTR [rcx], rax
mov rax, QWORD PTR this$[rbp]
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
??$?0U?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@PEAUCreditPayment@External@TechnicalServices@@@?$_Compressed_pair@U?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@PEAVPaymentHandlerInterface@External@TechnicalServices@@$00@std@@QEAA@U_One_then_variadic_args_t@1@$$QEAU?$default_delete@UCreditPayment@External@TechnicalServices@@@1@$$QEAPEAUCreditPayment@External@TechnicalServices@@@Z ENDP ; std::_Compressed_pair<std::default_delete<TechnicalServices::External::PaymentHandlerInterface>,TechnicalServices::External::PaymentHandlerInterface *,1>::_Compressed_pair<std::default_delete<TechnicalServices::External::PaymentHandlerInterface>,TechnicalServices::External::PaymentHandlerInterface *,1><std::default_delete<TechnicalServices::External::CreditPayment>,TechnicalServices::External::CreditPayment *>
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\type_traits
; COMDAT ??$forward@U?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@@std@@YA$$QEAU?$default_delete@UCreditPayment@External@TechnicalServices@@@0@AEAU10@@Z
_TEXT SEGMENT
_Arg$ = 224
??$forward@U?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@@std@@YA$$QEAU?$default_delete@UCreditPayment@External@TechnicalServices@@@0@AEAU10@@Z PROC ; std::forward<std::default_delete<TechnicalServices::External::CreditPayment> >, COMDAT
; 1442 : remove_reference_t<_Ty>& _Arg) noexcept { // forward an lvalue as either an lvalue or an rvalue
$LN3:
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+264]
lea rcx, OFFSET FLAT:__2D26A21E_type_traits
call __CheckForDebuggerJustMyCode
; 1443 : return static_cast<_Ty&&>(_Arg);
mov rax, QWORD PTR _Arg$[rbp]
; 1444 : }
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
??$forward@U?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@@std@@YA$$QEAU?$default_delete@UCreditPayment@External@TechnicalServices@@@0@AEAU10@@Z ENDP ; std::forward<std::default_delete<TechnicalServices::External::CreditPayment> >
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\memory
; COMDAT ??$?0U?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@$0A@@?$unique_ptr@UCreditPayment@External@TechnicalServices@@U?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@@std@@QEAA@PEAUCreditPayment@External@TechnicalServices@@@Z
_TEXT SEGMENT
$T1 = 196
tv70 = 216
this$ = 256
_Ptr$ = 264
??$?0U?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@$0A@@?$unique_ptr@UCreditPayment@External@TechnicalServices@@U?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@@std@@QEAA@PEAUCreditPayment@External@TechnicalServices@@@Z PROC ; std::unique_ptr<TechnicalServices::External::CreditPayment,std::default_delete<TechnicalServices::External::CreditPayment> >::unique_ptr<TechnicalServices::External::CreditPayment,std::default_delete<TechnicalServices::External::CreditPayment> ><std::default_delete<TechnicalServices::External::CreditPayment>,0>, COMDAT
; 2590 : explicit unique_ptr(pointer _Ptr) noexcept : _Mypair(_Zero_then_variadic_args_t{}, _Ptr) {}
$LN3:
mov QWORD PTR [rsp+16], rdx
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 264 ; 00000108H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 66 ; 00000042H
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+296]
lea rcx, OFFSET FLAT:__6A935154_memory
call __CheckForDebuggerJustMyCode
mov rax, QWORD PTR this$[rbp]
mov QWORD PTR tv70[rbp], rax
lea r8, QWORD PTR _Ptr$[rbp]
movzx edx, BYTE PTR $T1[rbp]
mov rcx, QWORD PTR tv70[rbp]
call ??$?0AEAPEAUCreditPayment@External@TechnicalServices@@@?$_Compressed_pair@U?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@PEAUCreditPayment@External@TechnicalServices@@$00@std@@QEAA@U_Zero_then_variadic_args_t@1@AEAPEAUCreditPayment@External@TechnicalServices@@@Z ; std::_Compressed_pair<std::default_delete<TechnicalServices::External::CreditPayment>,TechnicalServices::External::CreditPayment *,1>::_Compressed_pair<std::default_delete<TechnicalServices::External::CreditPayment>,TechnicalServices::External::CreditPayment *,1><TechnicalServices::External::CreditPayment * &>
mov rax, QWORD PTR this$[rbp]
lea rsp, QWORD PTR [rbp+232]
pop rdi
pop rbp
ret 0
??$?0U?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@$0A@@?$unique_ptr@UCreditPayment@External@TechnicalServices@@U?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@@std@@QEAA@PEAUCreditPayment@External@TechnicalServices@@@Z ENDP ; std::unique_ptr<TechnicalServices::External::CreditPayment,std::default_delete<TechnicalServices::External::CreditPayment> >::unique_ptr<TechnicalServices::External::CreditPayment,std::default_delete<TechnicalServices::External::CreditPayment> ><std::default_delete<TechnicalServices::External::CreditPayment>,0>
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\xstring
; COMDAT ??$_Insert_string@DU?$char_traits@D@std@@_K@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@QEBD_K@Z
_TEXT SEGMENT
_State$ = 4
_Pad$ = 40
_Ok$ = 72
$T4 = 308
$T5 = 340
$T6 = 372
$T7 = 404
$T8 = 440
tv136 = 452
tv312 = 456
tv310 = 456
tv307 = 456
tv302 = 456
tv287 = 456
tv273 = 456
tv252 = 464
tv216 = 464
tv191 = 464
tv313 = 472
tv311 = 472
tv308 = 472
tv250 = 473
tv189 = 473
tv314 = 476
tv309 = 476
__$ArrayPad$ = 480
_Ostr$ = 528
_Data$ = 536
_Size$ = 544
??$_Insert_string@DU?$char_traits@D@std@@_K@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@QEBD_K@Z PROC ; std::_Insert_string<char,std::char_traits<char>,unsigned __int64>, COMDAT
; 479 : basic_ostream<_Elem, _Traits>& _Ostr, const _Elem* const _Data, const _SizeT _Size) {
$LN26:
mov QWORD PTR [rsp+24], r8
mov QWORD PTR [rsp+16], rdx
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 536 ; 00000218H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 134 ; 00000086H
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+568]
mov rax, QWORD PTR __security_cookie
xor rax, rbp
mov QWORD PTR __$ArrayPad$[rbp], rax
lea rcx, OFFSET FLAT:__85A0121E_xstring
call __CheckForDebuggerJustMyCode
; 480 : // insert a character-type sequence into _Ostr as if through a basic_string copy
; 481 : using _Ostr_t = basic_ostream<_Elem, _Traits>;
; 482 : typename _Ostr_t::iostate _State = _Ostr_t::goodbit;
mov DWORD PTR _State$[rbp], 0
; 483 :
; 484 : _SizeT _Pad;
; 485 : if (_Ostr.width() <= 0 || static_cast<_SizeT>(_Ostr.width()) <= _Size) {
mov rax, QWORD PTR _Ostr$[rbp]
mov rax, QWORD PTR [rax]
movsxd rax, DWORD PTR [rax+4]
mov rcx, QWORD PTR _Ostr$[rbp]
add rcx, rax
mov rax, rcx
mov rcx, rax
call QWORD PTR __imp_?width@ios_base@std@@QEBA_JXZ
test rax, rax
jle SHORT $LN10@Insert_str
mov rax, QWORD PTR _Ostr$[rbp]
mov rax, QWORD PTR [rax]
movsxd rax, DWORD PTR [rax+4]
mov rcx, QWORD PTR _Ostr$[rbp]
add rcx, rax
mov rax, rcx
mov rcx, rax
call QWORD PTR __imp_?width@ios_base@std@@QEBA_JXZ
cmp rax, QWORD PTR _Size$[rbp]
ja SHORT $LN8@Insert_str
$LN10@Insert_str:
; 486 : _Pad = 0;
mov QWORD PTR _Pad$[rbp], 0
; 487 : } else {
jmp SHORT $LN9@Insert_str
$LN8@Insert_str:
; 488 : _Pad = static_cast<_SizeT>(_Ostr.width()) - _Size;
mov rax, QWORD PTR _Ostr$[rbp]
mov rax, QWORD PTR [rax]
movsxd rax, DWORD PTR [rax+4]
mov rcx, QWORD PTR _Ostr$[rbp]
add rcx, rax
mov rax, rcx
mov rcx, rax
call QWORD PTR __imp_?width@ios_base@std@@QEBA_JXZ
sub rax, QWORD PTR _Size$[rbp]
mov QWORD PTR _Pad$[rbp], rax
$LN9@Insert_str:
; 489 : }
; 490 :
; 491 : const typename _Ostr_t::sentry _Ok(_Ostr);
mov rdx, QWORD PTR _Ostr$[rbp]
lea rcx, QWORD PTR _Ok$[rbp]
call ??0sentry@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAA@AEAV12@@Z ; std::basic_ostream<char,std::char_traits<char> >::sentry::sentry
npad 1
; 492 :
; 493 : if (!_Ok) {
lea rcx, QWORD PTR _Ok$[rbp]
call ??Bsentry@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEBA_NXZ ; std::basic_ostream<char,std::char_traits<char> >::sentry::operator bool
movzx eax, al
test eax, eax
jne SHORT $LN11@Insert_str
; 494 : _State |= _Ostr_t::badbit;
mov eax, DWORD PTR _State$[rbp]
or eax, 4
mov DWORD PTR _State$[rbp], eax
; 495 : } else { // state okay, insert characters
jmp $LN12@Insert_str
$LN11@Insert_str:
; 496 : _TRY_IO_BEGIN
; 497 : if ((_Ostr.flags() & _Ostr_t::adjustfield) != _Ostr_t::left) {
mov rax, QWORD PTR _Ostr$[rbp]
mov rax, QWORD PTR [rax]
movsxd rax, DWORD PTR [rax+4]
mov rcx, QWORD PTR _Ostr$[rbp]
add rcx, rax
mov rax, rcx
mov rcx, rax
call QWORD PTR __imp_?flags@ios_base@std@@QEBAHXZ
mov DWORD PTR tv136[rbp], eax
mov eax, DWORD PTR tv136[rbp]
and eax, 448 ; 000001c0H
cmp eax, 64 ; 00000040H
je $LN14@Insert_str
; 498 : for (; 0 < _Pad; --_Pad) { // pad on left
jmp SHORT $LN4@Insert_str
$LN2@Insert_str:
mov rax, QWORD PTR _Pad$[rbp]
dec rax
mov QWORD PTR _Pad$[rbp], rax
$LN4@Insert_str:
cmp QWORD PTR _Pad$[rbp], 0
jbe $LN14@Insert_str
; 499 : if (_Traits::eq_int_type(_Traits::eof(), _Ostr.rdbuf()->sputc(_Ostr.fill()))) {
mov rax, QWORD PTR _Ostr$[rbp]
mov rax, QWORD PTR [rax]
movsxd rax, DWORD PTR [rax+4]
mov rcx, QWORD PTR _Ostr$[rbp]
add rcx, rax
mov rax, rcx
mov rcx, rax
call QWORD PTR __imp_?rdbuf@?$basic_ios@DU?$char_traits@D@std@@@std@@QEBAPEAV?$basic_streambuf@DU?$char_traits@D@std@@@2@XZ
mov QWORD PTR tv307[rbp], rax
mov rax, QWORD PTR tv307[rbp]
mov QWORD PTR tv191[rbp], rax
mov rax, QWORD PTR _Ostr$[rbp]
mov rax, QWORD PTR [rax]
movsxd rax, DWORD PTR [rax+4]
mov rcx, QWORD PTR _Ostr$[rbp]
add rcx, rax
mov rax, rcx
mov rcx, rax
call QWORD PTR __imp_?fill@?$basic_ios@DU?$char_traits@D@std@@@std@@QEBADXZ
mov BYTE PTR tv308[rbp], al
movzx eax, BYTE PTR tv308[rbp]
mov BYTE PTR tv189[rbp], al
movzx edx, BYTE PTR tv189[rbp]
mov rcx, QWORD PTR tv191[rbp]
call QWORD PTR __imp_?sputc@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QEAAHD@Z
mov DWORD PTR tv309[rbp], eax
mov eax, DWORD PTR tv309[rbp]
mov DWORD PTR $T4[rbp], eax
call ?eof@?$_Narrow_char_traits@DH@std@@SAHXZ ; std::_Narrow_char_traits<char,int>::eof
mov DWORD PTR $T5[rbp], eax
lea rdx, QWORD PTR $T4[rbp]
lea rcx, QWORD PTR $T5[rbp]
call ?eq_int_type@?$_Narrow_char_traits@DH@std@@SA_NAEBH0@Z ; std::_Narrow_char_traits<char,int>::eq_int_type
movzx eax, al
test eax, eax
je SHORT $LN15@Insert_str
; 500 : _State |= _Ostr_t::badbit; // insertion failed, quit
mov eax, DWORD PTR _State$[rbp]
or eax, 4
mov DWORD PTR _State$[rbp], eax
; 501 : break;
jmp SHORT $LN14@Insert_str
$LN15@Insert_str:
; 502 : }
; 503 : }
jmp $LN2@Insert_str
$LN14@Insert_str:
; 504 : }
; 505 :
; 506 : if (_State == _Ostr_t::goodbit
; 507 : && _Ostr.rdbuf()->sputn(_Data, static_cast<streamsize>(_Size)) != static_cast<streamsize>(_Size)) {
cmp DWORD PTR _State$[rbp], 0
jne SHORT $LN16@Insert_str
mov rax, QWORD PTR _Ostr$[rbp]
mov rax, QWORD PTR [rax]
movsxd rax, DWORD PTR [rax+4]
mov rcx, QWORD PTR _Ostr$[rbp]
add rcx, rax
mov rax, rcx
mov rcx, rax
call QWORD PTR __imp_?rdbuf@?$basic_ios@DU?$char_traits@D@std@@@std@@QEBAPEAV?$basic_streambuf@DU?$char_traits@D@std@@@2@XZ
mov QWORD PTR tv310[rbp], rax
mov rax, QWORD PTR tv310[rbp]
mov QWORD PTR tv216[rbp], rax
mov r8, QWORD PTR _Size$[rbp]
mov rdx, QWORD PTR _Data$[rbp]
mov rcx, QWORD PTR tv216[rbp]
call QWORD PTR __imp_?sputn@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QEAA_JPEBD_J@Z
mov QWORD PTR tv311[rbp], rax
mov rax, QWORD PTR _Size$[rbp]
cmp QWORD PTR tv311[rbp], rax
je SHORT $LN16@Insert_str
; 508 : _State |= _Ostr_t::badbit;
mov eax, DWORD PTR _State$[rbp]
or eax, 4
mov DWORD PTR _State$[rbp], eax
; 509 : } else {
jmp $LN17@Insert_str
$LN16@Insert_str:
; 510 : for (; 0 < _Pad; --_Pad) { // pad on right
jmp SHORT $LN7@Insert_str
$LN5@Insert_str:
mov rax, QWORD PTR _Pad$[rbp]
dec rax
mov QWORD PTR _Pad$[rbp], rax
$LN7@Insert_str:
cmp QWORD PTR _Pad$[rbp], 0
jbe $LN17@Insert_str
; 511 : if (_Traits::eq_int_type(_Traits::eof(), _Ostr.rdbuf()->sputc(_Ostr.fill()))) {
mov rax, QWORD PTR _Ostr$[rbp]
mov rax, QWORD PTR [rax]
movsxd rax, DWORD PTR [rax+4]
mov rcx, QWORD PTR _Ostr$[rbp]
add rcx, rax
mov rax, rcx
mov rcx, rax
call QWORD PTR __imp_?rdbuf@?$basic_ios@DU?$char_traits@D@std@@@std@@QEBAPEAV?$basic_streambuf@DU?$char_traits@D@std@@@2@XZ
mov QWORD PTR tv312[rbp], rax
mov rax, QWORD PTR tv312[rbp]
mov QWORD PTR tv252[rbp], rax
mov rax, QWORD PTR _Ostr$[rbp]
mov rax, QWORD PTR [rax]
movsxd rax, DWORD PTR [rax+4]
mov rcx, QWORD PTR _Ostr$[rbp]
add rcx, rax
mov rax, rcx
mov rcx, rax
call QWORD PTR __imp_?fill@?$basic_ios@DU?$char_traits@D@std@@@std@@QEBADXZ
mov BYTE PTR tv313[rbp], al
movzx eax, BYTE PTR tv313[rbp]
mov BYTE PTR tv250[rbp], al
movzx edx, BYTE PTR tv250[rbp]
mov rcx, QWORD PTR tv252[rbp]
call QWORD PTR __imp_?sputc@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QEAAHD@Z
mov DWORD PTR tv314[rbp], eax
mov eax, DWORD PTR tv314[rbp]
mov DWORD PTR $T6[rbp], eax
call ?eof@?$_Narrow_char_traits@DH@std@@SAHXZ ; std::_Narrow_char_traits<char,int>::eof
mov DWORD PTR $T7[rbp], eax
lea rdx, QWORD PTR $T6[rbp]
lea rcx, QWORD PTR $T7[rbp]
call ?eq_int_type@?$_Narrow_char_traits@DH@std@@SA_NAEBH0@Z ; std::_Narrow_char_traits<char,int>::eq_int_type
movzx eax, al
test eax, eax
je SHORT $LN18@Insert_str
; 512 : _State |= _Ostr_t::badbit; // insertion failed, quit
mov eax, DWORD PTR _State$[rbp]
or eax, 4
mov DWORD PTR _State$[rbp], eax
; 513 : break;
jmp SHORT $LN17@Insert_str
$LN18@Insert_str:
; 514 : }
; 515 : }
jmp $LN5@Insert_str
$LN17@Insert_str:
; 516 : }
; 517 :
; 518 : _Ostr.width(0);
mov rax, QWORD PTR _Ostr$[rbp]
mov rax, QWORD PTR [rax]
movsxd rax, DWORD PTR [rax+4]
mov rcx, QWORD PTR _Ostr$[rbp]
add rcx, rax
mov rax, rcx
mov QWORD PTR tv273[rbp], rax
xor edx, edx
mov rcx, QWORD PTR tv273[rbp]
call QWORD PTR __imp_?width@ios_base@std@@QEAA_J_J@Z
npad 1
jmp SHORT $LN12@Insert_str
$LN24@Insert_str:
$LN12@Insert_str:
; 519 : _CATCH_IO_(_Ostr_t, _Ostr)
; 520 : }
; 521 :
; 522 : _Ostr.setstate(_State);
mov rax, QWORD PTR _Ostr$[rbp]
mov rax, QWORD PTR [rax]
movsxd rax, DWORD PTR [rax+4]
mov rcx, QWORD PTR _Ostr$[rbp]
add rcx, rax
mov rax, rcx
mov QWORD PTR tv302[rbp], rax
xor r8d, r8d
mov edx, DWORD PTR _State$[rbp]
mov rcx, QWORD PTR tv302[rbp]
call QWORD PTR __imp_?setstate@?$basic_ios@DU?$char_traits@D@std@@@std@@QEAAXH_N@Z
; 523 : return _Ostr;
mov rax, QWORD PTR _Ostr$[rbp]
mov QWORD PTR $T8[rbp], rax
lea rcx, QWORD PTR _Ok$[rbp]
call ??1sentry@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAA@XZ ; std::basic_ostream<char,std::char_traits<char> >::sentry::~sentry
mov rax, QWORD PTR $T8[rbp]
; 524 : }
mov rdi, rax
lea rcx, QWORD PTR [rbp-32]
lea rdx, OFFSET FLAT:??$_Insert_string@DU?$char_traits@D@std@@_K@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@QEBD_K@Z$rtcFrameData
call _RTC_CheckStackVars
mov rax, rdi
mov rcx, QWORD PTR __$ArrayPad$[rbp]
xor rcx, rbp
call __security_check_cookie
lea rsp, QWORD PTR [rbp+504]
pop rdi
pop rbp
ret 0
??$_Insert_string@DU?$char_traits@D@std@@_K@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@QEBD_K@Z ENDP ; std::_Insert_string<char,std::char_traits<char>,unsigned __int64>
_TEXT ENDS
; COMDAT text$x
text$x SEGMENT
_State$ = 4
_Pad$ = 40
_Ok$ = 72
$T4 = 308
$T5 = 340
$T6 = 372
$T7 = 404
$T8 = 440
tv136 = 452
tv312 = 456
tv310 = 456
tv307 = 456
tv302 = 456
tv287 = 456
tv273 = 456
tv252 = 464
tv216 = 464
tv191 = 464
tv313 = 472
tv311 = 472
tv308 = 472
tv250 = 473
tv189 = 473
tv314 = 476
tv309 = 476
__$ArrayPad$ = 480
_Ostr$ = 528
_Data$ = 536
_Size$ = 544
?dtor$0@?0???$_Insert_string@DU?$char_traits@D@std@@_K@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@QEBD_K@Z@4HA PROC ; `std::_Insert_string<char,std::char_traits<char>,unsigned __int64>'::`1'::dtor$0
mov QWORD PTR [rsp+8], rcx
mov QWORD PTR [rsp+16], rdx
push rbp
push rdi
sub rsp, 40 ; 00000028H
lea rbp, QWORD PTR [rdx+32]
lea rcx, QWORD PTR _Ok$[rbp]
call ??1sentry@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAA@XZ ; std::basic_ostream<char,std::char_traits<char> >::sentry::~sentry
add rsp, 40 ; 00000028H
pop rdi
pop rbp
ret 0
?dtor$0@?0???$_Insert_string@DU?$char_traits@D@std@@_K@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@QEBD_K@Z@4HA ENDP ; `std::_Insert_string<char,std::char_traits<char>,unsigned __int64>'::`1'::dtor$0
text$x ENDS
; COMDAT text$x
text$x SEGMENT
_State$ = 4
_Pad$ = 40
_Ok$ = 72
$T4 = 308
$T5 = 340
$T6 = 372
$T7 = 404
$T8 = 440
tv136 = 452
tv312 = 456
tv310 = 456
tv307 = 456
tv302 = 456
tv287 = 456
tv273 = 456
tv252 = 464
tv216 = 464
tv191 = 464
tv313 = 472
tv311 = 472
tv308 = 472
tv250 = 473
tv189 = 473
tv314 = 476
tv309 = 476
__$ArrayPad$ = 480
_Ostr$ = 528
_Data$ = 536
_Size$ = 544
?catch$1@?0???$_Insert_string@DU?$char_traits@D@std@@_K@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@QEBD_K@Z@4HA PROC ; `std::_Insert_string<char,std::char_traits<char>,unsigned __int64>'::`1'::catch$1
; 519 : _CATCH_IO_(_Ostr_t, _Ostr)
mov QWORD PTR [rsp+8], rcx
mov QWORD PTR [rsp+16], rdx
push rbp
push rdi
sub rsp, 40 ; 00000028H
lea rbp, QWORD PTR [rdx+32]
__catch$??$_Insert_string@DU?$char_traits@D@std@@_K@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@QEBD_K@Z$0:
mov rax, QWORD PTR _Ostr$[rbp]
mov rax, QWORD PTR [rax]
movsxd rax, DWORD PTR [rax+4]
mov rcx, QWORD PTR _Ostr$[rbp]
add rcx, rax
mov rax, rcx
mov QWORD PTR tv287[rbp], rax
mov r8b, 1
mov edx, 4
mov rcx, QWORD PTR tv287[rbp]
call QWORD PTR __imp_?setstate@?$basic_ios@DU?$char_traits@D@std@@@std@@QEAAXH_N@Z
npad 1
lea rax, $LN24@catch$1
add rsp, 40 ; 00000028H
pop rdi
pop rbp
ret 0
int 3
?catch$1@?0???$_Insert_string@DU?$char_traits@D@std@@_K@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@QEBD_K@Z@4HA ENDP ; `std::_Insert_string<char,std::char_traits<char>,unsigned __int64>'::`1'::catch$1
text$x ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; COMDAT text$x
text$x SEGMENT
_State$ = 4
_Pad$ = 40
_Ok$ = 72
$T4 = 308
$T5 = 340
$T6 = 372
$T7 = 404
$T8 = 440
tv136 = 452
tv312 = 456
tv310 = 456
tv307 = 456
tv302 = 456
tv287 = 456
tv273 = 456
tv252 = 464
tv216 = 464
tv191 = 464
tv313 = 472
tv311 = 472
tv308 = 472
tv250 = 473
tv189 = 473
tv314 = 476
tv309 = 476
__$ArrayPad$ = 480
_Ostr$ = 528
_Data$ = 536
_Size$ = 544
?dtor$0@?0???$_Insert_string@DU?$char_traits@D@std@@_K@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@QEBD_K@Z@4HA PROC ; `std::_Insert_string<char,std::char_traits<char>,unsigned __int64>'::`1'::dtor$0
mov QWORD PTR [rsp+8], rcx
mov QWORD PTR [rsp+16], rdx
push rbp
push rdi
sub rsp, 40 ; 00000028H
lea rbp, QWORD PTR [rdx+32]
lea rcx, QWORD PTR _Ok$[rbp]
call ??1sentry@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAA@XZ ; std::basic_ostream<char,std::char_traits<char> >::sentry::~sentry
add rsp, 40 ; 00000028H
pop rdi
pop rbp
ret 0
?dtor$0@?0???$_Insert_string@DU?$char_traits@D@std@@_K@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@QEBD_K@Z@4HA ENDP ; `std::_Insert_string<char,std::char_traits<char>,unsigned __int64>'::`1'::dtor$0
text$x ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; COMDAT text$x
text$x SEGMENT
_State$ = 4
_Pad$ = 40
_Ok$ = 72
$T4 = 308
$T5 = 340
$T6 = 372
$T7 = 404
$T8 = 440
tv136 = 452
tv312 = 456
tv310 = 456
tv307 = 456
tv302 = 456
tv287 = 456
tv273 = 456
tv252 = 464
tv216 = 464
tv191 = 464
tv313 = 472
tv311 = 472
tv308 = 472
tv250 = 473
tv189 = 473
tv314 = 476
tv309 = 476
__$ArrayPad$ = 480
_Ostr$ = 528
_Data$ = 536
_Size$ = 544
?catch$1@?0???$_Insert_string@DU?$char_traits@D@std@@_K@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@QEBD_K@Z@4HA PROC ; `std::_Insert_string<char,std::char_traits<char>,unsigned __int64>'::`1'::catch$1
; 519 : _CATCH_IO_(_Ostr_t, _Ostr)
mov QWORD PTR [rsp+8], rcx
mov QWORD PTR [rsp+16], rdx
push rbp
push rdi
sub rsp, 40 ; 00000028H
lea rbp, QWORD PTR [rdx+32]
__catch$??$_Insert_string@DU?$char_traits@D@std@@_K@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@QEBD_K@Z$0:
mov rax, QWORD PTR _Ostr$[rbp]
mov rax, QWORD PTR [rax]
movsxd rax, DWORD PTR [rax+4]
mov rcx, QWORD PTR _Ostr$[rbp]
add rcx, rax
mov rax, rcx
mov QWORD PTR tv287[rbp], rax
mov r8b, 1
mov edx, 4
mov rcx, QWORD PTR tv287[rbp]
call QWORD PTR __imp_?setstate@?$basic_ios@DU?$char_traits@D@std@@@std@@QEAAXH_N@Z
npad 1
lea rax, $LN24@catch$1
add rsp, 40 ; 00000028H
pop rdi
pop rbp
ret 0
int 3
?catch$1@?0???$_Insert_string@DU?$char_traits@D@std@@_K@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@QEBD_K@Z@4HA ENDP ; `std::_Insert_string<char,std::char_traits<char>,unsigned __int64>'::`1'::catch$1
text$x ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\type_traits
; COMDAT ??$forward@PEAU_Container_base12@std@@@std@@YA$$QEAPEAU_Container_base12@0@AEAPEAU10@@Z
_TEXT SEGMENT
_Arg$ = 224
??$forward@PEAU_Container_base12@std@@@std@@YA$$QEAPEAU_Container_base12@0@AEAPEAU10@@Z PROC ; std::forward<std::_Container_base12 *>, COMDAT
; 1442 : remove_reference_t<_Ty>& _Arg) noexcept { // forward an lvalue as either an lvalue or an rvalue
$LN3:
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+264]
lea rcx, OFFSET FLAT:__2D26A21E_type_traits
call __CheckForDebuggerJustMyCode
; 1443 : return static_cast<_Ty&&>(_Arg);
mov rax, QWORD PTR _Arg$[rbp]
; 1444 : }
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
??$forward@PEAU_Container_base12@std@@@std@@YA$$QEAPEAU_Container_base12@0@AEAPEAU10@@Z ENDP ; std::forward<std::_Container_base12 *>
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\xstddef
; COMDAT ??$addressof@U_Container_proxy@std@@@std@@YAPEAU_Container_proxy@0@AEAU10@@Z
_TEXT SEGMENT
_Val$ = 224
??$addressof@U_Container_proxy@std@@@std@@YAPEAU_Container_proxy@0@AEAU10@@Z PROC ; std::addressof<std::_Container_proxy>, COMDAT
; 274 : _NODISCARD constexpr _Ty* addressof(_Ty& _Val) noexcept {
$LN3:
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+264]
lea rcx, OFFSET FLAT:__6CF96053_xstddef
call __CheckForDebuggerJustMyCode
; 275 : return __builtin_addressof(_Val);
mov rax, QWORD PTR _Val$[rbp]
; 276 : }
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
??$addressof@U_Container_proxy@std@@@std@@YAPEAU_Container_proxy@0@AEAU10@@Z ENDP ; std::addressof<std::_Container_proxy>
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\xmemory
; COMDAT ??$_Get_size_of_n@$00@std@@YA_K_K@Z
_TEXT SEGMENT
_Overflow_is_possible$ = 4
_Count$ = 256
??$_Get_size_of_n@$00@std@@YA_K_K@Z PROC ; std::_Get_size_of_n<1>, COMDAT
; 55 : _NODISCARD constexpr size_t _Get_size_of_n(const size_t _Count) {
$LN3:
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 264 ; 00000108H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 66 ; 00000042H
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+296]
lea rcx, OFFSET FLAT:__F1739482_xmemory
call __CheckForDebuggerJustMyCode
; 56 : constexpr bool _Overflow_is_possible = _Ty_size > 1;
mov BYTE PTR _Overflow_is_possible$[rbp], 0
; 57 :
; 58 : if _CONSTEXPR_IF (_Overflow_is_possible) {
; 59 : constexpr size_t _Max_possible = static_cast<size_t>(-1) / _Ty_size;
; 60 : if (_Count > _Max_possible) {
; 61 : _Throw_bad_array_new_length(); // multiply overflow
; 62 : }
; 63 : }
; 64 :
; 65 : return _Count * _Ty_size;
mov rax, QWORD PTR _Count$[rbp]
; 66 : }
lea rsp, QWORD PTR [rbp+232]
pop rdi
pop rbp
ret 0
??$_Get_size_of_n@$00@std@@YA_K_K@Z ENDP ; std::_Get_size_of_n<1>
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\xmemory
; COMDAT ??$_Deallocate@$0BA@$0A@@std@@YAXPEAX_K@Z
_TEXT SEGMENT
_Ptr$ = 224
_Bytes$ = 232
??$_Deallocate@$0BA@$0A@@std@@YAXPEAX_K@Z PROC ; std::_Deallocate<16,0>, COMDAT
; 213 : void _Deallocate(void* _Ptr, size_t _Bytes) noexcept {
$LN4:
mov QWORD PTR [rsp+16], rdx
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+264]
lea rcx, OFFSET FLAT:__F1739482_xmemory
call __CheckForDebuggerJustMyCode
; 214 : // deallocate storage allocated by _Allocate when !_HAS_ALIGNED_NEW || _Align <= __STDCPP_DEFAULT_NEW_ALIGNMENT__
; 215 : #if defined(_M_IX86) || defined(_M_X64)
; 216 : if (_Bytes >= _Big_allocation_threshold) { // boost the alignment of big allocations to help autovectorization
cmp QWORD PTR _Bytes$[rbp], 4096 ; 00001000H
jb SHORT $LN2@Deallocate
; 217 : _Adjust_manually_vector_aligned(_Ptr, _Bytes);
lea rdx, QWORD PTR _Bytes$[rbp]
lea rcx, QWORD PTR _Ptr$[rbp]
call ?_Adjust_manually_vector_aligned@std@@YAXAEAPEAXAEA_K@Z ; std::_Adjust_manually_vector_aligned
$LN2@Deallocate:
; 218 : }
; 219 : #endif // defined(_M_IX86) || defined(_M_X64)
; 220 :
; 221 : ::operator delete(_Ptr, _Bytes);
mov rdx, QWORD PTR _Bytes$[rbp]
mov rcx, QWORD PTR _Ptr$[rbp]
call ??3@YAXPEAX_K@Z ; operator delete
npad 1
; 222 : }
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
??$_Deallocate@$0BA@$0A@@std@@YAXPEAX_K@Z ENDP ; std::_Deallocate<16,0>
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\xmemory
; COMDAT ??$_Destroy_range@V?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@@std@@YAXPEAUPaymentOption@Persistence@TechnicalServices@@QEAU123@AEAV?$allocator@UPaymentOption@Persistence@TechnicalServices@@@0@@Z
_TEXT SEGMENT
_First$ = 224
_Last$ = 232
_Al$ = 240
??$_Destroy_range@V?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@@std@@YAXPEAUPaymentOption@Persistence@TechnicalServices@@QEAU123@AEAV?$allocator@UPaymentOption@Persistence@TechnicalServices@@@0@@Z PROC ; std::_Destroy_range<std::allocator<TechnicalServices::Persistence::PaymentOption> >, COMDAT
; 962 : _Alloc_ptr_t<_Alloc> _First, const _Alloc_ptr_t<_Alloc> _Last, _Alloc& _Al) noexcept {
$LN6:
mov QWORD PTR [rsp+24], r8
mov QWORD PTR [rsp+16], rdx
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+264]
lea rcx, OFFSET FLAT:__F1739482_xmemory
call __CheckForDebuggerJustMyCode
; 963 : // note that this is an optimization for debug mode codegen; in release mode the BE removes all of this
; 964 : using _Ty = typename _Alloc::value_type;
; 965 : if _CONSTEXPR_IF (!conjunction_v<is_trivially_destructible<_Ty>, _Uses_default_destroy<_Alloc, _Ty*>>) {
; 966 : for (; _First != _Last; ++_First) {
jmp SHORT $LN4@Destroy_ra
$LN2@Destroy_ra:
mov rax, QWORD PTR _First$[rbp]
add rax, 48 ; 00000030H
mov QWORD PTR _First$[rbp], rax
$LN4@Destroy_ra:
mov rax, QWORD PTR _Last$[rbp]
cmp QWORD PTR _First$[rbp], rax
je SHORT $LN3@Destroy_ra
; 967 : allocator_traits<_Alloc>::destroy(_Al, _Unfancy(_First));
mov rcx, QWORD PTR _First$[rbp]
call ??$_Unfancy@UPaymentOption@Persistence@TechnicalServices@@@std@@YAPEAUPaymentOption@Persistence@TechnicalServices@@PEAU123@@Z ; std::_Unfancy<TechnicalServices::Persistence::PaymentOption>
mov rdx, rax
mov rcx, QWORD PTR _Al$[rbp]
call ??$destroy@UPaymentOption@Persistence@TechnicalServices@@@?$_Default_allocator_traits@V?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@@std@@SAXAEAV?$allocator@UPaymentOption@Persistence@TechnicalServices@@@1@QEAUPaymentOption@Persistence@TechnicalServices@@@Z ; std::_Default_allocator_traits<std::allocator<TechnicalServices::Persistence::PaymentOption> >::destroy<TechnicalServices::Persistence::PaymentOption>
; 968 : }
jmp SHORT $LN2@Destroy_ra
$LN3@Destroy_ra:
; 969 : }
; 970 : }
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
??$_Destroy_range@V?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@@std@@YAXPEAUPaymentOption@Persistence@TechnicalServices@@QEAU123@AEAV?$allocator@UPaymentOption@Persistence@TechnicalServices@@@0@@Z ENDP ; std::_Destroy_range<std::allocator<TechnicalServices::Persistence::PaymentOption> >
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\xmemory
; COMDAT ??$_Allocate@$0BA@U_Default_allocate_traits@std@@$0A@@std@@YAPEAX_K@Z
_TEXT SEGMENT
_Bytes$ = 224
??$_Allocate@$0BA@U_Default_allocate_traits@std@@$0A@@std@@YAPEAX_K@Z PROC ; std::_Allocate<16,std::_Default_allocate_traits,0>, COMDAT
; 197 : __declspec(allocator) void* _Allocate(const size_t _Bytes) {
$LN5:
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+264]
lea rcx, OFFSET FLAT:__F1739482_xmemory
call __CheckForDebuggerJustMyCode
; 198 : // allocate _Bytes when !_HAS_ALIGNED_NEW || _Align <= __STDCPP_DEFAULT_NEW_ALIGNMENT__
; 199 : #if defined(_M_IX86) || defined(_M_X64)
; 200 : if (_Bytes >= _Big_allocation_threshold) { // boost the alignment of big allocations to help autovectorization
cmp QWORD PTR _Bytes$[rbp], 4096 ; 00001000H
jb SHORT $LN2@Allocate
; 201 : return _Allocate_manually_vector_aligned<_Traits>(_Bytes);
mov rcx, QWORD PTR _Bytes$[rbp]
call ??$_Allocate_manually_vector_aligned@U_Default_allocate_traits@std@@@std@@YAPEAX_K@Z ; std::_Allocate_manually_vector_aligned<std::_Default_allocate_traits>
jmp SHORT $LN1@Allocate
$LN2@Allocate:
; 202 : }
; 203 : #endif // defined(_M_IX86) || defined(_M_X64)
; 204 :
; 205 : if (_Bytes != 0) {
cmp QWORD PTR _Bytes$[rbp], 0
je SHORT $LN3@Allocate
; 206 : return _Traits::_Allocate(_Bytes);
mov rcx, QWORD PTR _Bytes$[rbp]
call ?_Allocate@_Default_allocate_traits@std@@SAPEAX_K@Z ; std::_Default_allocate_traits::_Allocate
jmp SHORT $LN1@Allocate
$LN3@Allocate:
; 207 : }
; 208 :
; 209 : return nullptr;
xor eax, eax
$LN1@Allocate:
; 210 : }
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
??$_Allocate@$0BA@U_Default_allocate_traits@std@@$0A@@std@@YAPEAX_K@Z ENDP ; std::_Allocate<16,std::_Default_allocate_traits,0>
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\xmemory
; COMDAT ??$_Get_size_of_n@$0BA@@std@@YA_K_K@Z
_TEXT SEGMENT
_Overflow_is_possible$ = 4
_Max_possible$1 = 40
_Count$ = 288
??$_Get_size_of_n@$0BA@@std@@YA_K_K@Z PROC ; std::_Get_size_of_n<16>, COMDAT
; 55 : _NODISCARD constexpr size_t _Get_size_of_n(const size_t _Count) {
$LN4:
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 296 ; 00000128H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 74 ; 0000004aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+328]
lea rcx, OFFSET FLAT:__F1739482_xmemory
call __CheckForDebuggerJustMyCode
; 56 : constexpr bool _Overflow_is_possible = _Ty_size > 1;
mov BYTE PTR _Overflow_is_possible$[rbp], 1
; 57 :
; 58 : if _CONSTEXPR_IF (_Overflow_is_possible) {
; 59 : constexpr size_t _Max_possible = static_cast<size_t>(-1) / _Ty_size;
mov rax, 1152921504606846975 ; 0fffffffffffffffH
mov QWORD PTR _Max_possible$1[rbp], rax
; 60 : if (_Count > _Max_possible) {
mov rax, 1152921504606846975 ; 0fffffffffffffffH
cmp QWORD PTR _Count$[rbp], rax
jbe SHORT $LN2@Get_size_o
; 61 : _Throw_bad_array_new_length(); // multiply overflow
call ?_Throw_bad_array_new_length@std@@YAXXZ ; std::_Throw_bad_array_new_length
$LN2@Get_size_o:
; 62 : }
; 63 : }
; 64 :
; 65 : return _Count * _Ty_size;
imul rax, QWORD PTR _Count$[rbp], 16
$LN3@Get_size_o:
; 66 : }
lea rsp, QWORD PTR [rbp+264]
pop rdi
pop rbp
ret 0
??$_Get_size_of_n@$0BA@@std@@YA_K_K@Z ENDP ; std::_Get_size_of_n<16>
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\utility
; COMDAT ??$max@_K@std@@YAAEB_KAEB_K0@Z
_TEXT SEGMENT
$T1 = 200
tv65 = 216
_Left$ = 256
_Right$ = 264
??$max@_K@std@@YAAEB_KAEB_K0@Z PROC ; std::max<unsigned __int64>, COMDAT
; 42 : const _Ty& _Left, const _Ty& _Right) noexcept(noexcept(_Left < _Right)) /* strengthened */ {
$LN5:
mov QWORD PTR [rsp+16], rdx
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 264 ; 00000108H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 66 ; 00000042H
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+296]
lea rcx, OFFSET FLAT:__9BE6F741_utility
call __CheckForDebuggerJustMyCode
; 43 : // return larger of _Left and _Right
; 44 : return _Left < _Right ? _Right : _Left;
mov rax, QWORD PTR _Left$[rbp]
mov rcx, QWORD PTR _Right$[rbp]
mov rcx, QWORD PTR [rcx]
cmp QWORD PTR [rax], rcx
jae SHORT $LN3@max
mov rax, QWORD PTR _Right$[rbp]
mov QWORD PTR tv65[rbp], rax
jmp SHORT $LN4@max
$LN3@max:
mov rax, QWORD PTR _Left$[rbp]
mov QWORD PTR tv65[rbp], rax
$LN4@max:
mov rax, QWORD PTR tv65[rbp]
mov QWORD PTR $T1[rbp], rax
mov rax, QWORD PTR $T1[rbp]
; 45 : }
lea rsp, QWORD PTR [rbp+232]
pop rdi
pop rbp
ret 0
??$max@_K@std@@YAAEB_KAEB_K0@Z ENDP ; std::max<unsigned __int64>
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\xstddef
; COMDAT ??$_Unfancy@D@std@@YAPEADPEAD@Z
_TEXT SEGMENT
_Ptr$ = 224
??$_Unfancy@D@std@@YAPEADPEAD@Z PROC ; std::_Unfancy<char>, COMDAT
; 288 : _NODISCARD constexpr _Ty* _Unfancy(_Ty* _Ptr) noexcept { // do nothing for plain pointers
$LN3:
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+264]
lea rcx, OFFSET FLAT:__6CF96053_xstddef
call __CheckForDebuggerJustMyCode
; 289 : return _Ptr;
mov rax, QWORD PTR _Ptr$[rbp]
; 290 : }
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
??$_Unfancy@D@std@@YAPEADPEAD@Z ENDP ; std::_Unfancy<char>
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\xmemory
; COMDAT ??$_Construct_in_place@PEADAEBQEAD@std@@YAXAEAPEADAEBQEAD@Z
_TEXT SEGMENT
$T1 = 200
_Obj$ = 256
<_Args_0>$ = 264
??$_Construct_in_place@PEADAEBQEAD@std@@YAXAEAPEADAEBQEAD@Z PROC ; std::_Construct_in_place<char *,char * const &>, COMDAT
; 228 : void _Construct_in_place(_Ty& _Obj, _Types&&... _Args) noexcept(is_nothrow_constructible_v<_Ty, _Types...>) {
$LN3:
mov QWORD PTR [rsp+16], rdx
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 264 ; 00000108H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 66 ; 00000042H
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+296]
lea rcx, OFFSET FLAT:__F1739482_xmemory
call __CheckForDebuggerJustMyCode
mov rcx, QWORD PTR _Obj$[rbp]
call ??$addressof@PEAD@std@@YAPEAPEADAEAPEAD@Z ; std::addressof<char *>
mov rdx, rax
mov ecx, 8
call ??2@YAPEAX_KPEAX@Z ; operator new
mov QWORD PTR $T1[rbp], rax
mov rcx, QWORD PTR <_Args_0>$[rbp]
call ??$forward@AEBQEAD@std@@YAAEBQEADAEBQEAD@Z ; std::forward<char * const &>
mov rcx, QWORD PTR $T1[rbp]
mov rax, QWORD PTR [rax]
mov QWORD PTR [rcx], rax
; 229 : ::new (const_cast<void*>(static_cast<const volatile void*>(_STD addressof(_Obj))))
; 230 : _Ty(_STD forward<_Types>(_Args)...);
; 231 : }
lea rsp, QWORD PTR [rbp+232]
pop rdi
pop rbp
ret 0
??$_Construct_in_place@PEADAEBQEAD@std@@YAXAEAPEADAEBQEAD@Z ENDP ; std::_Construct_in_place<char *,char * const &>
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\xmemory
; COMDAT ??$_Pocca@V?$allocator@D@std@@@std@@YAXAEAV?$allocator@D@0@AEBV10@@Z
_TEXT SEGMENT
_Left$ = 224
_Right$ = 232
??$_Pocca@V?$allocator@D@std@@@std@@YAXAEAV?$allocator@D@0@AEBV10@@Z PROC ; std::_Pocca<std::allocator<char> >, COMDAT
; 885 : void _Pocca(_Alloc& _Left, const _Alloc& _Right) noexcept {
$LN3:
mov QWORD PTR [rsp+16], rdx
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+264]
lea rcx, OFFSET FLAT:__F1739482_xmemory
call __CheckForDebuggerJustMyCode
; 886 : if constexpr (allocator_traits<_Alloc>::propagate_on_container_copy_assignment::value) {
; 887 : _Left = _Right;
; 888 : }
; 889 : }
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
??$_Pocca@V?$allocator@D@std@@@std@@YAXAEAV?$allocator@D@0@AEBV10@@Z ENDP ; std::_Pocca<std::allocator<char> >
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\xstring
; COMDAT ??$_Reallocate_for@V<lambda_66f57f934f28d61049862f64df852ff0>@@PEBD@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@AEAAAEAV01@_KV<lambda_66f57f934f28d61049862f64df852ff0>@@PEBD@Z
_TEXT SEGMENT
_Old_capacity$ = 8
_New_capacity$ = 40
_Al$ = 72
_New_ptr$ = 104
__$ArrayPad$ = 312
this$ = 352
_New_size$ = 360
_Fn$ = 368
<_Args_0>$ = 376
??$_Reallocate_for@V<lambda_66f57f934f28d61049862f64df852ff0>@@PEBD@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@AEAAAEAV01@_KV<lambda_66f57f934f28d61049862f64df852ff0>@@PEBD@Z PROC ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::_Reallocate_for<<lambda_66f57f934f28d61049862f64df852ff0>,char const *>, COMDAT
; 4302 : basic_string& _Reallocate_for(const size_type _New_size, _Fty _Fn, _ArgTys... _Args) {
$LN6:
mov QWORD PTR [rsp+32], r9
mov BYTE PTR [rsp+24], r8b
mov QWORD PTR [rsp+16], rdx
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 360 ; 00000168H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 90 ; 0000005aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+392]
mov rax, QWORD PTR __security_cookie
xor rax, rbp
mov QWORD PTR __$ArrayPad$[rbp], rax
lea rcx, OFFSET FLAT:__85A0121E_xstring
call __CheckForDebuggerJustMyCode
; 4303 : // reallocate to store exactly _New_size elements, new buffer prepared by
; 4304 : // _Fn(_New_ptr, _New_size, _Args...)
; 4305 : if (_New_size > max_size()) {
mov rcx, QWORD PTR this$[rbp]
call ?max_size@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEBA_KXZ ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::max_size
cmp QWORD PTR _New_size$[rbp], rax
jbe SHORT $LN2@Reallocate
; 4306 : _Xlen_string(); // result too long
call ?_Xlen_string@std@@YAXXZ ; std::_Xlen_string
$LN2@Reallocate:
; 4307 : }
; 4308 :
; 4309 : const size_type _Old_capacity = _Mypair._Myval2._Myres;
mov rax, QWORD PTR this$[rbp]
mov rax, QWORD PTR [rax+32]
mov QWORD PTR _Old_capacity$[rbp], rax
; 4310 : const size_type _New_capacity = _Calculate_growth(_New_size);
mov rdx, QWORD PTR _New_size$[rbp]
mov rcx, QWORD PTR this$[rbp]
call ?_Calculate_growth@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@AEBA_K_K@Z ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::_Calculate_growth
mov QWORD PTR _New_capacity$[rbp], rax
; 4311 : auto& _Al = _Getal();
mov rcx, QWORD PTR this$[rbp]
call ?_Getal@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@AEAAAEAV?$allocator@D@2@XZ ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::_Getal
mov QWORD PTR _Al$[rbp], rax
; 4312 : const pointer _New_ptr = _Al.allocate(_New_capacity + 1); // throws
mov rax, QWORD PTR _New_capacity$[rbp]
add rax, 1
mov rcx, -1
cmovb rax, rcx
mov rdx, rax
mov rcx, QWORD PTR _Al$[rbp]
call ?allocate@?$allocator@D@std@@QEAAPEAD_K@Z ; std::allocator<char>::allocate
mov QWORD PTR _New_ptr$[rbp], rax
; 4313 : _Mypair._Myval2._Orphan_all();
mov rax, QWORD PTR this$[rbp]
mov rcx, rax
call ?_Orphan_all@_Container_base12@std@@QEAAXXZ ; std::_Container_base12::_Orphan_all
; 4314 : _Mypair._Myval2._Mysize = _New_size;
mov rax, QWORD PTR this$[rbp]
mov rcx, QWORD PTR _New_size$[rbp]
mov QWORD PTR [rax+24], rcx
; 4315 : _Mypair._Myval2._Myres = _New_capacity;
mov rax, QWORD PTR this$[rbp]
mov rcx, QWORD PTR _New_capacity$[rbp]
mov QWORD PTR [rax+32], rcx
; 4316 : _Fn(_Unfancy(_New_ptr), _New_size, _Args...);
mov rcx, QWORD PTR _New_ptr$[rbp]
call ??$_Unfancy@D@std@@YAPEADPEAD@Z ; std::_Unfancy<char>
mov r9, QWORD PTR <_Args_0>$[rbp]
mov r8, QWORD PTR _New_size$[rbp]
mov rdx, rax
lea rcx, QWORD PTR _Fn$[rbp]
call ??R<lambda_66f57f934f28d61049862f64df852ff0>@@QEBA@QEAD_KQEBD@Z ; <lambda_66f57f934f28d61049862f64df852ff0>::operator()
; 4317 : if (_BUF_SIZE <= _Old_capacity) {
cmp QWORD PTR _Old_capacity$[rbp], 16
jb SHORT $LN3@Reallocate
; 4318 : _Al.deallocate(_Mypair._Myval2._Bx._Ptr, _Old_capacity + 1);
mov rax, QWORD PTR _Old_capacity$[rbp]
inc rax
mov r8, rax
mov rax, QWORD PTR this$[rbp]
mov rdx, QWORD PTR [rax+8]
mov rcx, QWORD PTR _Al$[rbp]
call ?deallocate@?$allocator@D@std@@QEAAXQEAD_K@Z ; std::allocator<char>::deallocate
; 4319 : _Mypair._Myval2._Bx._Ptr = _New_ptr;
mov rax, QWORD PTR this$[rbp]
mov rcx, QWORD PTR _New_ptr$[rbp]
mov QWORD PTR [rax+8], rcx
; 4320 : } else {
jmp SHORT $LN4@Reallocate
$LN3@Reallocate:
; 4321 : _Construct_in_place(_Mypair._Myval2._Bx._Ptr, _New_ptr);
mov rax, QWORD PTR this$[rbp]
add rax, 8
lea rdx, QWORD PTR _New_ptr$[rbp]
mov rcx, rax
call ??$_Construct_in_place@PEADAEBQEAD@std@@YAXAEAPEADAEBQEAD@Z ; std::_Construct_in_place<char *,char * const &>
$LN4@Reallocate:
; 4322 : }
; 4323 :
; 4324 : return *this;
mov rax, QWORD PTR this$[rbp]
$LN5@Reallocate:
; 4325 : }
mov rdi, rax
lea rcx, QWORD PTR [rbp-32]
lea rdx, OFFSET FLAT:??$_Reallocate_for@V<lambda_66f57f934f28d61049862f64df852ff0>@@PEBD@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@AEAAAEAV01@_KV<lambda_66f57f934f28d61049862f64df852ff0>@@PEBD@Z$rtcFrameData
call _RTC_CheckStackVars
mov rax, rdi
mov rcx, QWORD PTR __$ArrayPad$[rbp]
xor rcx, rbp
call __security_check_cookie
lea rsp, QWORD PTR [rbp+328]
pop rdi
pop rbp
ret 0
??$_Reallocate_for@V<lambda_66f57f934f28d61049862f64df852ff0>@@PEBD@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@AEAAAEAV01@_KV<lambda_66f57f934f28d61049862f64df852ff0>@@PEBD@Z ENDP ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::_Reallocate_for<<lambda_66f57f934f28d61049862f64df852ff0>,char const *>
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\xstring
; COMDAT ??R<lambda_66f57f934f28d61049862f64df852ff0>@@QEBA@QEAD_KQEBD@Z
_TEXT SEGMENT
$T1 = 196
this$ = 256
_New_ptr$ = 264
_Count$ = 272
_Ptr$ = 280
??R<lambda_66f57f934f28d61049862f64df852ff0>@@QEBA@QEAD_KQEBD@Z PROC ; <lambda_66f57f934f28d61049862f64df852ff0>::operator(), COMDAT
; 3054 : [](_Elem* const _New_ptr, const size_type _Count, const _Elem* const _Ptr) {
$LN3:
mov QWORD PTR [rsp+32], r9
mov QWORD PTR [rsp+24], r8
mov QWORD PTR [rsp+16], rdx
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 264 ; 00000108H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 66 ; 00000042H
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+296]
lea rcx, OFFSET FLAT:__85A0121E_xstring
call __CheckForDebuggerJustMyCode
; 3055 : _Traits::copy(_New_ptr, _Ptr, _Count);
mov r8, QWORD PTR _Count$[rbp]
mov rdx, QWORD PTR _Ptr$[rbp]
mov rcx, QWORD PTR _New_ptr$[rbp]
call ?copy@?$_Char_traits@DH@std@@SAPEADQEADQEBD_K@Z ; std::_Char_traits<char,int>::copy
; 3056 : _Traits::assign(_New_ptr[_Count], _Elem());
mov BYTE PTR $T1[rbp], 0
mov rax, QWORD PTR _Count$[rbp]
mov rcx, QWORD PTR _New_ptr$[rbp]
add rcx, rax
mov rax, rcx
lea rdx, QWORD PTR $T1[rbp]
mov rcx, rax
call ?assign@?$_Narrow_char_traits@DH@std@@SAXAEADAEBD@Z ; std::_Narrow_char_traits<char,int>::assign
; 3057 : },
lea rsp, QWORD PTR [rbp+232]
pop rdi
pop rbp
ret 0
??R<lambda_66f57f934f28d61049862f64df852ff0>@@QEBA@QEAD_KQEBD@Z ENDP ; <lambda_66f57f934f28d61049862f64df852ff0>::operator()
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\xmemory
; COMDAT ??$_Destroy_in_place@PEAD@std@@YAXAEAPEAD@Z
_TEXT SEGMENT
_Obj$ = 224
??$_Destroy_in_place@PEAD@std@@YAXAEAPEAD@Z PROC ; std::_Destroy_in_place<char *>, COMDAT
; 270 : /* _CONSTEXPR20_DYNALLOC */ void _Destroy_in_place(_Ty& _Obj) noexcept {
$LN3:
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+264]
lea rcx, OFFSET FLAT:__F1739482_xmemory
call __CheckForDebuggerJustMyCode
; 271 : #if _HAS_IF_CONSTEXPR
; 272 : if constexpr (is_array_v<_Ty>) {
; 273 : _Destroy_range(_Obj, _Obj + extent_v<_Ty>);
; 274 : } else
; 275 : #endif // _HAS_IF_CONSTEXPR
; 276 : {
; 277 : _Obj.~_Ty();
; 278 : }
; 279 : }
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
??$_Destroy_in_place@PEAD@std@@YAXAEAPEAD@Z ENDP ; std::_Destroy_in_place<char *>
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\xstddef
; COMDAT ??$_Unfancy@U_Container_proxy@std@@@std@@YAPEAU_Container_proxy@0@PEAU10@@Z
_TEXT SEGMENT
_Ptr$ = 224
??$_Unfancy@U_Container_proxy@std@@@std@@YAPEAU_Container_proxy@0@PEAU10@@Z PROC ; std::_Unfancy<std::_Container_proxy>, COMDAT
; 288 : _NODISCARD constexpr _Ty* _Unfancy(_Ty* _Ptr) noexcept { // do nothing for plain pointers
$LN3:
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+264]
lea rcx, OFFSET FLAT:__6CF96053_xstddef
call __CheckForDebuggerJustMyCode
; 289 : return _Ptr;
mov rax, QWORD PTR _Ptr$[rbp]
; 290 : }
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
??$_Unfancy@U_Container_proxy@std@@@std@@YAPEAU_Container_proxy@0@PEAU10@@Z ENDP ; std::_Unfancy<std::_Container_proxy>
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\xmemory
; COMDAT ??$?0$$V@?$_Compressed_pair@V?$allocator@D@std@@V?$_String_val@U?$_Simple_types@D@std@@@2@$00@std@@QEAA@U_Zero_then_variadic_args_t@1@@Z
_TEXT SEGMENT
this$ = 224
__formal$ = 232
??$?0$$V@?$_Compressed_pair@V?$allocator@D@std@@V?$_String_val@U?$_Simple_types@D@std@@@2@$00@std@@QEAA@U_Zero_then_variadic_args_t@1@@Z PROC ; std::_Compressed_pair<std::allocator<char>,std::_String_val<std::_Simple_types<char> >,1>::_Compressed_pair<std::allocator<char>,std::_String_val<std::_Simple_types<char> >,1><>, COMDAT
; 1339 : : _Ty1(), _Myval2(_STD forward<_Other2>(_Val2)...) {}
$LN3:
mov BYTE PTR [rsp+16], dl
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+264]
lea rcx, OFFSET FLAT:__F1739482_xmemory
call __CheckForDebuggerJustMyCode
mov rcx, QWORD PTR this$[rbp]
call ??0?$allocator@D@std@@QEAA@XZ ; std::allocator<char>::allocator<char>
mov rax, QWORD PTR this$[rbp]
mov rcx, rax
call ??0?$_String_val@U?$_Simple_types@D@std@@@std@@QEAA@XZ ; std::_String_val<std::_Simple_types<char> >::_String_val<std::_Simple_types<char> >
mov rax, QWORD PTR this$[rbp]
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
??$?0$$V@?$_Compressed_pair@V?$allocator@D@std@@V?$_String_val@U?$_Simple_types@D@std@@@2@$00@std@@QEAA@U_Zero_then_variadic_args_t@1@@Z ENDP ; std::_Compressed_pair<std::allocator<char>,std::_String_val<std::_Simple_types<char> >,1>::_Compressed_pair<std::allocator<char>,std::_String_val<std::_Simple_types<char> >,1><>
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\xmemory
; COMDAT ??$?0D@?$allocator@U_Container_proxy@std@@@std@@QEAA@AEBV?$allocator@D@1@@Z
_TEXT SEGMENT
this$ = 224
__formal$ = 232
??$?0D@?$allocator@U_Container_proxy@std@@@std@@QEAA@AEBV?$allocator@D@1@@Z PROC ; std::allocator<std::_Container_proxy>::allocator<std::_Container_proxy><char>, COMDAT
; 806 : constexpr allocator(const allocator<_Other>&) noexcept {}
$LN3:
mov QWORD PTR [rsp+16], rdx
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+264]
lea rcx, OFFSET FLAT:__F1739482_xmemory
call __CheckForDebuggerJustMyCode
mov rax, QWORD PTR this$[rbp]
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
??$?0D@?$allocator@U_Container_proxy@std@@@std@@QEAA@AEBV?$allocator@D@1@@Z ENDP ; std::allocator<std::_Container_proxy>::allocator<std::_Container_proxy><char>
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\xstddef
; COMDAT ??$addressof@$$CBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@@std@@YAPEBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@0@AEBV10@@Z
_TEXT SEGMENT
_Val$ = 224
??$addressof@$$CBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@@std@@YAPEBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@0@AEBV10@@Z PROC ; std::addressof<std::basic_string<char,std::char_traits<char>,std::allocator<char> > const >, COMDAT
; 274 : _NODISCARD constexpr _Ty* addressof(_Ty& _Val) noexcept {
$LN3:
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+264]
lea rcx, OFFSET FLAT:__6CF96053_xstddef
call __CheckForDebuggerJustMyCode
; 275 : return __builtin_addressof(_Val);
mov rax, QWORD PTR _Val$[rbp]
; 276 : }
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
??$addressof@$$CBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@@std@@YAPEBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@0@AEBV10@@Z ENDP ; std::addressof<std::basic_string<char,std::char_traits<char>,std::allocator<char> > const >
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\xmemory
; COMDAT ??$_Alloc_proxy@V?$allocator@U_Container_proxy@std@@@std@@@_Container_base12@std@@QEAAX$$QEAV?$allocator@U_Container_proxy@std@@@1@@Z
_TEXT SEGMENT
_New_proxy$ = 8
$T1 = 232
this$ = 288
_Al$ = 296
??$_Alloc_proxy@V?$allocator@U_Container_proxy@std@@@std@@@_Container_base12@std@@QEAAX$$QEAV?$allocator@U_Container_proxy@std@@@1@@Z PROC ; std::_Container_base12::_Alloc_proxy<std::allocator<std::_Container_proxy> >, COMDAT
; 1106 : void _Alloc_proxy(_Alloc&& _Al) {
$LN3:
mov QWORD PTR [rsp+16], rdx
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 296 ; 00000128H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 74 ; 0000004aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+328]
lea rcx, OFFSET FLAT:__F1739482_xmemory
call __CheckForDebuggerJustMyCode
; 1107 : _Container_proxy* const _New_proxy = _Unfancy(_Al.allocate(1));
mov edx, 1
mov rcx, QWORD PTR _Al$[rbp]
call ?allocate@?$allocator@U_Container_proxy@std@@@std@@QEAAPEAU_Container_proxy@2@_K@Z ; std::allocator<std::_Container_proxy>::allocate
mov rcx, rax
call ??$_Unfancy@U_Container_proxy@std@@@std@@YAPEAU_Container_proxy@0@PEAU10@@Z ; std::_Unfancy<std::_Container_proxy>
mov QWORD PTR _New_proxy$[rbp], rax
; 1108 : _Construct_in_place(*_New_proxy, this);
mov rax, QWORD PTR this$[rbp]
mov QWORD PTR $T1[rbp], rax
lea rdx, QWORD PTR $T1[rbp]
mov rcx, QWORD PTR _New_proxy$[rbp]
call ??$_Construct_in_place@U_Container_proxy@std@@PEAU_Container_base12@2@@std@@YAXAEAU_Container_proxy@0@$$QEAPEAU_Container_base12@0@@Z ; std::_Construct_in_place<std::_Container_proxy,std::_Container_base12 *>
; 1109 : _Myproxy = _New_proxy;
mov rax, QWORD PTR this$[rbp]
mov rcx, QWORD PTR _New_proxy$[rbp]
mov QWORD PTR [rax], rcx
; 1110 : _New_proxy->_Mycont = this;
mov rax, QWORD PTR _New_proxy$[rbp]
mov rcx, QWORD PTR this$[rbp]
mov QWORD PTR [rax], rcx
; 1111 : }
lea rsp, QWORD PTR [rbp+264]
pop rdi
pop rbp
ret 0
??$_Alloc_proxy@V?$allocator@U_Container_proxy@std@@@std@@@_Container_base12@std@@QEAAX$$QEAV?$allocator@U_Container_proxy@std@@@1@@Z ENDP ; std::_Container_base12::_Alloc_proxy<std::allocator<std::_Container_proxy> >
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\utility
; COMDAT ??$min@_K@std@@YAAEB_KAEB_K0@Z
_TEXT SEGMENT
$T1 = 200
tv65 = 216
_Left$ = 256
_Right$ = 264
??$min@_K@std@@YAAEB_KAEB_K0@Z PROC ; std::min<unsigned __int64>, COMDAT
; 66 : const _Ty& _Left, const _Ty& _Right) noexcept(noexcept(_Right < _Left)) /* strengthened */ {
$LN5:
mov QWORD PTR [rsp+16], rdx
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 264 ; 00000108H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 66 ; 00000042H
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+296]
lea rcx, OFFSET FLAT:__9BE6F741_utility
call __CheckForDebuggerJustMyCode
; 67 : // return smaller of _Left and _Right
; 68 : return _Right < _Left ? _Right : _Left;
mov rax, QWORD PTR _Right$[rbp]
mov rcx, QWORD PTR _Left$[rbp]
mov rcx, QWORD PTR [rcx]
cmp QWORD PTR [rax], rcx
jae SHORT $LN3@min
mov rax, QWORD PTR _Right$[rbp]
mov QWORD PTR tv65[rbp], rax
jmp SHORT $LN4@min
$LN3@min:
mov rax, QWORD PTR _Left$[rbp]
mov QWORD PTR tv65[rbp], rax
$LN4@min:
mov rax, QWORD PTR tv65[rbp]
mov QWORD PTR $T1[rbp], rax
mov rax, QWORD PTR $T1[rbp]
; 69 : }
lea rsp, QWORD PTR [rbp+232]
pop rdi
pop rbp
ret 0
??$min@_K@std@@YAAEB_KAEB_K0@Z ENDP ; std::min<unsigned __int64>
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\ostream
; COMDAT ??Bsentry@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEBA_NXZ
_TEXT SEGMENT
this$ = 224
??Bsentry@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEBA_NXZ PROC ; std::basic_ostream<char,std::char_traits<char> >::sentry::operator bool, COMDAT
; 124 : explicit __CLR_OR_THIS_CALL operator bool() const {
$LN3:
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+264]
lea rcx, OFFSET FLAT:__498EBCEB_ostream
call __CheckForDebuggerJustMyCode
; 125 : return _Ok;
mov rax, QWORD PTR this$[rbp]
movzx eax, BYTE PTR [rax+8]
; 126 : }
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
??Bsentry@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEBA_NXZ ENDP ; std::basic_ostream<char,std::char_traits<char> >::sentry::operator bool
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\ostream
; COMDAT ??1sentry@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAA@XZ
_TEXT SEGMENT
_Zero_uncaught_exceptions$ = 4
tv72 = 212
this$ = 256
??1sentry@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAA@XZ PROC ; std::basic_ostream<char,std::char_traits<char> >::sentry::~sentry, COMDAT
; 109 : __CLR_OR_THIS_CALL ~sentry() noexcept {
$LN6:
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 264 ; 00000108H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 66 ; 00000042H
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+296]
lea rcx, OFFSET FLAT:__498EBCEB_ostream
call __CheckForDebuggerJustMyCode
; 110 : #if !_HAS_EXCEPTIONS
; 111 : const bool _Zero_uncaught_exceptions = true;
; 112 : #elif _HAS_DEPRECATED_UNCAUGHT_EXCEPTION
; 113 : const bool _Zero_uncaught_exceptions = !_STD uncaught_exception(); // TRANSITION, ArchivedOS-12000909
call ?uncaught_exception@std@@YA_NXZ ; std::uncaught_exception
movzx eax, al
test eax, eax
jne SHORT $LN4@sentry
mov BYTE PTR tv72[rbp], 1
jmp SHORT $LN5@sentry
$LN4@sentry:
mov BYTE PTR tv72[rbp], 0
$LN5@sentry:
movzx eax, BYTE PTR tv72[rbp]
mov BYTE PTR _Zero_uncaught_exceptions$[rbp], al
; 114 : #else // ^^^ _HAS_DEPRECATED_UNCAUGHT_EXCEPTION / !_HAS_DEPRECATED_UNCAUGHT_EXCEPTION vvv
; 115 : const bool _Zero_uncaught_exceptions = _STD uncaught_exceptions() == 0;
; 116 : #endif // !_HAS_DEPRECATED_UNCAUGHT_EXCEPTION
; 117 :
; 118 : if (_Zero_uncaught_exceptions) {
movzx eax, BYTE PTR _Zero_uncaught_exceptions$[rbp]
test eax, eax
je SHORT $LN2@sentry
; 119 : this->_Myostr._Osfx();
mov rax, QWORD PTR this$[rbp]
mov rcx, QWORD PTR [rax]
call QWORD PTR __imp_?_Osfx@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAAXXZ
$LN2@sentry:
; 120 : }
; 121 : }
mov rcx, QWORD PTR this$[rbp]
call ??1_Sentry_base@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAA@XZ ; std::basic_ostream<char,std::char_traits<char> >::_Sentry_base::~_Sentry_base
npad 1
lea rsp, QWORD PTR [rbp+232]
pop rdi
pop rbp
ret 0
??1sentry@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAA@XZ ENDP ; std::basic_ostream<char,std::char_traits<char> >::sentry::~sentry
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\ostream
; COMDAT ??0sentry@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAA@AEAV12@@Z
_TEXT SEGMENT
_Tied$ = 8
this$ = 256
_Ostr$ = 264
??0sentry@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAA@AEAV12@@Z PROC ; std::basic_ostream<char,std::char_traits<char> >::sentry::sentry, COMDAT
; 92 : explicit __CLR_OR_THIS_CALL sentry(basic_ostream& _Ostr) : _Sentry_base(_Ostr) {
$LN7:
mov QWORD PTR [rsp+16], rdx
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 264 ; 00000108H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 66 ; 00000042H
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+296]
lea rcx, OFFSET FLAT:__498EBCEB_ostream
call __CheckForDebuggerJustMyCode
mov rdx, QWORD PTR _Ostr$[rbp]
mov rcx, QWORD PTR this$[rbp]
call ??0_Sentry_base@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAA@AEAV12@@Z ; std::basic_ostream<char,std::char_traits<char> >::_Sentry_base::_Sentry_base
npad 1
; 93 : if (!_Ostr.good()) {
mov rax, QWORD PTR _Ostr$[rbp]
mov rax, QWORD PTR [rax]
movsxd rax, DWORD PTR [rax+4]
mov rcx, QWORD PTR _Ostr$[rbp]
add rcx, rax
mov rax, rcx
mov rcx, rax
call QWORD PTR __imp_?good@ios_base@std@@QEBA_NXZ
movzx eax, al
test eax, eax
jne SHORT $LN2@sentry
; 94 : _Ok = false;
mov rax, QWORD PTR this$[rbp]
mov BYTE PTR [rax+8], 0
; 95 : return;
jmp $LN1@sentry
$LN2@sentry:
; 96 : }
; 97 :
; 98 : const auto _Tied = _Ostr.tie();
mov rax, QWORD PTR _Ostr$[rbp]
mov rax, QWORD PTR [rax]
movsxd rax, DWORD PTR [rax+4]
mov rcx, QWORD PTR _Ostr$[rbp]
add rcx, rax
mov rax, rcx
mov rcx, rax
call QWORD PTR __imp_?tie@?$basic_ios@DU?$char_traits@D@std@@@std@@QEBAPEAV?$basic_ostream@DU?$char_traits@D@std@@@2@XZ
mov QWORD PTR _Tied$[rbp], rax
; 99 : if (!_Tied || _Tied == &_Ostr) {
cmp QWORD PTR _Tied$[rbp], 0
je SHORT $LN4@sentry
mov rax, QWORD PTR _Ostr$[rbp]
cmp QWORD PTR _Tied$[rbp], rax
jne SHORT $LN3@sentry
$LN4@sentry:
; 100 : _Ok = true;
mov rax, QWORD PTR this$[rbp]
mov BYTE PTR [rax+8], 1
; 101 : return;
jmp SHORT $LN1@sentry
$LN3@sentry:
; 102 : }
; 103 :
; 104 : _Tied->flush();
mov rcx, QWORD PTR _Tied$[rbp]
call QWORD PTR __imp_?flush@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAAAEAV12@XZ
; 105 : _Ok = _Ostr.good(); // store test only after flushing tie
mov rax, QWORD PTR _Ostr$[rbp]
mov rax, QWORD PTR [rax]
movsxd rax, DWORD PTR [rax+4]
mov rcx, QWORD PTR _Ostr$[rbp]
add rcx, rax
mov rax, rcx
mov rcx, rax
call QWORD PTR __imp_?good@ios_base@std@@QEBA_NXZ
mov rcx, QWORD PTR this$[rbp]
mov BYTE PTR [rcx+8], al
$LN1@sentry:
; 106 : }
mov rax, QWORD PTR this$[rbp]
lea rsp, QWORD PTR [rbp+232]
pop rdi
pop rbp
ret 0
??0sentry@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAA@AEAV12@@Z ENDP ; std::basic_ostream<char,std::char_traits<char> >::sentry::sentry
_TEXT ENDS
; COMDAT text$x
text$x SEGMENT
_Tied$ = 8
this$ = 256
_Ostr$ = 264
?dtor$0@?0???0sentry@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAA@AEAV12@@Z@4HA PROC ; `std::basic_ostream<char,std::char_traits<char> >::sentry::sentry'::`1'::dtor$0
mov QWORD PTR [rsp+8], rcx
mov QWORD PTR [rsp+16], rdx
push rbp
push rdi
sub rsp, 40 ; 00000028H
lea rbp, QWORD PTR [rdx+32]
mov rcx, QWORD PTR this$[rbp]
call ??1_Sentry_base@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAA@XZ ; std::basic_ostream<char,std::char_traits<char> >::_Sentry_base::~_Sentry_base
add rsp, 40 ; 00000028H
pop rdi
pop rbp
ret 0
?dtor$0@?0???0sentry@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAA@AEAV12@@Z@4HA ENDP ; `std::basic_ostream<char,std::char_traits<char> >::sentry::sentry'::`1'::dtor$0
text$x ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; COMDAT text$x
text$x SEGMENT
_Tied$ = 8
this$ = 256
_Ostr$ = 264
?dtor$0@?0???0sentry@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAA@AEAV12@@Z@4HA PROC ; `std::basic_ostream<char,std::char_traits<char> >::sentry::sentry'::`1'::dtor$0
mov QWORD PTR [rsp+8], rcx
mov QWORD PTR [rsp+16], rdx
push rbp
push rdi
sub rsp, 40 ; 00000028H
lea rbp, QWORD PTR [rdx+32]
mov rcx, QWORD PTR this$[rbp]
call ??1_Sentry_base@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAA@XZ ; std::basic_ostream<char,std::char_traits<char> >::_Sentry_base::~_Sentry_base
add rsp, 40 ; 00000028H
pop rdi
pop rbp
ret 0
?dtor$0@?0???0sentry@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAA@AEAV12@@Z@4HA ENDP ; `std::basic_ostream<char,std::char_traits<char> >::sentry::sentry'::`1'::dtor$0
text$x ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\ostream
; COMDAT ??1_Sentry_base@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAA@XZ
_TEXT SEGMENT
_Rdbuf$ = 8
tv72 = 216
this$ = 256
??1_Sentry_base@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAA@XZ PROC ; std::basic_ostream<char,std::char_traits<char> >::_Sentry_base::~_Sentry_base, COMDAT
; 78 : __CLR_OR_THIS_CALL ~_Sentry_base() noexcept { // destroy after unlocking
$LN4:
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 264 ; 00000108H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 66 ; 00000042H
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+296]
lea rcx, OFFSET FLAT:__498EBCEB_ostream
call __CheckForDebuggerJustMyCode
; 79 : const auto _Rdbuf = _Myostr.rdbuf();
mov rax, QWORD PTR this$[rbp]
mov rax, QWORD PTR [rax]
mov QWORD PTR tv72[rbp], rax
mov rax, QWORD PTR tv72[rbp]
mov rax, QWORD PTR [rax]
movsxd rax, DWORD PTR [rax+4]
mov rcx, QWORD PTR tv72[rbp]
add rcx, rax
mov rax, rcx
mov rcx, rax
call QWORD PTR __imp_?rdbuf@?$basic_ios@DU?$char_traits@D@std@@@std@@QEBAPEAV?$basic_streambuf@DU?$char_traits@D@std@@@2@XZ
mov QWORD PTR _Rdbuf$[rbp], rax
; 80 : if (_Rdbuf) {
cmp QWORD PTR _Rdbuf$[rbp], 0
je SHORT $LN2@Sentry_bas
; 81 : _Rdbuf->_Unlock();
mov rax, QWORD PTR _Rdbuf$[rbp]
mov rax, QWORD PTR [rax]
mov rcx, QWORD PTR _Rdbuf$[rbp]
call QWORD PTR [rax+16]
npad 1
$LN2@Sentry_bas:
; 82 : }
; 83 : }
lea rsp, QWORD PTR [rbp+232]
pop rdi
pop rbp
ret 0
??1_Sentry_base@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAA@XZ ENDP ; std::basic_ostream<char,std::char_traits<char> >::_Sentry_base::~_Sentry_base
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\ostream
; COMDAT ??0_Sentry_base@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAA@AEAV12@@Z
_TEXT SEGMENT
_Rdbuf$ = 8
tv73 = 216
this$ = 256
_Ostr$ = 264
??0_Sentry_base@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAA@AEAV12@@Z PROC ; std::basic_ostream<char,std::char_traits<char> >::_Sentry_base::_Sentry_base, COMDAT
; 71 : __CLR_OR_THIS_CALL _Sentry_base(basic_ostream& _Ostr) : _Myostr(_Ostr) { // lock the stream buffer, if there
$LN4:
mov QWORD PTR [rsp+16], rdx
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 264 ; 00000108H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 66 ; 00000042H
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+296]
lea rcx, OFFSET FLAT:__498EBCEB_ostream
call __CheckForDebuggerJustMyCode
mov rax, QWORD PTR this$[rbp]
mov rcx, QWORD PTR _Ostr$[rbp]
mov QWORD PTR [rax], rcx
; 72 : const auto _Rdbuf = _Myostr.rdbuf();
mov rax, QWORD PTR this$[rbp]
mov rax, QWORD PTR [rax]
mov QWORD PTR tv73[rbp], rax
mov rax, QWORD PTR tv73[rbp]
mov rax, QWORD PTR [rax]
movsxd rax, DWORD PTR [rax+4]
mov rcx, QWORD PTR tv73[rbp]
add rcx, rax
mov rax, rcx
mov rcx, rax
call QWORD PTR __imp_?rdbuf@?$basic_ios@DU?$char_traits@D@std@@@std@@QEBAPEAV?$basic_streambuf@DU?$char_traits@D@std@@@2@XZ
mov QWORD PTR _Rdbuf$[rbp], rax
; 73 : if (_Rdbuf) {
cmp QWORD PTR _Rdbuf$[rbp], 0
je SHORT $LN2@Sentry_bas
; 74 : _Rdbuf->_Lock();
mov rax, QWORD PTR _Rdbuf$[rbp]
mov rax, QWORD PTR [rax]
mov rcx, QWORD PTR _Rdbuf$[rbp]
call QWORD PTR [rax+8]
$LN2@Sentry_bas:
; 75 : }
; 76 : }
mov rax, QWORD PTR this$[rbp]
lea rsp, QWORD PTR [rbp+232]
pop rdi
pop rbp
ret 0
??0_Sentry_base@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAA@AEAV12@@Z ENDP ; std::basic_ostream<char,std::char_traits<char> >::_Sentry_base::_Sentry_base
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\xmemory
; COMDAT ??$_Delete_plain_internal@V?$allocator@U_Container_proxy@std@@@std@@@std@@YAXAEAV?$allocator@U_Container_proxy@std@@@0@QEAU_Container_proxy@0@@Z
_TEXT SEGMENT
_Al$ = 224
_Ptr$ = 232
??$_Delete_plain_internal@V?$allocator@U_Container_proxy@std@@@std@@@std@@YAXAEAV?$allocator@U_Container_proxy@std@@@0@QEAU_Container_proxy@0@@Z PROC ; std::_Delete_plain_internal<std::allocator<std::_Container_proxy> >, COMDAT
; 1031 : void _Delete_plain_internal(_Alloc& _Al, typename _Alloc::value_type* const _Ptr) noexcept {
$LN3:
mov QWORD PTR [rsp+16], rdx
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+264]
lea rcx, OFFSET FLAT:__F1739482_xmemory
call __CheckForDebuggerJustMyCode
; 1032 : // destroy *_Ptr in place, then deallocate _Ptr using _Al; used for internal container types the user didn't name
; 1033 : using _Ty = typename _Alloc::value_type;
; 1034 : _Ptr->~_Ty();
; 1035 : _Deallocate_plain(_Al, _Ptr);
mov rdx, QWORD PTR _Ptr$[rbp]
mov rcx, QWORD PTR _Al$[rbp]
call ??$_Deallocate_plain@V?$allocator@U_Container_proxy@std@@@std@@@std@@YAXAEAV?$allocator@U_Container_proxy@std@@@0@QEAU_Container_proxy@0@@Z ; std::_Deallocate_plain<std::allocator<std::_Container_proxy> >
; 1036 : }
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
??$_Delete_plain_internal@V?$allocator@U_Container_proxy@std@@@std@@@std@@YAXAEAV?$allocator@U_Container_proxy@std@@@0@QEAU_Container_proxy@0@@Z ENDP ; std::_Delete_plain_internal<std::allocator<std::_Container_proxy> >
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\utility
; COMDAT ??$exchange@PEAU_Container_proxy@std@@$$T@std@@YAPEAU_Container_proxy@0@AEAPEAU10@$$QEA$$T@Z
_TEXT SEGMENT
_Old_val$ = 8
_Val$ = 256
_New_val$ = 264
??$exchange@PEAU_Container_proxy@std@@$$T@std@@YAPEAU_Container_proxy@0@AEAPEAU10@$$QEA$$T@Z PROC ; std::exchange<std::_Container_proxy *,std::nullptr_t>, COMDAT
; 596 : conjunction_v<is_nothrow_move_constructible<_Ty>, is_nothrow_assignable<_Ty&, _Other>>) /* strengthened */ {
$LN3:
mov QWORD PTR [rsp+16], rdx
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 264 ; 00000108H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 66 ; 00000042H
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+296]
lea rcx, OFFSET FLAT:__9BE6F741_utility
call __CheckForDebuggerJustMyCode
; 597 : // assign _New_val to _Val, return previous _Val
; 598 : _Ty _Old_val = static_cast<_Ty&&>(_Val);
mov rax, QWORD PTR _Val$[rbp]
mov rax, QWORD PTR [rax]
mov QWORD PTR _Old_val$[rbp], rax
; 599 : _Val = static_cast<_Other&&>(_New_val);
mov rax, QWORD PTR _Val$[rbp]
mov rcx, QWORD PTR _New_val$[rbp]
mov rcx, QWORD PTR [rcx]
mov QWORD PTR [rax], rcx
; 600 : return _Old_val;
mov rax, QWORD PTR _Old_val$[rbp]
; 601 : }
lea rsp, QWORD PTR [rbp+232]
pop rdi
pop rbp
ret 0
??$exchange@PEAU_Container_proxy@std@@$$T@std@@YAPEAU_Container_proxy@0@AEAPEAU10@$$QEA$$T@Z ENDP ; std::exchange<std::_Container_proxy *,std::nullptr_t>
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\xmemory
; COMDAT ??$?0UPaymentOption@Persistence@TechnicalServices@@@?$allocator@U_Container_proxy@std@@@std@@QEAA@AEBV?$allocator@UPaymentOption@Persistence@TechnicalServices@@@1@@Z
_TEXT SEGMENT
this$ = 224
__formal$ = 232
??$?0UPaymentOption@Persistence@TechnicalServices@@@?$allocator@U_Container_proxy@std@@@std@@QEAA@AEBV?$allocator@UPaymentOption@Persistence@TechnicalServices@@@1@@Z PROC ; std::allocator<std::_Container_proxy>::allocator<std::_Container_proxy><TechnicalServices::Persistence::PaymentOption>, COMDAT
; 806 : constexpr allocator(const allocator<_Other>&) noexcept {}
$LN3:
mov QWORD PTR [rsp+16], rdx
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+264]
lea rcx, OFFSET FLAT:__F1739482_xmemory
call __CheckForDebuggerJustMyCode
mov rax, QWORD PTR this$[rbp]
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
??$?0UPaymentOption@Persistence@TechnicalServices@@@?$allocator@U_Container_proxy@std@@@std@@QEAA@AEBV?$allocator@UPaymentOption@Persistence@TechnicalServices@@@1@@Z ENDP ; std::allocator<std::_Container_proxy>::allocator<std::_Container_proxy><TechnicalServices::Persistence::PaymentOption>
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\xmemory
; COMDAT ?allocate@?$allocator@U_Container_proxy@std@@@std@@QEAAPEAU_Container_proxy@2@_K@Z
_TEXT SEGMENT
this$ = 224
_Count$ = 232
?allocate@?$allocator@U_Container_proxy@std@@@std@@QEAAPEAU_Container_proxy@2@_K@Z PROC ; std::allocator<std::_Container_proxy>::allocate, COMDAT
; 813 : _NODISCARD __declspec(allocator) _Ty* allocate(_CRT_GUARDOVERFLOW const size_t _Count) {
$LN3:
mov QWORD PTR [rsp+16], rdx
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+264]
lea rcx, OFFSET FLAT:__F1739482_xmemory
call __CheckForDebuggerJustMyCode
; 814 : return static_cast<_Ty*>(_Allocate<_New_alignof<_Ty>>(_Get_size_of_n<sizeof(_Ty)>(_Count)));
mov rcx, QWORD PTR _Count$[rbp]
call ??$_Get_size_of_n@$0BA@@std@@YA_K_K@Z ; std::_Get_size_of_n<16>
mov rcx, rax
call ??$_Allocate@$0BA@U_Default_allocate_traits@std@@$0A@@std@@YAPEAX_K@Z ; std::_Allocate<16,std::_Default_allocate_traits,0>
; 815 : }
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
?allocate@?$allocator@U_Container_proxy@std@@@std@@QEAAPEAU_Container_proxy@2@_K@Z ENDP ; std::allocator<std::_Container_proxy>::allocate
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\memory
; COMDAT ??$?0UGatewayPayment@External@TechnicalServices@@U?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@$0A@@?$unique_ptr@VPaymentHandlerInterface@External@TechnicalServices@@U?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@@std@@QEAA@$$QEAV?$unique_ptr@UGatewayPayment@External@TechnicalServices@@U?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@@1@@Z
_TEXT SEGMENT
$T1 = 200
$T2 = 228
$T3 = 260
tv80 = 280
tv78 = 288
this$ = 336
_Right$ = 344
??$?0UGatewayPayment@External@TechnicalServices@@U?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@$0A@@?$unique_ptr@VPaymentHandlerInterface@External@TechnicalServices@@U?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@@std@@QEAA@$$QEAV?$unique_ptr@UGatewayPayment@External@TechnicalServices@@U?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@@1@@Z PROC ; std::unique_ptr<TechnicalServices::External::PaymentHandlerInterface,std::default_delete<TechnicalServices::External::PaymentHandlerInterface> >::unique_ptr<TechnicalServices::External::PaymentHandlerInterface,std::default_delete<TechnicalServices::External::PaymentHandlerInterface> ><TechnicalServices::External::GatewayPayment,std::default_delete<TechnicalServices::External::GatewayPayment>,0>, COMDAT
; 2613 : : _Mypair(_One_then_variadic_args_t{}, _STD forward<_Dx2>(_Right.get_deleter()), _Right.release()) {}
$LN3:
mov QWORD PTR [rsp+16], rdx
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 344 ; 00000158H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 86 ; 00000056H
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+376]
lea rcx, OFFSET FLAT:__6A935154_memory
call __CheckForDebuggerJustMyCode
mov rax, QWORD PTR this$[rbp]
mov QWORD PTR tv80[rbp], rax
mov rcx, QWORD PTR _Right$[rbp]
call ?release@?$unique_ptr@UGatewayPayment@External@TechnicalServices@@U?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@@std@@QEAAPEAUGatewayPayment@External@TechnicalServices@@XZ ; std::unique_ptr<TechnicalServices::External::GatewayPayment,std::default_delete<TechnicalServices::External::GatewayPayment> >::release
mov QWORD PTR $T1[rbp], rax
mov rcx, QWORD PTR _Right$[rbp]
call ?get_deleter@?$unique_ptr@UGatewayPayment@External@TechnicalServices@@U?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@@std@@QEAAAEAU?$default_delete@UGatewayPayment@External@TechnicalServices@@@2@XZ ; std::unique_ptr<TechnicalServices::External::GatewayPayment,std::default_delete<TechnicalServices::External::GatewayPayment> >::get_deleter
mov rcx, rax
call ??$forward@U?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@@std@@YA$$QEAU?$default_delete@UGatewayPayment@External@TechnicalServices@@@0@AEAU10@@Z ; std::forward<std::default_delete<TechnicalServices::External::GatewayPayment> >
mov QWORD PTR tv78[rbp], rax
movzx eax, BYTE PTR $T2[rbp]
mov BYTE PTR $T3[rbp], al
lea r9, QWORD PTR $T1[rbp]
mov r8, QWORD PTR tv78[rbp]
movzx edx, BYTE PTR $T3[rbp]
mov rcx, QWORD PTR tv80[rbp]
call ??$?0U?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@PEAUGatewayPayment@External@TechnicalServices@@@?$_Compressed_pair@U?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@PEAVPaymentHandlerInterface@External@TechnicalServices@@$00@std@@QEAA@U_One_then_variadic_args_t@1@$$QEAU?$default_delete@UGatewayPayment@External@TechnicalServices@@@1@$$QEAPEAUGatewayPayment@External@TechnicalServices@@@Z ; std::_Compressed_pair<std::default_delete<TechnicalServices::External::PaymentHandlerInterface>,TechnicalServices::External::PaymentHandlerInterface *,1>::_Compressed_pair<std::default_delete<TechnicalServices::External::PaymentHandlerInterface>,TechnicalServices::External::PaymentHandlerInterface *,1><std::default_delete<TechnicalServices::External::GatewayPayment>,TechnicalServices::External::GatewayPayment *>
mov rax, QWORD PTR this$[rbp]
lea rsp, QWORD PTR [rbp+312]
pop rdi
pop rbp
ret 0
??$?0UGatewayPayment@External@TechnicalServices@@U?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@$0A@@?$unique_ptr@VPaymentHandlerInterface@External@TechnicalServices@@U?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@@std@@QEAA@$$QEAV?$unique_ptr@UGatewayPayment@External@TechnicalServices@@U?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@@1@@Z ENDP ; std::unique_ptr<TechnicalServices::External::PaymentHandlerInterface,std::default_delete<TechnicalServices::External::PaymentHandlerInterface> >::unique_ptr<TechnicalServices::External::PaymentHandlerInterface,std::default_delete<TechnicalServices::External::PaymentHandlerInterface> ><TechnicalServices::External::GatewayPayment,std::default_delete<TechnicalServices::External::GatewayPayment>,0>
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\memory
; COMDAT ??$?0UGatewayPayment@External@TechnicalServices@@$0A@@?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@QEAA@AEBU?$default_delete@UGatewayPayment@External@TechnicalServices@@@1@@Z
_TEXT SEGMENT
this$ = 224
__formal$ = 232
??$?0UGatewayPayment@External@TechnicalServices@@$0A@@?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@QEAA@AEBU?$default_delete@UGatewayPayment@External@TechnicalServices@@@1@@Z PROC ; std::default_delete<TechnicalServices::External::PaymentHandlerInterface>::default_delete<TechnicalServices::External::PaymentHandlerInterface><TechnicalServices::External::GatewayPayment,0>, COMDAT
; 2533 : default_delete(const default_delete<_Ty2>&) noexcept {}
$LN3:
mov QWORD PTR [rsp+16], rdx
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+264]
lea rcx, OFFSET FLAT:__6A935154_memory
call __CheckForDebuggerJustMyCode
mov rax, QWORD PTR this$[rbp]
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
??$?0UGatewayPayment@External@TechnicalServices@@$0A@@?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@QEAA@AEBU?$default_delete@UGatewayPayment@External@TechnicalServices@@@1@@Z ENDP ; std::default_delete<TechnicalServices::External::PaymentHandlerInterface>::default_delete<TechnicalServices::External::PaymentHandlerInterface><TechnicalServices::External::GatewayPayment,0>
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\xmemory
; COMDAT ?_Get_first@?$_Compressed_pair@U?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@PEAUGatewayPayment@External@TechnicalServices@@$00@std@@QEAAAEAU?$default_delete@UGatewayPayment@External@TechnicalServices@@@2@XZ
_TEXT SEGMENT
this$ = 224
?_Get_first@?$_Compressed_pair@U?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@PEAUGatewayPayment@External@TechnicalServices@@$00@std@@QEAAAEAU?$default_delete@UGatewayPayment@External@TechnicalServices@@@2@XZ PROC ; std::_Compressed_pair<std::default_delete<TechnicalServices::External::GatewayPayment>,TechnicalServices::External::GatewayPayment *,1>::_Get_first, COMDAT
; 1346 : constexpr _Ty1& _Get_first() noexcept {
$LN3:
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+264]
lea rcx, OFFSET FLAT:__F1739482_xmemory
call __CheckForDebuggerJustMyCode
; 1347 : return *this;
mov rax, QWORD PTR this$[rbp]
; 1348 : }
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
?_Get_first@?$_Compressed_pair@U?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@PEAUGatewayPayment@External@TechnicalServices@@$00@std@@QEAAAEAU?$default_delete@UGatewayPayment@External@TechnicalServices@@@2@XZ ENDP ; std::_Compressed_pair<std::default_delete<TechnicalServices::External::GatewayPayment>,TechnicalServices::External::GatewayPayment *,1>::_Get_first
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\memory
; COMDAT ?release@?$unique_ptr@UGatewayPayment@External@TechnicalServices@@U?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@@std@@QEAAPEAUGatewayPayment@External@TechnicalServices@@XZ
_TEXT SEGMENT
$T1 = 200
this$ = 256
?release@?$unique_ptr@UGatewayPayment@External@TechnicalServices@@U?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@@std@@QEAAPEAUGatewayPayment@External@TechnicalServices@@XZ PROC ; std::unique_ptr<TechnicalServices::External::GatewayPayment,std::default_delete<TechnicalServices::External::GatewayPayment> >::release, COMDAT
; 2675 : pointer release() noexcept {
$LN3:
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 264 ; 00000108H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 66 ; 00000042H
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+296]
lea rcx, OFFSET FLAT:__6A935154_memory
call __CheckForDebuggerJustMyCode
; 2676 : return _STD exchange(_Mypair._Myval2, pointer());
mov QWORD PTR $T1[rbp], 0
mov rax, QWORD PTR this$[rbp]
lea rdx, QWORD PTR $T1[rbp]
mov rcx, rax
call ??$exchange@PEAUGatewayPayment@External@TechnicalServices@@PEAU123@@std@@YAPEAUGatewayPayment@External@TechnicalServices@@AEAPEAU123@$$QEAPEAU123@@Z ; std::exchange<TechnicalServices::External::GatewayPayment *,TechnicalServices::External::GatewayPayment *>
; 2677 : }
lea rsp, QWORD PTR [rbp+232]
pop rdi
pop rbp
ret 0
?release@?$unique_ptr@UGatewayPayment@External@TechnicalServices@@U?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@@std@@QEAAPEAUGatewayPayment@External@TechnicalServices@@XZ ENDP ; std::unique_ptr<TechnicalServices::External::GatewayPayment,std::default_delete<TechnicalServices::External::GatewayPayment> >::release
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\memory
; COMDAT ?get_deleter@?$unique_ptr@UGatewayPayment@External@TechnicalServices@@U?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@@std@@QEAAAEAU?$default_delete@UGatewayPayment@External@TechnicalServices@@@2@XZ
_TEXT SEGMENT
this$ = 224
?get_deleter@?$unique_ptr@UGatewayPayment@External@TechnicalServices@@U?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@@std@@QEAAAEAU?$default_delete@UGatewayPayment@External@TechnicalServices@@@2@XZ PROC ; std::unique_ptr<TechnicalServices::External::GatewayPayment,std::default_delete<TechnicalServices::External::GatewayPayment> >::get_deleter, COMDAT
; 2651 : _NODISCARD _Dx& get_deleter() noexcept {
$LN3:
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+264]
lea rcx, OFFSET FLAT:__6A935154_memory
call __CheckForDebuggerJustMyCode
; 2652 : return _Mypair._Get_first();
mov rax, QWORD PTR this$[rbp]
mov rcx, rax
call ?_Get_first@?$_Compressed_pair@U?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@PEAUGatewayPayment@External@TechnicalServices@@$00@std@@QEAAAEAU?$default_delete@UGatewayPayment@External@TechnicalServices@@@2@XZ ; std::_Compressed_pair<std::default_delete<TechnicalServices::External::GatewayPayment>,TechnicalServices::External::GatewayPayment *,1>::_Get_first
; 2653 : }
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
?get_deleter@?$unique_ptr@UGatewayPayment@External@TechnicalServices@@U?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@@std@@QEAAAEAU?$default_delete@UGatewayPayment@External@TechnicalServices@@@2@XZ ENDP ; std::unique_ptr<TechnicalServices::External::GatewayPayment,std::default_delete<TechnicalServices::External::GatewayPayment> >::get_deleter
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\memory
; COMDAT ??1?$unique_ptr@UGatewayPayment@External@TechnicalServices@@U?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@@std@@QEAA@XZ
_TEXT SEGMENT
tv77 = 192
tv75 = 200
this$ = 240
??1?$unique_ptr@UGatewayPayment@External@TechnicalServices@@U?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@@std@@QEAA@XZ PROC ; std::unique_ptr<TechnicalServices::External::GatewayPayment,std::default_delete<TechnicalServices::External::GatewayPayment> >::~unique_ptr<TechnicalServices::External::GatewayPayment,std::default_delete<TechnicalServices::External::GatewayPayment> >, COMDAT
; 2645 : ~unique_ptr() noexcept {
$LN4:
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 248 ; 000000f8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 62 ; 0000003eH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+280]
lea rcx, OFFSET FLAT:__6A935154_memory
call __CheckForDebuggerJustMyCode
; 2646 : if (_Mypair._Myval2) {
mov rax, QWORD PTR this$[rbp]
cmp QWORD PTR [rax], 0
je SHORT $LN2@unique_ptr
; 2647 : _Mypair._Get_first()(_Mypair._Myval2);
mov rax, QWORD PTR this$[rbp]
mov rcx, rax
call ?_Get_first@?$_Compressed_pair@U?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@PEAUGatewayPayment@External@TechnicalServices@@$00@std@@QEAAAEAU?$default_delete@UGatewayPayment@External@TechnicalServices@@@2@XZ ; std::_Compressed_pair<std::default_delete<TechnicalServices::External::GatewayPayment>,TechnicalServices::External::GatewayPayment *,1>::_Get_first
mov QWORD PTR tv77[rbp], rax
mov rax, QWORD PTR this$[rbp]
mov rax, QWORD PTR [rax]
mov QWORD PTR tv75[rbp], rax
mov rdx, QWORD PTR tv75[rbp]
mov rcx, QWORD PTR tv77[rbp]
call ??R?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@QEBAXPEAUGatewayPayment@External@TechnicalServices@@@Z ; std::default_delete<TechnicalServices::External::GatewayPayment>::operator()
$LN2@unique_ptr:
; 2648 : }
; 2649 : }
lea rsp, QWORD PTR [rbp+216]
pop rdi
pop rbp
ret 0
??1?$unique_ptr@UGatewayPayment@External@TechnicalServices@@U?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@@std@@QEAA@XZ ENDP ; std::unique_ptr<TechnicalServices::External::GatewayPayment,std::default_delete<TechnicalServices::External::GatewayPayment> >::~unique_ptr<TechnicalServices::External::GatewayPayment,std::default_delete<TechnicalServices::External::GatewayPayment> >
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\memory
; COMDAT ??R?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@QEBAXPEAUGatewayPayment@External@TechnicalServices@@@Z
_TEXT SEGMENT
$T1 = 200
tv75 = 216
tv76 = 224
this$ = 272
_Ptr$ = 280
??R?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@QEBAXPEAUGatewayPayment@External@TechnicalServices@@@Z PROC ; std::default_delete<TechnicalServices::External::GatewayPayment>::operator(), COMDAT
; 2535 : void operator()(_Ty* _Ptr) const noexcept /* strengthened */ { // delete a pointer
$LN5:
mov QWORD PTR [rsp+16], rdx
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 280 ; 00000118H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 70 ; 00000046H
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+312]
lea rcx, OFFSET FLAT:__6A935154_memory
call __CheckForDebuggerJustMyCode
; 2536 : static_assert(0 < sizeof(_Ty), "can't delete an incomplete type");
; 2537 : delete _Ptr;
mov rax, QWORD PTR _Ptr$[rbp]
mov QWORD PTR $T1[rbp], rax
cmp QWORD PTR $T1[rbp], 0
je SHORT $LN3@operator
mov rax, QWORD PTR $T1[rbp]
mov rax, QWORD PTR [rax]
mov rax, QWORD PTR [rax+8]
mov QWORD PTR tv75[rbp], rax
mov edx, 1
mov rcx, QWORD PTR $T1[rbp]
call QWORD PTR tv75[rbp]
mov QWORD PTR tv76[rbp], rax
jmp SHORT $LN4@operator
$LN3@operator:
mov QWORD PTR tv76[rbp], 0
$LN4@operator:
; 2538 : }
lea rsp, QWORD PTR [rbp+248]
pop rdi
pop rbp
ret 0
??R?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@QEBAXPEAUGatewayPayment@External@TechnicalServices@@@Z ENDP ; std::default_delete<TechnicalServices::External::GatewayPayment>::operator()
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\memory
; COMDAT ??$make_unique@UGatewayPayment@External@TechnicalServices@@$$V$0A@@std@@YA?AV?$unique_ptr@UGatewayPayment@External@TechnicalServices@@U?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@@0@XZ
_TEXT SEGMENT
$T1 = 200
$T2 = 228
tv72 = 248
__$ReturnUdt$ = 288
??$make_unique@UGatewayPayment@External@TechnicalServices@@$$V$0A@@std@@YA?AV?$unique_ptr@UGatewayPayment@External@TechnicalServices@@U?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@@0@XZ PROC ; std::make_unique<TechnicalServices::External::GatewayPayment,0>, COMDAT
; 2832 : _NODISCARD unique_ptr<_Ty> make_unique(_Types&&... _Args) { // make a unique_ptr
$LN7:
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 296 ; 00000128H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 74 ; 0000004aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+328]
mov DWORD PTR $T2[rbp], 0
lea rcx, OFFSET FLAT:__6A935154_memory
call __CheckForDebuggerJustMyCode
; 2833 : return unique_ptr<_Ty>(new _Ty(_STD forward<_Types>(_Args)...));
mov ecx, 8
call ??2@YAPEAX_K@Z ; operator new
mov QWORD PTR $T1[rbp], rax
cmp QWORD PTR $T1[rbp], 0
je SHORT $LN3@make_uniqu
mov rdi, QWORD PTR $T1[rbp]
xor eax, eax
mov ecx, 8
rep stosb
mov rcx, QWORD PTR $T1[rbp]
call ??0GatewayPayment@External@TechnicalServices@@QEAA@XZ
mov QWORD PTR tv72[rbp], rax
jmp SHORT $LN4@make_uniqu
$LN3@make_uniqu:
mov QWORD PTR tv72[rbp], 0
$LN4@make_uniqu:
mov rdx, QWORD PTR tv72[rbp]
mov rcx, QWORD PTR __$ReturnUdt$[rbp]
call ??$?0U?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@$0A@@?$unique_ptr@UGatewayPayment@External@TechnicalServices@@U?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@@std@@QEAA@PEAUGatewayPayment@External@TechnicalServices@@@Z ; std::unique_ptr<TechnicalServices::External::GatewayPayment,std::default_delete<TechnicalServices::External::GatewayPayment> >::unique_ptr<TechnicalServices::External::GatewayPayment,std::default_delete<TechnicalServices::External::GatewayPayment> ><std::default_delete<TechnicalServices::External::GatewayPayment>,0>
mov eax, DWORD PTR $T2[rbp]
or eax, 1
mov DWORD PTR $T2[rbp], eax
mov rax, QWORD PTR __$ReturnUdt$[rbp]
; 2834 : }
lea rsp, QWORD PTR [rbp+264]
pop rdi
pop rbp
ret 0
??$make_unique@UGatewayPayment@External@TechnicalServices@@$$V$0A@@std@@YA?AV?$unique_ptr@UGatewayPayment@External@TechnicalServices@@U?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@@0@XZ ENDP ; std::make_unique<TechnicalServices::External::GatewayPayment,0>
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\memory
; COMDAT ??$?0UDebitPayment@External@TechnicalServices@@U?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@$0A@@?$unique_ptr@VPaymentHandlerInterface@External@TechnicalServices@@U?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@@std@@QEAA@$$QEAV?$unique_ptr@UDebitPayment@External@TechnicalServices@@U?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@@1@@Z
_TEXT SEGMENT
$T1 = 200
$T2 = 228
$T3 = 260
tv80 = 280
tv78 = 288
this$ = 336
_Right$ = 344
??$?0UDebitPayment@External@TechnicalServices@@U?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@$0A@@?$unique_ptr@VPaymentHandlerInterface@External@TechnicalServices@@U?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@@std@@QEAA@$$QEAV?$unique_ptr@UDebitPayment@External@TechnicalServices@@U?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@@1@@Z PROC ; std::unique_ptr<TechnicalServices::External::PaymentHandlerInterface,std::default_delete<TechnicalServices::External::PaymentHandlerInterface> >::unique_ptr<TechnicalServices::External::PaymentHandlerInterface,std::default_delete<TechnicalServices::External::PaymentHandlerInterface> ><TechnicalServices::External::DebitPayment,std::default_delete<TechnicalServices::External::DebitPayment>,0>, COMDAT
; 2613 : : _Mypair(_One_then_variadic_args_t{}, _STD forward<_Dx2>(_Right.get_deleter()), _Right.release()) {}
$LN3:
mov QWORD PTR [rsp+16], rdx
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 344 ; 00000158H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 86 ; 00000056H
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+376]
lea rcx, OFFSET FLAT:__6A935154_memory
call __CheckForDebuggerJustMyCode
mov rax, QWORD PTR this$[rbp]
mov QWORD PTR tv80[rbp], rax
mov rcx, QWORD PTR _Right$[rbp]
call ?release@?$unique_ptr@UDebitPayment@External@TechnicalServices@@U?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@@std@@QEAAPEAUDebitPayment@External@TechnicalServices@@XZ ; std::unique_ptr<TechnicalServices::External::DebitPayment,std::default_delete<TechnicalServices::External::DebitPayment> >::release
mov QWORD PTR $T1[rbp], rax
mov rcx, QWORD PTR _Right$[rbp]
call ?get_deleter@?$unique_ptr@UDebitPayment@External@TechnicalServices@@U?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@@std@@QEAAAEAU?$default_delete@UDebitPayment@External@TechnicalServices@@@2@XZ ; std::unique_ptr<TechnicalServices::External::DebitPayment,std::default_delete<TechnicalServices::External::DebitPayment> >::get_deleter
mov rcx, rax
call ??$forward@U?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@@std@@YA$$QEAU?$default_delete@UDebitPayment@External@TechnicalServices@@@0@AEAU10@@Z ; std::forward<std::default_delete<TechnicalServices::External::DebitPayment> >
mov QWORD PTR tv78[rbp], rax
movzx eax, BYTE PTR $T2[rbp]
mov BYTE PTR $T3[rbp], al
lea r9, QWORD PTR $T1[rbp]
mov r8, QWORD PTR tv78[rbp]
movzx edx, BYTE PTR $T3[rbp]
mov rcx, QWORD PTR tv80[rbp]
call ??$?0U?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@PEAUDebitPayment@External@TechnicalServices@@@?$_Compressed_pair@U?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@PEAVPaymentHandlerInterface@External@TechnicalServices@@$00@std@@QEAA@U_One_then_variadic_args_t@1@$$QEAU?$default_delete@UDebitPayment@External@TechnicalServices@@@1@$$QEAPEAUDebitPayment@External@TechnicalServices@@@Z ; std::_Compressed_pair<std::default_delete<TechnicalServices::External::PaymentHandlerInterface>,TechnicalServices::External::PaymentHandlerInterface *,1>::_Compressed_pair<std::default_delete<TechnicalServices::External::PaymentHandlerInterface>,TechnicalServices::External::PaymentHandlerInterface *,1><std::default_delete<TechnicalServices::External::DebitPayment>,TechnicalServices::External::DebitPayment *>
mov rax, QWORD PTR this$[rbp]
lea rsp, QWORD PTR [rbp+312]
pop rdi
pop rbp
ret 0
??$?0UDebitPayment@External@TechnicalServices@@U?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@$0A@@?$unique_ptr@VPaymentHandlerInterface@External@TechnicalServices@@U?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@@std@@QEAA@$$QEAV?$unique_ptr@UDebitPayment@External@TechnicalServices@@U?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@@1@@Z ENDP ; std::unique_ptr<TechnicalServices::External::PaymentHandlerInterface,std::default_delete<TechnicalServices::External::PaymentHandlerInterface> >::unique_ptr<TechnicalServices::External::PaymentHandlerInterface,std::default_delete<TechnicalServices::External::PaymentHandlerInterface> ><TechnicalServices::External::DebitPayment,std::default_delete<TechnicalServices::External::DebitPayment>,0>
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\memory
; COMDAT ??$?0UDebitPayment@External@TechnicalServices@@$0A@@?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@QEAA@AEBU?$default_delete@UDebitPayment@External@TechnicalServices@@@1@@Z
_TEXT SEGMENT
this$ = 224
__formal$ = 232
??$?0UDebitPayment@External@TechnicalServices@@$0A@@?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@QEAA@AEBU?$default_delete@UDebitPayment@External@TechnicalServices@@@1@@Z PROC ; std::default_delete<TechnicalServices::External::PaymentHandlerInterface>::default_delete<TechnicalServices::External::PaymentHandlerInterface><TechnicalServices::External::DebitPayment,0>, COMDAT
; 2533 : default_delete(const default_delete<_Ty2>&) noexcept {}
$LN3:
mov QWORD PTR [rsp+16], rdx
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+264]
lea rcx, OFFSET FLAT:__6A935154_memory
call __CheckForDebuggerJustMyCode
mov rax, QWORD PTR this$[rbp]
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
??$?0UDebitPayment@External@TechnicalServices@@$0A@@?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@QEAA@AEBU?$default_delete@UDebitPayment@External@TechnicalServices@@@1@@Z ENDP ; std::default_delete<TechnicalServices::External::PaymentHandlerInterface>::default_delete<TechnicalServices::External::PaymentHandlerInterface><TechnicalServices::External::DebitPayment,0>
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\xmemory
; COMDAT ?_Get_first@?$_Compressed_pair@U?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@PEAUDebitPayment@External@TechnicalServices@@$00@std@@QEAAAEAU?$default_delete@UDebitPayment@External@TechnicalServices@@@2@XZ
_TEXT SEGMENT
this$ = 224
?_Get_first@?$_Compressed_pair@U?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@PEAUDebitPayment@External@TechnicalServices@@$00@std@@QEAAAEAU?$default_delete@UDebitPayment@External@TechnicalServices@@@2@XZ PROC ; std::_Compressed_pair<std::default_delete<TechnicalServices::External::DebitPayment>,TechnicalServices::External::DebitPayment *,1>::_Get_first, COMDAT
; 1346 : constexpr _Ty1& _Get_first() noexcept {
$LN3:
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+264]
lea rcx, OFFSET FLAT:__F1739482_xmemory
call __CheckForDebuggerJustMyCode
; 1347 : return *this;
mov rax, QWORD PTR this$[rbp]
; 1348 : }
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
?_Get_first@?$_Compressed_pair@U?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@PEAUDebitPayment@External@TechnicalServices@@$00@std@@QEAAAEAU?$default_delete@UDebitPayment@External@TechnicalServices@@@2@XZ ENDP ; std::_Compressed_pair<std::default_delete<TechnicalServices::External::DebitPayment>,TechnicalServices::External::DebitPayment *,1>::_Get_first
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\memory
; COMDAT ?release@?$unique_ptr@UDebitPayment@External@TechnicalServices@@U?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@@std@@QEAAPEAUDebitPayment@External@TechnicalServices@@XZ
_TEXT SEGMENT
$T1 = 200
this$ = 256
?release@?$unique_ptr@UDebitPayment@External@TechnicalServices@@U?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@@std@@QEAAPEAUDebitPayment@External@TechnicalServices@@XZ PROC ; std::unique_ptr<TechnicalServices::External::DebitPayment,std::default_delete<TechnicalServices::External::DebitPayment> >::release, COMDAT
; 2675 : pointer release() noexcept {
$LN3:
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 264 ; 00000108H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 66 ; 00000042H
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+296]
lea rcx, OFFSET FLAT:__6A935154_memory
call __CheckForDebuggerJustMyCode
; 2676 : return _STD exchange(_Mypair._Myval2, pointer());
mov QWORD PTR $T1[rbp], 0
mov rax, QWORD PTR this$[rbp]
lea rdx, QWORD PTR $T1[rbp]
mov rcx, rax
call ??$exchange@PEAUDebitPayment@External@TechnicalServices@@PEAU123@@std@@YAPEAUDebitPayment@External@TechnicalServices@@AEAPEAU123@$$QEAPEAU123@@Z ; std::exchange<TechnicalServices::External::DebitPayment *,TechnicalServices::External::DebitPayment *>
; 2677 : }
lea rsp, QWORD PTR [rbp+232]
pop rdi
pop rbp
ret 0
?release@?$unique_ptr@UDebitPayment@External@TechnicalServices@@U?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@@std@@QEAAPEAUDebitPayment@External@TechnicalServices@@XZ ENDP ; std::unique_ptr<TechnicalServices::External::DebitPayment,std::default_delete<TechnicalServices::External::DebitPayment> >::release
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\memory
; COMDAT ?get_deleter@?$unique_ptr@UDebitPayment@External@TechnicalServices@@U?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@@std@@QEAAAEAU?$default_delete@UDebitPayment@External@TechnicalServices@@@2@XZ
_TEXT SEGMENT
this$ = 224
?get_deleter@?$unique_ptr@UDebitPayment@External@TechnicalServices@@U?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@@std@@QEAAAEAU?$default_delete@UDebitPayment@External@TechnicalServices@@@2@XZ PROC ; std::unique_ptr<TechnicalServices::External::DebitPayment,std::default_delete<TechnicalServices::External::DebitPayment> >::get_deleter, COMDAT
; 2651 : _NODISCARD _Dx& get_deleter() noexcept {
$LN3:
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+264]
lea rcx, OFFSET FLAT:__6A935154_memory
call __CheckForDebuggerJustMyCode
; 2652 : return _Mypair._Get_first();
mov rax, QWORD PTR this$[rbp]
mov rcx, rax
call ?_Get_first@?$_Compressed_pair@U?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@PEAUDebitPayment@External@TechnicalServices@@$00@std@@QEAAAEAU?$default_delete@UDebitPayment@External@TechnicalServices@@@2@XZ ; std::_Compressed_pair<std::default_delete<TechnicalServices::External::DebitPayment>,TechnicalServices::External::DebitPayment *,1>::_Get_first
; 2653 : }
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
?get_deleter@?$unique_ptr@UDebitPayment@External@TechnicalServices@@U?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@@std@@QEAAAEAU?$default_delete@UDebitPayment@External@TechnicalServices@@@2@XZ ENDP ; std::unique_ptr<TechnicalServices::External::DebitPayment,std::default_delete<TechnicalServices::External::DebitPayment> >::get_deleter
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\memory
; COMDAT ??1?$unique_ptr@UDebitPayment@External@TechnicalServices@@U?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@@std@@QEAA@XZ
_TEXT SEGMENT
tv77 = 192
tv75 = 200
this$ = 240
??1?$unique_ptr@UDebitPayment@External@TechnicalServices@@U?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@@std@@QEAA@XZ PROC ; std::unique_ptr<TechnicalServices::External::DebitPayment,std::default_delete<TechnicalServices::External::DebitPayment> >::~unique_ptr<TechnicalServices::External::DebitPayment,std::default_delete<TechnicalServices::External::DebitPayment> >, COMDAT
; 2645 : ~unique_ptr() noexcept {
$LN4:
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 248 ; 000000f8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 62 ; 0000003eH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+280]
lea rcx, OFFSET FLAT:__6A935154_memory
call __CheckForDebuggerJustMyCode
; 2646 : if (_Mypair._Myval2) {
mov rax, QWORD PTR this$[rbp]
cmp QWORD PTR [rax], 0
je SHORT $LN2@unique_ptr
; 2647 : _Mypair._Get_first()(_Mypair._Myval2);
mov rax, QWORD PTR this$[rbp]
mov rcx, rax
call ?_Get_first@?$_Compressed_pair@U?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@PEAUDebitPayment@External@TechnicalServices@@$00@std@@QEAAAEAU?$default_delete@UDebitPayment@External@TechnicalServices@@@2@XZ ; std::_Compressed_pair<std::default_delete<TechnicalServices::External::DebitPayment>,TechnicalServices::External::DebitPayment *,1>::_Get_first
mov QWORD PTR tv77[rbp], rax
mov rax, QWORD PTR this$[rbp]
mov rax, QWORD PTR [rax]
mov QWORD PTR tv75[rbp], rax
mov rdx, QWORD PTR tv75[rbp]
mov rcx, QWORD PTR tv77[rbp]
call ??R?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@QEBAXPEAUDebitPayment@External@TechnicalServices@@@Z ; std::default_delete<TechnicalServices::External::DebitPayment>::operator()
$LN2@unique_ptr:
; 2648 : }
; 2649 : }
lea rsp, QWORD PTR [rbp+216]
pop rdi
pop rbp
ret 0
??1?$unique_ptr@UDebitPayment@External@TechnicalServices@@U?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@@std@@QEAA@XZ ENDP ; std::unique_ptr<TechnicalServices::External::DebitPayment,std::default_delete<TechnicalServices::External::DebitPayment> >::~unique_ptr<TechnicalServices::External::DebitPayment,std::default_delete<TechnicalServices::External::DebitPayment> >
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\memory
; COMDAT ??R?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@QEBAXPEAUDebitPayment@External@TechnicalServices@@@Z
_TEXT SEGMENT
$T1 = 200
tv75 = 216
tv76 = 224
this$ = 272
_Ptr$ = 280
??R?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@QEBAXPEAUDebitPayment@External@TechnicalServices@@@Z PROC ; std::default_delete<TechnicalServices::External::DebitPayment>::operator(), COMDAT
; 2535 : void operator()(_Ty* _Ptr) const noexcept /* strengthened */ { // delete a pointer
$LN5:
mov QWORD PTR [rsp+16], rdx
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 280 ; 00000118H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 70 ; 00000046H
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+312]
lea rcx, OFFSET FLAT:__6A935154_memory
call __CheckForDebuggerJustMyCode
; 2536 : static_assert(0 < sizeof(_Ty), "can't delete an incomplete type");
; 2537 : delete _Ptr;
mov rax, QWORD PTR _Ptr$[rbp]
mov QWORD PTR $T1[rbp], rax
cmp QWORD PTR $T1[rbp], 0
je SHORT $LN3@operator
mov rax, QWORD PTR $T1[rbp]
mov rax, QWORD PTR [rax]
mov rax, QWORD PTR [rax+8]
mov QWORD PTR tv75[rbp], rax
mov edx, 1
mov rcx, QWORD PTR $T1[rbp]
call QWORD PTR tv75[rbp]
mov QWORD PTR tv76[rbp], rax
jmp SHORT $LN4@operator
$LN3@operator:
mov QWORD PTR tv76[rbp], 0
$LN4@operator:
; 2538 : }
lea rsp, QWORD PTR [rbp+248]
pop rdi
pop rbp
ret 0
??R?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@QEBAXPEAUDebitPayment@External@TechnicalServices@@@Z ENDP ; std::default_delete<TechnicalServices::External::DebitPayment>::operator()
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\memory
; COMDAT ??$make_unique@UDebitPayment@External@TechnicalServices@@$$V$0A@@std@@YA?AV?$unique_ptr@UDebitPayment@External@TechnicalServices@@U?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@@0@XZ
_TEXT SEGMENT
$T1 = 200
$T2 = 228
tv72 = 248
__$ReturnUdt$ = 288
??$make_unique@UDebitPayment@External@TechnicalServices@@$$V$0A@@std@@YA?AV?$unique_ptr@UDebitPayment@External@TechnicalServices@@U?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@@0@XZ PROC ; std::make_unique<TechnicalServices::External::DebitPayment,0>, COMDAT
; 2832 : _NODISCARD unique_ptr<_Ty> make_unique(_Types&&... _Args) { // make a unique_ptr
$LN7:
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 296 ; 00000128H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 74 ; 0000004aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+328]
mov DWORD PTR $T2[rbp], 0
lea rcx, OFFSET FLAT:__6A935154_memory
call __CheckForDebuggerJustMyCode
; 2833 : return unique_ptr<_Ty>(new _Ty(_STD forward<_Types>(_Args)...));
mov ecx, 8
call ??2@YAPEAX_K@Z ; operator new
mov QWORD PTR $T1[rbp], rax
cmp QWORD PTR $T1[rbp], 0
je SHORT $LN3@make_uniqu
mov rdi, QWORD PTR $T1[rbp]
xor eax, eax
mov ecx, 8
rep stosb
mov rcx, QWORD PTR $T1[rbp]
call ??0DebitPayment@External@TechnicalServices@@QEAA@XZ
mov QWORD PTR tv72[rbp], rax
jmp SHORT $LN4@make_uniqu
$LN3@make_uniqu:
mov QWORD PTR tv72[rbp], 0
$LN4@make_uniqu:
mov rdx, QWORD PTR tv72[rbp]
mov rcx, QWORD PTR __$ReturnUdt$[rbp]
call ??$?0U?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@$0A@@?$unique_ptr@UDebitPayment@External@TechnicalServices@@U?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@@std@@QEAA@PEAUDebitPayment@External@TechnicalServices@@@Z ; std::unique_ptr<TechnicalServices::External::DebitPayment,std::default_delete<TechnicalServices::External::DebitPayment> >::unique_ptr<TechnicalServices::External::DebitPayment,std::default_delete<TechnicalServices::External::DebitPayment> ><std::default_delete<TechnicalServices::External::DebitPayment>,0>
mov eax, DWORD PTR $T2[rbp]
or eax, 1
mov DWORD PTR $T2[rbp], eax
mov rax, QWORD PTR __$ReturnUdt$[rbp]
; 2834 : }
lea rsp, QWORD PTR [rbp+264]
pop rdi
pop rbp
ret 0
??$make_unique@UDebitPayment@External@TechnicalServices@@$$V$0A@@std@@YA?AV?$unique_ptr@UDebitPayment@External@TechnicalServices@@U?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@@0@XZ ENDP ; std::make_unique<TechnicalServices::External::DebitPayment,0>
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\memory
; COMDAT ??$?0UCreditPayment@External@TechnicalServices@@U?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@$0A@@?$unique_ptr@VPaymentHandlerInterface@External@TechnicalServices@@U?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@@std@@QEAA@$$QEAV?$unique_ptr@UCreditPayment@External@TechnicalServices@@U?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@@1@@Z
_TEXT SEGMENT
$T1 = 200
$T2 = 228
$T3 = 260
tv80 = 280
tv78 = 288
this$ = 336
_Right$ = 344
??$?0UCreditPayment@External@TechnicalServices@@U?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@$0A@@?$unique_ptr@VPaymentHandlerInterface@External@TechnicalServices@@U?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@@std@@QEAA@$$QEAV?$unique_ptr@UCreditPayment@External@TechnicalServices@@U?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@@1@@Z PROC ; std::unique_ptr<TechnicalServices::External::PaymentHandlerInterface,std::default_delete<TechnicalServices::External::PaymentHandlerInterface> >::unique_ptr<TechnicalServices::External::PaymentHandlerInterface,std::default_delete<TechnicalServices::External::PaymentHandlerInterface> ><TechnicalServices::External::CreditPayment,std::default_delete<TechnicalServices::External::CreditPayment>,0>, COMDAT
; 2613 : : _Mypair(_One_then_variadic_args_t{}, _STD forward<_Dx2>(_Right.get_deleter()), _Right.release()) {}
$LN3:
mov QWORD PTR [rsp+16], rdx
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 344 ; 00000158H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 86 ; 00000056H
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+376]
lea rcx, OFFSET FLAT:__6A935154_memory
call __CheckForDebuggerJustMyCode
mov rax, QWORD PTR this$[rbp]
mov QWORD PTR tv80[rbp], rax
mov rcx, QWORD PTR _Right$[rbp]
call ?release@?$unique_ptr@UCreditPayment@External@TechnicalServices@@U?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@@std@@QEAAPEAUCreditPayment@External@TechnicalServices@@XZ ; std::unique_ptr<TechnicalServices::External::CreditPayment,std::default_delete<TechnicalServices::External::CreditPayment> >::release
mov QWORD PTR $T1[rbp], rax
mov rcx, QWORD PTR _Right$[rbp]
call ?get_deleter@?$unique_ptr@UCreditPayment@External@TechnicalServices@@U?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@@std@@QEAAAEAU?$default_delete@UCreditPayment@External@TechnicalServices@@@2@XZ ; std::unique_ptr<TechnicalServices::External::CreditPayment,std::default_delete<TechnicalServices::External::CreditPayment> >::get_deleter
mov rcx, rax
call ??$forward@U?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@@std@@YA$$QEAU?$default_delete@UCreditPayment@External@TechnicalServices@@@0@AEAU10@@Z ; std::forward<std::default_delete<TechnicalServices::External::CreditPayment> >
mov QWORD PTR tv78[rbp], rax
movzx eax, BYTE PTR $T2[rbp]
mov BYTE PTR $T3[rbp], al
lea r9, QWORD PTR $T1[rbp]
mov r8, QWORD PTR tv78[rbp]
movzx edx, BYTE PTR $T3[rbp]
mov rcx, QWORD PTR tv80[rbp]
call ??$?0U?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@PEAUCreditPayment@External@TechnicalServices@@@?$_Compressed_pair@U?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@PEAVPaymentHandlerInterface@External@TechnicalServices@@$00@std@@QEAA@U_One_then_variadic_args_t@1@$$QEAU?$default_delete@UCreditPayment@External@TechnicalServices@@@1@$$QEAPEAUCreditPayment@External@TechnicalServices@@@Z ; std::_Compressed_pair<std::default_delete<TechnicalServices::External::PaymentHandlerInterface>,TechnicalServices::External::PaymentHandlerInterface *,1>::_Compressed_pair<std::default_delete<TechnicalServices::External::PaymentHandlerInterface>,TechnicalServices::External::PaymentHandlerInterface *,1><std::default_delete<TechnicalServices::External::CreditPayment>,TechnicalServices::External::CreditPayment *>
mov rax, QWORD PTR this$[rbp]
lea rsp, QWORD PTR [rbp+312]
pop rdi
pop rbp
ret 0
??$?0UCreditPayment@External@TechnicalServices@@U?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@$0A@@?$unique_ptr@VPaymentHandlerInterface@External@TechnicalServices@@U?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@@std@@QEAA@$$QEAV?$unique_ptr@UCreditPayment@External@TechnicalServices@@U?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@@1@@Z ENDP ; std::unique_ptr<TechnicalServices::External::PaymentHandlerInterface,std::default_delete<TechnicalServices::External::PaymentHandlerInterface> >::unique_ptr<TechnicalServices::External::PaymentHandlerInterface,std::default_delete<TechnicalServices::External::PaymentHandlerInterface> ><TechnicalServices::External::CreditPayment,std::default_delete<TechnicalServices::External::CreditPayment>,0>
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\memory
; COMDAT ??$?0UCreditPayment@External@TechnicalServices@@$0A@@?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@QEAA@AEBU?$default_delete@UCreditPayment@External@TechnicalServices@@@1@@Z
_TEXT SEGMENT
this$ = 224
__formal$ = 232
??$?0UCreditPayment@External@TechnicalServices@@$0A@@?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@QEAA@AEBU?$default_delete@UCreditPayment@External@TechnicalServices@@@1@@Z PROC ; std::default_delete<TechnicalServices::External::PaymentHandlerInterface>::default_delete<TechnicalServices::External::PaymentHandlerInterface><TechnicalServices::External::CreditPayment,0>, COMDAT
; 2533 : default_delete(const default_delete<_Ty2>&) noexcept {}
$LN3:
mov QWORD PTR [rsp+16], rdx
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+264]
lea rcx, OFFSET FLAT:__6A935154_memory
call __CheckForDebuggerJustMyCode
mov rax, QWORD PTR this$[rbp]
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
??$?0UCreditPayment@External@TechnicalServices@@$0A@@?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@QEAA@AEBU?$default_delete@UCreditPayment@External@TechnicalServices@@@1@@Z ENDP ; std::default_delete<TechnicalServices::External::PaymentHandlerInterface>::default_delete<TechnicalServices::External::PaymentHandlerInterface><TechnicalServices::External::CreditPayment,0>
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\xmemory
; COMDAT ?_Get_first@?$_Compressed_pair@U?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@PEAUCreditPayment@External@TechnicalServices@@$00@std@@QEAAAEAU?$default_delete@UCreditPayment@External@TechnicalServices@@@2@XZ
_TEXT SEGMENT
this$ = 224
?_Get_first@?$_Compressed_pair@U?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@PEAUCreditPayment@External@TechnicalServices@@$00@std@@QEAAAEAU?$default_delete@UCreditPayment@External@TechnicalServices@@@2@XZ PROC ; std::_Compressed_pair<std::default_delete<TechnicalServices::External::CreditPayment>,TechnicalServices::External::CreditPayment *,1>::_Get_first, COMDAT
; 1346 : constexpr _Ty1& _Get_first() noexcept {
$LN3:
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+264]
lea rcx, OFFSET FLAT:__F1739482_xmemory
call __CheckForDebuggerJustMyCode
; 1347 : return *this;
mov rax, QWORD PTR this$[rbp]
; 1348 : }
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
?_Get_first@?$_Compressed_pair@U?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@PEAUCreditPayment@External@TechnicalServices@@$00@std@@QEAAAEAU?$default_delete@UCreditPayment@External@TechnicalServices@@@2@XZ ENDP ; std::_Compressed_pair<std::default_delete<TechnicalServices::External::CreditPayment>,TechnicalServices::External::CreditPayment *,1>::_Get_first
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\memory
; COMDAT ?release@?$unique_ptr@UCreditPayment@External@TechnicalServices@@U?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@@std@@QEAAPEAUCreditPayment@External@TechnicalServices@@XZ
_TEXT SEGMENT
$T1 = 200
this$ = 256
?release@?$unique_ptr@UCreditPayment@External@TechnicalServices@@U?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@@std@@QEAAPEAUCreditPayment@External@TechnicalServices@@XZ PROC ; std::unique_ptr<TechnicalServices::External::CreditPayment,std::default_delete<TechnicalServices::External::CreditPayment> >::release, COMDAT
; 2675 : pointer release() noexcept {
$LN3:
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 264 ; 00000108H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 66 ; 00000042H
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+296]
lea rcx, OFFSET FLAT:__6A935154_memory
call __CheckForDebuggerJustMyCode
; 2676 : return _STD exchange(_Mypair._Myval2, pointer());
mov QWORD PTR $T1[rbp], 0
mov rax, QWORD PTR this$[rbp]
lea rdx, QWORD PTR $T1[rbp]
mov rcx, rax
call ??$exchange@PEAUCreditPayment@External@TechnicalServices@@PEAU123@@std@@YAPEAUCreditPayment@External@TechnicalServices@@AEAPEAU123@$$QEAPEAU123@@Z ; std::exchange<TechnicalServices::External::CreditPayment *,TechnicalServices::External::CreditPayment *>
; 2677 : }
lea rsp, QWORD PTR [rbp+232]
pop rdi
pop rbp
ret 0
?release@?$unique_ptr@UCreditPayment@External@TechnicalServices@@U?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@@std@@QEAAPEAUCreditPayment@External@TechnicalServices@@XZ ENDP ; std::unique_ptr<TechnicalServices::External::CreditPayment,std::default_delete<TechnicalServices::External::CreditPayment> >::release
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\memory
; COMDAT ?get_deleter@?$unique_ptr@UCreditPayment@External@TechnicalServices@@U?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@@std@@QEAAAEAU?$default_delete@UCreditPayment@External@TechnicalServices@@@2@XZ
_TEXT SEGMENT
this$ = 224
?get_deleter@?$unique_ptr@UCreditPayment@External@TechnicalServices@@U?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@@std@@QEAAAEAU?$default_delete@UCreditPayment@External@TechnicalServices@@@2@XZ PROC ; std::unique_ptr<TechnicalServices::External::CreditPayment,std::default_delete<TechnicalServices::External::CreditPayment> >::get_deleter, COMDAT
; 2651 : _NODISCARD _Dx& get_deleter() noexcept {
$LN3:
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+264]
lea rcx, OFFSET FLAT:__6A935154_memory
call __CheckForDebuggerJustMyCode
; 2652 : return _Mypair._Get_first();
mov rax, QWORD PTR this$[rbp]
mov rcx, rax
call ?_Get_first@?$_Compressed_pair@U?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@PEAUCreditPayment@External@TechnicalServices@@$00@std@@QEAAAEAU?$default_delete@UCreditPayment@External@TechnicalServices@@@2@XZ ; std::_Compressed_pair<std::default_delete<TechnicalServices::External::CreditPayment>,TechnicalServices::External::CreditPayment *,1>::_Get_first
; 2653 : }
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
?get_deleter@?$unique_ptr@UCreditPayment@External@TechnicalServices@@U?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@@std@@QEAAAEAU?$default_delete@UCreditPayment@External@TechnicalServices@@@2@XZ ENDP ; std::unique_ptr<TechnicalServices::External::CreditPayment,std::default_delete<TechnicalServices::External::CreditPayment> >::get_deleter
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\memory
; COMDAT ??1?$unique_ptr@UCreditPayment@External@TechnicalServices@@U?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@@std@@QEAA@XZ
_TEXT SEGMENT
tv77 = 192
tv75 = 200
this$ = 240
??1?$unique_ptr@UCreditPayment@External@TechnicalServices@@U?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@@std@@QEAA@XZ PROC ; std::unique_ptr<TechnicalServices::External::CreditPayment,std::default_delete<TechnicalServices::External::CreditPayment> >::~unique_ptr<TechnicalServices::External::CreditPayment,std::default_delete<TechnicalServices::External::CreditPayment> >, COMDAT
; 2645 : ~unique_ptr() noexcept {
$LN4:
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 248 ; 000000f8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 62 ; 0000003eH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+280]
lea rcx, OFFSET FLAT:__6A935154_memory
call __CheckForDebuggerJustMyCode
; 2646 : if (_Mypair._Myval2) {
mov rax, QWORD PTR this$[rbp]
cmp QWORD PTR [rax], 0
je SHORT $LN2@unique_ptr
; 2647 : _Mypair._Get_first()(_Mypair._Myval2);
mov rax, QWORD PTR this$[rbp]
mov rcx, rax
call ?_Get_first@?$_Compressed_pair@U?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@PEAUCreditPayment@External@TechnicalServices@@$00@std@@QEAAAEAU?$default_delete@UCreditPayment@External@TechnicalServices@@@2@XZ ; std::_Compressed_pair<std::default_delete<TechnicalServices::External::CreditPayment>,TechnicalServices::External::CreditPayment *,1>::_Get_first
mov QWORD PTR tv77[rbp], rax
mov rax, QWORD PTR this$[rbp]
mov rax, QWORD PTR [rax]
mov QWORD PTR tv75[rbp], rax
mov rdx, QWORD PTR tv75[rbp]
mov rcx, QWORD PTR tv77[rbp]
call ??R?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@QEBAXPEAUCreditPayment@External@TechnicalServices@@@Z ; std::default_delete<TechnicalServices::External::CreditPayment>::operator()
$LN2@unique_ptr:
; 2648 : }
; 2649 : }
lea rsp, QWORD PTR [rbp+216]
pop rdi
pop rbp
ret 0
??1?$unique_ptr@UCreditPayment@External@TechnicalServices@@U?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@@std@@QEAA@XZ ENDP ; std::unique_ptr<TechnicalServices::External::CreditPayment,std::default_delete<TechnicalServices::External::CreditPayment> >::~unique_ptr<TechnicalServices::External::CreditPayment,std::default_delete<TechnicalServices::External::CreditPayment> >
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\memory
; COMDAT ??R?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@QEBAXPEAUCreditPayment@External@TechnicalServices@@@Z
_TEXT SEGMENT
$T1 = 200
tv75 = 216
tv76 = 224
this$ = 272
_Ptr$ = 280
??R?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@QEBAXPEAUCreditPayment@External@TechnicalServices@@@Z PROC ; std::default_delete<TechnicalServices::External::CreditPayment>::operator(), COMDAT
; 2535 : void operator()(_Ty* _Ptr) const noexcept /* strengthened */ { // delete a pointer
$LN5:
mov QWORD PTR [rsp+16], rdx
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 280 ; 00000118H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 70 ; 00000046H
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+312]
lea rcx, OFFSET FLAT:__6A935154_memory
call __CheckForDebuggerJustMyCode
; 2536 : static_assert(0 < sizeof(_Ty), "can't delete an incomplete type");
; 2537 : delete _Ptr;
mov rax, QWORD PTR _Ptr$[rbp]
mov QWORD PTR $T1[rbp], rax
cmp QWORD PTR $T1[rbp], 0
je SHORT $LN3@operator
mov rax, QWORD PTR $T1[rbp]
mov rax, QWORD PTR [rax]
mov rax, QWORD PTR [rax+8]
mov QWORD PTR tv75[rbp], rax
mov edx, 1
mov rcx, QWORD PTR $T1[rbp]
call QWORD PTR tv75[rbp]
mov QWORD PTR tv76[rbp], rax
jmp SHORT $LN4@operator
$LN3@operator:
mov QWORD PTR tv76[rbp], 0
$LN4@operator:
; 2538 : }
lea rsp, QWORD PTR [rbp+248]
pop rdi
pop rbp
ret 0
??R?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@QEBAXPEAUCreditPayment@External@TechnicalServices@@@Z ENDP ; std::default_delete<TechnicalServices::External::CreditPayment>::operator()
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\memory
; COMDAT ??$make_unique@UCreditPayment@External@TechnicalServices@@$$V$0A@@std@@YA?AV?$unique_ptr@UCreditPayment@External@TechnicalServices@@U?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@@0@XZ
_TEXT SEGMENT
$T1 = 200
$T2 = 228
tv72 = 248
__$ReturnUdt$ = 288
??$make_unique@UCreditPayment@External@TechnicalServices@@$$V$0A@@std@@YA?AV?$unique_ptr@UCreditPayment@External@TechnicalServices@@U?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@@0@XZ PROC ; std::make_unique<TechnicalServices::External::CreditPayment,0>, COMDAT
; 2832 : _NODISCARD unique_ptr<_Ty> make_unique(_Types&&... _Args) { // make a unique_ptr
$LN7:
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 296 ; 00000128H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 74 ; 0000004aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+328]
mov DWORD PTR $T2[rbp], 0
lea rcx, OFFSET FLAT:__6A935154_memory
call __CheckForDebuggerJustMyCode
; 2833 : return unique_ptr<_Ty>(new _Ty(_STD forward<_Types>(_Args)...));
mov ecx, 8
call ??2@YAPEAX_K@Z ; operator new
mov QWORD PTR $T1[rbp], rax
cmp QWORD PTR $T1[rbp], 0
je SHORT $LN3@make_uniqu
mov rdi, QWORD PTR $T1[rbp]
xor eax, eax
mov ecx, 8
rep stosb
mov rcx, QWORD PTR $T1[rbp]
call ??0CreditPayment@External@TechnicalServices@@QEAA@XZ
mov QWORD PTR tv72[rbp], rax
jmp SHORT $LN4@make_uniqu
$LN3@make_uniqu:
mov QWORD PTR tv72[rbp], 0
$LN4@make_uniqu:
mov rdx, QWORD PTR tv72[rbp]
mov rcx, QWORD PTR __$ReturnUdt$[rbp]
call ??$?0U?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@$0A@@?$unique_ptr@UCreditPayment@External@TechnicalServices@@U?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@@std@@QEAA@PEAUCreditPayment@External@TechnicalServices@@@Z ; std::unique_ptr<TechnicalServices::External::CreditPayment,std::default_delete<TechnicalServices::External::CreditPayment> >::unique_ptr<TechnicalServices::External::CreditPayment,std::default_delete<TechnicalServices::External::CreditPayment> ><std::default_delete<TechnicalServices::External::CreditPayment>,0>
mov eax, DWORD PTR $T2[rbp]
or eax, 1
mov DWORD PTR $T2[rbp], eax
mov rax, QWORD PTR __$ReturnUdt$[rbp]
; 2834 : }
lea rsp, QWORD PTR [rbp+264]
pop rdi
pop rbp
ret 0
??$make_unique@UCreditPayment@External@TechnicalServices@@$$V$0A@@std@@YA?AV?$unique_ptr@UCreditPayment@External@TechnicalServices@@U?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@@0@XZ ENDP ; std::make_unique<TechnicalServices::External::CreditPayment,0>
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\xstring
; COMDAT ??$?8DU?$char_traits@D@std@@V?$allocator@D@1@@std@@YA_NAEBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@0@QEBD@Z
_TEXT SEGMENT
_Left$ = 224
_Right$ = 232
??$?8DU?$char_traits@D@std@@V?$allocator@D@1@@std@@YA_NAEBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@0@QEBD@Z PROC ; std::operator==<char,std::char_traits<char>,std::allocator<char> >, COMDAT
; 4564 : _NODISCARD bool operator==(const basic_string<_Elem, _Traits, _Alloc>& _Left, _In_z_ const _Elem* const _Right) {
$LN3:
mov QWORD PTR [rsp+16], rdx
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+264]
lea rcx, OFFSET FLAT:__85A0121E_xstring
call __CheckForDebuggerJustMyCode
; 4565 : return _Left._Equal(_Right);
mov rdx, QWORD PTR _Right$[rbp]
mov rcx, QWORD PTR _Left$[rbp]
call ?_Equal@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEBA_NQEBD@Z ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::_Equal
; 4566 : }
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
??$?8DU?$char_traits@D@std@@V?$allocator@D@1@@std@@YA_NAEBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@0@QEBD@Z ENDP ; std::operator==<char,std::char_traits<char>,std::allocator<char> >
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\xstring
; COMDAT ??$?6DU?$char_traits@D@std@@V?$allocator@D@1@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@AEBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@0@@Z
_TEXT SEGMENT
tv75 = 192
tv73 = 200
_Ostr$ = 240
_Str$ = 248
??$?6DU?$char_traits@D@std@@V?$allocator@D@1@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@AEBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@0@@Z PROC ; std::operator<<<char,std::char_traits<char>,std::allocator<char> >, COMDAT
; 4725 : basic_ostream<_Elem, _Traits>& _Ostr, const basic_string<_Elem, _Traits, _Alloc>& _Str) {
$LN3:
mov QWORD PTR [rsp+16], rdx
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 248 ; 000000f8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 62 ; 0000003eH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+280]
lea rcx, OFFSET FLAT:__85A0121E_xstring
call __CheckForDebuggerJustMyCode
; 4726 : return _Insert_string(_Ostr, _Str.data(), _Str.size());
mov rcx, QWORD PTR _Str$[rbp]
call ?size@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEBA_KXZ ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::size
mov QWORD PTR tv75[rbp], rax
mov rcx, QWORD PTR _Str$[rbp]
call ?data@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEBAPEBDXZ ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::data
mov QWORD PTR tv73[rbp], rax
mov r8, QWORD PTR tv75[rbp]
mov rdx, QWORD PTR tv73[rbp]
mov rcx, QWORD PTR _Ostr$[rbp]
call ??$_Insert_string@DU?$char_traits@D@std@@_K@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@QEBD_K@Z ; std::_Insert_string<char,std::char_traits<char>,unsigned __int64>
; 4727 : }
lea rsp, QWORD PTR [rbp+216]
pop rdi
pop rbp
ret 0
??$?6DU?$char_traits@D@std@@V?$allocator@D@1@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@AEBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@0@@Z ENDP ; std::operator<<<char,std::char_traits<char>,std::allocator<char> >
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\iomanip
; COMDAT ??$?6DU?$char_traits@D@std@@_J@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@AEBU?$_Smanip@_J@0@@Z
_TEXT SEGMENT
tv79 = 192
_Ostr$ = 240
_Manip$ = 248
??$?6DU?$char_traits@D@std@@_J@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@AEBU?$_Smanip@_J@0@@Z PROC ; std::operator<<<char,std::char_traits<char>,__int64>, COMDAT
; 423 : const _Smanip<_Arg>& _Manip) { // insert by calling function with output stream and argument
$LN3:
mov QWORD PTR [rsp+16], rdx
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 248 ; 000000f8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 62 ; 0000003eH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+280]
lea rcx, OFFSET FLAT:__D69C4F83_iomanip
call __CheckForDebuggerJustMyCode
; 424 : (*_Manip._Pfun)(_Ostr, _Manip._Manarg);
mov rax, QWORD PTR _Manip$[rbp]
mov rax, QWORD PTR [rax]
mov QWORD PTR tv79[rbp], rax
mov rax, QWORD PTR _Ostr$[rbp]
mov rax, QWORD PTR [rax]
movsxd rax, DWORD PTR [rax+4]
mov rcx, QWORD PTR _Ostr$[rbp]
add rcx, rax
mov rax, rcx
mov rcx, QWORD PTR _Manip$[rbp]
mov rdx, QWORD PTR [rcx+8]
mov rcx, rax
call QWORD PTR tv79[rbp]
; 425 : return _Ostr;
mov rax, QWORD PTR _Ostr$[rbp]
; 426 : }
lea rsp, QWORD PTR [rbp+216]
pop rdi
pop rbp
ret 0
??$?6DU?$char_traits@D@std@@_J@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@AEBU?$_Smanip@_J@0@@Z ENDP ; std::operator<<<char,std::char_traits<char>,__int64>
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\ostream
; COMDAT ??$?6U?$char_traits@D@std@@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@D@Z
_TEXT SEGMENT
_State$ = 4
_Ok$ = 40
_Pad$4 = 88
$T5 = 308
$T6 = 340
$T7 = 372
$T8 = 404
$T9 = 436
$T10 = 468
$T11 = 504
tv65 = 516
tv305 = 520
tv303 = 520
tv300 = 520
tv295 = 520
tv281 = 520
tv266 = 520
tv130 = 520
tv245 = 528
tv204 = 528
tv179 = 528
tv306 = 536
tv304 = 536
tv301 = 536
tv243 = 537
tv177 = 537
tv307 = 540
tv302 = 540
__$ArrayPad$ = 544
_Ostr$ = 592
_Ch$ = 600
??$?6U?$char_traits@D@std@@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@D@Z PROC ; std::operator<<<std::char_traits<char> >, COMDAT
; 779 : basic_ostream<char, _Traits>& _Ostr, char _Ch) { // insert a char into char stream
$LN23:
mov BYTE PTR [rsp+16], dl
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 600 ; 00000258H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 150 ; 00000096H
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+632]
mov rax, QWORD PTR __security_cookie
xor rax, rbp
mov QWORD PTR __$ArrayPad$[rbp], rax
lea rcx, OFFSET FLAT:__498EBCEB_ostream
call __CheckForDebuggerJustMyCode
; 780 : using _Elem = char;
; 781 : using _Myos = basic_ostream<_Elem, _Traits>;
; 782 :
; 783 : ios_base::iostate _State = ios_base::goodbit;
mov DWORD PTR _State$[rbp], 0
; 784 : const typename _Myos::sentry _Ok(_Ostr);
mov rdx, QWORD PTR _Ostr$[rbp]
lea rcx, QWORD PTR _Ok$[rbp]
call ??0sentry@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAA@AEAV12@@Z ; std::basic_ostream<char,std::char_traits<char> >::sentry::sentry
npad 1
; 785 :
; 786 : if (_Ok) { // state okay, insert
lea rcx, QWORD PTR _Ok$[rbp]
call ??Bsentry@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEBA_NXZ ; std::basic_ostream<char,std::char_traits<char> >::sentry::operator bool
movzx eax, al
test eax, eax
je $LN8@operator
; 787 : streamsize _Pad = _Ostr.width() <= 1 ? 0 : _Ostr.width() - 1;
mov rax, QWORD PTR _Ostr$[rbp]
mov rax, QWORD PTR [rax]
movsxd rax, DWORD PTR [rax+4]
mov rcx, QWORD PTR _Ostr$[rbp]
add rcx, rax
mov rax, rcx
mov rcx, rax
call QWORD PTR __imp_?width@ios_base@std@@QEBA_JXZ
cmp rax, 1
jg SHORT $LN15@operator
mov QWORD PTR tv130[rbp], 0
jmp SHORT $LN16@operator
$LN15@operator:
mov rax, QWORD PTR _Ostr$[rbp]
mov rax, QWORD PTR [rax]
movsxd rax, DWORD PTR [rax+4]
mov rcx, QWORD PTR _Ostr$[rbp]
add rcx, rax
mov rax, rcx
mov rcx, rax
call QWORD PTR __imp_?width@ios_base@std@@QEBA_JXZ
dec rax
mov QWORD PTR tv130[rbp], rax
$LN16@operator:
mov rax, QWORD PTR tv130[rbp]
mov QWORD PTR _Pad$4[rbp], rax
; 788 :
; 789 : _TRY_IO_BEGIN
; 790 : if ((_Ostr.flags() & ios_base::adjustfield) != ios_base::left) {
mov rax, QWORD PTR _Ostr$[rbp]
mov rax, QWORD PTR [rax]
movsxd rax, DWORD PTR [rax+4]
mov rcx, QWORD PTR _Ostr$[rbp]
add rcx, rax
mov rax, rcx
mov rcx, rax
call QWORD PTR __imp_?flags@ios_base@std@@QEBAHXZ
mov DWORD PTR tv65[rbp], eax
mov eax, DWORD PTR tv65[rbp]
and eax, 448 ; 000001c0H
cmp eax, 64 ; 00000040H
je $LN10@operator
; 791 : for (; _State == ios_base::goodbit && 0 < _Pad; --_Pad) { // pad on left
jmp SHORT $LN4@operator
$LN2@operator:
mov rax, QWORD PTR _Pad$4[rbp]
dec rax
mov QWORD PTR _Pad$4[rbp], rax
$LN4@operator:
cmp DWORD PTR _State$[rbp], 0
jne $LN10@operator
cmp QWORD PTR _Pad$4[rbp], 0
jle $LN10@operator
; 792 : if (_Traits::eq_int_type(_Traits::eof(), _Ostr.rdbuf()->sputc(_Ostr.fill()))) {
mov rax, QWORD PTR _Ostr$[rbp]
mov rax, QWORD PTR [rax]
movsxd rax, DWORD PTR [rax+4]
mov rcx, QWORD PTR _Ostr$[rbp]
add rcx, rax
mov rax, rcx
mov rcx, rax
call QWORD PTR __imp_?rdbuf@?$basic_ios@DU?$char_traits@D@std@@@std@@QEBAPEAV?$basic_streambuf@DU?$char_traits@D@std@@@2@XZ
mov QWORD PTR tv300[rbp], rax
mov rax, QWORD PTR tv300[rbp]
mov QWORD PTR tv179[rbp], rax
mov rax, QWORD PTR _Ostr$[rbp]
mov rax, QWORD PTR [rax]
movsxd rax, DWORD PTR [rax+4]
mov rcx, QWORD PTR _Ostr$[rbp]
add rcx, rax
mov rax, rcx
mov rcx, rax
call QWORD PTR __imp_?fill@?$basic_ios@DU?$char_traits@D@std@@@std@@QEBADXZ
mov BYTE PTR tv301[rbp], al
movzx eax, BYTE PTR tv301[rbp]
mov BYTE PTR tv177[rbp], al
movzx edx, BYTE PTR tv177[rbp]
mov rcx, QWORD PTR tv179[rbp]
call QWORD PTR __imp_?sputc@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QEAAHD@Z
mov DWORD PTR tv302[rbp], eax
mov eax, DWORD PTR tv302[rbp]
mov DWORD PTR $T5[rbp], eax
call ?eof@?$_Narrow_char_traits@DH@std@@SAHXZ ; std::_Narrow_char_traits<char,int>::eof
mov DWORD PTR $T6[rbp], eax
lea rdx, QWORD PTR $T5[rbp]
lea rcx, QWORD PTR $T6[rbp]
call ?eq_int_type@?$_Narrow_char_traits@DH@std@@SA_NAEBH0@Z ; std::_Narrow_char_traits<char,int>::eq_int_type
movzx eax, al
test eax, eax
je SHORT $LN11@operator
; 793 : _State |= ios_base::badbit;
mov eax, DWORD PTR _State$[rbp]
or eax, 4
mov DWORD PTR _State$[rbp], eax
$LN11@operator:
; 794 : }
; 795 : }
jmp $LN2@operator
$LN10@operator:
; 796 : }
; 797 :
; 798 : if (_State == ios_base::goodbit && _Traits::eq_int_type(_Traits::eof(), _Ostr.rdbuf()->sputc(_Ch))) {
cmp DWORD PTR _State$[rbp], 0
jne $LN12@operator
mov rax, QWORD PTR _Ostr$[rbp]
mov rax, QWORD PTR [rax]
movsxd rax, DWORD PTR [rax+4]
mov rcx, QWORD PTR _Ostr$[rbp]
add rcx, rax
mov rax, rcx
mov rcx, rax
call QWORD PTR __imp_?rdbuf@?$basic_ios@DU?$char_traits@D@std@@@std@@QEBAPEAV?$basic_streambuf@DU?$char_traits@D@std@@@2@XZ
mov QWORD PTR tv303[rbp], rax
mov rax, QWORD PTR tv303[rbp]
mov QWORD PTR tv204[rbp], rax
movzx edx, BYTE PTR _Ch$[rbp]
mov rcx, QWORD PTR tv204[rbp]
call QWORD PTR __imp_?sputc@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QEAAHD@Z
mov DWORD PTR tv304[rbp], eax
mov eax, DWORD PTR tv304[rbp]
mov DWORD PTR $T7[rbp], eax
call ?eof@?$_Narrow_char_traits@DH@std@@SAHXZ ; std::_Narrow_char_traits<char,int>::eof
mov DWORD PTR $T8[rbp], eax
lea rdx, QWORD PTR $T7[rbp]
lea rcx, QWORD PTR $T8[rbp]
call ?eq_int_type@?$_Narrow_char_traits@DH@std@@SA_NAEBH0@Z ; std::_Narrow_char_traits<char,int>::eq_int_type
movzx eax, al
test eax, eax
je SHORT $LN12@operator
; 799 : _State |= ios_base::badbit;
mov eax, DWORD PTR _State$[rbp]
or eax, 4
mov DWORD PTR _State$[rbp], eax
$LN12@operator:
; 800 : }
; 801 :
; 802 : for (; _State == ios_base::goodbit && 0 < _Pad; --_Pad) { // pad on right
jmp SHORT $LN7@operator
$LN5@operator:
mov rax, QWORD PTR _Pad$4[rbp]
dec rax
mov QWORD PTR _Pad$4[rbp], rax
$LN7@operator:
cmp DWORD PTR _State$[rbp], 0
jne $LN6@operator
cmp QWORD PTR _Pad$4[rbp], 0
jle $LN6@operator
; 803 : if (_Traits::eq_int_type(_Traits::eof(), _Ostr.rdbuf()->sputc(_Ostr.fill()))) {
mov rax, QWORD PTR _Ostr$[rbp]
mov rax, QWORD PTR [rax]
movsxd rax, DWORD PTR [rax+4]
mov rcx, QWORD PTR _Ostr$[rbp]
add rcx, rax
mov rax, rcx
mov rcx, rax
call QWORD PTR __imp_?rdbuf@?$basic_ios@DU?$char_traits@D@std@@@std@@QEBAPEAV?$basic_streambuf@DU?$char_traits@D@std@@@2@XZ
mov QWORD PTR tv305[rbp], rax
mov rax, QWORD PTR tv305[rbp]
mov QWORD PTR tv245[rbp], rax
mov rax, QWORD PTR _Ostr$[rbp]
mov rax, QWORD PTR [rax]
movsxd rax, DWORD PTR [rax+4]
mov rcx, QWORD PTR _Ostr$[rbp]
add rcx, rax
mov rax, rcx
mov rcx, rax
call QWORD PTR __imp_?fill@?$basic_ios@DU?$char_traits@D@std@@@std@@QEBADXZ
mov BYTE PTR tv306[rbp], al
movzx eax, BYTE PTR tv306[rbp]
mov BYTE PTR tv243[rbp], al
movzx edx, BYTE PTR tv243[rbp]
mov rcx, QWORD PTR tv245[rbp]
call QWORD PTR __imp_?sputc@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QEAAHD@Z
mov DWORD PTR tv307[rbp], eax
mov eax, DWORD PTR tv307[rbp]
mov DWORD PTR $T9[rbp], eax
call ?eof@?$_Narrow_char_traits@DH@std@@SAHXZ ; std::_Narrow_char_traits<char,int>::eof
mov DWORD PTR $T10[rbp], eax
lea rdx, QWORD PTR $T9[rbp]
lea rcx, QWORD PTR $T10[rbp]
call ?eq_int_type@?$_Narrow_char_traits@DH@std@@SA_NAEBH0@Z ; std::_Narrow_char_traits<char,int>::eq_int_type
movzx eax, al
test eax, eax
je SHORT $LN13@operator
; 804 : _State |= ios_base::badbit;
mov eax, DWORD PTR _State$[rbp]
or eax, 4
mov DWORD PTR _State$[rbp], eax
$LN13@operator:
; 805 : }
; 806 : }
jmp $LN5@operator
$LN6@operator:
jmp SHORT $LN8@operator
$LN21@operator:
$LN8@operator:
; 807 : _CATCH_IO_(ios_base, _Ostr)
; 808 : }
; 809 :
; 810 : _Ostr.width(0);
mov rax, QWORD PTR _Ostr$[rbp]
mov rax, QWORD PTR [rax]
movsxd rax, DWORD PTR [rax+4]
mov rcx, QWORD PTR _Ostr$[rbp]
add rcx, rax
mov rax, rcx
mov QWORD PTR tv281[rbp], rax
xor edx, edx
mov rcx, QWORD PTR tv281[rbp]
call QWORD PTR __imp_?width@ios_base@std@@QEAA_J_J@Z
; 811 : _Ostr.setstate(_State);
mov rax, QWORD PTR _Ostr$[rbp]
mov rax, QWORD PTR [rax]
movsxd rax, DWORD PTR [rax+4]
mov rcx, QWORD PTR _Ostr$[rbp]
add rcx, rax
mov rax, rcx
mov QWORD PTR tv295[rbp], rax
xor r8d, r8d
mov edx, DWORD PTR _State$[rbp]
mov rcx, QWORD PTR tv295[rbp]
call QWORD PTR __imp_?setstate@?$basic_ios@DU?$char_traits@D@std@@@std@@QEAAXH_N@Z
; 812 : return _Ostr;
mov rax, QWORD PTR _Ostr$[rbp]
mov QWORD PTR $T11[rbp], rax
lea rcx, QWORD PTR _Ok$[rbp]
call ??1sentry@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAA@XZ ; std::basic_ostream<char,std::char_traits<char> >::sentry::~sentry
mov rax, QWORD PTR $T11[rbp]
; 813 : }
mov rdi, rax
lea rcx, QWORD PTR [rbp-32]
lea rdx, OFFSET FLAT:??$?6U?$char_traits@D@std@@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@D@Z$rtcFrameData
call _RTC_CheckStackVars
mov rax, rdi
mov rcx, QWORD PTR __$ArrayPad$[rbp]
xor rcx, rbp
call __security_check_cookie
lea rsp, QWORD PTR [rbp+568]
pop rdi
pop rbp
ret 0
??$?6U?$char_traits@D@std@@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@D@Z ENDP ; std::operator<<<std::char_traits<char> >
_TEXT ENDS
; COMDAT text$x
text$x SEGMENT
_State$ = 4
_Ok$ = 40
_Pad$4 = 88
$T5 = 308
$T6 = 340
$T7 = 372
$T8 = 404
$T9 = 436
$T10 = 468
$T11 = 504
tv65 = 516
tv305 = 520
tv303 = 520
tv300 = 520
tv295 = 520
tv281 = 520
tv266 = 520
tv130 = 520
tv245 = 528
tv204 = 528
tv179 = 528
tv306 = 536
tv304 = 536
tv301 = 536
tv243 = 537
tv177 = 537
tv307 = 540
tv302 = 540
__$ArrayPad$ = 544
_Ostr$ = 592
_Ch$ = 600
?dtor$0@?0???$?6U?$char_traits@D@std@@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@D@Z@4HA PROC ; `std::operator<<<std::char_traits<char> >'::`1'::dtor$0
mov QWORD PTR [rsp+8], rcx
mov QWORD PTR [rsp+16], rdx
push rbp
push rdi
sub rsp, 40 ; 00000028H
lea rbp, QWORD PTR [rdx+32]
lea rcx, QWORD PTR _Ok$[rbp]
call ??1sentry@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAA@XZ ; std::basic_ostream<char,std::char_traits<char> >::sentry::~sentry
add rsp, 40 ; 00000028H
pop rdi
pop rbp
ret 0
?dtor$0@?0???$?6U?$char_traits@D@std@@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@D@Z@4HA ENDP ; `std::operator<<<std::char_traits<char> >'::`1'::dtor$0
text$x ENDS
; COMDAT text$x
text$x SEGMENT
_State$ = 4
_Ok$ = 40
_Pad$4 = 88
$T5 = 308
$T6 = 340
$T7 = 372
$T8 = 404
$T9 = 436
$T10 = 468
$T11 = 504
tv65 = 516
tv305 = 520
tv303 = 520
tv300 = 520
tv295 = 520
tv281 = 520
tv266 = 520
tv130 = 520
tv245 = 528
tv204 = 528
tv179 = 528
tv306 = 536
tv304 = 536
tv301 = 536
tv243 = 537
tv177 = 537
tv307 = 540
tv302 = 540
__$ArrayPad$ = 544
_Ostr$ = 592
_Ch$ = 600
?catch$1@?0???$?6U?$char_traits@D@std@@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@D@Z@4HA PROC ; `std::operator<<<std::char_traits<char> >'::`1'::catch$1
; 807 : _CATCH_IO_(ios_base, _Ostr)
mov QWORD PTR [rsp+8], rcx
mov QWORD PTR [rsp+16], rdx
push rbp
push rdi
sub rsp, 40 ; 00000028H
lea rbp, QWORD PTR [rdx+32]
__catch$??$?6U?$char_traits@D@std@@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@D@Z$0:
mov rax, QWORD PTR _Ostr$[rbp]
mov rax, QWORD PTR [rax]
movsxd rax, DWORD PTR [rax+4]
mov rcx, QWORD PTR _Ostr$[rbp]
add rcx, rax
mov rax, rcx
mov QWORD PTR tv266[rbp], rax
mov r8b, 1
mov edx, 4
mov rcx, QWORD PTR tv266[rbp]
call QWORD PTR __imp_?setstate@?$basic_ios@DU?$char_traits@D@std@@@std@@QEAAXH_N@Z
npad 1
lea rax, $LN21@catch$1
add rsp, 40 ; 00000028H
pop rdi
pop rbp
ret 0
int 3
?catch$1@?0???$?6U?$char_traits@D@std@@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@D@Z@4HA ENDP ; `std::operator<<<std::char_traits<char> >'::`1'::catch$1
text$x ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; COMDAT text$x
text$x SEGMENT
_State$ = 4
_Ok$ = 40
_Pad$4 = 88
$T5 = 308
$T6 = 340
$T7 = 372
$T8 = 404
$T9 = 436
$T10 = 468
$T11 = 504
tv65 = 516
tv305 = 520
tv303 = 520
tv300 = 520
tv295 = 520
tv281 = 520
tv266 = 520
tv130 = 520
tv245 = 528
tv204 = 528
tv179 = 528
tv306 = 536
tv304 = 536
tv301 = 536
tv243 = 537
tv177 = 537
tv307 = 540
tv302 = 540
__$ArrayPad$ = 544
_Ostr$ = 592
_Ch$ = 600
?dtor$0@?0???$?6U?$char_traits@D@std@@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@D@Z@4HA PROC ; `std::operator<<<std::char_traits<char> >'::`1'::dtor$0
mov QWORD PTR [rsp+8], rcx
mov QWORD PTR [rsp+16], rdx
push rbp
push rdi
sub rsp, 40 ; 00000028H
lea rbp, QWORD PTR [rdx+32]
lea rcx, QWORD PTR _Ok$[rbp]
call ??1sentry@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAA@XZ ; std::basic_ostream<char,std::char_traits<char> >::sentry::~sentry
add rsp, 40 ; 00000028H
pop rdi
pop rbp
ret 0
?dtor$0@?0???$?6U?$char_traits@D@std@@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@D@Z@4HA ENDP ; `std::operator<<<std::char_traits<char> >'::`1'::dtor$0
text$x ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; COMDAT text$x
text$x SEGMENT
_State$ = 4
_Ok$ = 40
_Pad$4 = 88
$T5 = 308
$T6 = 340
$T7 = 372
$T8 = 404
$T9 = 436
$T10 = 468
$T11 = 504
tv65 = 516
tv305 = 520
tv303 = 520
tv300 = 520
tv295 = 520
tv281 = 520
tv266 = 520
tv130 = 520
tv245 = 528
tv204 = 528
tv179 = 528
tv306 = 536
tv304 = 536
tv301 = 536
tv243 = 537
tv177 = 537
tv307 = 540
tv302 = 540
__$ArrayPad$ = 544
_Ostr$ = 592
_Ch$ = 600
?catch$1@?0???$?6U?$char_traits@D@std@@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@D@Z@4HA PROC ; `std::operator<<<std::char_traits<char> >'::`1'::catch$1
; 807 : _CATCH_IO_(ios_base, _Ostr)
mov QWORD PTR [rsp+8], rcx
mov QWORD PTR [rsp+16], rdx
push rbp
push rdi
sub rsp, 40 ; 00000028H
lea rbp, QWORD PTR [rdx+32]
__catch$??$?6U?$char_traits@D@std@@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@D@Z$0:
mov rax, QWORD PTR _Ostr$[rbp]
mov rax, QWORD PTR [rax]
movsxd rax, DWORD PTR [rax+4]
mov rcx, QWORD PTR _Ostr$[rbp]
add rcx, rax
mov rax, rcx
mov QWORD PTR tv266[rbp], rax
mov r8b, 1
mov edx, 4
mov rcx, QWORD PTR tv266[rbp]
call QWORD PTR __imp_?setstate@?$basic_ios@DU?$char_traits@D@std@@@std@@QEAAXH_N@Z
npad 1
lea rax, $LN21@catch$1
add rsp, 40 ; 00000028H
pop rdi
pop rbp
ret 0
int 3
?catch$1@?0???$?6U?$char_traits@D@std@@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@D@Z@4HA ENDP ; `std::operator<<<std::char_traits<char> >'::`1'::catch$1
text$x ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\ostream
; COMDAT ??$?6U?$char_traits@D@std@@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@PEBD@Z
_TEXT SEGMENT
_State$ = 4
_Count$ = 40
_Pad$ = 72
_Ok$ = 104
$T4 = 340
$T5 = 372
$T6 = 404
$T7 = 436
$T8 = 472
tv139 = 484
tv316 = 488
tv314 = 488
tv311 = 488
tv306 = 488
tv291 = 488
tv277 = 488
tv137 = 488
tv256 = 496
tv219 = 496
tv194 = 496
tv317 = 504
tv315 = 504
tv312 = 504
tv254 = 505
tv192 = 505
tv318 = 508
tv313 = 508
__$ArrayPad$ = 512
_Ostr$ = 560
_Val$ = 568
??$?6U?$char_traits@D@std@@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@PEBD@Z PROC ; std::operator<<<std::char_traits<char> >, COMDAT
; 734 : const char* _Val) { // insert NTBS into char stream
$LN25:
mov QWORD PTR [rsp+16], rdx
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 568 ; 00000238H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 142 ; 0000008eH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+600]
mov rax, QWORD PTR __security_cookie
xor rax, rbp
mov QWORD PTR __$ArrayPad$[rbp], rax
lea rcx, OFFSET FLAT:__498EBCEB_ostream
call __CheckForDebuggerJustMyCode
; 735 : using _Elem = char;
; 736 : using _Myos = basic_ostream<_Elem, _Traits>;
; 737 :
; 738 : ios_base::iostate _State = ios_base::goodbit;
mov DWORD PTR _State$[rbp], 0
; 739 : streamsize _Count = static_cast<streamsize>(_Traits::length(_Val));
mov rcx, QWORD PTR _Val$[rbp]
call ?length@?$_Narrow_char_traits@DH@std@@SA_KQEBD@Z ; std::_Narrow_char_traits<char,int>::length
mov QWORD PTR _Count$[rbp], rax
; 740 : streamsize _Pad = _Ostr.width() <= 0 || _Ostr.width() <= _Count ? 0 : _Ostr.width() - _Count;
mov rax, QWORD PTR _Ostr$[rbp]
mov rax, QWORD PTR [rax]
movsxd rax, DWORD PTR [rax+4]
mov rcx, QWORD PTR _Ostr$[rbp]
add rcx, rax
mov rax, rcx
mov rcx, rax
call QWORD PTR __imp_?width@ios_base@std@@QEBA_JXZ
test rax, rax
jle SHORT $LN17@operator
mov rax, QWORD PTR _Ostr$[rbp]
mov rax, QWORD PTR [rax]
movsxd rax, DWORD PTR [rax+4]
mov rcx, QWORD PTR _Ostr$[rbp]
add rcx, rax
mov rax, rcx
mov rcx, rax
call QWORD PTR __imp_?width@ios_base@std@@QEBA_JXZ
cmp rax, QWORD PTR _Count$[rbp]
jle SHORT $LN17@operator
mov rax, QWORD PTR _Ostr$[rbp]
mov rax, QWORD PTR [rax]
movsxd rax, DWORD PTR [rax+4]
mov rcx, QWORD PTR _Ostr$[rbp]
add rcx, rax
mov rax, rcx
mov rcx, rax
call QWORD PTR __imp_?width@ios_base@std@@QEBA_JXZ
sub rax, QWORD PTR _Count$[rbp]
mov QWORD PTR tv137[rbp], rax
jmp SHORT $LN18@operator
$LN17@operator:
mov QWORD PTR tv137[rbp], 0
$LN18@operator:
mov rax, QWORD PTR tv137[rbp]
mov QWORD PTR _Pad$[rbp], rax
; 741 : const typename _Myos::sentry _Ok(_Ostr);
mov rdx, QWORD PTR _Ostr$[rbp]
lea rcx, QWORD PTR _Ok$[rbp]
call ??0sentry@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAA@AEAV12@@Z ; std::basic_ostream<char,std::char_traits<char> >::sentry::sentry
npad 1
; 742 :
; 743 : if (!_Ok) {
lea rcx, QWORD PTR _Ok$[rbp]
call ??Bsentry@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEBA_NXZ ; std::basic_ostream<char,std::char_traits<char> >::sentry::operator bool
movzx eax, al
test eax, eax
jne SHORT $LN8@operator
; 744 : _State |= ios_base::badbit;
mov eax, DWORD PTR _State$[rbp]
or eax, 4
mov DWORD PTR _State$[rbp], eax
; 745 : } else { // state okay, insert
jmp $LN9@operator
$LN8@operator:
; 746 : _TRY_IO_BEGIN
; 747 : if ((_Ostr.flags() & ios_base::adjustfield) != ios_base::left) {
mov rax, QWORD PTR _Ostr$[rbp]
mov rax, QWORD PTR [rax]
movsxd rax, DWORD PTR [rax+4]
mov rcx, QWORD PTR _Ostr$[rbp]
add rcx, rax
mov rax, rcx
mov rcx, rax
call QWORD PTR __imp_?flags@ios_base@std@@QEBAHXZ
mov DWORD PTR tv139[rbp], eax
mov eax, DWORD PTR tv139[rbp]
and eax, 448 ; 000001c0H
cmp eax, 64 ; 00000040H
je $LN11@operator
; 748 : for (; 0 < _Pad; --_Pad) { // pad on left
jmp SHORT $LN4@operator
$LN2@operator:
mov rax, QWORD PTR _Pad$[rbp]
dec rax
mov QWORD PTR _Pad$[rbp], rax
$LN4@operator:
cmp QWORD PTR _Pad$[rbp], 0
jle $LN11@operator
; 749 : if (_Traits::eq_int_type(_Traits::eof(), _Ostr.rdbuf()->sputc(_Ostr.fill()))) {
mov rax, QWORD PTR _Ostr$[rbp]
mov rax, QWORD PTR [rax]
movsxd rax, DWORD PTR [rax+4]
mov rcx, QWORD PTR _Ostr$[rbp]
add rcx, rax
mov rax, rcx
mov rcx, rax
call QWORD PTR __imp_?rdbuf@?$basic_ios@DU?$char_traits@D@std@@@std@@QEBAPEAV?$basic_streambuf@DU?$char_traits@D@std@@@2@XZ
mov QWORD PTR tv311[rbp], rax
mov rax, QWORD PTR tv311[rbp]
mov QWORD PTR tv194[rbp], rax
mov rax, QWORD PTR _Ostr$[rbp]
mov rax, QWORD PTR [rax]
movsxd rax, DWORD PTR [rax+4]
mov rcx, QWORD PTR _Ostr$[rbp]
add rcx, rax
mov rax, rcx
mov rcx, rax
call QWORD PTR __imp_?fill@?$basic_ios@DU?$char_traits@D@std@@@std@@QEBADXZ
mov BYTE PTR tv312[rbp], al
movzx eax, BYTE PTR tv312[rbp]
mov BYTE PTR tv192[rbp], al
movzx edx, BYTE PTR tv192[rbp]
mov rcx, QWORD PTR tv194[rbp]
call QWORD PTR __imp_?sputc@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QEAAHD@Z
mov DWORD PTR tv313[rbp], eax
mov eax, DWORD PTR tv313[rbp]
mov DWORD PTR $T4[rbp], eax
call ?eof@?$_Narrow_char_traits@DH@std@@SAHXZ ; std::_Narrow_char_traits<char,int>::eof
mov DWORD PTR $T5[rbp], eax
lea rdx, QWORD PTR $T4[rbp]
lea rcx, QWORD PTR $T5[rbp]
call ?eq_int_type@?$_Narrow_char_traits@DH@std@@SA_NAEBH0@Z ; std::_Narrow_char_traits<char,int>::eq_int_type
movzx eax, al
test eax, eax
je SHORT $LN12@operator
; 750 : _State |= ios_base::badbit; // insertion failed, quit
mov eax, DWORD PTR _State$[rbp]
or eax, 4
mov DWORD PTR _State$[rbp], eax
; 751 : break;
jmp SHORT $LN11@operator
$LN12@operator:
; 752 : }
; 753 : }
jmp $LN2@operator
$LN11@operator:
; 754 : }
; 755 :
; 756 : if (_State == ios_base::goodbit && _Ostr.rdbuf()->sputn(_Val, _Count) != _Count) {
cmp DWORD PTR _State$[rbp], 0
jne SHORT $LN13@operator
mov rax, QWORD PTR _Ostr$[rbp]
mov rax, QWORD PTR [rax]
movsxd rax, DWORD PTR [rax+4]
mov rcx, QWORD PTR _Ostr$[rbp]
add rcx, rax
mov rax, rcx
mov rcx, rax
call QWORD PTR __imp_?rdbuf@?$basic_ios@DU?$char_traits@D@std@@@std@@QEBAPEAV?$basic_streambuf@DU?$char_traits@D@std@@@2@XZ
mov QWORD PTR tv314[rbp], rax
mov rax, QWORD PTR tv314[rbp]
mov QWORD PTR tv219[rbp], rax
mov r8, QWORD PTR _Count$[rbp]
mov rdx, QWORD PTR _Val$[rbp]
mov rcx, QWORD PTR tv219[rbp]
call QWORD PTR __imp_?sputn@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QEAA_JPEBD_J@Z
mov QWORD PTR tv315[rbp], rax
mov rax, QWORD PTR _Count$[rbp]
cmp QWORD PTR tv315[rbp], rax
je SHORT $LN13@operator
; 757 : _State |= ios_base::badbit;
mov eax, DWORD PTR _State$[rbp]
or eax, 4
mov DWORD PTR _State$[rbp], eax
$LN13@operator:
; 758 : }
; 759 :
; 760 : if (_State == ios_base::goodbit) {
cmp DWORD PTR _State$[rbp], 0
jne $LN14@operator
; 761 : for (; 0 < _Pad; --_Pad) { // pad on right
jmp SHORT $LN7@operator
$LN5@operator:
mov rax, QWORD PTR _Pad$[rbp]
dec rax
mov QWORD PTR _Pad$[rbp], rax
$LN7@operator:
cmp QWORD PTR _Pad$[rbp], 0
jle $LN14@operator
; 762 : if (_Traits::eq_int_type(_Traits::eof(), _Ostr.rdbuf()->sputc(_Ostr.fill()))) {
mov rax, QWORD PTR _Ostr$[rbp]
mov rax, QWORD PTR [rax]
movsxd rax, DWORD PTR [rax+4]
mov rcx, QWORD PTR _Ostr$[rbp]
add rcx, rax
mov rax, rcx
mov rcx, rax
call QWORD PTR __imp_?rdbuf@?$basic_ios@DU?$char_traits@D@std@@@std@@QEBAPEAV?$basic_streambuf@DU?$char_traits@D@std@@@2@XZ
mov QWORD PTR tv316[rbp], rax
mov rax, QWORD PTR tv316[rbp]
mov QWORD PTR tv256[rbp], rax
mov rax, QWORD PTR _Ostr$[rbp]
mov rax, QWORD PTR [rax]
movsxd rax, DWORD PTR [rax+4]
mov rcx, QWORD PTR _Ostr$[rbp]
add rcx, rax
mov rax, rcx
mov rcx, rax
call QWORD PTR __imp_?fill@?$basic_ios@DU?$char_traits@D@std@@@std@@QEBADXZ
mov BYTE PTR tv317[rbp], al
movzx eax, BYTE PTR tv317[rbp]
mov BYTE PTR tv254[rbp], al
movzx edx, BYTE PTR tv254[rbp]
mov rcx, QWORD PTR tv256[rbp]
call QWORD PTR __imp_?sputc@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QEAAHD@Z
mov DWORD PTR tv318[rbp], eax
mov eax, DWORD PTR tv318[rbp]
mov DWORD PTR $T6[rbp], eax
call ?eof@?$_Narrow_char_traits@DH@std@@SAHXZ ; std::_Narrow_char_traits<char,int>::eof
mov DWORD PTR $T7[rbp], eax
lea rdx, QWORD PTR $T6[rbp]
lea rcx, QWORD PTR $T7[rbp]
call ?eq_int_type@?$_Narrow_char_traits@DH@std@@SA_NAEBH0@Z ; std::_Narrow_char_traits<char,int>::eq_int_type
movzx eax, al
test eax, eax
je SHORT $LN15@operator
; 763 : _State |= ios_base::badbit; // insertion failed, quit
mov eax, DWORD PTR _State$[rbp]
or eax, 4
mov DWORD PTR _State$[rbp], eax
; 764 : break;
jmp SHORT $LN14@operator
$LN15@operator:
; 765 : }
; 766 : }
jmp $LN5@operator
$LN14@operator:
; 767 : }
; 768 :
; 769 : _Ostr.width(0);
mov rax, QWORD PTR _Ostr$[rbp]
mov rax, QWORD PTR [rax]
movsxd rax, DWORD PTR [rax+4]
mov rcx, QWORD PTR _Ostr$[rbp]
add rcx, rax
mov rax, rcx
mov QWORD PTR tv277[rbp], rax
xor edx, edx
mov rcx, QWORD PTR tv277[rbp]
call QWORD PTR __imp_?width@ios_base@std@@QEAA_J_J@Z
npad 1
jmp SHORT $LN9@operator
$LN23@operator:
$LN9@operator:
; 770 : _CATCH_IO_(ios_base, _Ostr)
; 771 : }
; 772 :
; 773 : _Ostr.setstate(_State);
mov rax, QWORD PTR _Ostr$[rbp]
mov rax, QWORD PTR [rax]
movsxd rax, DWORD PTR [rax+4]
mov rcx, QWORD PTR _Ostr$[rbp]
add rcx, rax
mov rax, rcx
mov QWORD PTR tv306[rbp], rax
xor r8d, r8d
mov edx, DWORD PTR _State$[rbp]
mov rcx, QWORD PTR tv306[rbp]
call QWORD PTR __imp_?setstate@?$basic_ios@DU?$char_traits@D@std@@@std@@QEAAXH_N@Z
; 774 : return _Ostr;
mov rax, QWORD PTR _Ostr$[rbp]
mov QWORD PTR $T8[rbp], rax
lea rcx, QWORD PTR _Ok$[rbp]
call ??1sentry@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAA@XZ ; std::basic_ostream<char,std::char_traits<char> >::sentry::~sentry
mov rax, QWORD PTR $T8[rbp]
; 775 : }
mov rdi, rax
lea rcx, QWORD PTR [rbp-32]
lea rdx, OFFSET FLAT:??$?6U?$char_traits@D@std@@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@PEBD@Z$rtcFrameData
call _RTC_CheckStackVars
mov rax, rdi
mov rcx, QWORD PTR __$ArrayPad$[rbp]
xor rcx, rbp
call __security_check_cookie
lea rsp, QWORD PTR [rbp+536]
pop rdi
pop rbp
ret 0
??$?6U?$char_traits@D@std@@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@PEBD@Z ENDP ; std::operator<<<std::char_traits<char> >
_TEXT ENDS
; COMDAT text$x
text$x SEGMENT
_State$ = 4
_Count$ = 40
_Pad$ = 72
_Ok$ = 104
$T4 = 340
$T5 = 372
$T6 = 404
$T7 = 436
$T8 = 472
tv139 = 484
tv316 = 488
tv314 = 488
tv311 = 488
tv306 = 488
tv291 = 488
tv277 = 488
tv137 = 488
tv256 = 496
tv219 = 496
tv194 = 496
tv317 = 504
tv315 = 504
tv312 = 504
tv254 = 505
tv192 = 505
tv318 = 508
tv313 = 508
__$ArrayPad$ = 512
_Ostr$ = 560
_Val$ = 568
?dtor$0@?0???$?6U?$char_traits@D@std@@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@PEBD@Z@4HA PROC ; `std::operator<<<std::char_traits<char> >'::`1'::dtor$0
mov QWORD PTR [rsp+8], rcx
mov QWORD PTR [rsp+16], rdx
push rbp
push rdi
sub rsp, 40 ; 00000028H
lea rbp, QWORD PTR [rdx+32]
lea rcx, QWORD PTR _Ok$[rbp]
call ??1sentry@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAA@XZ ; std::basic_ostream<char,std::char_traits<char> >::sentry::~sentry
add rsp, 40 ; 00000028H
pop rdi
pop rbp
ret 0
?dtor$0@?0???$?6U?$char_traits@D@std@@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@PEBD@Z@4HA ENDP ; `std::operator<<<std::char_traits<char> >'::`1'::dtor$0
text$x ENDS
; COMDAT text$x
text$x SEGMENT
_State$ = 4
_Count$ = 40
_Pad$ = 72
_Ok$ = 104
$T4 = 340
$T5 = 372
$T6 = 404
$T7 = 436
$T8 = 472
tv139 = 484
tv316 = 488
tv314 = 488
tv311 = 488
tv306 = 488
tv291 = 488
tv277 = 488
tv137 = 488
tv256 = 496
tv219 = 496
tv194 = 496
tv317 = 504
tv315 = 504
tv312 = 504
tv254 = 505
tv192 = 505
tv318 = 508
tv313 = 508
__$ArrayPad$ = 512
_Ostr$ = 560
_Val$ = 568
?catch$1@?0???$?6U?$char_traits@D@std@@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@PEBD@Z@4HA PROC ; `std::operator<<<std::char_traits<char> >'::`1'::catch$1
; 770 : _CATCH_IO_(ios_base, _Ostr)
mov QWORD PTR [rsp+8], rcx
mov QWORD PTR [rsp+16], rdx
push rbp
push rdi
sub rsp, 40 ; 00000028H
lea rbp, QWORD PTR [rdx+32]
__catch$??$?6U?$char_traits@D@std@@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@PEBD@Z$0:
mov rax, QWORD PTR _Ostr$[rbp]
mov rax, QWORD PTR [rax]
movsxd rax, DWORD PTR [rax+4]
mov rcx, QWORD PTR _Ostr$[rbp]
add rcx, rax
mov rax, rcx
mov QWORD PTR tv291[rbp], rax
mov r8b, 1
mov edx, 4
mov rcx, QWORD PTR tv291[rbp]
call QWORD PTR __imp_?setstate@?$basic_ios@DU?$char_traits@D@std@@@std@@QEAAXH_N@Z
npad 1
lea rax, $LN23@catch$1
add rsp, 40 ; 00000028H
pop rdi
pop rbp
ret 0
int 3
?catch$1@?0???$?6U?$char_traits@D@std@@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@PEBD@Z@4HA ENDP ; `std::operator<<<std::char_traits<char> >'::`1'::catch$1
text$x ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; COMDAT text$x
text$x SEGMENT
_State$ = 4
_Count$ = 40
_Pad$ = 72
_Ok$ = 104
$T4 = 340
$T5 = 372
$T6 = 404
$T7 = 436
$T8 = 472
tv139 = 484
tv316 = 488
tv314 = 488
tv311 = 488
tv306 = 488
tv291 = 488
tv277 = 488
tv137 = 488
tv256 = 496
tv219 = 496
tv194 = 496
tv317 = 504
tv315 = 504
tv312 = 504
tv254 = 505
tv192 = 505
tv318 = 508
tv313 = 508
__$ArrayPad$ = 512
_Ostr$ = 560
_Val$ = 568
?dtor$0@?0???$?6U?$char_traits@D@std@@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@PEBD@Z@4HA PROC ; `std::operator<<<std::char_traits<char> >'::`1'::dtor$0
mov QWORD PTR [rsp+8], rcx
mov QWORD PTR [rsp+16], rdx
push rbp
push rdi
sub rsp, 40 ; 00000028H
lea rbp, QWORD PTR [rdx+32]
lea rcx, QWORD PTR _Ok$[rbp]
call ??1sentry@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAA@XZ ; std::basic_ostream<char,std::char_traits<char> >::sentry::~sentry
add rsp, 40 ; 00000028H
pop rdi
pop rbp
ret 0
?dtor$0@?0???$?6U?$char_traits@D@std@@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@PEBD@Z@4HA ENDP ; `std::operator<<<std::char_traits<char> >'::`1'::dtor$0
text$x ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; COMDAT text$x
text$x SEGMENT
_State$ = 4
_Count$ = 40
_Pad$ = 72
_Ok$ = 104
$T4 = 340
$T5 = 372
$T6 = 404
$T7 = 436
$T8 = 472
tv139 = 484
tv316 = 488
tv314 = 488
tv311 = 488
tv306 = 488
tv291 = 488
tv277 = 488
tv137 = 488
tv256 = 496
tv219 = 496
tv194 = 496
tv317 = 504
tv315 = 504
tv312 = 504
tv254 = 505
tv192 = 505
tv318 = 508
tv313 = 508
__$ArrayPad$ = 512
_Ostr$ = 560
_Val$ = 568
?catch$1@?0???$?6U?$char_traits@D@std@@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@PEBD@Z@4HA PROC ; `std::operator<<<std::char_traits<char> >'::`1'::catch$1
; 770 : _CATCH_IO_(ios_base, _Ostr)
mov QWORD PTR [rsp+8], rcx
mov QWORD PTR [rsp+16], rdx
push rbp
push rdi
sub rsp, 40 ; 00000028H
lea rbp, QWORD PTR [rdx+32]
__catch$??$?6U?$char_traits@D@std@@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@PEBD@Z$0:
mov rax, QWORD PTR _Ostr$[rbp]
mov rax, QWORD PTR [rax]
movsxd rax, DWORD PTR [rax+4]
mov rcx, QWORD PTR _Ostr$[rbp]
add rcx, rax
mov rax, rcx
mov QWORD PTR tv291[rbp], rax
mov r8b, 1
mov edx, 4
mov rcx, QWORD PTR tv291[rbp]
call QWORD PTR __imp_?setstate@?$basic_ios@DU?$char_traits@D@std@@@std@@QEAAXH_N@Z
npad 1
lea rax, $LN23@catch$1
add rsp, 40 ; 00000028H
pop rdi
pop rbp
ret 0
int 3
?catch$1@?0???$?6U?$char_traits@D@std@@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@PEBD@Z@4HA ENDP ; `std::operator<<<std::char_traits<char> >'::`1'::catch$1
text$x ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; COMDAT ?__autoclassinit2@?$vector@UPaymentOption@Persistence@TechnicalServices@@V?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@@std@@QEAAX_K@Z
_TEXT SEGMENT
this$ = 224
classSize$ = 232
?__autoclassinit2@?$vector@UPaymentOption@Persistence@TechnicalServices@@V?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@@std@@QEAAX_K@Z PROC ; std::vector<TechnicalServices::Persistence::PaymentOption,std::allocator<TechnicalServices::Persistence::PaymentOption> >::__autoclassinit2, COMDAT
$LN3:
mov QWORD PTR [rsp+16], rdx
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 200 ; 000000c8H
mov rbp, rsp
mov rdi, rsp
mov ecx, 50 ; 00000032H
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+232]
mov rdi, QWORD PTR this$[rbp]
xor eax, eax
mov rcx, QWORD PTR classSize$[rbp]
rep stosb
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
?__autoclassinit2@?$vector@UPaymentOption@Persistence@TechnicalServices@@V?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@@std@@QEAAX_K@Z ENDP ; std::vector<TechnicalServices::Persistence::PaymentOption,std::allocator<TechnicalServices::Persistence::PaymentOption> >::__autoclassinit2
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\xmemory
; COMDAT ?_Get_first@?$_Compressed_pair@V?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@V?$_Vector_val@U?$_Simple_types@UPaymentOption@Persistence@TechnicalServices@@@std@@@2@$00@std@@QEAAAEAV?$allocator@UPaymentOption@Persistence@TechnicalServices@@@2@XZ
_TEXT SEGMENT
this$ = 224
?_Get_first@?$_Compressed_pair@V?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@V?$_Vector_val@U?$_Simple_types@UPaymentOption@Persistence@TechnicalServices@@@std@@@2@$00@std@@QEAAAEAV?$allocator@UPaymentOption@Persistence@TechnicalServices@@@2@XZ PROC ; std::_Compressed_pair<std::allocator<TechnicalServices::Persistence::PaymentOption>,std::_Vector_val<std::_Simple_types<TechnicalServices::Persistence::PaymentOption> >,1>::_Get_first, COMDAT
; 1346 : constexpr _Ty1& _Get_first() noexcept {
$LN3:
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+264]
lea rcx, OFFSET FLAT:__F1739482_xmemory
call __CheckForDebuggerJustMyCode
; 1347 : return *this;
mov rax, QWORD PTR this$[rbp]
; 1348 : }
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
?_Get_first@?$_Compressed_pair@V?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@V?$_Vector_val@U?$_Simple_types@UPaymentOption@Persistence@TechnicalServices@@@std@@@2@$00@std@@QEAAAEAV?$allocator@UPaymentOption@Persistence@TechnicalServices@@@2@XZ ENDP ; std::_Compressed_pair<std::allocator<TechnicalServices::Persistence::PaymentOption>,std::_Vector_val<std::_Simple_types<TechnicalServices::Persistence::PaymentOption> >,1>::_Get_first
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\vector
; COMDAT ?_Getal@?$vector@UPaymentOption@Persistence@TechnicalServices@@V?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@@std@@AEAAAEAV?$allocator@UPaymentOption@Persistence@TechnicalServices@@@2@XZ
_TEXT SEGMENT
this$ = 224
?_Getal@?$vector@UPaymentOption@Persistence@TechnicalServices@@V?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@@std@@AEAAAEAV?$allocator@UPaymentOption@Persistence@TechnicalServices@@@2@XZ PROC ; std::vector<TechnicalServices::Persistence::PaymentOption,std::allocator<TechnicalServices::Persistence::PaymentOption> >::_Getal, COMDAT
; 1732 : _Alty& _Getal() noexcept {
$LN3:
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+264]
lea rcx, OFFSET FLAT:__9B902D3A_vector
call __CheckForDebuggerJustMyCode
; 1733 : return _Mypair._Get_first();
mov rax, QWORD PTR this$[rbp]
mov rcx, rax
call ?_Get_first@?$_Compressed_pair@V?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@V?$_Vector_val@U?$_Simple_types@UPaymentOption@Persistence@TechnicalServices@@@std@@@2@$00@std@@QEAAAEAV?$allocator@UPaymentOption@Persistence@TechnicalServices@@@2@XZ ; std::_Compressed_pair<std::allocator<TechnicalServices::Persistence::PaymentOption>,std::_Vector_val<std::_Simple_types<TechnicalServices::Persistence::PaymentOption> >,1>::_Get_first
; 1734 : }
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
?_Getal@?$vector@UPaymentOption@Persistence@TechnicalServices@@V?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@@std@@AEAAAEAV?$allocator@UPaymentOption@Persistence@TechnicalServices@@@2@XZ ENDP ; std::vector<TechnicalServices::Persistence::PaymentOption,std::allocator<TechnicalServices::Persistence::PaymentOption> >::_Getal
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\vector
; COMDAT ?_Tidy@?$vector@UPaymentOption@Persistence@TechnicalServices@@V?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@@std@@AEAAXXZ
_TEXT SEGMENT
_My_data$ = 8
_Myfirst$ = 40
_Mylast$ = 72
_Myend$ = 104
tv90 = 312
tv88 = 320
tv86 = 328
this$ = 368
?_Tidy@?$vector@UPaymentOption@Persistence@TechnicalServices@@V?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@@std@@AEAAXXZ PROC ; std::vector<TechnicalServices::Persistence::PaymentOption,std::allocator<TechnicalServices::Persistence::PaymentOption> >::_Tidy, COMDAT
; 1686 : void _Tidy() noexcept { // free all storage
$LN4:
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 376 ; 00000178H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 94 ; 0000005eH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+408]
lea rcx, OFFSET FLAT:__9B902D3A_vector
call __CheckForDebuggerJustMyCode
; 1687 : auto& _My_data = _Mypair._Myval2;
mov rax, QWORD PTR this$[rbp]
mov QWORD PTR _My_data$[rbp], rax
; 1688 : pointer& _Myfirst = _My_data._Myfirst;
mov rax, QWORD PTR _My_data$[rbp]
add rax, 8
mov QWORD PTR _Myfirst$[rbp], rax
; 1689 : pointer& _Mylast = _My_data._Mylast;
mov rax, QWORD PTR _My_data$[rbp]
add rax, 16
mov QWORD PTR _Mylast$[rbp], rax
; 1690 : pointer& _Myend = _My_data._Myend;
mov rax, QWORD PTR _My_data$[rbp]
add rax, 24
mov QWORD PTR _Myend$[rbp], rax
; 1691 :
; 1692 : _My_data._Orphan_all();
mov rcx, QWORD PTR _My_data$[rbp]
call ?_Orphan_all@_Container_base12@std@@QEAAXXZ ; std::_Container_base12::_Orphan_all
; 1693 :
; 1694 : if (_Myfirst) { // destroy and deallocate old array
mov rax, QWORD PTR _Myfirst$[rbp]
cmp QWORD PTR [rax], 0
je $LN2@Tidy
; 1695 : _Destroy(_Myfirst, _Mylast);
mov rax, QWORD PTR _Mylast$[rbp]
mov r8, QWORD PTR [rax]
mov rax, QWORD PTR _Myfirst$[rbp]
mov rdx, QWORD PTR [rax]
mov rcx, QWORD PTR this$[rbp]
call ?_Destroy@?$vector@UPaymentOption@Persistence@TechnicalServices@@V?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@@std@@AEAAXPEAUPaymentOption@Persistence@TechnicalServices@@0@Z ; std::vector<TechnicalServices::Persistence::PaymentOption,std::allocator<TechnicalServices::Persistence::PaymentOption> >::_Destroy
; 1696 : _Getal().deallocate(_Myfirst, static_cast<size_type>(_Myend - _Myfirst));
mov rcx, QWORD PTR this$[rbp]
call ?_Getal@?$vector@UPaymentOption@Persistence@TechnicalServices@@V?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@@std@@AEAAAEAV?$allocator@UPaymentOption@Persistence@TechnicalServices@@@2@XZ ; std::vector<TechnicalServices::Persistence::PaymentOption,std::allocator<TechnicalServices::Persistence::PaymentOption> >::_Getal
mov QWORD PTR tv90[rbp], rax
mov rax, QWORD PTR _Myend$[rbp]
mov rcx, QWORD PTR _Myfirst$[rbp]
mov rcx, QWORD PTR [rcx]
mov rax, QWORD PTR [rax]
sub rax, rcx
cdq
mov ecx, 48 ; 00000030H
idiv rcx
mov QWORD PTR tv88[rbp], rax
mov rax, QWORD PTR _Myfirst$[rbp]
mov rax, QWORD PTR [rax]
mov QWORD PTR tv86[rbp], rax
mov r8, QWORD PTR tv88[rbp]
mov rdx, QWORD PTR tv86[rbp]
mov rcx, QWORD PTR tv90[rbp]
call ?deallocate@?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@QEAAXQEAUPaymentOption@Persistence@TechnicalServices@@_K@Z ; std::allocator<TechnicalServices::Persistence::PaymentOption>::deallocate
; 1697 :
; 1698 : _Myfirst = pointer();
mov rax, QWORD PTR _Myfirst$[rbp]
mov QWORD PTR [rax], 0
; 1699 : _Mylast = pointer();
mov rax, QWORD PTR _Mylast$[rbp]
mov QWORD PTR [rax], 0
; 1700 : _Myend = pointer();
mov rax, QWORD PTR _Myend$[rbp]
mov QWORD PTR [rax], 0
$LN2@Tidy:
; 1701 : }
; 1702 : }
lea rsp, QWORD PTR [rbp+344]
pop rdi
pop rbp
ret 0
?_Tidy@?$vector@UPaymentOption@Persistence@TechnicalServices@@V?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@@std@@AEAAXXZ ENDP ; std::vector<TechnicalServices::Persistence::PaymentOption,std::allocator<TechnicalServices::Persistence::PaymentOption> >::_Tidy
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\vector
; COMDAT ?_Destroy@?$vector@UPaymentOption@Persistence@TechnicalServices@@V?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@@std@@AEAAXPEAUPaymentOption@Persistence@TechnicalServices@@0@Z
_TEXT SEGMENT
this$ = 224
_First$ = 232
_Last$ = 240
?_Destroy@?$vector@UPaymentOption@Persistence@TechnicalServices@@V?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@@std@@AEAAXPEAUPaymentOption@Persistence@TechnicalServices@@0@Z PROC ; std::vector<TechnicalServices::Persistence::PaymentOption,std::allocator<TechnicalServices::Persistence::PaymentOption> >::_Destroy, COMDAT
; 1611 : void _Destroy(pointer _First, pointer _Last) { // destroy [_First, _Last) using allocator
$LN3:
mov QWORD PTR [rsp+24], r8
mov QWORD PTR [rsp+16], rdx
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+264]
lea rcx, OFFSET FLAT:__9B902D3A_vector
call __CheckForDebuggerJustMyCode
; 1612 : _Destroy_range(_First, _Last, _Getal());
mov rcx, QWORD PTR this$[rbp]
call ?_Getal@?$vector@UPaymentOption@Persistence@TechnicalServices@@V?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@@std@@AEAAAEAV?$allocator@UPaymentOption@Persistence@TechnicalServices@@@2@XZ ; std::vector<TechnicalServices::Persistence::PaymentOption,std::allocator<TechnicalServices::Persistence::PaymentOption> >::_Getal
mov r8, rax
mov rdx, QWORD PTR _Last$[rbp]
mov rcx, QWORD PTR _First$[rbp]
call ??$_Destroy_range@V?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@@std@@YAXPEAUPaymentOption@Persistence@TechnicalServices@@QEAU123@AEAV?$allocator@UPaymentOption@Persistence@TechnicalServices@@@0@@Z ; std::_Destroy_range<std::allocator<TechnicalServices::Persistence::PaymentOption> >
; 1613 : }
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
?_Destroy@?$vector@UPaymentOption@Persistence@TechnicalServices@@V?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@@std@@AEAAXPEAUPaymentOption@Persistence@TechnicalServices@@0@Z ENDP ; std::vector<TechnicalServices::Persistence::PaymentOption,std::allocator<TechnicalServices::Persistence::PaymentOption> >::_Destroy
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\vector
; COMDAT ??A?$vector@UPaymentOption@Persistence@TechnicalServices@@V?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@@std@@QEAAAEAUPaymentOption@Persistence@TechnicalServices@@_K@Z
_TEXT SEGMENT
_My_data$ = 8
this$ = 256
_Pos$ = 264
??A?$vector@UPaymentOption@Persistence@TechnicalServices@@V?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@@std@@QEAAAEAUPaymentOption@Persistence@TechnicalServices@@_K@Z PROC ; std::vector<TechnicalServices::Persistence::PaymentOption,std::allocator<TechnicalServices::Persistence::PaymentOption> >::operator[], COMDAT
; 1497 : _NODISCARD _Ty& operator[](const size_type _Pos) noexcept /* strengthened */ {
$LN12:
mov QWORD PTR [rsp+16], rdx
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 280 ; 00000118H
lea rbp, QWORD PTR [rsp+48]
mov rdi, rsp
mov ecx, 70 ; 00000046H
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+312]
lea rcx, OFFSET FLAT:__9B902D3A_vector
call __CheckForDebuggerJustMyCode
; 1498 : auto& _My_data = _Mypair._Myval2;
mov rax, QWORD PTR this$[rbp]
mov QWORD PTR _My_data$[rbp], rax
$LN4@operator:
; 1499 : #if _CONTAINER_DEBUG_LEVEL > 0
; 1500 : _STL_VERIFY(
mov rax, QWORD PTR _My_data$[rbp]
mov rcx, QWORD PTR _My_data$[rbp]
mov rcx, QWORD PTR [rcx+8]
mov rax, QWORD PTR [rax+16]
sub rax, rcx
cdq
mov ecx, 48 ; 00000030H
idiv rcx
cmp QWORD PTR _Pos$[rbp], rax
jae SHORT $LN7@operator
jmp SHORT $LN9@operator
$LN7@operator:
lea rax, OFFSET FLAT:??_C@_0BO@PFKOHNJC@vector?5subscript?5out?5of?5range@
mov QWORD PTR [rsp+40], rax
lea rax, OFFSET FLAT:??_C@_02DKCKIIND@?$CFs@
mov QWORD PTR [rsp+32], rax
xor r9d, r9d
mov r8d, 1501 ; 000005ddH
lea rdx, OFFSET FLAT:??_C@_0GH@CENCAHKH@C?3?2Program?5Files?5?$CIx86?$CJ?2Microsof@
mov ecx, 2
call QWORD PTR __imp__CrtDbgReport
cmp eax, 1
jne SHORT $LN11@operator
int 3
xor eax, eax
$LN11@operator:
mov QWORD PTR [rsp+32], 0
mov r9d, 1501 ; 000005ddH
lea r8, OFFSET FLAT:??_C@_1MO@BFNDGJJP@?$AAC?$AA?3?$AA?2?$AAP?$AAr?$AAo?$AAg?$AAr?$AAa?$AAm?$AA?5?$AAF?$AAi?$AAl?$AAe@
lea rdx, OFFSET FLAT:??_C@_1BDG@KBAFNKDI@?$AAs?$AAt?$AAd?$AA?3?$AA?3?$AAv?$AAe?$AAc?$AAt?$AAo?$AAr?$AA?$DM?$AAs?$AAt?$AAr@
lea rcx, OFFSET FLAT:??_C@_1EA@LEKOKFNB@?$AA?$CC?$AAv?$AAe?$AAc?$AAt?$AAo?$AAr?$AA?5?$AAs?$AAu?$AAb?$AAs?$AAc?$AAr?$AAi@
call QWORD PTR __imp__invalid_parameter
xor eax, eax
test eax, eax
jne SHORT $LN7@operator
$LN9@operator:
xor eax, eax
test eax, eax
jne $LN4@operator
; 1501 : _Pos < static_cast<size_type>(_My_data._Mylast - _My_data._Myfirst), "vector subscript out of range");
; 1502 : #endif // _CONTAINER_DEBUG_LEVEL > 0
; 1503 :
; 1504 : return _My_data._Myfirst[_Pos];
imul rax, QWORD PTR _Pos$[rbp], 48 ; 00000030H
mov rcx, QWORD PTR _My_data$[rbp]
add rax, QWORD PTR [rcx+8]
; 1505 : }
lea rsp, QWORD PTR [rbp+232]
pop rdi
pop rbp
ret 0
??A?$vector@UPaymentOption@Persistence@TechnicalServices@@V?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@@std@@QEAAAEAUPaymentOption@Persistence@TechnicalServices@@_K@Z ENDP ; std::vector<TechnicalServices::Persistence::PaymentOption,std::allocator<TechnicalServices::Persistence::PaymentOption> >::operator[]
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\vector
; COMDAT ?size@?$vector@UPaymentOption@Persistence@TechnicalServices@@V?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@@std@@QEBA_KXZ
_TEXT SEGMENT
_My_data$ = 8
this$ = 256
?size@?$vector@UPaymentOption@Persistence@TechnicalServices@@V?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@@std@@QEBA_KXZ PROC ; std::vector<TechnicalServices::Persistence::PaymentOption,std::allocator<TechnicalServices::Persistence::PaymentOption> >::size, COMDAT
; 1482 : _NODISCARD size_type size() const noexcept {
$LN3:
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 264 ; 00000108H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 66 ; 00000042H
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+296]
lea rcx, OFFSET FLAT:__9B902D3A_vector
call __CheckForDebuggerJustMyCode
; 1483 : auto& _My_data = _Mypair._Myval2;
mov rax, QWORD PTR this$[rbp]
mov QWORD PTR _My_data$[rbp], rax
; 1484 : return static_cast<size_type>(_My_data._Mylast - _My_data._Myfirst);
mov rax, QWORD PTR _My_data$[rbp]
mov rcx, QWORD PTR _My_data$[rbp]
mov rcx, QWORD PTR [rcx+8]
mov rax, QWORD PTR [rax+16]
sub rax, rcx
cdq
mov ecx, 48 ; 00000030H
idiv rcx
; 1485 : }
lea rsp, QWORD PTR [rbp+232]
pop rdi
pop rbp
ret 0
?size@?$vector@UPaymentOption@Persistence@TechnicalServices@@V?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@@std@@QEBA_KXZ ENDP ; std::vector<TechnicalServices::Persistence::PaymentOption,std::allocator<TechnicalServices::Persistence::PaymentOption> >::size
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\vector
; COMDAT ??1?$vector@UPaymentOption@Persistence@TechnicalServices@@V?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@@std@@QEAA@XZ
_TEXT SEGMENT
_Alproxy$ = 8
$S1$ = 36
$T4 = 260
__$ArrayPad$ = 280
this$ = 320
??1?$vector@UPaymentOption@Persistence@TechnicalServices@@V?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@@std@@QEAA@XZ PROC ; std::vector<TechnicalServices::Persistence::PaymentOption,std::allocator<TechnicalServices::Persistence::PaymentOption> >::~vector<TechnicalServices::Persistence::PaymentOption,std::allocator<TechnicalServices::Persistence::PaymentOption> >, COMDAT
; 672 : ~vector() noexcept {
$LN3:
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 328 ; 00000148H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 82 ; 00000052H
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+360]
mov rax, QWORD PTR __security_cookie
xor rax, rbp
mov QWORD PTR __$ArrayPad$[rbp], rax
lea rcx, OFFSET FLAT:__9B902D3A_vector
call __CheckForDebuggerJustMyCode
; 673 : _Tidy();
mov rcx, QWORD PTR this$[rbp]
call ?_Tidy@?$vector@UPaymentOption@Persistence@TechnicalServices@@V?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@@std@@AEAAXXZ ; std::vector<TechnicalServices::Persistence::PaymentOption,std::allocator<TechnicalServices::Persistence::PaymentOption> >::_Tidy
; 674 : #if _ITERATOR_DEBUG_LEVEL != 0
; 675 : auto&& _Alproxy = _GET_PROXY_ALLOCATOR(_Alty, _Getal());
mov rcx, QWORD PTR this$[rbp]
call ?_Getal@?$vector@UPaymentOption@Persistence@TechnicalServices@@V?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@@std@@AEAAAEAV?$allocator@UPaymentOption@Persistence@TechnicalServices@@@2@XZ ; std::vector<TechnicalServices::Persistence::PaymentOption,std::allocator<TechnicalServices::Persistence::PaymentOption> >::_Getal
mov rdx, rax
lea rcx, QWORD PTR $S1$[rbp]
call ??$?0UPaymentOption@Persistence@TechnicalServices@@@?$allocator@U_Container_proxy@std@@@std@@QEAA@AEBV?$allocator@UPaymentOption@Persistence@TechnicalServices@@@1@@Z ; std::allocator<std::_Container_proxy>::allocator<std::_Container_proxy><TechnicalServices::Persistence::PaymentOption>
lea rax, QWORD PTR $S1$[rbp]
mov QWORD PTR _Alproxy$[rbp], rax
; 676 : _Delete_plain_internal(_Alproxy, _STD exchange(_Mypair._Myval2._Myproxy, nullptr));
mov QWORD PTR $T4[rbp], 0
mov rax, QWORD PTR this$[rbp]
lea rdx, QWORD PTR $T4[rbp]
mov rcx, rax
call ??$exchange@PEAU_Container_proxy@std@@$$T@std@@YAPEAU_Container_proxy@0@AEAPEAU10@$$QEA$$T@Z ; std::exchange<std::_Container_proxy *,std::nullptr_t>
mov rdx, rax
mov rcx, QWORD PTR _Alproxy$[rbp]
call ??$_Delete_plain_internal@V?$allocator@U_Container_proxy@std@@@std@@@std@@YAXAEAV?$allocator@U_Container_proxy@std@@@0@QEAU_Container_proxy@0@@Z ; std::_Delete_plain_internal<std::allocator<std::_Container_proxy> >
; 677 : #endif // _ITERATOR_DEBUG_LEVEL != 0
; 678 : }
lea rcx, QWORD PTR [rbp-32]
lea rdx, OFFSET FLAT:??1?$vector@UPaymentOption@Persistence@TechnicalServices@@V?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@@std@@QEAA@XZ$rtcFrameData
call _RTC_CheckStackVars
mov rcx, QWORD PTR __$ArrayPad$[rbp]
xor rcx, rbp
call __security_check_cookie
lea rsp, QWORD PTR [rbp+296]
pop rdi
pop rbp
ret 0
??1?$vector@UPaymentOption@Persistence@TechnicalServices@@V?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@@std@@QEAA@XZ ENDP ; std::vector<TechnicalServices::Persistence::PaymentOption,std::allocator<TechnicalServices::Persistence::PaymentOption> >::~vector<TechnicalServices::Persistence::PaymentOption,std::allocator<TechnicalServices::Persistence::PaymentOption> >
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\xmemory
; COMDAT ?deallocate@?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@QEAAXQEAUPaymentOption@Persistence@TechnicalServices@@_K@Z
_TEXT SEGMENT
this$ = 224
_Ptr$ = 232
_Count$ = 240
?deallocate@?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@QEAAXQEAUPaymentOption@Persistence@TechnicalServices@@_K@Z PROC ; std::allocator<TechnicalServices::Persistence::PaymentOption>::deallocate, COMDAT
; 808 : void deallocate(_Ty* const _Ptr, const size_t _Count) {
$LN3:
mov QWORD PTR [rsp+24], r8
mov QWORD PTR [rsp+16], rdx
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+264]
lea rcx, OFFSET FLAT:__F1739482_xmemory
call __CheckForDebuggerJustMyCode
; 809 : // no overflow check on the following multiply; we assume _Allocate did that check
; 810 : _Deallocate<_New_alignof<_Ty>>(_Ptr, sizeof(_Ty) * _Count);
imul rax, QWORD PTR _Count$[rbp], 48 ; 00000030H
mov rdx, rax
mov rcx, QWORD PTR _Ptr$[rbp]
call ??$_Deallocate@$0BA@$0A@@std@@YAXPEAX_K@Z ; std::_Deallocate<16,0>
; 811 : }
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
?deallocate@?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@QEAAXQEAUPaymentOption@Persistence@TechnicalServices@@_K@Z ENDP ; std::allocator<TechnicalServices::Persistence::PaymentOption>::deallocate
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; COMDAT ??_GGatewayPayment@External@TechnicalServices@@UEAAPEAXI@Z
_TEXT SEGMENT
this$ = 224
__flags$ = 232
??_GGatewayPayment@External@TechnicalServices@@UEAAPEAXI@Z PROC ; TechnicalServices::External::GatewayPayment::`scalar deleting destructor', COMDAT
$LN4:
mov DWORD PTR [rsp+16], edx
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+264]
mov rcx, QWORD PTR this$[rbp]
call ??1GatewayPayment@External@TechnicalServices@@UEAA@XZ
mov eax, DWORD PTR __flags$[rbp]
and eax, 1
test eax, eax
je SHORT $LN2@scalar
mov edx, 8
mov rcx, QWORD PTR this$[rbp]
call ??3@YAXPEAX_K@Z ; operator delete
$LN2@scalar:
mov rax, QWORD PTR this$[rbp]
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
??_GGatewayPayment@External@TechnicalServices@@UEAAPEAXI@Z ENDP ; TechnicalServices::External::GatewayPayment::`scalar deleting destructor'
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; COMDAT ??1GatewayPayment@External@TechnicalServices@@UEAA@XZ
_TEXT SEGMENT
this$ = 224
??1GatewayPayment@External@TechnicalServices@@UEAA@XZ PROC ; TechnicalServices::External::GatewayPayment::~GatewayPayment, COMDAT
$LN3:
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+264]
mov rcx, QWORD PTR this$[rbp]
call ??1PaymentHandlerInterface@External@TechnicalServices@@UEAA@XZ ; TechnicalServices::External::PaymentHandlerInterface::~PaymentHandlerInterface
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
??1GatewayPayment@External@TechnicalServices@@UEAA@XZ ENDP ; TechnicalServices::External::GatewayPayment::~GatewayPayment
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; COMDAT ??0GatewayPayment@External@TechnicalServices@@QEAA@XZ
_TEXT SEGMENT
this$ = 224
??0GatewayPayment@External@TechnicalServices@@QEAA@XZ PROC ; TechnicalServices::External::GatewayPayment::GatewayPayment, COMDAT
$LN3:
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+264]
mov rcx, QWORD PTR this$[rbp]
call ??0PaymentHandlerInterface@External@TechnicalServices@@QEAA@XZ
mov rax, QWORD PTR this$[rbp]
lea rcx, OFFSET FLAT:??_7GatewayPayment@External@TechnicalServices@@6B@
mov QWORD PTR [rax], rcx
mov rax, QWORD PTR this$[rbp]
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
??0GatewayPayment@External@TechnicalServices@@QEAA@XZ ENDP ; TechnicalServices::External::GatewayPayment::GatewayPayment
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; COMDAT ??_GDebitPayment@External@TechnicalServices@@UEAAPEAXI@Z
_TEXT SEGMENT
this$ = 224
__flags$ = 232
??_GDebitPayment@External@TechnicalServices@@UEAAPEAXI@Z PROC ; TechnicalServices::External::DebitPayment::`scalar deleting destructor', COMDAT
$LN4:
mov DWORD PTR [rsp+16], edx
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+264]
mov rcx, QWORD PTR this$[rbp]
call ??1DebitPayment@External@TechnicalServices@@UEAA@XZ
mov eax, DWORD PTR __flags$[rbp]
and eax, 1
test eax, eax
je SHORT $LN2@scalar
mov edx, 8
mov rcx, QWORD PTR this$[rbp]
call ??3@YAXPEAX_K@Z ; operator delete
$LN2@scalar:
mov rax, QWORD PTR this$[rbp]
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
??_GDebitPayment@External@TechnicalServices@@UEAAPEAXI@Z ENDP ; TechnicalServices::External::DebitPayment::`scalar deleting destructor'
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; COMDAT ??1DebitPayment@External@TechnicalServices@@UEAA@XZ
_TEXT SEGMENT
this$ = 224
??1DebitPayment@External@TechnicalServices@@UEAA@XZ PROC ; TechnicalServices::External::DebitPayment::~DebitPayment, COMDAT
$LN3:
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+264]
mov rcx, QWORD PTR this$[rbp]
call ??1PaymentHandlerInterface@External@TechnicalServices@@UEAA@XZ ; TechnicalServices::External::PaymentHandlerInterface::~PaymentHandlerInterface
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
??1DebitPayment@External@TechnicalServices@@UEAA@XZ ENDP ; TechnicalServices::External::DebitPayment::~DebitPayment
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; COMDAT ??0DebitPayment@External@TechnicalServices@@QEAA@XZ
_TEXT SEGMENT
this$ = 224
??0DebitPayment@External@TechnicalServices@@QEAA@XZ PROC ; TechnicalServices::External::DebitPayment::DebitPayment, COMDAT
$LN3:
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+264]
mov rcx, QWORD PTR this$[rbp]
call ??0PaymentHandlerInterface@External@TechnicalServices@@QEAA@XZ
mov rax, QWORD PTR this$[rbp]
lea rcx, OFFSET FLAT:??_7DebitPayment@External@TechnicalServices@@6B@
mov QWORD PTR [rax], rcx
mov rax, QWORD PTR this$[rbp]
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
??0DebitPayment@External@TechnicalServices@@QEAA@XZ ENDP ; TechnicalServices::External::DebitPayment::DebitPayment
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; COMDAT ??_GCreditPayment@External@TechnicalServices@@UEAAPEAXI@Z
_TEXT SEGMENT
this$ = 224
__flags$ = 232
??_GCreditPayment@External@TechnicalServices@@UEAAPEAXI@Z PROC ; TechnicalServices::External::CreditPayment::`scalar deleting destructor', COMDAT
$LN4:
mov DWORD PTR [rsp+16], edx
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+264]
mov rcx, QWORD PTR this$[rbp]
call ??1CreditPayment@External@TechnicalServices@@UEAA@XZ
mov eax, DWORD PTR __flags$[rbp]
and eax, 1
test eax, eax
je SHORT $LN2@scalar
mov edx, 8
mov rcx, QWORD PTR this$[rbp]
call ??3@YAXPEAX_K@Z ; operator delete
$LN2@scalar:
mov rax, QWORD PTR this$[rbp]
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
??_GCreditPayment@External@TechnicalServices@@UEAAPEAXI@Z ENDP ; TechnicalServices::External::CreditPayment::`scalar deleting destructor'
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; COMDAT ??1CreditPayment@External@TechnicalServices@@UEAA@XZ
_TEXT SEGMENT
this$ = 224
??1CreditPayment@External@TechnicalServices@@UEAA@XZ PROC ; TechnicalServices::External::CreditPayment::~CreditPayment, COMDAT
$LN3:
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+264]
mov rcx, QWORD PTR this$[rbp]
call ??1PaymentHandlerInterface@External@TechnicalServices@@UEAA@XZ ; TechnicalServices::External::PaymentHandlerInterface::~PaymentHandlerInterface
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
??1CreditPayment@External@TechnicalServices@@UEAA@XZ ENDP ; TechnicalServices::External::CreditPayment::~CreditPayment
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; COMDAT ??0CreditPayment@External@TechnicalServices@@QEAA@XZ
_TEXT SEGMENT
this$ = 224
??0CreditPayment@External@TechnicalServices@@QEAA@XZ PROC ; TechnicalServices::External::CreditPayment::CreditPayment, COMDAT
$LN3:
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+264]
mov rcx, QWORD PTR this$[rbp]
call ??0PaymentHandlerInterface@External@TechnicalServices@@QEAA@XZ
mov rax, QWORD PTR this$[rbp]
lea rcx, OFFSET FLAT:??_7CreditPayment@External@TechnicalServices@@6B@
mov QWORD PTR [rax], rcx
mov rax, QWORD PTR this$[rbp]
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
??0CreditPayment@External@TechnicalServices@@QEAA@XZ ENDP ; TechnicalServices::External::CreditPayment::CreditPayment
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; COMDAT ??0PaymentHandlerInterface@External@TechnicalServices@@QEAA@XZ
_TEXT SEGMENT
this$ = 224
??0PaymentHandlerInterface@External@TechnicalServices@@QEAA@XZ PROC ; TechnicalServices::External::PaymentHandlerInterface::PaymentHandlerInterface, COMDAT
$LN3:
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 200 ; 000000c8H
mov rbp, rsp
mov rdi, rsp
mov ecx, 50 ; 00000032H
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+232]
mov rax, QWORD PTR this$[rbp]
lea rcx, OFFSET FLAT:??_7PaymentHandlerInterface@External@TechnicalServices@@6B@
mov QWORD PTR [rax], rcx
mov rax, QWORD PTR this$[rbp]
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
??0PaymentHandlerInterface@External@TechnicalServices@@QEAA@XZ ENDP ; TechnicalServices::External::PaymentHandlerInterface::PaymentHandlerInterface
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Users\danhp\Documents\GitHub\CPSC-462-GROUP-2\C++ Development Root\SourceCode\TechnicalServices\External\PaymentHandler.cpp
; COMDAT ??1PaymentHandlerInterface@External@TechnicalServices@@UEAA@XZ
_TEXT SEGMENT
this$ = 224
??1PaymentHandlerInterface@External@TechnicalServices@@UEAA@XZ PROC ; TechnicalServices::External::PaymentHandlerInterface::~PaymentHandlerInterface, COMDAT
; 20 : PaymentHandlerInterface::~PaymentHandlerInterface() noexcept = default;
$LN3:
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+264]
lea rcx, OFFSET FLAT:__3559405B_PaymentHandler@cpp
call __CheckForDebuggerJustMyCode
mov rax, QWORD PTR this$[rbp]
lea rcx, OFFSET FLAT:??_7PaymentHandlerInterface@External@TechnicalServices@@6B@
mov QWORD PTR [rax], rcx
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
??1PaymentHandlerInterface@External@TechnicalServices@@UEAA@XZ ENDP ; TechnicalServices::External::PaymentHandlerInterface::~PaymentHandlerInterface
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Users\danhp\Documents\GitHub\CPSC-462-GROUP-2\C++ Development Root\SourceCode\TechnicalServices\External\PaymentHandler.cpp
; COMDAT ?PaySystemFactory@PaymentHandlerInterface@External@TechnicalServices@@SA?AV?$unique_ptr@VPaymentHandlerInterface@External@TechnicalServices@@U?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@@std@@XZ
_TEXT SEGMENT
persistentData$ = 8
PayOps$ = 40
selectedPaymethod$ = 104
menuPaySelection$ = 164
i$6 = 196
$T7 = 424
$T8 = 472
$T9 = 504
$T10 = 536
$T11 = 564
tv230 = 584
tv225 = 584
tv217 = 584
tv162 = 584
tv160 = 584
tv133 = 584
tv79 = 584
tv73 = 584
tv158 = 592
tv135 = 592
tv140 = 600
tv144 = 608
tv146 = 616
__$ArrayPad$ = 624
__$ReturnUdt$ = 672
?PaySystemFactory@PaymentHandlerInterface@External@TechnicalServices@@SA?AV?$unique_ptr@VPaymentHandlerInterface@External@TechnicalServices@@U?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@@std@@XZ PROC ; TechnicalServices::External::PaymentHandlerInterface::PaySystemFactory, COMDAT
; 27 : {
$LN19:
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 680 ; 000002a8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 170 ; 000000aaH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+712]
mov rax, QWORD PTR __security_cookie
xor rax, rbp
mov QWORD PTR __$ArrayPad$[rbp], rax
mov DWORD PTR $T11[rbp], 0
lea rcx, OFFSET FLAT:__3559405B_PaymentHandler@cpp
call __CheckForDebuggerJustMyCode
; 28 :
; 29 : auto& persistentData = TechnicalServices::Persistence::PersistenceHandler::instance();
call ?instance@PersistenceHandler@Persistence@TechnicalServices@@SAAEAV123@XZ ; TechnicalServices::Persistence::PersistenceHandler::instance
mov QWORD PTR persistentData$[rbp], rax
; 30 : std::vector<TechnicalServices::Persistence::PaymentOption>PayOps = persistentData.ShowAllPaymentOption();
mov edx, 32 ; 00000020H
lea rcx, QWORD PTR PayOps$[rbp]
call ?__autoclassinit2@?$vector@UPaymentOption@Persistence@TechnicalServices@@V?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@@std@@QEAAX_K@Z
mov rax, QWORD PTR persistentData$[rbp]
mov rax, QWORD PTR [rax]
mov rax, QWORD PTR [rax+104]
mov QWORD PTR tv73[rbp], rax
lea rdx, QWORD PTR PayOps$[rbp]
mov rcx, QWORD PTR persistentData$[rbp]
call QWORD PTR tv73[rbp]
npad 1
; 31 : std::string selectedPaymethod;
lea rcx, QWORD PTR selectedPaymethod$[rbp]
call ??0?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEAA@XZ ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::basic_string<char,std::char_traits<char>,std::allocator<char> >
npad 1
$LN4@PaySystemF:
; 32 : unsigned menuPaySelection;
; 33 : do
; 34 : {
; 35 :
; 36 :
; 37 : for (unsigned i = 0; i != PayOps.size(); ++i) std::cout << std::setw(2) << i << " - " << PayOps[i].PaymentTypeName << '\n';
mov DWORD PTR i$6[rbp], 0
jmp SHORT $LN7@PaySystemF
$LN5@PaySystemF:
mov eax, DWORD PTR i$6[rbp]
inc eax
mov DWORD PTR i$6[rbp], eax
$LN7@PaySystemF:
mov eax, DWORD PTR i$6[rbp]
mov QWORD PTR tv79[rbp], rax
lea rcx, QWORD PTR PayOps$[rbp]
call ?size@?$vector@UPaymentOption@Persistence@TechnicalServices@@V?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@@std@@QEBA_KXZ ; std::vector<TechnicalServices::Persistence::PaymentOption,std::allocator<TechnicalServices::Persistence::PaymentOption> >::size
mov rcx, QWORD PTR tv79[rbp]
cmp rcx, rax
je $LN6@PaySystemF
mov rax, QWORD PTR __imp_?cout@std@@3V?$basic_ostream@DU?$char_traits@D@std@@@1@A
mov QWORD PTR tv133[rbp], rax
mov edx, 2
lea rcx, QWORD PTR $T7[rbp]
call ?setw@std@@YA?AU?$_Smanip@_J@1@_J@Z ; std::setw
mov QWORD PTR tv135[rbp], rax
mov rdx, QWORD PTR tv135[rbp]
mov rcx, QWORD PTR tv133[rbp]
call ??$?6DU?$char_traits@D@std@@_J@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@AEBU?$_Smanip@_J@0@@Z ; std::operator<<<char,std::char_traits<char>,__int64>
mov QWORD PTR tv140[rbp], rax
mov edx, DWORD PTR i$6[rbp]
mov rcx, QWORD PTR tv140[rbp]
call QWORD PTR __imp_??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@I@Z
lea rdx, OFFSET FLAT:??_C@_03NLJIHOMM@?5?9?5@
mov rcx, rax
call ??$?6U?$char_traits@D@std@@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@PEBD@Z ; std::operator<<<std::char_traits<char> >
mov QWORD PTR tv144[rbp], rax
mov eax, DWORD PTR i$6[rbp]
mov edx, eax
lea rcx, QWORD PTR PayOps$[rbp]
call ??A?$vector@UPaymentOption@Persistence@TechnicalServices@@V?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@@std@@QEAAAEAUPaymentOption@Persistence@TechnicalServices@@_K@Z ; std::vector<TechnicalServices::Persistence::PaymentOption,std::allocator<TechnicalServices::Persistence::PaymentOption> >::operator[]
add rax, 8
mov QWORD PTR tv146[rbp], rax
mov rdx, QWORD PTR tv146[rbp]
mov rcx, QWORD PTR tv144[rbp]
call ??$?6DU?$char_traits@D@std@@V?$allocator@D@1@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@AEBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@0@@Z ; std::operator<<<char,std::char_traits<char>,std::allocator<char> >
mov dl, 10
mov rcx, rax
call ??$?6U?$char_traits@D@std@@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@D@Z ; std::operator<<<std::char_traits<char> >
jmp $LN5@PaySystemF
$LN6@PaySystemF:
; 38 :
; 39 : std::cout << " action (0-" << PayOps.size() << "): ";
lea rdx, OFFSET FLAT:??_C@_0N@HNKDLDDO@?5?5action?5?$CI0?9@
mov rcx, QWORD PTR __imp_?cout@std@@3V?$basic_ostream@DU?$char_traits@D@std@@@1@A
call ??$?6U?$char_traits@D@std@@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@PEBD@Z ; std::operator<<<std::char_traits<char> >
mov QWORD PTR tv160[rbp], rax
lea rcx, QWORD PTR PayOps$[rbp]
call ?size@?$vector@UPaymentOption@Persistence@TechnicalServices@@V?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@@std@@QEBA_KXZ ; std::vector<TechnicalServices::Persistence::PaymentOption,std::allocator<TechnicalServices::Persistence::PaymentOption> >::size
mov QWORD PTR tv158[rbp], rax
mov rdx, QWORD PTR tv158[rbp]
mov rcx, QWORD PTR tv160[rbp]
call QWORD PTR __imp_??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@_K@Z
lea rdx, OFFSET FLAT:??_C@_03LPPJIELD@?$CJ?3?5@
mov rcx, rax
call ??$?6U?$char_traits@D@std@@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@PEBD@Z ; std::operator<<<std::char_traits<char> >
; 40 : std::cin >> menuPaySelection;
lea rdx, QWORD PTR menuPaySelection$[rbp]
mov rcx, QWORD PTR __imp_?cin@std@@3V?$basic_istream@DU?$char_traits@D@std@@@1@A
call QWORD PTR __imp_??5?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@AEAI@Z
; 41 : } while (menuPaySelection > PayOps.size());
mov eax, DWORD PTR menuPaySelection$[rbp]
mov QWORD PTR tv162[rbp], rax
lea rcx, QWORD PTR PayOps$[rbp]
call ?size@?$vector@UPaymentOption@Persistence@TechnicalServices@@V?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@@std@@QEBA_KXZ ; std::vector<TechnicalServices::Persistence::PaymentOption,std::allocator<TechnicalServices::Persistence::PaymentOption> >::size
mov rcx, QWORD PTR tv162[rbp]
cmp rcx, rax
ja $LN4@PaySystemF
; 42 :
; 43 :
; 44 : selectedPaymethod = PayOps[menuPaySelection].PaymentTypeName;
mov eax, DWORD PTR menuPaySelection$[rbp]
mov edx, eax
lea rcx, QWORD PTR PayOps$[rbp]
call ??A?$vector@UPaymentOption@Persistence@TechnicalServices@@V?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@@std@@QEAAAEAUPaymentOption@Persistence@TechnicalServices@@_K@Z ; std::vector<TechnicalServices::Persistence::PaymentOption,std::allocator<TechnicalServices::Persistence::PaymentOption> >::operator[]
add rax, 8
mov rdx, rax
lea rcx, QWORD PTR selectedPaymethod$[rbp]
call ??4?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEAAAEAV01@AEBV01@@Z ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::operator=
; 45 : if (selectedPaymethod == "Credit")
lea rdx, OFFSET FLAT:??_C@_06LIFJDHJL@Credit@
lea rcx, QWORD PTR selectedPaymethod$[rbp]
call ??$?8DU?$char_traits@D@std@@V?$allocator@D@1@@std@@YA_NAEBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@0@QEBD@Z ; std::operator==<char,std::char_traits<char>,std::allocator<char> >
movzx eax, al
test eax, eax
je SHORT $LN8@PaySystemF
; 46 : {
; 47 : return std::make_unique<TechnicalServices::External::CreditPayment>();
lea rcx, QWORD PTR $T8[rbp]
call ??$make_unique@UCreditPayment@External@TechnicalServices@@$$V$0A@@std@@YA?AV?$unique_ptr@UCreditPayment@External@TechnicalServices@@U?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@@0@XZ ; std::make_unique<TechnicalServices::External::CreditPayment,0>
mov QWORD PTR tv217[rbp], rax
mov rdx, QWORD PTR tv217[rbp]
mov rcx, QWORD PTR __$ReturnUdt$[rbp]
call ??$?0UCreditPayment@External@TechnicalServices@@U?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@$0A@@?$unique_ptr@VPaymentHandlerInterface@External@TechnicalServices@@U?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@@std@@QEAA@$$QEAV?$unique_ptr@UCreditPayment@External@TechnicalServices@@U?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@@1@@Z ; std::unique_ptr<TechnicalServices::External::PaymentHandlerInterface,std::default_delete<TechnicalServices::External::PaymentHandlerInterface> >::unique_ptr<TechnicalServices::External::PaymentHandlerInterface,std::default_delete<TechnicalServices::External::PaymentHandlerInterface> ><TechnicalServices::External::CreditPayment,std::default_delete<TechnicalServices::External::CreditPayment>,0>
mov eax, DWORD PTR $T11[rbp]
or eax, 1
mov DWORD PTR $T11[rbp], eax
lea rcx, QWORD PTR $T8[rbp]
call ??1?$unique_ptr@UCreditPayment@External@TechnicalServices@@U?$default_delete@UCreditPayment@External@TechnicalServices@@@std@@@std@@QEAA@XZ ; std::unique_ptr<TechnicalServices::External::CreditPayment,std::default_delete<TechnicalServices::External::CreditPayment> >::~unique_ptr<TechnicalServices::External::CreditPayment,std::default_delete<TechnicalServices::External::CreditPayment> >
npad 1
lea rcx, QWORD PTR selectedPaymethod$[rbp]
call ??1?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEAA@XZ ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::~basic_string<char,std::char_traits<char>,std::allocator<char> >
npad 1
lea rcx, QWORD PTR PayOps$[rbp]
call ??1?$vector@UPaymentOption@Persistence@TechnicalServices@@V?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@@std@@QEAA@XZ ; std::vector<TechnicalServices::Persistence::PaymentOption,std::allocator<TechnicalServices::Persistence::PaymentOption> >::~vector<TechnicalServices::Persistence::PaymentOption,std::allocator<TechnicalServices::Persistence::PaymentOption> >
mov rax, QWORD PTR __$ReturnUdt$[rbp]
jmp $LN1@PaySystemF
$LN8@PaySystemF:
; 48 : }
; 49 :
; 50 : if (selectedPaymethod == "Debit") {
lea rdx, OFFSET FLAT:??_C@_05BGFMJNMO@Debit@
lea rcx, QWORD PTR selectedPaymethod$[rbp]
call ??$?8DU?$char_traits@D@std@@V?$allocator@D@1@@std@@YA_NAEBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@0@QEBD@Z ; std::operator==<char,std::char_traits<char>,std::allocator<char> >
movzx eax, al
test eax, eax
je SHORT $LN9@PaySystemF
; 51 :
; 52 : return std::make_unique<TechnicalServices::External::DebitPayment>();
lea rcx, QWORD PTR $T9[rbp]
call ??$make_unique@UDebitPayment@External@TechnicalServices@@$$V$0A@@std@@YA?AV?$unique_ptr@UDebitPayment@External@TechnicalServices@@U?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@@0@XZ ; std::make_unique<TechnicalServices::External::DebitPayment,0>
mov QWORD PTR tv225[rbp], rax
mov rdx, QWORD PTR tv225[rbp]
mov rcx, QWORD PTR __$ReturnUdt$[rbp]
call ??$?0UDebitPayment@External@TechnicalServices@@U?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@$0A@@?$unique_ptr@VPaymentHandlerInterface@External@TechnicalServices@@U?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@@std@@QEAA@$$QEAV?$unique_ptr@UDebitPayment@External@TechnicalServices@@U?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@@1@@Z ; std::unique_ptr<TechnicalServices::External::PaymentHandlerInterface,std::default_delete<TechnicalServices::External::PaymentHandlerInterface> >::unique_ptr<TechnicalServices::External::PaymentHandlerInterface,std::default_delete<TechnicalServices::External::PaymentHandlerInterface> ><TechnicalServices::External::DebitPayment,std::default_delete<TechnicalServices::External::DebitPayment>,0>
mov eax, DWORD PTR $T11[rbp]
or eax, 1
mov DWORD PTR $T11[rbp], eax
lea rcx, QWORD PTR $T9[rbp]
call ??1?$unique_ptr@UDebitPayment@External@TechnicalServices@@U?$default_delete@UDebitPayment@External@TechnicalServices@@@std@@@std@@QEAA@XZ ; std::unique_ptr<TechnicalServices::External::DebitPayment,std::default_delete<TechnicalServices::External::DebitPayment> >::~unique_ptr<TechnicalServices::External::DebitPayment,std::default_delete<TechnicalServices::External::DebitPayment> >
npad 1
lea rcx, QWORD PTR selectedPaymethod$[rbp]
call ??1?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEAA@XZ ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::~basic_string<char,std::char_traits<char>,std::allocator<char> >
npad 1
lea rcx, QWORD PTR PayOps$[rbp]
call ??1?$vector@UPaymentOption@Persistence@TechnicalServices@@V?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@@std@@QEAA@XZ ; std::vector<TechnicalServices::Persistence::PaymentOption,std::allocator<TechnicalServices::Persistence::PaymentOption> >::~vector<TechnicalServices::Persistence::PaymentOption,std::allocator<TechnicalServices::Persistence::PaymentOption> >
mov rax, QWORD PTR __$ReturnUdt$[rbp]
jmp $LN1@PaySystemF
$LN9@PaySystemF:
; 53 :
; 54 : }
; 55 : if (selectedPaymethod == "GateWay") return std::make_unique<TechnicalServices::External::GatewayPayment>();
lea rdx, OFFSET FLAT:??_C@_07LEBHEPGK@GateWay@
lea rcx, QWORD PTR selectedPaymethod$[rbp]
call ??$?8DU?$char_traits@D@std@@V?$allocator@D@1@@std@@YA_NAEBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@0@QEBD@Z ; std::operator==<char,std::char_traits<char>,std::allocator<char> >
movzx eax, al
test eax, eax
je SHORT $LN10@PaySystemF
lea rcx, QWORD PTR $T10[rbp]
call ??$make_unique@UGatewayPayment@External@TechnicalServices@@$$V$0A@@std@@YA?AV?$unique_ptr@UGatewayPayment@External@TechnicalServices@@U?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@@0@XZ ; std::make_unique<TechnicalServices::External::GatewayPayment,0>
mov QWORD PTR tv230[rbp], rax
mov rdx, QWORD PTR tv230[rbp]
mov rcx, QWORD PTR __$ReturnUdt$[rbp]
call ??$?0UGatewayPayment@External@TechnicalServices@@U?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@$0A@@?$unique_ptr@VPaymentHandlerInterface@External@TechnicalServices@@U?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@@std@@QEAA@$$QEAV?$unique_ptr@UGatewayPayment@External@TechnicalServices@@U?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@@1@@Z ; std::unique_ptr<TechnicalServices::External::PaymentHandlerInterface,std::default_delete<TechnicalServices::External::PaymentHandlerInterface> >::unique_ptr<TechnicalServices::External::PaymentHandlerInterface,std::default_delete<TechnicalServices::External::PaymentHandlerInterface> ><TechnicalServices::External::GatewayPayment,std::default_delete<TechnicalServices::External::GatewayPayment>,0>
mov eax, DWORD PTR $T11[rbp]
or eax, 1
mov DWORD PTR $T11[rbp], eax
lea rcx, QWORD PTR $T10[rbp]
call ??1?$unique_ptr@UGatewayPayment@External@TechnicalServices@@U?$default_delete@UGatewayPayment@External@TechnicalServices@@@std@@@std@@QEAA@XZ ; std::unique_ptr<TechnicalServices::External::GatewayPayment,std::default_delete<TechnicalServices::External::GatewayPayment> >::~unique_ptr<TechnicalServices::External::GatewayPayment,std::default_delete<TechnicalServices::External::GatewayPayment> >
npad 1
lea rcx, QWORD PTR selectedPaymethod$[rbp]
call ??1?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEAA@XZ ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::~basic_string<char,std::char_traits<char>,std::allocator<char> >
npad 1
lea rcx, QWORD PTR PayOps$[rbp]
call ??1?$vector@UPaymentOption@Persistence@TechnicalServices@@V?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@@std@@QEAA@XZ ; std::vector<TechnicalServices::Persistence::PaymentOption,std::allocator<TechnicalServices::Persistence::PaymentOption> >::~vector<TechnicalServices::Persistence::PaymentOption,std::allocator<TechnicalServices::Persistence::PaymentOption> >
mov rax, QWORD PTR __$ReturnUdt$[rbp]
jmp SHORT $LN1@PaySystemF
$LN10@PaySystemF:
; 56 :
; 57 :
; 58 : }
lea rcx, QWORD PTR selectedPaymethod$[rbp]
call ??1?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEAA@XZ ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::~basic_string<char,std::char_traits<char>,std::allocator<char> >
npad 1
lea rcx, QWORD PTR PayOps$[rbp]
call ??1?$vector@UPaymentOption@Persistence@TechnicalServices@@V?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@@std@@QEAA@XZ ; std::vector<TechnicalServices::Persistence::PaymentOption,std::allocator<TechnicalServices::Persistence::PaymentOption> >::~vector<TechnicalServices::Persistence::PaymentOption,std::allocator<TechnicalServices::Persistence::PaymentOption> >
$LN1@PaySystemF:
mov rdi, rax
lea rcx, QWORD PTR [rbp-32]
lea rdx, OFFSET FLAT:?PaySystemFactory@PaymentHandlerInterface@External@TechnicalServices@@SA?AV?$unique_ptr@VPaymentHandlerInterface@External@TechnicalServices@@U?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@@std@@XZ$rtcFrameData
call _RTC_CheckStackVars
mov rax, rdi
mov rcx, QWORD PTR __$ArrayPad$[rbp]
xor rcx, rbp
call __security_check_cookie
lea rsp, QWORD PTR [rbp+648]
pop rdi
pop rbp
ret 0
?PaySystemFactory@PaymentHandlerInterface@External@TechnicalServices@@SA?AV?$unique_ptr@VPaymentHandlerInterface@External@TechnicalServices@@U?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@@std@@XZ ENDP ; TechnicalServices::External::PaymentHandlerInterface::PaySystemFactory
_TEXT ENDS
; COMDAT text$x
text$x SEGMENT
persistentData$ = 8
PayOps$ = 40
selectedPaymethod$ = 104
menuPaySelection$ = 164
i$6 = 196
$T7 = 424
$T8 = 472
$T9 = 504
$T10 = 536
$T11 = 564
tv230 = 584
tv225 = 584
tv217 = 584
tv162 = 584
tv160 = 584
tv133 = 584
tv79 = 584
tv73 = 584
tv158 = 592
tv135 = 592
tv140 = 600
tv144 = 608
tv146 = 616
__$ArrayPad$ = 624
__$ReturnUdt$ = 672
?dtor$0@?0??PaySystemFactory@PaymentHandlerInterface@External@TechnicalServices@@SA?AV?$unique_ptr@VPaymentHandlerInterface@External@TechnicalServices@@U?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@@std@@XZ@4HA PROC ; `TechnicalServices::External::PaymentHandlerInterface::PaySystemFactory'::`1'::dtor$0
mov QWORD PTR [rsp+8], rcx
mov QWORD PTR [rsp+16], rdx
push rbp
push rdi
sub rsp, 40 ; 00000028H
lea rbp, QWORD PTR [rdx+32]
lea rcx, QWORD PTR PayOps$[rbp]
call ??1?$vector@UPaymentOption@Persistence@TechnicalServices@@V?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@@std@@QEAA@XZ ; std::vector<TechnicalServices::Persistence::PaymentOption,std::allocator<TechnicalServices::Persistence::PaymentOption> >::~vector<TechnicalServices::Persistence::PaymentOption,std::allocator<TechnicalServices::Persistence::PaymentOption> >
add rsp, 40 ; 00000028H
pop rdi
pop rbp
ret 0
?dtor$0@?0??PaySystemFactory@PaymentHandlerInterface@External@TechnicalServices@@SA?AV?$unique_ptr@VPaymentHandlerInterface@External@TechnicalServices@@U?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@@std@@XZ@4HA ENDP ; `TechnicalServices::External::PaymentHandlerInterface::PaySystemFactory'::`1'::dtor$0
text$x ENDS
; COMDAT text$x
text$x SEGMENT
persistentData$ = 8
PayOps$ = 40
selectedPaymethod$ = 104
menuPaySelection$ = 164
i$6 = 196
$T7 = 424
$T8 = 472
$T9 = 504
$T10 = 536
$T11 = 564
tv230 = 584
tv225 = 584
tv217 = 584
tv162 = 584
tv160 = 584
tv133 = 584
tv79 = 584
tv73 = 584
tv158 = 592
tv135 = 592
tv140 = 600
tv144 = 608
tv146 = 616
__$ArrayPad$ = 624
__$ReturnUdt$ = 672
?dtor$1@?0??PaySystemFactory@PaymentHandlerInterface@External@TechnicalServices@@SA?AV?$unique_ptr@VPaymentHandlerInterface@External@TechnicalServices@@U?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@@std@@XZ@4HA PROC ; `TechnicalServices::External::PaymentHandlerInterface::PaySystemFactory'::`1'::dtor$1
mov QWORD PTR [rsp+8], rcx
mov QWORD PTR [rsp+16], rdx
push rbp
push rdi
sub rsp, 40 ; 00000028H
lea rbp, QWORD PTR [rdx+32]
lea rcx, QWORD PTR selectedPaymethod$[rbp]
call ??1?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEAA@XZ ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::~basic_string<char,std::char_traits<char>,std::allocator<char> >
add rsp, 40 ; 00000028H
pop rdi
pop rbp
ret 0
?dtor$1@?0??PaySystemFactory@PaymentHandlerInterface@External@TechnicalServices@@SA?AV?$unique_ptr@VPaymentHandlerInterface@External@TechnicalServices@@U?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@@std@@XZ@4HA ENDP ; `TechnicalServices::External::PaymentHandlerInterface::PaySystemFactory'::`1'::dtor$1
text$x ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; COMDAT text$x
text$x SEGMENT
persistentData$ = 8
PayOps$ = 40
selectedPaymethod$ = 104
menuPaySelection$ = 164
i$6 = 196
$T7 = 424
$T8 = 472
$T9 = 504
$T10 = 536
$T11 = 564
tv230 = 584
tv225 = 584
tv217 = 584
tv162 = 584
tv160 = 584
tv133 = 584
tv79 = 584
tv73 = 584
tv158 = 592
tv135 = 592
tv140 = 600
tv144 = 608
tv146 = 616
__$ArrayPad$ = 624
__$ReturnUdt$ = 672
?dtor$0@?0??PaySystemFactory@PaymentHandlerInterface@External@TechnicalServices@@SA?AV?$unique_ptr@VPaymentHandlerInterface@External@TechnicalServices@@U?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@@std@@XZ@4HA PROC ; `TechnicalServices::External::PaymentHandlerInterface::PaySystemFactory'::`1'::dtor$0
mov QWORD PTR [rsp+8], rcx
mov QWORD PTR [rsp+16], rdx
push rbp
push rdi
sub rsp, 40 ; 00000028H
lea rbp, QWORD PTR [rdx+32]
lea rcx, QWORD PTR PayOps$[rbp]
call ??1?$vector@UPaymentOption@Persistence@TechnicalServices@@V?$allocator@UPaymentOption@Persistence@TechnicalServices@@@std@@@std@@QEAA@XZ ; std::vector<TechnicalServices::Persistence::PaymentOption,std::allocator<TechnicalServices::Persistence::PaymentOption> >::~vector<TechnicalServices::Persistence::PaymentOption,std::allocator<TechnicalServices::Persistence::PaymentOption> >
add rsp, 40 ; 00000028H
pop rdi
pop rbp
ret 0
?dtor$0@?0??PaySystemFactory@PaymentHandlerInterface@External@TechnicalServices@@SA?AV?$unique_ptr@VPaymentHandlerInterface@External@TechnicalServices@@U?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@@std@@XZ@4HA ENDP ; `TechnicalServices::External::PaymentHandlerInterface::PaySystemFactory'::`1'::dtor$0
text$x ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; COMDAT text$x
text$x SEGMENT
persistentData$ = 8
PayOps$ = 40
selectedPaymethod$ = 104
menuPaySelection$ = 164
i$6 = 196
$T7 = 424
$T8 = 472
$T9 = 504
$T10 = 536
$T11 = 564
tv230 = 584
tv225 = 584
tv217 = 584
tv162 = 584
tv160 = 584
tv133 = 584
tv79 = 584
tv73 = 584
tv158 = 592
tv135 = 592
tv140 = 600
tv144 = 608
tv146 = 616
__$ArrayPad$ = 624
__$ReturnUdt$ = 672
?dtor$1@?0??PaySystemFactory@PaymentHandlerInterface@External@TechnicalServices@@SA?AV?$unique_ptr@VPaymentHandlerInterface@External@TechnicalServices@@U?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@@std@@XZ@4HA PROC ; `TechnicalServices::External::PaymentHandlerInterface::PaySystemFactory'::`1'::dtor$1
mov QWORD PTR [rsp+8], rcx
mov QWORD PTR [rsp+16], rdx
push rbp
push rdi
sub rsp, 40 ; 00000028H
lea rbp, QWORD PTR [rdx+32]
lea rcx, QWORD PTR selectedPaymethod$[rbp]
call ??1?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEAA@XZ ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::~basic_string<char,std::char_traits<char>,std::allocator<char> >
add rsp, 40 ; 00000028H
pop rdi
pop rbp
ret 0
?dtor$1@?0??PaySystemFactory@PaymentHandlerInterface@External@TechnicalServices@@SA?AV?$unique_ptr@VPaymentHandlerInterface@External@TechnicalServices@@U?$default_delete@VPaymentHandlerInterface@External@TechnicalServices@@@std@@@std@@XZ@4HA ENDP ; `TechnicalServices::External::PaymentHandlerInterface::PaySystemFactory'::`1'::dtor$1
text$x ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; COMDAT ??_GPaymentOption@Persistence@TechnicalServices@@QEAAPEAXI@Z
_TEXT SEGMENT
this$ = 224
__flags$ = 232
??_GPaymentOption@Persistence@TechnicalServices@@QEAAPEAXI@Z PROC ; TechnicalServices::Persistence::PaymentOption::`scalar deleting destructor', COMDAT
$LN4:
mov DWORD PTR [rsp+16], edx
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+264]
mov rcx, QWORD PTR this$[rbp]
call ??1PaymentOption@Persistence@TechnicalServices@@QEAA@XZ
mov eax, DWORD PTR __flags$[rbp]
and eax, 1
test eax, eax
je SHORT $LN2@scalar
mov edx, 48 ; 00000030H
mov rcx, QWORD PTR this$[rbp]
call ??3@YAXPEAX_K@Z ; operator delete
$LN2@scalar:
mov rax, QWORD PTR this$[rbp]
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
??_GPaymentOption@Persistence@TechnicalServices@@QEAAPEAXI@Z ENDP ; TechnicalServices::Persistence::PaymentOption::`scalar deleting destructor'
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; COMDAT ??1PaymentOption@Persistence@TechnicalServices@@QEAA@XZ
_TEXT SEGMENT
this$ = 224
??1PaymentOption@Persistence@TechnicalServices@@QEAA@XZ PROC ; TechnicalServices::Persistence::PaymentOption::~PaymentOption, COMDAT
$LN3:
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+264]
mov rax, QWORD PTR this$[rbp]
add rax, 8
mov rcx, rax
call ??1?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEAA@XZ ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::~basic_string<char,std::char_traits<char>,std::allocator<char> >
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
??1PaymentOption@Persistence@TechnicalServices@@QEAA@XZ ENDP ; TechnicalServices::Persistence::PaymentOption::~PaymentOption
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\xloctime
; COMDAT ??$_Getvals@_W@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@IEAAX_WAEBV_Locinfo@1@@Z
_TEXT SEGMENT
$T1 = 200
tv93 = 264
tv85 = 264
this$ = 304
__formal$ = 312
_Lobj$ = 320
??$_Getvals@_W@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@IEAAX_WAEBV_Locinfo@1@@Z PROC ; std::time_get<wchar_t,std::istreambuf_iterator<wchar_t,std::char_traits<wchar_t> > >::_Getvals<wchar_t>, COMDAT
; 181 : void __CLR_OR_THIS_CALL _Getvals(_Elem2, const _Locinfo& _Lobj) { // get values
$LN5:
mov QWORD PTR [rsp+24], r8
mov WORD PTR [rsp+16], dx
mov QWORD PTR [rsp+8], rcx
push rbp
push rsi
push rdi
sub rsp, 304 ; 00000130H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 76 ; 0000004cH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+344]
lea rcx, OFFSET FLAT:__3F86D9A6_xloctime
call __CheckForDebuggerJustMyCode
; 182 : _Cvt = _Lobj._Getcvt();
lea rdx, QWORD PTR $T1[rbp]
mov rcx, QWORD PTR _Lobj$[rbp]
call QWORD PTR __imp_?_Getcvt@_Locinfo@std@@QEBA?AU_Cvtvec@@XZ
mov rcx, QWORD PTR this$[rbp]
lea rdi, QWORD PTR [rcx+44]
mov rsi, rax
mov ecx, 44 ; 0000002cH
rep movsb
; 183 :
; 184 : if (is_same_v<_Elem2, wchar_t>) {
xor eax, eax
cmp eax, 1
je SHORT $LN2@Getvals
; 185 : _Days = reinterpret_cast<const _Elem*>(_Maklocwcs(reinterpret_cast<const wchar_t*>(_Lobj._W_Getdays())));
mov rcx, QWORD PTR _Lobj$[rbp]
call QWORD PTR __imp_?_W_Getdays@_Locinfo@std@@QEBAPEBGXZ
mov rcx, rax
call ?_Maklocwcs@std@@YAPEA_WPEB_W@Z ; std::_Maklocwcs
mov rcx, QWORD PTR this$[rbp]
mov QWORD PTR [rcx+16], rax
; 186 : _Months =
mov rcx, QWORD PTR _Lobj$[rbp]
call QWORD PTR __imp_?_W_Getmonths@_Locinfo@std@@QEBAPEBGXZ
mov rcx, rax
call ?_Maklocwcs@std@@YAPEA_WPEB_W@Z ; std::_Maklocwcs
mov rcx, QWORD PTR this$[rbp]
mov QWORD PTR [rcx+24], rax
; 187 : reinterpret_cast<const _Elem*>(_Maklocwcs(reinterpret_cast<const wchar_t*>(_Lobj._W_Getmonths())));
; 188 : _Ampm = reinterpret_cast<const _Elem*>(_Maklocwcs(L":AM:am:PM:pm"));
lea rcx, OFFSET FLAT:??_C@_1BK@MHIKGOKE@?$AA?3?$AAA?$AAM?$AA?3?$AAa?$AAm?$AA?3?$AAP?$AAM?$AA?3?$AAp?$AAm@
call ?_Maklocwcs@std@@YAPEA_WPEB_W@Z ; std::_Maklocwcs
mov rcx, QWORD PTR this$[rbp]
mov QWORD PTR [rcx+32], rax
; 189 : } else {
jmp $LN3@Getvals
$LN2@Getvals:
; 190 : _Days = _Maklocstr(_Lobj._Getdays(), static_cast<_Elem*>(nullptr), _Cvt);
mov rax, QWORD PTR this$[rbp]
add rax, 44 ; 0000002cH
mov QWORD PTR tv85[rbp], rax
mov rcx, QWORD PTR _Lobj$[rbp]
call QWORD PTR __imp_?_Getdays@_Locinfo@std@@QEBAPEBDXZ
mov rcx, QWORD PTR tv85[rbp]
mov r8, rcx
xor edx, edx
mov rcx, rax
call ??$_Maklocstr@_W@std@@YAPEA_WPEBDPEA_WAEBU_Cvtvec@@@Z ; std::_Maklocstr<wchar_t>
mov rcx, QWORD PTR this$[rbp]
mov QWORD PTR [rcx+16], rax
; 191 : _Months = _Maklocstr(_Lobj._Getmonths(), static_cast<_Elem*>(nullptr), _Cvt);
mov rax, QWORD PTR this$[rbp]
add rax, 44 ; 0000002cH
mov QWORD PTR tv93[rbp], rax
mov rcx, QWORD PTR _Lobj$[rbp]
call QWORD PTR __imp_?_Getmonths@_Locinfo@std@@QEBAPEBDXZ
mov rcx, QWORD PTR tv93[rbp]
mov r8, rcx
xor edx, edx
mov rcx, rax
call ??$_Maklocstr@_W@std@@YAPEA_WPEBDPEA_WAEBU_Cvtvec@@@Z ; std::_Maklocstr<wchar_t>
mov rcx, QWORD PTR this$[rbp]
mov QWORD PTR [rcx+24], rax
; 192 : _Ampm = _Maklocstr(":AM:am:PM:pm", static_cast<_Elem*>(nullptr), _Cvt);
mov rax, QWORD PTR this$[rbp]
add rax, 44 ; 0000002cH
mov r8, rax
xor edx, edx
lea rcx, OFFSET FLAT:??_C@_0N@LPFKKEBD@?3AM?3am?3PM?3pm@
call ??$_Maklocstr@_W@std@@YAPEA_WPEBDPEA_WAEBU_Cvtvec@@@Z ; std::_Maklocstr<wchar_t>
mov rcx, QWORD PTR this$[rbp]
mov QWORD PTR [rcx+32], rax
$LN3@Getvals:
; 193 : }
; 194 : }
lea rsp, QWORD PTR [rbp+272]
pop rdi
pop rsi
pop rbp
ret 0
??$_Getvals@_W@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@IEAAX_WAEBV_Locinfo@1@@Z ENDP ; std::time_get<wchar_t,std::istreambuf_iterator<wchar_t,std::char_traits<wchar_t> > >::_Getvals<wchar_t>
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\xloctime
; COMDAT ??$_Getvals@_W@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@IEAAX_WAEBV_Locinfo@1@@Z
_TEXT SEGMENT
$T1 = 200
tv93 = 264
tv85 = 264
this$ = 304
__formal$ = 312
_Lobj$ = 320
??$_Getvals@_W@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@IEAAX_WAEBV_Locinfo@1@@Z PROC ; std::time_get<char,std::istreambuf_iterator<char,std::char_traits<char> > >::_Getvals<wchar_t>, COMDAT
; 181 : void __CLR_OR_THIS_CALL _Getvals(_Elem2, const _Locinfo& _Lobj) { // get values
$LN5:
mov QWORD PTR [rsp+24], r8
mov WORD PTR [rsp+16], dx
mov QWORD PTR [rsp+8], rcx
push rbp
push rsi
push rdi
sub rsp, 304 ; 00000130H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 76 ; 0000004cH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+344]
lea rcx, OFFSET FLAT:__3F86D9A6_xloctime
call __CheckForDebuggerJustMyCode
; 182 : _Cvt = _Lobj._Getcvt();
lea rdx, QWORD PTR $T1[rbp]
mov rcx, QWORD PTR _Lobj$[rbp]
call QWORD PTR __imp_?_Getcvt@_Locinfo@std@@QEBA?AU_Cvtvec@@XZ
mov rcx, QWORD PTR this$[rbp]
lea rdi, QWORD PTR [rcx+44]
mov rsi, rax
mov ecx, 44 ; 0000002cH
rep movsb
; 183 :
; 184 : if (is_same_v<_Elem2, wchar_t>) {
xor eax, eax
cmp eax, 1
je SHORT $LN2@Getvals
; 185 : _Days = reinterpret_cast<const _Elem*>(_Maklocwcs(reinterpret_cast<const wchar_t*>(_Lobj._W_Getdays())));
mov rcx, QWORD PTR _Lobj$[rbp]
call QWORD PTR __imp_?_W_Getdays@_Locinfo@std@@QEBAPEBGXZ
mov rcx, rax
call ?_Maklocwcs@std@@YAPEA_WPEB_W@Z ; std::_Maklocwcs
mov rcx, QWORD PTR this$[rbp]
mov QWORD PTR [rcx+16], rax
; 186 : _Months =
mov rcx, QWORD PTR _Lobj$[rbp]
call QWORD PTR __imp_?_W_Getmonths@_Locinfo@std@@QEBAPEBGXZ
mov rcx, rax
call ?_Maklocwcs@std@@YAPEA_WPEB_W@Z ; std::_Maklocwcs
mov rcx, QWORD PTR this$[rbp]
mov QWORD PTR [rcx+24], rax
; 187 : reinterpret_cast<const _Elem*>(_Maklocwcs(reinterpret_cast<const wchar_t*>(_Lobj._W_Getmonths())));
; 188 : _Ampm = reinterpret_cast<const _Elem*>(_Maklocwcs(L":AM:am:PM:pm"));
lea rcx, OFFSET FLAT:??_C@_1BK@MHIKGOKE@?$AA?3?$AAA?$AAM?$AA?3?$AAa?$AAm?$AA?3?$AAP?$AAM?$AA?3?$AAp?$AAm@
call ?_Maklocwcs@std@@YAPEA_WPEB_W@Z ; std::_Maklocwcs
mov rcx, QWORD PTR this$[rbp]
mov QWORD PTR [rcx+32], rax
; 189 : } else {
jmp $LN3@Getvals
$LN2@Getvals:
; 190 : _Days = _Maklocstr(_Lobj._Getdays(), static_cast<_Elem*>(nullptr), _Cvt);
mov rax, QWORD PTR this$[rbp]
add rax, 44 ; 0000002cH
mov QWORD PTR tv85[rbp], rax
mov rcx, QWORD PTR _Lobj$[rbp]
call QWORD PTR __imp_?_Getdays@_Locinfo@std@@QEBAPEBDXZ
mov rcx, QWORD PTR tv85[rbp]
mov r8, rcx
xor edx, edx
mov rcx, rax
call ??$_Maklocstr@D@std@@YAPEADPEBDPEADAEBU_Cvtvec@@@Z ; std::_Maklocstr<char>
mov rcx, QWORD PTR this$[rbp]
mov QWORD PTR [rcx+16], rax
; 191 : _Months = _Maklocstr(_Lobj._Getmonths(), static_cast<_Elem*>(nullptr), _Cvt);
mov rax, QWORD PTR this$[rbp]
add rax, 44 ; 0000002cH
mov QWORD PTR tv93[rbp], rax
mov rcx, QWORD PTR _Lobj$[rbp]
call QWORD PTR __imp_?_Getmonths@_Locinfo@std@@QEBAPEBDXZ
mov rcx, QWORD PTR tv93[rbp]
mov r8, rcx
xor edx, edx
mov rcx, rax
call ??$_Maklocstr@D@std@@YAPEADPEBDPEADAEBU_Cvtvec@@@Z ; std::_Maklocstr<char>
mov rcx, QWORD PTR this$[rbp]
mov QWORD PTR [rcx+24], rax
; 192 : _Ampm = _Maklocstr(":AM:am:PM:pm", static_cast<_Elem*>(nullptr), _Cvt);
mov rax, QWORD PTR this$[rbp]
add rax, 44 ; 0000002cH
mov r8, rax
xor edx, edx
lea rcx, OFFSET FLAT:??_C@_0N@LPFKKEBD@?3AM?3am?3PM?3pm@
call ??$_Maklocstr@D@std@@YAPEADPEBDPEADAEBU_Cvtvec@@@Z ; std::_Maklocstr<char>
mov rcx, QWORD PTR this$[rbp]
mov QWORD PTR [rcx+32], rax
$LN3@Getvals:
; 193 : }
; 194 : }
lea rsp, QWORD PTR [rbp+272]
pop rdi
pop rsi
pop rbp
ret 0
??$_Getvals@_W@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@IEAAX_WAEBV_Locinfo@1@@Z ENDP ; std::time_get<char,std::istreambuf_iterator<char,std::char_traits<char> > >::_Getvals<wchar_t>
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\xlocale
; COMDAT ??$_Maklocstr@D@std@@YAPEADPEBDPEADAEBU_Cvtvec@@@Z
_TEXT SEGMENT
_Count$ = 8
_Ptrdest$ = 40
_Ptrnext$1 = 72
_Ptr$ = 320
__formal$ = 328
__formal$ = 336
??$_Maklocstr@D@std@@YAPEADPEBDPEADAEBU_Cvtvec@@@Z PROC ; std::_Maklocstr<char>, COMDAT
; 520 : _Elem* __CRTDECL _Maklocstr(const char* _Ptr, _Elem*, const _Locinfo::_Cvtvec&) {
$LN7:
mov QWORD PTR [rsp+24], r8
mov QWORD PTR [rsp+16], rdx
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 344 ; 00000158H
lea rbp, QWORD PTR [rsp+48]
mov rdi, rsp
mov ecx, 86 ; 00000056H
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+376]
lea rcx, OFFSET FLAT:__5A9E662F_xlocale
call __CheckForDebuggerJustMyCode
; 521 : // convert C string to _Elem sequence using _Cvtvec
; 522 : size_t _Count = _CSTD strlen(_Ptr) + 1;
mov rcx, QWORD PTR _Ptr$[rbp]
call strlen
inc rax
mov QWORD PTR _Count$[rbp], rax
; 523 :
; 524 : _Elem* _Ptrdest = static_cast<_Elem*>(_calloc_dbg(_Count, sizeof(_Elem), _CRT_BLOCK, __FILE__, __LINE__));
mov DWORD PTR [rsp+32], 524 ; 0000020cH
lea r9, OFFSET FLAT:??_C@_0GI@IDGLFOOP@C?3?2Program?5Files?5?$CIx86?$CJ?2Microsof@
mov r8d, 2
mov edx, 1
mov rcx, QWORD PTR _Count$[rbp]
call QWORD PTR __imp__calloc_dbg
mov QWORD PTR _Ptrdest$[rbp], rax
; 525 :
; 526 : if (!_Ptrdest) {
cmp QWORD PTR _Ptrdest$[rbp], 0
jne SHORT $LN5@Maklocstr
; 527 : _Xbad_alloc();
call ?_Xbad_alloc@std@@YAXXZ ; std::_Xbad_alloc
$LN5@Maklocstr:
; 528 : }
; 529 :
; 530 : for (_Elem* _Ptrnext = _Ptrdest; 0 < _Count; --_Count, ++_Ptrnext, ++_Ptr) {
mov rax, QWORD PTR _Ptrdest$[rbp]
mov QWORD PTR _Ptrnext$1[rbp], rax
jmp SHORT $LN4@Maklocstr
$LN2@Maklocstr:
mov rax, QWORD PTR _Count$[rbp]
dec rax
mov QWORD PTR _Count$[rbp], rax
mov rax, QWORD PTR _Ptrnext$1[rbp]
inc rax
mov QWORD PTR _Ptrnext$1[rbp], rax
mov rax, QWORD PTR _Ptr$[rbp]
inc rax
mov QWORD PTR _Ptr$[rbp], rax
$LN4@Maklocstr:
cmp QWORD PTR _Count$[rbp], 0
jbe SHORT $LN3@Maklocstr
; 531 : *_Ptrnext = static_cast<_Elem>(static_cast<unsigned char>(*_Ptr));
mov rax, QWORD PTR _Ptrnext$1[rbp]
mov rcx, QWORD PTR _Ptr$[rbp]
movzx ecx, BYTE PTR [rcx]
mov BYTE PTR [rax], cl
; 532 : }
jmp SHORT $LN2@Maklocstr
$LN3@Maklocstr:
; 533 :
; 534 : return _Ptrdest;
mov rax, QWORD PTR _Ptrdest$[rbp]
$LN6@Maklocstr:
; 535 : }
lea rsp, QWORD PTR [rbp+296]
pop rdi
pop rbp
ret 0
??$_Maklocstr@D@std@@YAPEADPEBDPEADAEBU_Cvtvec@@@Z ENDP ; std::_Maklocstr<char>
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\xlocnum
; COMDAT ?_Maklocwcs@std@@YAPEA_WPEB_W@Z
_TEXT SEGMENT
_Count$ = 8
_Ptrdest$ = 40
_Ptr$ = 288
?_Maklocwcs@std@@YAPEA_WPEB_W@Z PROC ; std::_Maklocwcs, COMDAT
; 90 : inline wchar_t* _Maklocwcs(const wchar_t* _Ptr) { // copy NTWCS to allocated storage
$LN4:
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 312 ; 00000138H
lea rbp, QWORD PTR [rsp+48]
mov rdi, rsp
mov ecx, 78 ; 0000004eH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+344]
lea rcx, OFFSET FLAT:__C4190038_xlocnum
call __CheckForDebuggerJustMyCode
; 91 : const size_t _Count = _CSTD wcslen(_Ptr) + 1;
mov rcx, QWORD PTR _Ptr$[rbp]
call QWORD PTR __imp_wcslen
inc rax
mov QWORD PTR _Count$[rbp], rax
; 92 :
; 93 : wchar_t* _Ptrdest = static_cast<wchar_t*>(_calloc_dbg(_Count, sizeof(wchar_t), _CRT_BLOCK, __FILE__, __LINE__));
mov eax, DWORD PTR ?__LINE__Var@?0??_Maklocwcs@std@@YAPEA_WPEB_W@Z@4JA
add eax, 3
mov DWORD PTR [rsp+32], eax
lea r9, OFFSET FLAT:??_C@_0GI@CGFMEO@C?3?2Program?5Files?5?$CIx86?$CJ?2Microsof@
mov r8d, 2
mov edx, 2
mov rcx, QWORD PTR _Count$[rbp]
call QWORD PTR __imp__calloc_dbg
mov QWORD PTR _Ptrdest$[rbp], rax
; 94 :
; 95 : if (!_Ptrdest) {
cmp QWORD PTR _Ptrdest$[rbp], 0
jne SHORT $LN2@Maklocwcs
; 96 : _Xbad_alloc();
call ?_Xbad_alloc@std@@YAXXZ ; std::_Xbad_alloc
$LN2@Maklocwcs:
; 97 : }
; 98 :
; 99 : _CSTD wmemcpy(_Ptrdest, _Ptr, _Count);
mov r8, QWORD PTR _Count$[rbp]
mov rdx, QWORD PTR _Ptr$[rbp]
mov rcx, QWORD PTR _Ptrdest$[rbp]
call wmemcpy
; 100 : return _Ptrdest;
mov rax, QWORD PTR _Ptrdest$[rbp]
$LN3@Maklocwcs:
; 101 : }
lea rsp, QWORD PTR [rbp+264]
pop rdi
pop rbp
ret 0
?_Maklocwcs@std@@YAPEA_WPEB_W@Z ENDP ; std::_Maklocwcs
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\xlocale
; COMDAT ??$_Maklocstr@_W@std@@YAPEA_WPEBDPEA_WAEBU_Cvtvec@@@Z
_TEXT SEGMENT
_Count$ = 8
_Count1$ = 40
_Wchars$ = 72
_Ptr1$ = 104
_Bytes$ = 132
_Wc$ = 164
_Mbst1$ = 200
_Ptrdest$ = 232
_Ptrnext$ = 264
_Mbst2$ = 296
__$ArrayPad$ = 504
_Ptr$ = 544
__formal$ = 552
_Cvt$ = 560
??$_Maklocstr@_W@std@@YAPEA_WPEBDPEA_WAEBU_Cvtvec@@@Z PROC ; std::_Maklocstr<wchar_t>, COMDAT
; 538 : inline wchar_t* __CRTDECL _Maklocstr(const char* _Ptr, wchar_t*, const _Locinfo::_Cvtvec& _Cvt) {
$LN12:
mov QWORD PTR [rsp+24], r8
mov QWORD PTR [rsp+16], rdx
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 568 ; 00000238H
lea rbp, QWORD PTR [rsp+48]
mov rdi, rsp
mov ecx, 142 ; 0000008eH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+600]
mov rax, QWORD PTR __security_cookie
xor rax, rbp
mov QWORD PTR __$ArrayPad$[rbp], rax
lea rcx, OFFSET FLAT:__5A9E662F_xlocale
call __CheckForDebuggerJustMyCode
; 539 : // convert C string to wchar_t sequence using _Cvtvec
; 540 : size_t _Count;
; 541 : size_t _Count1;
; 542 : size_t _Wchars;
; 543 : const char* _Ptr1;
; 544 : int _Bytes;
; 545 : wchar_t _Wc;
; 546 : mbstate_t _Mbst1 = {};
lea rax, QWORD PTR _Mbst1$[rbp]
mov rdi, rax
xor eax, eax
mov ecx, 8
rep stosb
; 547 :
; 548 : _Count1 = _CSTD strlen(_Ptr) + 1;
mov rcx, QWORD PTR _Ptr$[rbp]
call strlen
inc rax
mov QWORD PTR _Count1$[rbp], rax
; 549 : for (_Count = _Count1, _Wchars = 0, _Ptr1 = _Ptr; 0 < _Count; _Count -= _Bytes, _Ptr1 += _Bytes, ++_Wchars) {
mov rax, QWORD PTR _Count1$[rbp]
mov QWORD PTR _Count$[rbp], rax
mov QWORD PTR _Wchars$[rbp], 0
mov rax, QWORD PTR _Ptr$[rbp]
mov QWORD PTR _Ptr1$[rbp], rax
jmp SHORT $LN4@Maklocstr
$LN2@Maklocstr:
movsxd rax, DWORD PTR _Bytes$[rbp]
mov rcx, QWORD PTR _Count$[rbp]
sub rcx, rax
mov rax, rcx
mov QWORD PTR _Count$[rbp], rax
movsxd rax, DWORD PTR _Bytes$[rbp]
mov rcx, QWORD PTR _Ptr1$[rbp]
add rcx, rax
mov rax, rcx
mov QWORD PTR _Ptr1$[rbp], rax
mov rax, QWORD PTR _Wchars$[rbp]
inc rax
mov QWORD PTR _Wchars$[rbp], rax
$LN4@Maklocstr:
cmp QWORD PTR _Count$[rbp], 0
jbe SHORT $LN3@Maklocstr
; 550 : if ((_Bytes = _Mbrtowc(&_Wc, _Ptr1, _Count, &_Mbst1, &_Cvt)) <= 0) {
mov rax, QWORD PTR _Cvt$[rbp]
mov QWORD PTR [rsp+32], rax
lea r9, QWORD PTR _Mbst1$[rbp]
mov r8, QWORD PTR _Count$[rbp]
mov rdx, QWORD PTR _Ptr1$[rbp]
lea rcx, QWORD PTR _Wc$[rbp]
call _Mbrtowc
mov DWORD PTR _Bytes$[rbp], eax
cmp DWORD PTR _Bytes$[rbp], 0
jg SHORT $LN8@Maklocstr
; 551 : break;
jmp SHORT $LN3@Maklocstr
$LN8@Maklocstr:
; 552 : }
; 553 : }
jmp SHORT $LN2@Maklocstr
$LN3@Maklocstr:
; 554 :
; 555 : ++_Wchars; // count terminating nul
mov rax, QWORD PTR _Wchars$[rbp]
inc rax
mov QWORD PTR _Wchars$[rbp], rax
; 556 :
; 557 : wchar_t* _Ptrdest = static_cast<wchar_t*>(_calloc_dbg(_Wchars, sizeof(wchar_t), _CRT_BLOCK, __FILE__, __LINE__));
mov DWORD PTR [rsp+32], 557 ; 0000022dH
lea r9, OFFSET FLAT:??_C@_0GI@IDGLFOOP@C?3?2Program?5Files?5?$CIx86?$CJ?2Microsof@
mov r8d, 2
mov edx, 2
mov rcx, QWORD PTR _Wchars$[rbp]
call QWORD PTR __imp__calloc_dbg
mov QWORD PTR _Ptrdest$[rbp], rax
; 558 :
; 559 : if (!_Ptrdest) {
cmp QWORD PTR _Ptrdest$[rbp], 0
jne SHORT $LN9@Maklocstr
; 560 : _Xbad_alloc();
call ?_Xbad_alloc@std@@YAXXZ ; std::_Xbad_alloc
$LN9@Maklocstr:
; 561 : }
; 562 :
; 563 : wchar_t* _Ptrnext = _Ptrdest;
mov rax, QWORD PTR _Ptrdest$[rbp]
mov QWORD PTR _Ptrnext$[rbp], rax
; 564 : mbstate_t _Mbst2 = {};
lea rax, QWORD PTR _Mbst2$[rbp]
mov rdi, rax
xor eax, eax
mov ecx, 8
rep stosb
; 565 :
; 566 : for (; 0 < _Wchars; _Count -= _Bytes, _Ptr += _Bytes, --_Wchars, ++_Ptrnext) {
jmp SHORT $LN7@Maklocstr
$LN5@Maklocstr:
movsxd rax, DWORD PTR _Bytes$[rbp]
mov rcx, QWORD PTR _Count$[rbp]
sub rcx, rax
mov rax, rcx
mov QWORD PTR _Count$[rbp], rax
movsxd rax, DWORD PTR _Bytes$[rbp]
mov rcx, QWORD PTR _Ptr$[rbp]
add rcx, rax
mov rax, rcx
mov QWORD PTR _Ptr$[rbp], rax
mov rax, QWORD PTR _Wchars$[rbp]
dec rax
mov QWORD PTR _Wchars$[rbp], rax
mov rax, QWORD PTR _Ptrnext$[rbp]
add rax, 2
mov QWORD PTR _Ptrnext$[rbp], rax
$LN7@Maklocstr:
cmp QWORD PTR _Wchars$[rbp], 0
jbe SHORT $LN6@Maklocstr
; 567 : if ((_Bytes = _Mbrtowc(_Ptrnext, _Ptr, _Count1, &_Mbst2, &_Cvt)) <= 0) {
mov rax, QWORD PTR _Cvt$[rbp]
mov QWORD PTR [rsp+32], rax
lea r9, QWORD PTR _Mbst2$[rbp]
mov r8, QWORD PTR _Count1$[rbp]
mov rdx, QWORD PTR _Ptr$[rbp]
mov rcx, QWORD PTR _Ptrnext$[rbp]
call _Mbrtowc
mov DWORD PTR _Bytes$[rbp], eax
cmp DWORD PTR _Bytes$[rbp], 0
jg SHORT $LN10@Maklocstr
; 568 : break;
jmp SHORT $LN6@Maklocstr
$LN10@Maklocstr:
; 569 : }
; 570 : }
jmp $LN5@Maklocstr
$LN6@Maklocstr:
; 571 :
; 572 : *_Ptrnext = L'\0';
xor eax, eax
mov rcx, QWORD PTR _Ptrnext$[rbp]
mov WORD PTR [rcx], ax
; 573 :
; 574 : return _Ptrdest;
mov rax, QWORD PTR _Ptrdest$[rbp]
$LN11@Maklocstr:
; 575 : }
mov rdi, rax
lea rcx, QWORD PTR [rbp-48]
lea rdx, OFFSET FLAT:??$_Maklocstr@_W@std@@YAPEA_WPEBDPEA_WAEBU_Cvtvec@@@Z$rtcFrameData
call _RTC_CheckStackVars
mov rax, rdi
mov rcx, QWORD PTR __$ArrayPad$[rbp]
xor rcx, rbp
call __security_check_cookie
lea rsp, QWORD PTR [rbp+520]
pop rdi
pop rbp
ret 0
??$_Maklocstr@_W@std@@YAPEA_WPEBDPEA_WAEBU_Cvtvec@@@Z ENDP ; std::_Maklocstr<wchar_t>
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; COMDAT ??1?$_Compressed_pair@V?$allocator@D@std@@V?$_String_val@U?$_Simple_types@D@std@@@2@$00@std@@QEAA@XZ
_TEXT SEGMENT
this$ = 224
??1?$_Compressed_pair@V?$allocator@D@std@@V?$_String_val@U?$_Simple_types@D@std@@@2@$00@std@@QEAA@XZ PROC ; std::_Compressed_pair<std::allocator<char>,std::_String_val<std::_Simple_types<char> >,1>::~_Compressed_pair<std::allocator<char>,std::_String_val<std::_Simple_types<char> >,1>, COMDAT
$LN3:
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+264]
mov rax, QWORD PTR this$[rbp]
mov rcx, rax
call ??1?$_String_val@U?$_Simple_types@D@std@@@std@@QEAA@XZ
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
??1?$_Compressed_pair@V?$allocator@D@std@@V?$_String_val@U?$_Simple_types@D@std@@@2@$00@std@@QEAA@XZ ENDP ; std::_Compressed_pair<std::allocator<char>,std::_String_val<std::_Simple_types<char> >,1>::~_Compressed_pair<std::allocator<char>,std::_String_val<std::_Simple_types<char> >,1>
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\xmemory
; COMDAT ?_Get_first@?$_Compressed_pair@V?$allocator@D@std@@V?$_String_val@U?$_Simple_types@D@std@@@2@$00@std@@QEBAAEBV?$allocator@D@2@XZ
_TEXT SEGMENT
this$ = 224
?_Get_first@?$_Compressed_pair@V?$allocator@D@std@@V?$_String_val@U?$_Simple_types@D@std@@@2@$00@std@@QEBAAEBV?$allocator@D@2@XZ PROC ; std::_Compressed_pair<std::allocator<char>,std::_String_val<std::_Simple_types<char> >,1>::_Get_first, COMDAT
; 1350 : constexpr const _Ty1& _Get_first() const noexcept {
$LN3:
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+264]
lea rcx, OFFSET FLAT:__F1739482_xmemory
call __CheckForDebuggerJustMyCode
; 1351 : return *this;
mov rax, QWORD PTR this$[rbp]
; 1352 : }
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
?_Get_first@?$_Compressed_pair@V?$allocator@D@std@@V?$_String_val@U?$_Simple_types@D@std@@@2@$00@std@@QEBAAEBV?$allocator@D@2@XZ ENDP ; std::_Compressed_pair<std::allocator<char>,std::_String_val<std::_Simple_types<char> >,1>::_Get_first
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\xmemory
; COMDAT ?_Get_first@?$_Compressed_pair@V?$allocator@D@std@@V?$_String_val@U?$_Simple_types@D@std@@@2@$00@std@@QEAAAEAV?$allocator@D@2@XZ
_TEXT SEGMENT
this$ = 224
?_Get_first@?$_Compressed_pair@V?$allocator@D@std@@V?$_String_val@U?$_Simple_types@D@std@@@2@$00@std@@QEAAAEAV?$allocator@D@2@XZ PROC ; std::_Compressed_pair<std::allocator<char>,std::_String_val<std::_Simple_types<char> >,1>::_Get_first, COMDAT
; 1346 : constexpr _Ty1& _Get_first() noexcept {
$LN3:
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+264]
lea rcx, OFFSET FLAT:__F1739482_xmemory
call __CheckForDebuggerJustMyCode
; 1347 : return *this;
mov rax, QWORD PTR this$[rbp]
; 1348 : }
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
?_Get_first@?$_Compressed_pair@V?$allocator@D@std@@V?$_String_val@U?$_Simple_types@D@std@@@2@$00@std@@QEAAAEAV?$allocator@D@2@XZ ENDP ; std::_Compressed_pair<std::allocator<char>,std::_String_val<std::_Simple_types<char> >,1>::_Get_first
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\xstring
; COMDAT ?_Getal@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@AEBAAEBV?$allocator@D@2@XZ
_TEXT SEGMENT
this$ = 224
?_Getal@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@AEBAAEBV?$allocator@D@2@XZ PROC ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::_Getal, COMDAT
; 4412 : const _Alty& _Getal() const noexcept {
$LN3:
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+264]
lea rcx, OFFSET FLAT:__85A0121E_xstring
call __CheckForDebuggerJustMyCode
; 4413 : return _Mypair._Get_first();
mov rax, QWORD PTR this$[rbp]
mov rcx, rax
call ?_Get_first@?$_Compressed_pair@V?$allocator@D@std@@V?$_String_val@U?$_Simple_types@D@std@@@2@$00@std@@QEBAAEBV?$allocator@D@2@XZ ; std::_Compressed_pair<std::allocator<char>,std::_String_val<std::_Simple_types<char> >,1>::_Get_first
; 4414 : }
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
?_Getal@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@AEBAAEBV?$allocator@D@2@XZ ENDP ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::_Getal
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\xstring
; COMDAT ?_Getal@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@AEAAAEAV?$allocator@D@2@XZ
_TEXT SEGMENT
this$ = 224
?_Getal@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@AEAAAEAV?$allocator@D@2@XZ PROC ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::_Getal, COMDAT
; 4408 : _Alty& _Getal() noexcept {
$LN3:
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+264]
lea rcx, OFFSET FLAT:__85A0121E_xstring
call __CheckForDebuggerJustMyCode
; 4409 : return _Mypair._Get_first();
mov rax, QWORD PTR this$[rbp]
mov rcx, rax
call ?_Get_first@?$_Compressed_pair@V?$allocator@D@std@@V?$_String_val@U?$_Simple_types@D@std@@@2@$00@std@@QEAAAEAV?$allocator@D@2@XZ ; std::_Compressed_pair<std::allocator<char>,std::_String_val<std::_Simple_types<char> >,1>::_Get_first
; 4410 : }
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
?_Getal@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@AEAAAEAV?$allocator@D@2@XZ ENDP ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::_Getal
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\xstring
; COMDAT ?_Tidy_deallocate@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@AEAAXXZ
_TEXT SEGMENT
_Ptr$1 = 8
_Al$2 = 40
$T3 = 260
this$ = 320
?_Tidy_deallocate@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@AEAAXXZ PROC ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::_Tidy_deallocate, COMDAT
; 4383 : void _Tidy_deallocate() noexcept { // initialize buffer, deallocating any storage
$LN4:
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 328 ; 00000148H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 82 ; 00000052H
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+360]
lea rcx, OFFSET FLAT:__85A0121E_xstring
call __CheckForDebuggerJustMyCode
; 4384 : _Mypair._Myval2._Orphan_all();
mov rax, QWORD PTR this$[rbp]
mov rcx, rax
call ?_Orphan_all@_Container_base12@std@@QEAAXXZ ; std::_Container_base12::_Orphan_all
; 4385 : if (_Mypair._Myval2._Large_string_engaged()) {
mov rax, QWORD PTR this$[rbp]
mov rcx, rax
call ?_Large_string_engaged@?$_String_val@U?$_Simple_types@D@std@@@std@@QEBA_NXZ ; std::_String_val<std::_Simple_types<char> >::_Large_string_engaged
movzx eax, al
test eax, eax
je SHORT $LN2@Tidy_deall
; 4386 : const pointer _Ptr = _Mypair._Myval2._Bx._Ptr;
mov rax, QWORD PTR this$[rbp]
mov rax, QWORD PTR [rax+8]
mov QWORD PTR _Ptr$1[rbp], rax
; 4387 : auto& _Al = _Getal();
mov rcx, QWORD PTR this$[rbp]
call ?_Getal@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@AEAAAEAV?$allocator@D@2@XZ ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::_Getal
mov QWORD PTR _Al$2[rbp], rax
; 4388 : _Destroy_in_place(_Mypair._Myval2._Bx._Ptr);
mov rax, QWORD PTR this$[rbp]
add rax, 8
mov rcx, rax
call ??$_Destroy_in_place@PEAD@std@@YAXAEAPEAD@Z ; std::_Destroy_in_place<char *>
; 4389 : _Al.deallocate(_Ptr, _Mypair._Myval2._Myres + 1);
mov rax, QWORD PTR this$[rbp]
mov rax, QWORD PTR [rax+32]
inc rax
mov r8, rax
mov rdx, QWORD PTR _Ptr$1[rbp]
mov rcx, QWORD PTR _Al$2[rbp]
call ?deallocate@?$allocator@D@std@@QEAAXQEAD_K@Z ; std::allocator<char>::deallocate
$LN2@Tidy_deall:
; 4390 : }
; 4391 :
; 4392 : _Mypair._Myval2._Mysize = 0;
mov rax, QWORD PTR this$[rbp]
mov QWORD PTR [rax+24], 0
; 4393 : _Mypair._Myval2._Myres = _BUF_SIZE - 1;
mov rax, QWORD PTR this$[rbp]
mov QWORD PTR [rax+32], 15
; 4394 : // the _Traits::assign is last so the codegen doesn't think the char write can alias this
; 4395 : _Traits::assign(_Mypair._Myval2._Bx._Buf[0], _Elem());
mov BYTE PTR $T3[rbp], 0
mov eax, 1
imul rax, rax, 0
mov rcx, QWORD PTR this$[rbp]
lea rax, QWORD PTR [rcx+rax+8]
lea rdx, QWORD PTR $T3[rbp]
mov rcx, rax
call ?assign@?$_Narrow_char_traits@DH@std@@SAXAEADAEBD@Z ; std::_Narrow_char_traits<char,int>::assign
npad 1
; 4396 : }
lea rsp, QWORD PTR [rbp+296]
pop rdi
pop rbp
ret 0
?_Tidy_deallocate@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@AEAAXXZ ENDP ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::_Tidy_deallocate
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\xstring
; COMDAT ?_Tidy_init@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@AEAAXXZ
_TEXT SEGMENT
$T1 = 196
this$ = 256
?_Tidy_init@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@AEAAXXZ PROC ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::_Tidy_init, COMDAT
; 4376 : void _Tidy_init() noexcept { // initialize basic_string data members
$LN3:
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 264 ; 00000108H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 66 ; 00000042H
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+296]
lea rcx, OFFSET FLAT:__85A0121E_xstring
call __CheckForDebuggerJustMyCode
; 4377 : _Mypair._Myval2._Mysize = 0;
mov rax, QWORD PTR this$[rbp]
mov QWORD PTR [rax+24], 0
; 4378 : _Mypair._Myval2._Myres = _BUF_SIZE - 1;
mov rax, QWORD PTR this$[rbp]
mov QWORD PTR [rax+32], 15
; 4379 : // the _Traits::assign is last so the codegen doesn't think the char write can alias this
; 4380 : _Traits::assign(_Mypair._Myval2._Bx._Buf[0], _Elem());
mov BYTE PTR $T1[rbp], 0
mov eax, 1
imul rax, rax, 0
mov rcx, QWORD PTR this$[rbp]
lea rax, QWORD PTR [rcx+rax+8]
lea rdx, QWORD PTR $T1[rbp]
mov rcx, rax
call ?assign@?$_Narrow_char_traits@DH@std@@SAXAEADAEBD@Z ; std::_Narrow_char_traits<char,int>::assign
; 4381 : }
lea rsp, QWORD PTR [rbp+232]
pop rdi
pop rbp
ret 0
?_Tidy_init@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@AEAAXXZ ENDP ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::_Tidy_init
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\xstring
; COMDAT ?_Calculate_growth@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@AEBA_K_K@Z
_TEXT SEGMENT
tv76 = 192
tv74 = 200
this$ = 240
_Requested$ = 248
?_Calculate_growth@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@AEBA_K_K@Z PROC ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::_Calculate_growth, COMDAT
; 4297 : _NODISCARD size_type _Calculate_growth(const size_type _Requested) const noexcept {
$LN3:
mov QWORD PTR [rsp+16], rdx
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 248 ; 000000f8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 62 ; 0000003eH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+280]
lea rcx, OFFSET FLAT:__85A0121E_xstring
call __CheckForDebuggerJustMyCode
; 4298 : return _Calculate_growth(_Requested, _Mypair._Myval2._Myres, max_size());
mov rcx, QWORD PTR this$[rbp]
call ?max_size@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEBA_KXZ ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::max_size
mov QWORD PTR tv76[rbp], rax
mov rax, QWORD PTR this$[rbp]
mov rax, QWORD PTR [rax+32]
mov QWORD PTR tv74[rbp], rax
mov r8, QWORD PTR tv76[rbp]
mov rdx, QWORD PTR tv74[rbp]
mov rcx, QWORD PTR _Requested$[rbp]
call ?_Calculate_growth@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@CA_K_K00@Z ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::_Calculate_growth
; 4299 : }
lea rsp, QWORD PTR [rbp+216]
pop rdi
pop rbp
ret 0
?_Calculate_growth@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@AEBA_K_K@Z ENDP ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::_Calculate_growth
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\xstring
; COMDAT ?_Calculate_growth@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@CA_K_K00@Z
_TEXT SEGMENT
_Masked$ = 8
$T4 = 232
__$ArrayPad$ = 248
_Requested$ = 288
_Old$ = 296
_Max$ = 304
?_Calculate_growth@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@CA_K_K00@Z PROC ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::_Calculate_growth, COMDAT
; 4284 : const size_type _Requested, const size_type _Old, const size_type _Max) noexcept {
$LN5:
mov QWORD PTR [rsp+24], r8
mov QWORD PTR [rsp+16], rdx
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 296 ; 00000128H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 74 ; 0000004aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+328]
mov rax, QWORD PTR __security_cookie
xor rax, rbp
mov QWORD PTR __$ArrayPad$[rbp], rax
lea rcx, OFFSET FLAT:__85A0121E_xstring
call __CheckForDebuggerJustMyCode
; 4285 : const size_type _Masked = _Requested | _ALLOC_MASK;
mov rax, QWORD PTR _Requested$[rbp]
or rax, 15
mov QWORD PTR _Masked$[rbp], rax
; 4286 : if (_Masked > _Max) { // the mask overflows, settle for max_size()
mov rax, QWORD PTR _Max$[rbp]
cmp QWORD PTR _Masked$[rbp], rax
jbe SHORT $LN2@Calculate_
; 4287 : return _Max;
mov rax, QWORD PTR _Max$[rbp]
jmp SHORT $LN1@Calculate_
$LN2@Calculate_:
; 4288 : }
; 4289 :
; 4290 : if (_Old > _Max - _Old / 2) { // similarly, geometric overflows
xor edx, edx
mov rax, QWORD PTR _Old$[rbp]
mov ecx, 2
div rcx
mov rcx, QWORD PTR _Max$[rbp]
sub rcx, rax
mov rax, rcx
cmp QWORD PTR _Old$[rbp], rax
jbe SHORT $LN3@Calculate_
; 4291 : return _Max;
mov rax, QWORD PTR _Max$[rbp]
jmp SHORT $LN1@Calculate_
$LN3@Calculate_:
; 4292 : }
; 4293 :
; 4294 : return (_STD max)(_Masked, _Old + _Old / 2);
xor edx, edx
mov rax, QWORD PTR _Old$[rbp]
mov ecx, 2
div rcx
mov rcx, QWORD PTR _Old$[rbp]
add rcx, rax
mov rax, rcx
mov QWORD PTR $T4[rbp], rax
lea rdx, QWORD PTR $T4[rbp]
lea rcx, QWORD PTR _Masked$[rbp]
call ??$max@_K@std@@YAAEB_KAEB_K0@Z ; std::max<unsigned __int64>
mov rax, QWORD PTR [rax]
$LN1@Calculate_:
; 4295 : }
mov rdi, rax
lea rcx, QWORD PTR [rbp-32]
lea rdx, OFFSET FLAT:?_Calculate_growth@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@CA_K_K00@Z$rtcFrameData
call _RTC_CheckStackVars
mov rax, rdi
mov rcx, QWORD PTR __$ArrayPad$[rbp]
xor rcx, rbp
call __security_check_cookie
lea rsp, QWORD PTR [rbp+264]
pop rdi
pop rbp
ret 0
?_Calculate_growth@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@CA_K_K00@Z ENDP ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::_Calculate_growth
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\xstring
; COMDAT ?_Equal@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEBA_NQEBD@Z
_TEXT SEGMENT
tv83 = 192
tv81 = 200
tv79 = 208
this$ = 256
_Ptr$ = 264
?_Equal@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEBA_NQEBD@Z PROC ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::_Equal, COMDAT
; 4179 : bool _Equal(_In_z_ const _Elem* const _Ptr) const noexcept { // compare [0, size()) with _Ptr for equality
$LN3:
mov QWORD PTR [rsp+16], rdx
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 264 ; 00000108H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 66 ; 00000042H
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+296]
lea rcx, OFFSET FLAT:__85A0121E_xstring
call __CheckForDebuggerJustMyCode
; 4180 : return _Traits_equal<_Traits>(_Mypair._Myval2._Myptr(), _Mypair._Myval2._Mysize, _Ptr, _Traits::length(_Ptr));
mov rcx, QWORD PTR _Ptr$[rbp]
call ?length@?$_Narrow_char_traits@DH@std@@SA_KQEBD@Z ; std::_Narrow_char_traits<char,int>::length
mov QWORD PTR tv83[rbp], rax
mov rax, QWORD PTR this$[rbp]
mov rax, QWORD PTR [rax+24]
mov QWORD PTR tv81[rbp], rax
mov rax, QWORD PTR this$[rbp]
mov rcx, rax
call ?_Myptr@?$_String_val@U?$_Simple_types@D@std@@@std@@QEBAPEBDXZ ; std::_String_val<std::_Simple_types<char> >::_Myptr
mov QWORD PTR tv79[rbp], rax
mov r9, QWORD PTR tv83[rbp]
mov r8, QWORD PTR _Ptr$[rbp]
mov rdx, QWORD PTR tv81[rbp]
mov rcx, QWORD PTR tv79[rbp]
call ??$_Traits_equal@U?$char_traits@D@std@@@std@@YA_NQEBD_K01@Z ; std::_Traits_equal<std::char_traits<char> >
; 4181 : }
lea rsp, QWORD PTR [rbp+232]
pop rdi
pop rbp
ret 0
?_Equal@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEBA_NQEBD@Z ENDP ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::_Equal
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\xstring
; COMDAT ?max_size@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEBA_KXZ
_TEXT SEGMENT
_Alloc_max$ = 8
_Storage_max$ = 40
$T4 = 264
$T5 = 296
$T6 = 328
__$ArrayPad$ = 344
this$ = 384
?max_size@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEBA_KXZ PROC ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::max_size, COMDAT
; 3773 : _NODISCARD size_type max_size() const noexcept {
$LN3:
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 392 ; 00000188H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 98 ; 00000062H
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+424]
mov rax, QWORD PTR __security_cookie
xor rax, rbp
mov QWORD PTR __$ArrayPad$[rbp], rax
lea rcx, OFFSET FLAT:__85A0121E_xstring
call __CheckForDebuggerJustMyCode
; 3774 : const size_type _Alloc_max = _Alty_traits::max_size(_Getal());
mov rcx, QWORD PTR this$[rbp]
call ?_Getal@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@AEBAAEBV?$allocator@D@2@XZ ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::_Getal
mov rcx, rax
call ?max_size@?$_Default_allocator_traits@V?$allocator@D@std@@@std@@SA_KAEBV?$allocator@D@2@@Z ; std::_Default_allocator_traits<std::allocator<char> >::max_size
mov QWORD PTR _Alloc_max$[rbp], rax
; 3775 : const size_type _Storage_max = // can always store small string
mov QWORD PTR $T4[rbp], 16
lea rdx, QWORD PTR $T4[rbp]
lea rcx, QWORD PTR _Alloc_max$[rbp]
call ??$max@_K@std@@YAAEB_KAEB_K0@Z ; std::max<unsigned __int64>
mov rax, QWORD PTR [rax]
mov QWORD PTR _Storage_max$[rbp], rax
; 3776 : (_STD max)(_Alloc_max, static_cast<size_type>(_BUF_SIZE));
; 3777 : return (_STD min)(static_cast<size_type>((numeric_limits<difference_type>::max)()),
mov rax, QWORD PTR _Storage_max$[rbp]
dec rax
mov QWORD PTR $T5[rbp], rax
call ?max@?$numeric_limits@_J@std@@SA_JXZ ; std::numeric_limits<__int64>::max
mov QWORD PTR $T6[rbp], rax
lea rdx, QWORD PTR $T5[rbp]
lea rcx, QWORD PTR $T6[rbp]
call ??$min@_K@std@@YAAEB_KAEB_K0@Z ; std::min<unsigned __int64>
mov rax, QWORD PTR [rax]
; 3778 : _Storage_max - 1 // -1 is for null terminator and/or npos
; 3779 : );
; 3780 : }
mov rdi, rax
lea rcx, QWORD PTR [rbp-32]
lea rdx, OFFSET FLAT:?max_size@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEBA_KXZ$rtcFrameData
call _RTC_CheckStackVars
mov rax, rdi
mov rcx, QWORD PTR __$ArrayPad$[rbp]
xor rcx, rbp
call __security_check_cookie
lea rsp, QWORD PTR [rbp+360]
pop rdi
pop rbp
ret 0
?max_size@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEBA_KXZ ENDP ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::max_size
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\xstring
; COMDAT ?size@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEBA_KXZ
_TEXT SEGMENT
this$ = 224
?size@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEBA_KXZ PROC ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::size, COMDAT
; 3769 : _NODISCARD size_type size() const noexcept {
$LN3:
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+264]
lea rcx, OFFSET FLAT:__85A0121E_xstring
call __CheckForDebuggerJustMyCode
; 3770 : return _Mypair._Myval2._Mysize;
mov rax, QWORD PTR this$[rbp]
mov rax, QWORD PTR [rax+24]
; 3771 : }
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
?size@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEBA_KXZ ENDP ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::size
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\xstring
; COMDAT ?data@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEBAPEBDXZ
_TEXT SEGMENT
this$ = 224
?data@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEBAPEBDXZ PROC ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::data, COMDAT
; 3755 : _NODISCARD _Ret_z_ const _Elem* data() const noexcept {
$LN3:
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+264]
lea rcx, OFFSET FLAT:__85A0121E_xstring
call __CheckForDebuggerJustMyCode
; 3756 : return _Mypair._Myval2._Myptr();
mov rax, QWORD PTR this$[rbp]
mov rcx, rax
call ?_Myptr@?$_String_val@U?$_Simple_types@D@std@@@std@@QEBAPEBDXZ ; std::_String_val<std::_Simple_types<char> >::_Myptr
; 3757 : }
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
?data@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEBAPEBDXZ ENDP ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::data
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\xstring
; COMDAT ?assign@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEAAAEAV12@QEBD_K@Z
_TEXT SEGMENT
_Old_ptr$1 = 8
$T2 = 228
$T3 = 260
this$ = 320
_Ptr$ = 328
_Count$ = 336
?assign@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEAAAEAV12@QEBD_K@Z PROC ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::assign, COMDAT
; 3042 : basic_string& assign(_In_reads_(_Count) const _Elem* const _Ptr, _CRT_GUARDOVERFLOW const size_type _Count) {
$LN4:
mov QWORD PTR [rsp+24], r8
mov QWORD PTR [rsp+16], rdx
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 328 ; 00000148H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 82 ; 00000052H
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+360]
lea rcx, OFFSET FLAT:__85A0121E_xstring
call __CheckForDebuggerJustMyCode
; 3043 : // assign [_Ptr, _Ptr + _Count)
; 3044 : if (_Count <= _Mypair._Myval2._Myres) {
mov rax, QWORD PTR this$[rbp]
mov rax, QWORD PTR [rax+32]
cmp QWORD PTR _Count$[rbp], rax
ja SHORT $LN2@assign
; 3045 : _Elem* const _Old_ptr = _Mypair._Myval2._Myptr();
mov rax, QWORD PTR this$[rbp]
mov rcx, rax
call ?_Myptr@?$_String_val@U?$_Simple_types@D@std@@@std@@QEAAPEADXZ ; std::_String_val<std::_Simple_types<char> >::_Myptr
mov QWORD PTR _Old_ptr$1[rbp], rax
; 3046 : _Mypair._Myval2._Mysize = _Count;
mov rax, QWORD PTR this$[rbp]
mov rcx, QWORD PTR _Count$[rbp]
mov QWORD PTR [rax+24], rcx
; 3047 : _Traits::move(_Old_ptr, _Ptr, _Count);
mov r8, QWORD PTR _Count$[rbp]
mov rdx, QWORD PTR _Ptr$[rbp]
mov rcx, QWORD PTR _Old_ptr$1[rbp]
call ?move@?$_Char_traits@DH@std@@SAPEADQEADQEBD_K@Z ; std::_Char_traits<char,int>::move
; 3048 : _Traits::assign(_Old_ptr[_Count], _Elem());
mov BYTE PTR $T2[rbp], 0
mov rax, QWORD PTR _Count$[rbp]
mov rcx, QWORD PTR _Old_ptr$1[rbp]
add rcx, rax
mov rax, rcx
lea rdx, QWORD PTR $T2[rbp]
mov rcx, rax
call ?assign@?$_Narrow_char_traits@DH@std@@SAXAEADAEBD@Z ; std::_Narrow_char_traits<char,int>::assign
; 3049 : return *this;
mov rax, QWORD PTR this$[rbp]
jmp SHORT $LN1@assign
$LN2@assign:
; 3050 : }
; 3051 :
; 3052 : return _Reallocate_for(
lea rax, QWORD PTR $T3[rbp]
mov rdi, rax
xor eax, eax
mov ecx, 1
rep stosb
mov r9, QWORD PTR _Ptr$[rbp]
movzx r8d, BYTE PTR $T3[rbp]
mov rdx, QWORD PTR _Count$[rbp]
mov rcx, QWORD PTR this$[rbp]
call ??$_Reallocate_for@V<lambda_66f57f934f28d61049862f64df852ff0>@@PEBD@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@AEAAAEAV01@_KV<lambda_66f57f934f28d61049862f64df852ff0>@@PEBD@Z ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::_Reallocate_for<<lambda_66f57f934f28d61049862f64df852ff0>,char const *>
$LN1@assign:
; 3053 : _Count,
; 3054 : [](_Elem* const _New_ptr, const size_type _Count, const _Elem* const _Ptr) {
; 3055 : _Traits::copy(_New_ptr, _Ptr, _Count);
; 3056 : _Traits::assign(_New_ptr[_Count], _Elem());
; 3057 : },
; 3058 : _Ptr);
; 3059 : }
lea rsp, QWORD PTR [rbp+296]
pop rdi
pop rbp
ret 0
?assign@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEAAAEAV12@QEBD_K@Z ENDP ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::assign
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\xstring
; COMDAT ??4?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEAAAEAV01@AEBV01@@Z
_TEXT SEGMENT
$T1 = 196
this$ = 256
_Right$ = 264
??4?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEAAAEAV01@AEBV01@@Z PROC ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::operator=, COMDAT
; 2862 : basic_string& operator=(const basic_string& _Right) {
$LN4:
mov QWORD PTR [rsp+16], rdx
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 264 ; 00000108H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 66 ; 00000042H
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+296]
lea rcx, OFFSET FLAT:__85A0121E_xstring
call __CheckForDebuggerJustMyCode
; 2863 : if (this != _STD addressof(_Right)) {
mov rcx, QWORD PTR _Right$[rbp]
call ??$addressof@$$CBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@@std@@YAPEBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@0@AEBV10@@Z ; std::addressof<std::basic_string<char,std::char_traits<char>,std::allocator<char> > const >
cmp QWORD PTR this$[rbp], rax
je SHORT $LN2@operator
; 2864 : _Copy_assign(_Right, _Choose_pocca<_Alty>{});
lea rax, QWORD PTR $T1[rbp]
mov rdi, rax
xor eax, eax
mov ecx, 1
rep stosb
movzx r8d, BYTE PTR $T1[rbp]
mov rdx, QWORD PTR _Right$[rbp]
mov rcx, QWORD PTR this$[rbp]
call ?_Copy_assign@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@AEAAXAEBV12@U?$integral_constant@_N$0A@@2@@Z ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::_Copy_assign
$LN2@operator:
; 2865 : }
; 2866 :
; 2867 : return *this;
mov rax, QWORD PTR this$[rbp]
; 2868 : }
lea rsp, QWORD PTR [rbp+232]
pop rdi
pop rbp
ret 0
??4?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEAAAEAV01@AEBV01@@Z ENDP ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::operator=
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\xstring
; COMDAT ?_Copy_assign@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@AEAAXAEBV12@U?$integral_constant@_N$0A@@2@@Z
_TEXT SEGMENT
tv88 = 192
tv73 = 192
tv86 = 200
tv71 = 200
this$ = 240
_Right$ = 248
__formal$ = 256
?_Copy_assign@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@AEAAXAEBV12@U?$integral_constant@_N$0A@@2@@Z PROC ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::_Copy_assign, COMDAT
; 2826 : void _Copy_assign(const basic_string& _Right, false_type) {
$LN3:
mov BYTE PTR [rsp+24], r8b
mov QWORD PTR [rsp+16], rdx
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 248 ; 000000f8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 62 ; 0000003eH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+280]
lea rcx, OFFSET FLAT:__85A0121E_xstring
call __CheckForDebuggerJustMyCode
; 2827 : _Pocca(_Getal(), _Right._Getal());
mov rcx, QWORD PTR _Right$[rbp]
call ?_Getal@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@AEBAAEBV?$allocator@D@2@XZ ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::_Getal
mov QWORD PTR tv73[rbp], rax
mov rcx, QWORD PTR this$[rbp]
call ?_Getal@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@AEAAAEAV?$allocator@D@2@XZ ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::_Getal
mov QWORD PTR tv71[rbp], rax
mov rdx, QWORD PTR tv73[rbp]
mov rcx, QWORD PTR tv71[rbp]
call ??$_Pocca@V?$allocator@D@std@@@std@@YAXAEAV?$allocator@D@0@AEBV10@@Z ; std::_Pocca<std::allocator<char> >
; 2828 : assign(_Right._Mypair._Myval2._Myptr(), _Right._Mypair._Myval2._Mysize);
mov rax, QWORD PTR _Right$[rbp]
mov rax, QWORD PTR [rax+24]
mov QWORD PTR tv88[rbp], rax
mov rax, QWORD PTR _Right$[rbp]
mov rcx, rax
call ?_Myptr@?$_String_val@U?$_Simple_types@D@std@@@std@@QEBAPEBDXZ ; std::_String_val<std::_Simple_types<char> >::_Myptr
mov QWORD PTR tv86[rbp], rax
mov r8, QWORD PTR tv88[rbp]
mov rdx, QWORD PTR tv86[rbp]
mov rcx, QWORD PTR this$[rbp]
call ?assign@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEAAAEAV12@QEBD_K@Z ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::assign
; 2829 : }
lea rsp, QWORD PTR [rbp+216]
pop rdi
pop rbp
ret 0
?_Copy_assign@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@AEAAXAEBV12@U?$integral_constant@_N$0A@@2@@Z ENDP ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::_Copy_assign
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\xstring
; COMDAT ??1?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEAA@XZ
_TEXT SEGMENT
_Alproxy$ = 8
$S9$ = 36
_To_delete$ = 72
__$ArrayPad$ = 280
this$ = 320
??1?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEAA@XZ PROC ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::~basic_string<char,std::char_traits<char>,std::allocator<char> >, COMDAT
; 2800 : ~basic_string() noexcept {
$LN3:
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 328 ; 00000148H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 82 ; 00000052H
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+360]
mov rax, QWORD PTR __security_cookie
xor rax, rbp
mov QWORD PTR __$ArrayPad$[rbp], rax
lea rcx, OFFSET FLAT:__85A0121E_xstring
call __CheckForDebuggerJustMyCode
; 2801 : _Tidy_deallocate();
mov rcx, QWORD PTR this$[rbp]
call ?_Tidy_deallocate@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@AEAAXXZ ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::_Tidy_deallocate
; 2802 : #if _ITERATOR_DEBUG_LEVEL != 0
; 2803 : auto&& _Alproxy = _GET_PROXY_ALLOCATOR(_Alty, _Getal());
mov rcx, QWORD PTR this$[rbp]
call ?_Getal@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@AEAAAEAV?$allocator@D@2@XZ ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::_Getal
mov rdx, rax
lea rcx, QWORD PTR $S9$[rbp]
call ??$?0D@?$allocator@U_Container_proxy@std@@@std@@QEAA@AEBV?$allocator@D@1@@Z ; std::allocator<std::_Container_proxy>::allocator<std::_Container_proxy><char>
lea rax, QWORD PTR $S9$[rbp]
mov QWORD PTR _Alproxy$[rbp], rax
; 2804 : const auto _To_delete = _Mypair._Myval2._Myproxy;
mov rax, QWORD PTR this$[rbp]
mov rax, QWORD PTR [rax]
mov QWORD PTR _To_delete$[rbp], rax
; 2805 : _Mypair._Myval2._Myproxy = nullptr;
mov rax, QWORD PTR this$[rbp]
mov QWORD PTR [rax], 0
; 2806 : _Delete_plain_internal(_Alproxy, _To_delete);
mov rdx, QWORD PTR _To_delete$[rbp]
mov rcx, QWORD PTR _Alproxy$[rbp]
call ??$_Delete_plain_internal@V?$allocator@U_Container_proxy@std@@@std@@@std@@YAXAEAV?$allocator@U_Container_proxy@std@@@0@QEAU_Container_proxy@0@@Z ; std::_Delete_plain_internal<std::allocator<std::_Container_proxy> >
; 2807 : #endif // _ITERATOR_DEBUG_LEVEL != 0
; 2808 : }
mov rax, QWORD PTR this$[rbp]
mov rcx, rax
call ??1?$_Compressed_pair@V?$allocator@D@std@@V?$_String_val@U?$_Simple_types@D@std@@@2@$00@std@@QEAA@XZ
lea rcx, QWORD PTR [rbp-32]
lea rdx, OFFSET FLAT:??1?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEAA@XZ$rtcFrameData
call _RTC_CheckStackVars
mov rcx, QWORD PTR __$ArrayPad$[rbp]
xor rcx, rbp
call __security_check_cookie
lea rsp, QWORD PTR [rbp+296]
pop rdi
pop rbp
ret 0
??1?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEAA@XZ ENDP ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::~basic_string<char,std::char_traits<char>,std::allocator<char> >
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\xstring
; COMDAT ??0?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEAA@XZ
_TEXT SEGMENT
$T1 = 196
$T2 = 228
tv86 = 248
tv69 = 248
this$ = 288
??0?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEAA@XZ PROC ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::basic_string<char,std::char_traits<char>,std::allocator<char> >, COMDAT
; 2365 : basic_string() noexcept(is_nothrow_default_constructible_v<_Alty>) : _Mypair(_Zero_then_variadic_args_t{}) {
$LN3:
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 296 ; 00000128H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 74 ; 0000004aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+328]
lea rcx, OFFSET FLAT:__85A0121E_xstring
call __CheckForDebuggerJustMyCode
mov rax, QWORD PTR this$[rbp]
mov QWORD PTR tv69[rbp], rax
movzx edx, BYTE PTR $T1[rbp]
mov rcx, QWORD PTR tv69[rbp]
call ??$?0$$V@?$_Compressed_pair@V?$allocator@D@std@@V?$_String_val@U?$_Simple_types@D@std@@@2@$00@std@@QEAA@U_Zero_then_variadic_args_t@1@@Z ; std::_Compressed_pair<std::allocator<char>,std::_String_val<std::_Simple_types<char> >,1>::_Compressed_pair<std::allocator<char>,std::_String_val<std::_Simple_types<char> >,1><>
; 2366 : _Mypair._Myval2._Alloc_proxy(_GET_PROXY_ALLOCATOR(_Alty, _Getal()));
mov rax, QWORD PTR this$[rbp]
mov QWORD PTR tv86[rbp], rax
mov rcx, QWORD PTR this$[rbp]
call ?_Getal@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@AEAAAEAV?$allocator@D@2@XZ ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::_Getal
mov rdx, rax
lea rcx, QWORD PTR $T2[rbp]
call ??$?0D@?$allocator@U_Container_proxy@std@@@std@@QEAA@AEBV?$allocator@D@1@@Z ; std::allocator<std::_Container_proxy>::allocator<std::_Container_proxy><char>
mov rdx, rax
mov rcx, QWORD PTR tv86[rbp]
call ??$_Alloc_proxy@V?$allocator@U_Container_proxy@std@@@std@@@_Container_base12@std@@QEAAX$$QEAV?$allocator@U_Container_proxy@std@@@1@@Z ; std::_Container_base12::_Alloc_proxy<std::allocator<std::_Container_proxy> >
; 2367 : _Tidy_init();
mov rcx, QWORD PTR this$[rbp]
call ?_Tidy_init@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@AEAAXXZ ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::_Tidy_init
; 2368 : }
mov rax, QWORD PTR this$[rbp]
lea rsp, QWORD PTR [rbp+264]
pop rdi
pop rbp
ret 0
??0?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEAA@XZ ENDP ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::basic_string<char,std::char_traits<char>,std::allocator<char> >
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; COMDAT ??1?$_String_val@U?$_Simple_types@D@std@@@std@@QEAA@XZ
_TEXT SEGMENT
this$ = 224
??1?$_String_val@U?$_Simple_types@D@std@@@std@@QEAA@XZ PROC ; std::_String_val<std::_Simple_types<char> >::~_String_val<std::_Simple_types<char> >, COMDAT
$LN3:
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+264]
mov rax, QWORD PTR this$[rbp]
add rax, 8
mov rcx, rax
call ??1_Bxty@?$_String_val@U?$_Simple_types@D@std@@@std@@QEAA@XZ ; std::_String_val<std::_Simple_types<char> >::_Bxty::~_Bxty
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
??1?$_String_val@U?$_Simple_types@D@std@@@std@@QEAA@XZ ENDP ; std::_String_val<std::_Simple_types<char> >::~_String_val<std::_Simple_types<char> >
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\xstring
; COMDAT ??1_Bxty@?$_String_val@U?$_Simple_types@D@std@@@std@@QEAA@XZ
_TEXT SEGMENT
this$ = 224
??1_Bxty@?$_String_val@U?$_Simple_types@D@std@@@std@@QEAA@XZ PROC ; std::_String_val<std::_Simple_types<char> >::_Bxty::~_Bxty, COMDAT
; 2254 : ~_Bxty() noexcept {} // user-provided, for fancy pointers
$LN3:
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+264]
lea rcx, OFFSET FLAT:__85A0121E_xstring
call __CheckForDebuggerJustMyCode
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
??1_Bxty@?$_String_val@U?$_Simple_types@D@std@@@std@@QEAA@XZ ENDP ; std::_String_val<std::_Simple_types<char> >::_Bxty::~_Bxty
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\xstring
; COMDAT ??0_Bxty@?$_String_val@U?$_Simple_types@D@std@@@std@@QEAA@XZ
_TEXT SEGMENT
this$ = 224
??0_Bxty@?$_String_val@U?$_Simple_types@D@std@@@std@@QEAA@XZ PROC ; std::_String_val<std::_Simple_types<char> >::_Bxty::_Bxty, COMDAT
; 2252 : _Bxty() noexcept {} // user-provided, for fancy pointers
$LN3:
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+264]
lea rcx, OFFSET FLAT:__85A0121E_xstring
call __CheckForDebuggerJustMyCode
mov rax, QWORD PTR this$[rbp]
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
??0_Bxty@?$_String_val@U?$_Simple_types@D@std@@@std@@QEAA@XZ ENDP ; std::_String_val<std::_Simple_types<char> >::_Bxty::_Bxty
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\xstring
; COMDAT ?_Large_string_engaged@?$_String_val@U?$_Simple_types@D@std@@@std@@QEBA_NXZ
_TEXT SEGMENT
tv66 = 192
this$ = 240
?_Large_string_engaged@?$_String_val@U?$_Simple_types@D@std@@@std@@QEBA_NXZ PROC ; std::_String_val<std::_Simple_types<char> >::_Large_string_engaged, COMDAT
; 2226 : bool _Large_string_engaged() const noexcept {
$LN5:
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 248 ; 000000f8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 62 ; 0000003eH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+280]
lea rcx, OFFSET FLAT:__85A0121E_xstring
call __CheckForDebuggerJustMyCode
; 2227 : return _BUF_SIZE <= _Myres;
mov rax, QWORD PTR this$[rbp]
cmp QWORD PTR [rax+32], 16
jb SHORT $LN3@Large_stri
mov DWORD PTR tv66[rbp], 1
jmp SHORT $LN4@Large_stri
$LN3@Large_stri:
mov DWORD PTR tv66[rbp], 0
$LN4@Large_stri:
movzx eax, BYTE PTR tv66[rbp]
; 2228 : }
lea rsp, QWORD PTR [rbp+216]
pop rdi
pop rbp
ret 0
?_Large_string_engaged@?$_String_val@U?$_Simple_types@D@std@@@std@@QEBA_NXZ ENDP ; std::_String_val<std::_Simple_types<char> >::_Large_string_engaged
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\xstring
; COMDAT ?_Myptr@?$_String_val@U?$_Simple_types@D@std@@@std@@QEBAPEBDXZ
_TEXT SEGMENT
_Result$ = 8
this$ = 256
?_Myptr@?$_String_val@U?$_Simple_types@D@std@@@std@@QEBAPEBDXZ PROC ; std::_String_val<std::_Simple_types<char> >::_Myptr, COMDAT
; 2217 : const value_type* _Myptr() const noexcept {
$LN4:
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 264 ; 00000108H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 66 ; 00000042H
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+296]
lea rcx, OFFSET FLAT:__85A0121E_xstring
call __CheckForDebuggerJustMyCode
; 2218 : const value_type* _Result = _Bx._Buf;
mov rax, QWORD PTR this$[rbp]
add rax, 8
mov QWORD PTR _Result$[rbp], rax
; 2219 : if (_Large_string_engaged()) {
mov rcx, QWORD PTR this$[rbp]
call ?_Large_string_engaged@?$_String_val@U?$_Simple_types@D@std@@@std@@QEBA_NXZ ; std::_String_val<std::_Simple_types<char> >::_Large_string_engaged
movzx eax, al
test eax, eax
je SHORT $LN2@Myptr
; 2220 : _Result = _Unfancy(_Bx._Ptr);
mov rax, QWORD PTR this$[rbp]
mov rcx, QWORD PTR [rax+8]
call ??$_Unfancy@D@std@@YAPEADPEAD@Z ; std::_Unfancy<char>
mov QWORD PTR _Result$[rbp], rax
$LN2@Myptr:
; 2221 : }
; 2222 :
; 2223 : return _Result;
mov rax, QWORD PTR _Result$[rbp]
; 2224 : }
lea rsp, QWORD PTR [rbp+232]
pop rdi
pop rbp
ret 0
?_Myptr@?$_String_val@U?$_Simple_types@D@std@@@std@@QEBAPEBDXZ ENDP ; std::_String_val<std::_Simple_types<char> >::_Myptr
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\xstring
; COMDAT ?_Myptr@?$_String_val@U?$_Simple_types@D@std@@@std@@QEAAPEADXZ
_TEXT SEGMENT
_Result$ = 8
this$ = 256
?_Myptr@?$_String_val@U?$_Simple_types@D@std@@@std@@QEAAPEADXZ PROC ; std::_String_val<std::_Simple_types<char> >::_Myptr, COMDAT
; 2208 : value_type* _Myptr() noexcept {
$LN4:
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 264 ; 00000108H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 66 ; 00000042H
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+296]
lea rcx, OFFSET FLAT:__85A0121E_xstring
call __CheckForDebuggerJustMyCode
; 2209 : value_type* _Result = _Bx._Buf;
mov rax, QWORD PTR this$[rbp]
add rax, 8
mov QWORD PTR _Result$[rbp], rax
; 2210 : if (_Large_string_engaged()) {
mov rcx, QWORD PTR this$[rbp]
call ?_Large_string_engaged@?$_String_val@U?$_Simple_types@D@std@@@std@@QEBA_NXZ ; std::_String_val<std::_Simple_types<char> >::_Large_string_engaged
movzx eax, al
test eax, eax
je SHORT $LN2@Myptr
; 2211 : _Result = _Unfancy(_Bx._Ptr);
mov rax, QWORD PTR this$[rbp]
mov rcx, QWORD PTR [rax+8]
call ??$_Unfancy@D@std@@YAPEADPEAD@Z ; std::_Unfancy<char>
mov QWORD PTR _Result$[rbp], rax
$LN2@Myptr:
; 2212 : }
; 2213 :
; 2214 : return _Result;
mov rax, QWORD PTR _Result$[rbp]
; 2215 : }
lea rsp, QWORD PTR [rbp+232]
pop rdi
pop rbp
ret 0
?_Myptr@?$_String_val@U?$_Simple_types@D@std@@@std@@QEAAPEADXZ ENDP ; std::_String_val<std::_Simple_types<char> >::_Myptr
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\xstring
; COMDAT ??0?$_String_val@U?$_Simple_types@D@std@@@std@@QEAA@XZ
_TEXT SEGMENT
this$ = 224
??0?$_String_val@U?$_Simple_types@D@std@@@std@@QEAA@XZ PROC ; std::_String_val<std::_Simple_types<char> >::_String_val<std::_Simple_types<char> >, COMDAT
; 2198 : _String_val() noexcept : _Bx(), _Mysize(0), _Myres(0) {}
$LN3:
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+264]
lea rcx, OFFSET FLAT:__85A0121E_xstring
call __CheckForDebuggerJustMyCode
mov rcx, QWORD PTR this$[rbp]
call ??0_Container_base12@std@@QEAA@XZ ; std::_Container_base12::_Container_base12
mov rax, QWORD PTR this$[rbp]
add rax, 8
mov rcx, rax
call ??0_Bxty@?$_String_val@U?$_Simple_types@D@std@@@std@@QEAA@XZ ; std::_String_val<std::_Simple_types<char> >::_Bxty::_Bxty
mov rax, QWORD PTR this$[rbp]
mov QWORD PTR [rax+24], 0
mov rax, QWORD PTR this$[rbp]
mov QWORD PTR [rax+32], 0
mov rax, QWORD PTR this$[rbp]
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
??0?$_String_val@U?$_Simple_types@D@std@@@std@@QEAA@XZ ENDP ; std::_String_val<std::_Simple_types<char> >::_String_val<std::_Simple_types<char> >
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\xmemory
; COMDAT ?max_size@?$_Default_allocator_traits@V?$allocator@D@std@@@std@@SA_KAEBV?$allocator@D@2@@Z
_TEXT SEGMENT
__formal$ = 224
?max_size@?$_Default_allocator_traits@V?$allocator@D@std@@@std@@SA_KAEBV?$allocator@D@2@@Z PROC ; std::_Default_allocator_traits<std::allocator<char> >::max_size, COMDAT
; 709 : _NODISCARD static size_type max_size(const _Alloc&) noexcept {
$LN3:
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+264]
lea rcx, OFFSET FLAT:__F1739482_xmemory
call __CheckForDebuggerJustMyCode
; 710 : return static_cast<size_t>(-1) / sizeof(value_type);
mov rax, -1
; 711 : }
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
?max_size@?$_Default_allocator_traits@V?$allocator@D@std@@@std@@SA_KAEBV?$allocator@D@2@@Z ENDP ; std::_Default_allocator_traits<std::allocator<char> >::max_size
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\xstring
; COMDAT ?_Xlen_string@std@@YAXXZ
_TEXT SEGMENT
?_Xlen_string@std@@YAXXZ PROC ; std::_Xlen_string, COMDAT
; 2274 : [[noreturn]] inline void _Xlen_string() {
$LN3:
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
lea rcx, OFFSET FLAT:__85A0121E_xstring
call __CheckForDebuggerJustMyCode
; 2275 : _Xlength_error("string too long");
lea rcx, OFFSET FLAT:??_C@_0BA@JFNIOLAK@string?5too?5long@
call ?_Xlength_error@std@@YAXPEBD@Z ; std::_Xlength_error
$LN2@Xlen_strin:
; 2276 : }
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
?_Xlen_string@std@@YAXXZ ENDP ; std::_Xlen_string
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\xstring
; COMDAT ?eof@?$_Narrow_char_traits@DH@std@@SAHXZ
_TEXT SEGMENT
?eof@?$_Narrow_char_traits@DH@std@@SAHXZ PROC ; std::_Narrow_char_traits<char,int>::eof, COMDAT
; 455 : _NODISCARD static constexpr int_type eof() noexcept {
$LN3:
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
lea rcx, OFFSET FLAT:__85A0121E_xstring
call __CheckForDebuggerJustMyCode
; 456 : return static_cast<int_type>(EOF);
mov eax, -1
; 457 : }
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
?eof@?$_Narrow_char_traits@DH@std@@SAHXZ ENDP ; std::_Narrow_char_traits<char,int>::eof
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\xstring
; COMDAT ?eq_int_type@?$_Narrow_char_traits@DH@std@@SA_NAEBH0@Z
_TEXT SEGMENT
tv65 = 192
_Left$ = 240
_Right$ = 248
?eq_int_type@?$_Narrow_char_traits@DH@std@@SA_NAEBH0@Z PROC ; std::_Narrow_char_traits<char,int>::eq_int_type, COMDAT
; 447 : _NODISCARD static constexpr bool eq_int_type(const int_type& _Left, const int_type& _Right) noexcept {
$LN5:
mov QWORD PTR [rsp+16], rdx
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 248 ; 000000f8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 62 ; 0000003eH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+280]
lea rcx, OFFSET FLAT:__85A0121E_xstring
call __CheckForDebuggerJustMyCode
; 448 : return _Left == _Right;
mov rax, QWORD PTR _Left$[rbp]
mov rcx, QWORD PTR _Right$[rbp]
mov ecx, DWORD PTR [rcx]
cmp DWORD PTR [rax], ecx
jne SHORT $LN3@eq_int_typ
mov DWORD PTR tv65[rbp], 1
jmp SHORT $LN4@eq_int_typ
$LN3@eq_int_typ:
mov DWORD PTR tv65[rbp], 0
$LN4@eq_int_typ:
movzx eax, BYTE PTR tv65[rbp]
; 449 : }
lea rsp, QWORD PTR [rbp+216]
pop rdi
pop rbp
ret 0
?eq_int_type@?$_Narrow_char_traits@DH@std@@SA_NAEBH0@Z ENDP ; std::_Narrow_char_traits<char,int>::eq_int_type
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\xstring
; COMDAT ?assign@?$_Narrow_char_traits@DH@std@@SAXAEADAEBD@Z
_TEXT SEGMENT
_Left$ = 224
_Right$ = 232
?assign@?$_Narrow_char_traits@DH@std@@SAXAEADAEBD@Z PROC ; std::_Narrow_char_traits<char,int>::assign, COMDAT
; 427 : static _CONSTEXPR17 void assign(_Elem& _Left, const _Elem& _Right) noexcept {
$LN3:
mov QWORD PTR [rsp+16], rdx
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+264]
lea rcx, OFFSET FLAT:__85A0121E_xstring
call __CheckForDebuggerJustMyCode
; 428 : _Left = _Right;
mov rax, QWORD PTR _Left$[rbp]
mov rcx, QWORD PTR _Right$[rbp]
movzx ecx, BYTE PTR [rcx]
mov BYTE PTR [rax], cl
; 429 : }
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
?assign@?$_Narrow_char_traits@DH@std@@SAXAEADAEBD@Z ENDP ; std::_Narrow_char_traits<char,int>::assign
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\xstring
; COMDAT ?length@?$_Narrow_char_traits@DH@std@@SA_KQEBD@Z
_TEXT SEGMENT
tv68 = 192
tv69 = 200
_First$ = 240
?length@?$_Narrow_char_traits@DH@std@@SA_KQEBD@Z PROC ; std::_Narrow_char_traits<char,int>::length, COMDAT
; 373 : _NODISCARD static _CONSTEXPR17 size_t length(_In_z_ const _Elem* const _First) noexcept /* strengthened */ {
$LN4:
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 248 ; 000000f8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 62 ; 0000003eH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+280]
lea rcx, OFFSET FLAT:__85A0121E_xstring
call __CheckForDebuggerJustMyCode
; 374 : // find length of null-terminated string
; 375 : #if _HAS_CXX17
; 376 : #ifdef __cpp_char8_t
; 377 : if constexpr (is_same_v<_Elem, char8_t>) {
; 378 : #if _HAS_U8_INTRINSICS
; 379 : return __builtin_u8strlen(_First);
; 380 : #else // ^^^ use u8 intrinsics / no u8 intrinsics vvv
; 381 : return _Primary_char_traits::length(_First);
; 382 : #endif // _HAS_U8_INTRINSICS
; 383 : } else
; 384 : #endif // __cpp_char8_t
; 385 : {
; 386 : return __builtin_strlen(_First);
mov rax, QWORD PTR _First$[rbp]
mov QWORD PTR tv68[rbp], rax
mov QWORD PTR tv69[rbp], -1
$LL3@length:
inc QWORD PTR tv69[rbp]
mov rax, QWORD PTR tv68[rbp]
mov rcx, QWORD PTR tv69[rbp]
cmp BYTE PTR [rax+rcx], 0
jne SHORT $LL3@length
mov rax, QWORD PTR tv69[rbp]
; 387 : }
; 388 : #else // _HAS_CXX17
; 389 : return _CSTD strlen(reinterpret_cast<const char*>(_First));
; 390 : #endif // _HAS_CXX17
; 391 : }
lea rsp, QWORD PTR [rbp+216]
pop rdi
pop rbp
ret 0
?length@?$_Narrow_char_traits@DH@std@@SA_KQEBD@Z ENDP ; std::_Narrow_char_traits<char,int>::length
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\xstring
; COMDAT ?compare@?$_Narrow_char_traits@DH@std@@SAHQEBD0_K@Z
_TEXT SEGMENT
_First1$ = 224
_First2$ = 232
_Count$ = 240
?compare@?$_Narrow_char_traits@DH@std@@SAHQEBD0_K@Z PROC ; std::_Narrow_char_traits<char,int>::compare, COMDAT
; 364 : _In_reads_(_Count) const _Elem* const _First2, const size_t _Count) noexcept /* strengthened */ {
$LN3:
mov QWORD PTR [rsp+24], r8
mov QWORD PTR [rsp+16], rdx
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+264]
lea rcx, OFFSET FLAT:__85A0121E_xstring
call __CheckForDebuggerJustMyCode
; 365 : // compare [_First1, _First1 + _Count) with [_First2, ...)
; 366 : #if _HAS_CXX17
; 367 : return __builtin_memcmp(_First1, _First2, _Count);
mov r8, QWORD PTR _Count$[rbp]
mov rdx, QWORD PTR _First2$[rbp]
mov rcx, QWORD PTR _First1$[rbp]
call memcmp
; 368 : #else // _HAS_CXX17
; 369 : return _CSTD memcmp(_First1, _First2, _Count);
; 370 : #endif // _HAS_CXX17
; 371 : }
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
?compare@?$_Narrow_char_traits@DH@std@@SAHQEBD0_K@Z ENDP ; std::_Narrow_char_traits<char,int>::compare
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\xstring
; COMDAT ?move@?$_Char_traits@DH@std@@SAPEADQEADQEBD_K@Z
_TEXT SEGMENT
_First1$ = 224
_First2$ = 232
_Count$ = 240
?move@?$_Char_traits@DH@std@@SAPEADQEADQEBD_K@Z PROC ; std::_Char_traits<char,int>::move, COMDAT
; 77 : _In_reads_(_Count) const _Elem* const _First2, const size_t _Count) noexcept /* strengthened */ {
$LN3:
mov QWORD PTR [rsp+24], r8
mov QWORD PTR [rsp+16], rdx
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+264]
lea rcx, OFFSET FLAT:__85A0121E_xstring
call __CheckForDebuggerJustMyCode
; 78 : // copy [_First2, _First2 + _Count) to [_First1, ...), allowing overlap
; 79 : #if _HAS_MEMCPY_MEMMOVE_INTRINSICS
; 80 : __builtin_memmove(_First1, _First2, _Count * sizeof(_Elem));
; 81 : #else // ^^^ _HAS_MEMCPY_MEMMOVE_INTRINSICS ^^^ / vvv !_HAS_MEMCPY_MEMMOVE_INTRINSICS vvv
; 82 : #ifdef __cpp_lib_is_constant_evaluated
; 83 : if (_STD is_constant_evaluated()) {
; 84 : // dest: [_First1, _First1 + _Count)
; 85 : // src: [_First2, _First2 + _Count)
; 86 : // We need to handle overlapping ranges.
; 87 : // If _First1 is in the src range, we need a backward loop.
; 88 : // Otherwise, the forward loop works (even if the back of dest overlaps the front of src).
; 89 :
; 90 : if (_First1 == _First2) {
; 91 : return _First1; // Self-assignment; either loop would work, but returning immediately is faster.
; 92 : }
; 93 :
; 94 : // Usually, we would compare pointers with less-than, even though they could belong to different arrays.
; 95 : // However, we're not allowed to do that during constant evaluation, so we need a linear scan for equality.
; 96 : bool _Loop_forward = true;
; 97 :
; 98 : for (const _Elem* _Src = _First2; _Src != _First2 + _Count; ++_Src) {
; 99 : if (_First1 == _Src) {
; 100 : _Loop_forward = false;
; 101 : break;
; 102 : }
; 103 : }
; 104 :
; 105 : if (_Loop_forward) {
; 106 : for (size_t _Idx = 0; _Idx < _Count; ++_Idx) {
; 107 : _First1[_Idx] = _First2[_Idx];
; 108 : }
; 109 : } else {
; 110 : for (size_t _Idx = 0; _Idx < _Count; ++_Idx) {
; 111 : _First1[_Count - 1 - _Idx] = _First2[_Count - 1 - _Idx];
; 112 : }
; 113 : }
; 114 :
; 115 : return _First1;
; 116 : }
; 117 : #endif // __cpp_lib_is_constant_evaluated
; 118 :
; 119 : _CSTD memmove(_First1, _First2, _Count * sizeof(_Elem));
mov r8, QWORD PTR _Count$[rbp]
mov rdx, QWORD PTR _First2$[rbp]
mov rcx, QWORD PTR _First1$[rbp]
call memmove
; 120 : #endif // ^^^ !_HAS_MEMCPY_MEMMOVE_INTRINSICS ^^^
; 121 :
; 122 : return _First1;
mov rax, QWORD PTR _First1$[rbp]
; 123 : }
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
?move@?$_Char_traits@DH@std@@SAPEADQEADQEBD_K@Z ENDP ; std::_Char_traits<char,int>::move
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\xstring
; COMDAT ?copy@?$_Char_traits@DH@std@@SAPEADQEADQEBD_K@Z
_TEXT SEGMENT
_First1$ = 224
_First2$ = 232
_Count$ = 240
?copy@?$_Char_traits@DH@std@@SAPEADQEADQEBD_K@Z PROC ; std::_Char_traits<char,int>::copy, COMDAT
; 46 : _In_reads_(_Count) const _Elem* const _First2, const size_t _Count) noexcept /* strengthened */ {
$LN3:
mov QWORD PTR [rsp+24], r8
mov QWORD PTR [rsp+16], rdx
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+264]
lea rcx, OFFSET FLAT:__85A0121E_xstring
call __CheckForDebuggerJustMyCode
; 47 : // copy [_First2, _First2 + _Count) to [_First1, ...)
; 48 : #if _HAS_MEMCPY_MEMMOVE_INTRINSICS
; 49 : __builtin_memcpy(_First1, _First2, _Count * sizeof(_Elem));
; 50 : #else // ^^^ _HAS_MEMCPY_MEMMOVE_INTRINSICS ^^^ / vvv !_HAS_MEMCPY_MEMMOVE_INTRINSICS vvv
; 51 : #ifdef __cpp_lib_is_constant_evaluated
; 52 : if (_STD is_constant_evaluated()) {
; 53 : // pre: [_First1, _First1 + _Count) and [_First2, _First2 + _Count) do not overlap; see LWG-3085
; 54 : for (size_t _Idx = 0; _Idx < _Count; ++_Idx) {
; 55 : _First1[_Idx] = _First2[_Idx];
; 56 : }
; 57 :
; 58 : return _First1;
; 59 : }
; 60 : #endif // __cpp_lib_is_constant_evaluated
; 61 :
; 62 : _CSTD memcpy(_First1, _First2, _Count * sizeof(_Elem));
mov r8, QWORD PTR _Count$[rbp]
mov rdx, QWORD PTR _First2$[rbp]
mov rcx, QWORD PTR _First1$[rbp]
call memcpy
; 63 : #endif // ^^^ !_HAS_MEMCPY_MEMMOVE_INTRINSICS ^^^
; 64 :
; 65 : return _First1;
mov rax, QWORD PTR _First1$[rbp]
; 66 : }
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
?copy@?$_Char_traits@DH@std@@SAPEADQEADQEBD_K@Z ENDP ; std::_Char_traits<char,int>::copy
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\xmemory
; COMDAT ?allocate@?$allocator@D@std@@QEAAPEAD_K@Z
_TEXT SEGMENT
this$ = 224
_Count$ = 232
?allocate@?$allocator@D@std@@QEAAPEAD_K@Z PROC ; std::allocator<char>::allocate, COMDAT
; 813 : _NODISCARD __declspec(allocator) _Ty* allocate(_CRT_GUARDOVERFLOW const size_t _Count) {
$LN3:
mov QWORD PTR [rsp+16], rdx
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+264]
lea rcx, OFFSET FLAT:__F1739482_xmemory
call __CheckForDebuggerJustMyCode
; 814 : return static_cast<_Ty*>(_Allocate<_New_alignof<_Ty>>(_Get_size_of_n<sizeof(_Ty)>(_Count)));
mov rcx, QWORD PTR _Count$[rbp]
call ??$_Get_size_of_n@$00@std@@YA_K_K@Z ; std::_Get_size_of_n<1>
mov rcx, rax
call ??$_Allocate@$0BA@U_Default_allocate_traits@std@@$0A@@std@@YAPEAX_K@Z ; std::_Allocate<16,std::_Default_allocate_traits,0>
; 815 : }
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
?allocate@?$allocator@D@std@@QEAAPEAD_K@Z ENDP ; std::allocator<char>::allocate
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\xmemory
; COMDAT ?deallocate@?$allocator@D@std@@QEAAXQEAD_K@Z
_TEXT SEGMENT
this$ = 224
_Ptr$ = 232
_Count$ = 240
?deallocate@?$allocator@D@std@@QEAAXQEAD_K@Z PROC ; std::allocator<char>::deallocate, COMDAT
; 808 : void deallocate(_Ty* const _Ptr, const size_t _Count) {
$LN3:
mov QWORD PTR [rsp+24], r8
mov QWORD PTR [rsp+16], rdx
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+264]
lea rcx, OFFSET FLAT:__F1739482_xmemory
call __CheckForDebuggerJustMyCode
; 809 : // no overflow check on the following multiply; we assume _Allocate did that check
; 810 : _Deallocate<_New_alignof<_Ty>>(_Ptr, sizeof(_Ty) * _Count);
mov rdx, QWORD PTR _Count$[rbp]
mov rcx, QWORD PTR _Ptr$[rbp]
call ??$_Deallocate@$0BA@$0A@@std@@YAXPEAX_K@Z ; std::_Deallocate<16,0>
; 811 : }
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
?deallocate@?$allocator@D@std@@QEAAXQEAD_K@Z ENDP ; std::allocator<char>::deallocate
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\xmemory
; COMDAT ??0?$allocator@D@std@@QEAA@XZ
_TEXT SEGMENT
this$ = 224
??0?$allocator@D@std@@QEAA@XZ PROC ; std::allocator<char>::allocator<char>, COMDAT
; 802 : constexpr allocator() noexcept {}
$LN3:
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+264]
lea rcx, OFFSET FLAT:__F1739482_xmemory
call __CheckForDebuggerJustMyCode
mov rax, QWORD PTR this$[rbp]
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
??0?$allocator@D@std@@QEAA@XZ ENDP ; std::allocator<char>::allocator<char>
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\xmemory
; COMDAT ??$_Construct_in_place@U_Container_proxy@std@@PEAU_Container_base12@2@@std@@YAXAEAU_Container_proxy@0@$$QEAPEAU_Container_base12@0@@Z
_TEXT SEGMENT
$T1 = 200
tv78 = 216
_Obj$ = 256
<_Args_0>$ = 264
??$_Construct_in_place@U_Container_proxy@std@@PEAU_Container_base12@2@@std@@YAXAEAU_Container_proxy@0@$$QEAPEAU_Container_base12@0@@Z PROC ; std::_Construct_in_place<std::_Container_proxy,std::_Container_base12 *>, COMDAT
; 228 : void _Construct_in_place(_Ty& _Obj, _Types&&... _Args) noexcept(is_nothrow_constructible_v<_Ty, _Types...>) {
$LN3:
mov QWORD PTR [rsp+16], rdx
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 264 ; 00000108H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 66 ; 00000042H
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+296]
lea rcx, OFFSET FLAT:__F1739482_xmemory
call __CheckForDebuggerJustMyCode
mov rcx, QWORD PTR _Obj$[rbp]
call ??$addressof@U_Container_proxy@std@@@std@@YAPEAU_Container_proxy@0@AEAU10@@Z ; std::addressof<std::_Container_proxy>
mov rdx, rax
mov ecx, 16
call ??2@YAPEAX_KPEAX@Z ; operator new
mov QWORD PTR $T1[rbp], rax
mov rcx, QWORD PTR <_Args_0>$[rbp]
call ??$forward@PEAU_Container_base12@std@@@std@@YA$$QEAPEAU_Container_base12@0@AEAPEAU10@@Z ; std::forward<std::_Container_base12 *>
mov rax, QWORD PTR [rax]
mov QWORD PTR tv78[rbp], rax
mov rdx, QWORD PTR tv78[rbp]
mov rcx, QWORD PTR $T1[rbp]
call ??0_Container_proxy@std@@QEAA@PEAU_Container_base12@1@@Z ; std::_Container_proxy::_Container_proxy
; 229 : ::new (const_cast<void*>(static_cast<const volatile void*>(_STD addressof(_Obj))))
; 230 : _Ty(_STD forward<_Types>(_Args)...);
; 231 : }
lea rsp, QWORD PTR [rbp+232]
pop rdi
pop rbp
ret 0
??$_Construct_in_place@U_Container_proxy@std@@PEAU_Container_base12@2@@std@@YAXAEAU_Container_proxy@0@$$QEAPEAU_Container_base12@0@@Z ENDP ; std::_Construct_in_place<std::_Container_proxy,std::_Container_base12 *>
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\xmemory
; COMDAT ?_Orphan_all@_Container_base12@std@@QEAAXXZ
_TEXT SEGMENT
_Lock$4 = 4
_Pnext$5 = 40
__$ArrayPad$ = 248
this$ = 288
?_Orphan_all@_Container_base12@std@@QEAAXXZ PROC ; std::_Container_base12::_Orphan_all, COMDAT
; 1210 : inline void _Container_base12::_Orphan_all() noexcept {
$LN7:
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 296 ; 00000128H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 74 ; 0000004aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+328]
mov rax, QWORD PTR __security_cookie
xor rax, rbp
mov QWORD PTR __$ArrayPad$[rbp], rax
lea rcx, OFFSET FLAT:__F1739482_xmemory
call __CheckForDebuggerJustMyCode
; 1211 : #if _ITERATOR_DEBUG_LEVEL == 2
; 1212 : if (_Myproxy) { // proxy allocated, drain it
mov rax, QWORD PTR this$[rbp]
cmp QWORD PTR [rax], 0
je SHORT $LN5@Orphan_all
; 1213 : _Lockit _Lock(_LOCK_DEBUG);
mov edx, 3
lea rcx, QWORD PTR _Lock$4[rbp]
call QWORD PTR __imp_??0_Lockit@std@@QEAA@H@Z
; 1214 :
; 1215 : for (auto _Pnext = &_Myproxy->_Myfirstiter; *_Pnext; *_Pnext = (*_Pnext)->_Mynextiter) {
mov rax, QWORD PTR this$[rbp]
mov rax, QWORD PTR [rax]
add rax, 8
mov QWORD PTR _Pnext$5[rbp], rax
jmp SHORT $LN4@Orphan_all
$LN2@Orphan_all:
mov rax, QWORD PTR _Pnext$5[rbp]
mov rax, QWORD PTR [rax]
mov rcx, QWORD PTR _Pnext$5[rbp]
mov rax, QWORD PTR [rax+8]
mov QWORD PTR [rcx], rax
$LN4@Orphan_all:
mov rax, QWORD PTR _Pnext$5[rbp]
cmp QWORD PTR [rax], 0
je SHORT $LN3@Orphan_all
; 1216 : (*_Pnext)->_Myproxy = nullptr;
mov rax, QWORD PTR _Pnext$5[rbp]
mov rax, QWORD PTR [rax]
mov QWORD PTR [rax], 0
; 1217 : }
jmp SHORT $LN2@Orphan_all
$LN3@Orphan_all:
; 1218 :
; 1219 : _Myproxy->_Myfirstiter = nullptr;
mov rax, QWORD PTR this$[rbp]
mov rax, QWORD PTR [rax]
mov QWORD PTR [rax+8], 0
; 1220 : }
lea rcx, QWORD PTR _Lock$4[rbp]
call QWORD PTR __imp_??1_Lockit@std@@QEAA@XZ
$LN5@Orphan_all:
; 1221 : #endif // _ITERATOR_DEBUG_LEVEL == 2
; 1222 : }
lea rcx, QWORD PTR [rbp-32]
lea rdx, OFFSET FLAT:?_Orphan_all@_Container_base12@std@@QEAAXXZ$rtcFrameData
call _RTC_CheckStackVars
mov rcx, QWORD PTR __$ArrayPad$[rbp]
xor rcx, rbp
call __security_check_cookie
lea rsp, QWORD PTR [rbp+264]
pop rdi
pop rbp
ret 0
?_Orphan_all@_Container_base12@std@@QEAAXXZ ENDP ; std::_Container_base12::_Orphan_all
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\xmemory
; COMDAT ??0_Container_base12@std@@QEAA@XZ
_TEXT SEGMENT
this$ = 224
??0_Container_base12@std@@QEAA@XZ PROC ; std::_Container_base12::_Container_base12, COMDAT
; 1097 : _Container_base12() noexcept : _Myproxy(nullptr) {}
$LN3:
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+264]
lea rcx, OFFSET FLAT:__F1739482_xmemory
call __CheckForDebuggerJustMyCode
mov rax, QWORD PTR this$[rbp]
mov QWORD PTR [rax], 0
mov rax, QWORD PTR this$[rbp]
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
??0_Container_base12@std@@QEAA@XZ ENDP ; std::_Container_base12::_Container_base12
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\xmemory
; COMDAT ??0_Container_proxy@std@@QEAA@PEAU_Container_base12@1@@Z
_TEXT SEGMENT
this$ = 224
_Mycont_$ = 232
??0_Container_proxy@std@@QEAA@PEAU_Container_base12@1@@Z PROC ; std::_Container_proxy::_Container_proxy, COMDAT
; 1089 : _Container_proxy(_Container_base12* _Mycont_) noexcept : _Mycont(_Mycont_), _Myfirstiter(nullptr) {}
$LN3:
mov QWORD PTR [rsp+16], rdx
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+264]
lea rcx, OFFSET FLAT:__F1739482_xmemory
call __CheckForDebuggerJustMyCode
mov rax, QWORD PTR this$[rbp]
mov rcx, QWORD PTR _Mycont_$[rbp]
mov QWORD PTR [rax], rcx
mov rax, QWORD PTR this$[rbp]
mov QWORD PTR [rax+8], 0
mov rax, QWORD PTR this$[rbp]
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
??0_Container_proxy@std@@QEAA@PEAU_Container_base12@1@@Z ENDP ; std::_Container_proxy::_Container_proxy
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\xmemory
; COMDAT ?_Adjust_manually_vector_aligned@std@@YAXAEAPEAXAEA_K@Z
_TEXT SEGMENT
_Ptr_user$ = 8
_Ptr_container$ = 40
_Min_back_shift$ = 72
_Back_shift$ = 104
_Ptr$ = 352
_Bytes$ = 360
?_Adjust_manually_vector_aligned@std@@YAXAEAPEAXAEA_K@Z PROC ; std::_Adjust_manually_vector_aligned, COMDAT
; 132 : inline void _Adjust_manually_vector_aligned(void*& _Ptr, size_t& _Bytes) {
$LN21:
mov QWORD PTR [rsp+16], rdx
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 376 ; 00000178H
lea rbp, QWORD PTR [rsp+48]
mov rdi, rsp
mov ecx, 94 ; 0000005eH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+408]
lea rcx, OFFSET FLAT:__F1739482_xmemory
call __CheckForDebuggerJustMyCode
; 133 : // adjust parameters from _Allocate_manually_vector_aligned to pass to operator delete
; 134 : _Bytes += _Non_user_size;
mov rax, QWORD PTR _Bytes$[rbp]
mov rax, QWORD PTR [rax]
add rax, 47 ; 0000002fH
mov rcx, QWORD PTR _Bytes$[rbp]
mov QWORD PTR [rcx], rax
; 135 :
; 136 : const uintptr_t* const _Ptr_user = reinterpret_cast<uintptr_t*>(_Ptr);
mov rax, QWORD PTR _Ptr$[rbp]
mov rax, QWORD PTR [rax]
mov QWORD PTR _Ptr_user$[rbp], rax
; 137 : const uintptr_t _Ptr_container = _Ptr_user[-1];
mov eax, 8
imul rax, rax, -1
mov rcx, QWORD PTR _Ptr_user$[rbp]
mov rax, QWORD PTR [rcx+rax]
mov QWORD PTR _Ptr_container$[rbp], rax
$LN4@Adjust_man:
; 138 :
; 139 : // If the following asserts, it likely means that we are performing
; 140 : // an aligned delete on memory coming from an unaligned allocation.
; 141 : _STL_ASSERT(_Ptr_user[-2] == _Big_allocation_sentinel, "invalid argument");
mov eax, 8
imul rax, rax, -2
mov rcx, QWORD PTR _Ptr_user$[rbp]
mov rdx, -361700864190383366 ; fafafafafafafafaH
cmp QWORD PTR [rcx+rax], rdx
jne SHORT $LN14@Adjust_man
jmp SHORT $LN15@Adjust_man
$LN14@Adjust_man:
$LN7@Adjust_man:
mov eax, DWORD PTR ?__LINE__Var@?0??_Adjust_manually_vector_aligned@std@@YAXAEAPEAXAEA_K@Z@4JA
add eax, 9
lea rcx, OFFSET FLAT:??_C@_0BB@FCMFBGOM@invalid?5argument@
mov QWORD PTR [rsp+40], rcx
lea rcx, OFFSET FLAT:??_C@_02DKCKIIND@?$CFs@
mov QWORD PTR [rsp+32], rcx
xor r9d, r9d
mov r8d, eax
lea rdx, OFFSET FLAT:??_C@_0GI@CLKHGMEI@C?3?2Program?5Files?5?$CIx86?$CJ?2Microsof@
mov ecx, 2
call QWORD PTR __imp__CrtDbgReport
cmp eax, 1
jne SHORT $LN19@Adjust_man
int 3
xor eax, eax
$LN19@Adjust_man:
mov eax, DWORD PTR ?__LINE__Var@?0??_Adjust_manually_vector_aligned@std@@YAXAEAPEAXAEA_K@Z@4JA
add eax, 9
mov QWORD PTR [rsp+32], 0
mov r9d, eax
lea r8, OFFSET FLAT:??_C@_1NA@PDNNFCLD@?$AAC?$AA?3?$AA?2?$AAP?$AAr?$AAo?$AAg?$AAr?$AAa?$AAm?$AA?5?$AAF?$AAi?$AAl?$AAe@
lea rdx, OFFSET FLAT:??_C@_1EK@NIFDJFDG@?$AAs?$AAt?$AAd?$AA?3?$AA?3?$AA_?$AAA?$AAd?$AAj?$AAu?$AAs?$AAt?$AA_?$AAm?$AAa@
lea rcx, OFFSET FLAT:??_C@_1CG@JNLFBNGN@?$AA?$CC?$AAi?$AAn?$AAv?$AAa?$AAl?$AAi?$AAd?$AA?5?$AAa?$AAr?$AAg?$AAu?$AAm?$AAe@
call QWORD PTR __imp__invalid_parameter
xor eax, eax
test eax, eax
jne SHORT $LN7@Adjust_man
$LN15@Adjust_man:
xor eax, eax
test eax, eax
jne $LN4@Adjust_man
; 142 :
; 143 : // Extra paranoia on aligned allocation/deallocation; ensure _Ptr_container is
; 144 : // in range [_Min_back_shift, _Non_user_size]
; 145 : #ifdef _DEBUG
; 146 : constexpr uintptr_t _Min_back_shift = 2 * sizeof(void*);
mov QWORD PTR _Min_back_shift$[rbp], 16
; 147 : #else // ^^^ _DEBUG ^^^ // vvv !_DEBUG vvv
; 148 : constexpr uintptr_t _Min_back_shift = sizeof(void*);
; 149 : #endif // _DEBUG
; 150 : const uintptr_t _Back_shift = reinterpret_cast<uintptr_t>(_Ptr) - _Ptr_container;
mov rax, QWORD PTR _Ptr$[rbp]
mov rcx, QWORD PTR _Ptr_container$[rbp]
mov rax, QWORD PTR [rax]
sub rax, rcx
mov QWORD PTR _Back_shift$[rbp], rax
$LN10@Adjust_man:
; 151 : _STL_VERIFY(_Back_shift >= _Min_back_shift && _Back_shift <= _Non_user_size, "invalid argument");
cmp QWORD PTR _Back_shift$[rbp], 16
jb SHORT $LN16@Adjust_man
cmp QWORD PTR _Back_shift$[rbp], 47 ; 0000002fH
ja SHORT $LN16@Adjust_man
jmp SHORT $LN17@Adjust_man
$LN16@Adjust_man:
$LN13@Adjust_man:
mov eax, DWORD PTR ?__LINE__Var@?0??_Adjust_manually_vector_aligned@std@@YAXAEAPEAXAEA_K@Z@4JA
add eax, 19
lea rcx, OFFSET FLAT:??_C@_0BB@FCMFBGOM@invalid?5argument@
mov QWORD PTR [rsp+40], rcx
lea rcx, OFFSET FLAT:??_C@_02DKCKIIND@?$CFs@
mov QWORD PTR [rsp+32], rcx
xor r9d, r9d
mov r8d, eax
lea rdx, OFFSET FLAT:??_C@_0GI@CLKHGMEI@C?3?2Program?5Files?5?$CIx86?$CJ?2Microsof@
mov ecx, 2
call QWORD PTR __imp__CrtDbgReport
cmp eax, 1
jne SHORT $LN20@Adjust_man
int 3
xor eax, eax
$LN20@Adjust_man:
mov eax, DWORD PTR ?__LINE__Var@?0??_Adjust_manually_vector_aligned@std@@YAXAEAPEAXAEA_K@Z@4JA
add eax, 19
mov QWORD PTR [rsp+32], 0
mov r9d, eax
lea r8, OFFSET FLAT:??_C@_1NA@PDNNFCLD@?$AAC?$AA?3?$AA?2?$AAP?$AAr?$AAo?$AAg?$AAr?$AAa?$AAm?$AA?5?$AAF?$AAi?$AAl?$AAe@
lea rdx, OFFSET FLAT:??_C@_1EK@NIFDJFDG@?$AAs?$AAt?$AAd?$AA?3?$AA?3?$AA_?$AAA?$AAd?$AAj?$AAu?$AAs?$AAt?$AA_?$AAm?$AAa@
lea rcx, OFFSET FLAT:??_C@_1CG@JNLFBNGN@?$AA?$CC?$AAi?$AAn?$AAv?$AAa?$AAl?$AAi?$AAd?$AA?5?$AAa?$AAr?$AAg?$AAu?$AAm?$AAe@
call QWORD PTR __imp__invalid_parameter
xor eax, eax
test eax, eax
jne SHORT $LN13@Adjust_man
$LN17@Adjust_man:
xor eax, eax
test eax, eax
jne $LN10@Adjust_man
; 152 : _Ptr = reinterpret_cast<void*>(_Ptr_container);
mov rax, QWORD PTR _Ptr$[rbp]
mov rcx, QWORD PTR _Ptr_container$[rbp]
mov QWORD PTR [rax], rcx
; 153 : }
lea rsp, QWORD PTR [rbp+328]
pop rdi
pop rbp
ret 0
?_Adjust_manually_vector_aligned@std@@YAXAEAPEAXAEA_K@Z ENDP ; std::_Adjust_manually_vector_aligned
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\xmemory
; COMDAT ?_Allocate@_Default_allocate_traits@std@@SAPEAX_K@Z
_TEXT SEGMENT
_Bytes$ = 224
?_Allocate@_Default_allocate_traits@std@@SAPEAX_K@Z PROC ; std::_Default_allocate_traits::_Allocate, COMDAT
; 76 : __declspec(allocator) static void* _Allocate(const size_t _Bytes) {
$LN3:
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+264]
lea rcx, OFFSET FLAT:__F1739482_xmemory
call __CheckForDebuggerJustMyCode
; 77 : return ::operator new(_Bytes);
mov rcx, QWORD PTR _Bytes$[rbp]
call ??2@YAPEAX_K@Z ; operator new
; 78 : }
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
?_Allocate@_Default_allocate_traits@std@@SAPEAX_K@Z ENDP ; std::_Default_allocate_traits::_Allocate
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\exception
; COMDAT ?_Throw_bad_array_new_length@std@@YAXXZ
_TEXT SEGMENT
$T1 = 200
?_Throw_bad_array_new_length@std@@YAXXZ PROC ; std::_Throw_bad_array_new_length, COMDAT
; 320 : [[noreturn]] inline void _Throw_bad_array_new_length() {
$LN3:
push rbp
push rdi
sub rsp, 280 ; 00000118H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 70 ; 00000046H
mov eax, -858993460 ; ccccccccH
rep stosd
lea rcx, OFFSET FLAT:__8B12B611_exception
call __CheckForDebuggerJustMyCode
; 321 : _THROW(bad_array_new_length{});
lea rcx, QWORD PTR $T1[rbp]
call ??0bad_array_new_length@std@@QEAA@XZ ; std::bad_array_new_length::bad_array_new_length
lea rdx, OFFSET FLAT:_TI3?AVbad_array_new_length@std@@
lea rcx, QWORD PTR $T1[rbp]
call _CxxThrowException
$LN2@Throw_bad_:
; 322 : }
lea rsp, QWORD PTR [rbp+248]
pop rdi
pop rbp
ret 0
?_Throw_bad_array_new_length@std@@YAXXZ ENDP ; std::_Throw_bad_array_new_length
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; COMDAT ??_Gbad_array_new_length@std@@UEAAPEAXI@Z
_TEXT SEGMENT
this$ = 224
__flags$ = 232
??_Gbad_array_new_length@std@@UEAAPEAXI@Z PROC ; std::bad_array_new_length::`scalar deleting destructor', COMDAT
$LN4:
mov DWORD PTR [rsp+16], edx
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+264]
mov rcx, QWORD PTR this$[rbp]
call ??1bad_array_new_length@std@@UEAA@XZ
mov eax, DWORD PTR __flags$[rbp]
and eax, 1
test eax, eax
je SHORT $LN2@scalar
mov edx, 24
mov rcx, QWORD PTR this$[rbp]
call ??3@YAXPEAX_K@Z ; operator delete
$LN2@scalar:
mov rax, QWORD PTR this$[rbp]
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
??_Gbad_array_new_length@std@@UEAAPEAXI@Z ENDP ; std::bad_array_new_length::`scalar deleting destructor'
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; COMDAT ??0bad_array_new_length@std@@QEAA@AEBV01@@Z
_TEXT SEGMENT
this$ = 224
__that$ = 232
??0bad_array_new_length@std@@QEAA@AEBV01@@Z PROC ; std::bad_array_new_length::bad_array_new_length, COMDAT
$LN3:
mov QWORD PTR [rsp+16], rdx
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+264]
mov rdx, QWORD PTR __that$[rbp]
mov rcx, QWORD PTR this$[rbp]
call ??0bad_alloc@std@@QEAA@AEBV01@@Z
mov rax, QWORD PTR this$[rbp]
lea rcx, OFFSET FLAT:??_7bad_array_new_length@std@@6B@
mov QWORD PTR [rax], rcx
mov rax, QWORD PTR this$[rbp]
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
??0bad_array_new_length@std@@QEAA@AEBV01@@Z ENDP ; std::bad_array_new_length::bad_array_new_length
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; COMDAT ??1bad_array_new_length@std@@UEAA@XZ
_TEXT SEGMENT
this$ = 224
??1bad_array_new_length@std@@UEAA@XZ PROC ; std::bad_array_new_length::~bad_array_new_length, COMDAT
$LN3:
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+264]
mov rcx, QWORD PTR this$[rbp]
call ??1bad_alloc@std@@UEAA@XZ
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
??1bad_array_new_length@std@@UEAA@XZ ENDP ; std::bad_array_new_length::~bad_array_new_length
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\vcruntime_exception.h
; COMDAT ??0bad_array_new_length@std@@QEAA@XZ
_TEXT SEGMENT
this$ = 224
??0bad_array_new_length@std@@QEAA@XZ PROC ; std::bad_array_new_length::bad_array_new_length, COMDAT
; 141 : {
$LN3:
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+264]
lea rcx, OFFSET FLAT:__49CBC5C5_vcruntime_exception@h
call __CheckForDebuggerJustMyCode
; 140 : : bad_alloc("bad array new length")
lea rdx, OFFSET FLAT:??_C@_0BF@KINCDENJ@bad?5array?5new?5length@
mov rcx, QWORD PTR this$[rbp]
call ??0bad_alloc@std@@AEAA@QEBD@Z ; std::bad_alloc::bad_alloc
; 141 : {
mov rax, QWORD PTR this$[rbp]
lea rcx, OFFSET FLAT:??_7bad_array_new_length@std@@6B@
mov QWORD PTR [rax], rcx
; 142 : }
mov rax, QWORD PTR this$[rbp]
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
??0bad_array_new_length@std@@QEAA@XZ ENDP ; std::bad_array_new_length::bad_array_new_length
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; COMDAT ??_Gbad_alloc@std@@UEAAPEAXI@Z
_TEXT SEGMENT
this$ = 224
__flags$ = 232
??_Gbad_alloc@std@@UEAAPEAXI@Z PROC ; std::bad_alloc::`scalar deleting destructor', COMDAT
$LN4:
mov DWORD PTR [rsp+16], edx
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+264]
mov rcx, QWORD PTR this$[rbp]
call ??1bad_alloc@std@@UEAA@XZ
mov eax, DWORD PTR __flags$[rbp]
and eax, 1
test eax, eax
je SHORT $LN2@scalar
mov edx, 24
mov rcx, QWORD PTR this$[rbp]
call ??3@YAXPEAX_K@Z ; operator delete
$LN2@scalar:
mov rax, QWORD PTR this$[rbp]
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
??_Gbad_alloc@std@@UEAAPEAXI@Z ENDP ; std::bad_alloc::`scalar deleting destructor'
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; COMDAT ??0bad_alloc@std@@QEAA@AEBV01@@Z
_TEXT SEGMENT
this$ = 224
__that$ = 232
??0bad_alloc@std@@QEAA@AEBV01@@Z PROC ; std::bad_alloc::bad_alloc, COMDAT
$LN3:
mov QWORD PTR [rsp+16], rdx
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+264]
mov rdx, QWORD PTR __that$[rbp]
mov rcx, QWORD PTR this$[rbp]
call ??0exception@std@@QEAA@AEBV01@@Z ; std::exception::exception
mov rax, QWORD PTR this$[rbp]
lea rcx, OFFSET FLAT:??_7bad_alloc@std@@6B@
mov QWORD PTR [rax], rcx
mov rax, QWORD PTR this$[rbp]
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
??0bad_alloc@std@@QEAA@AEBV01@@Z ENDP ; std::bad_alloc::bad_alloc
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; COMDAT ??1bad_alloc@std@@UEAA@XZ
_TEXT SEGMENT
this$ = 224
??1bad_alloc@std@@UEAA@XZ PROC ; std::bad_alloc::~bad_alloc, COMDAT
$LN3:
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+264]
mov rcx, QWORD PTR this$[rbp]
call ??1exception@std@@UEAA@XZ ; std::exception::~exception
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
??1bad_alloc@std@@UEAA@XZ ENDP ; std::bad_alloc::~bad_alloc
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\vcruntime_exception.h
; COMDAT ??0bad_alloc@std@@AEAA@QEBD@Z
_TEXT SEGMENT
this$ = 224
_Message$ = 232
??0bad_alloc@std@@AEAA@QEBD@Z PROC ; std::bad_alloc::bad_alloc, COMDAT
; 130 : {
$LN3:
mov QWORD PTR [rsp+16], rdx
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+264]
lea rcx, OFFSET FLAT:__49CBC5C5_vcruntime_exception@h
call __CheckForDebuggerJustMyCode
; 129 : : exception(_Message, 1)
mov r8d, 1
mov rdx, QWORD PTR _Message$[rbp]
mov rcx, QWORD PTR this$[rbp]
call ??0exception@std@@QEAA@QEBDH@Z ; std::exception::exception
; 130 : {
mov rax, QWORD PTR this$[rbp]
lea rcx, OFFSET FLAT:??_7bad_alloc@std@@6B@
mov QWORD PTR [rax], rcx
; 131 : }
mov rax, QWORD PTR this$[rbp]
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
??0bad_alloc@std@@AEAA@QEBD@Z ENDP ; std::bad_alloc::bad_alloc
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; COMDAT ??_Gexception@std@@UEAAPEAXI@Z
_TEXT SEGMENT
this$ = 224
__flags$ = 232
??_Gexception@std@@UEAAPEAXI@Z PROC ; std::exception::`scalar deleting destructor', COMDAT
$LN4:
mov DWORD PTR [rsp+16], edx
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+264]
mov rcx, QWORD PTR this$[rbp]
call ??1exception@std@@UEAA@XZ ; std::exception::~exception
mov eax, DWORD PTR __flags$[rbp]
and eax, 1
test eax, eax
je SHORT $LN2@scalar
mov edx, 24
mov rcx, QWORD PTR this$[rbp]
call ??3@YAXPEAX_K@Z ; operator delete
$LN2@scalar:
mov rax, QWORD PTR this$[rbp]
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
??_Gexception@std@@UEAAPEAXI@Z ENDP ; std::exception::`scalar deleting destructor'
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\vcruntime_exception.h
; COMDAT ?what@exception@std@@UEBAPEBDXZ
_TEXT SEGMENT
tv69 = 192
this$ = 240
?what@exception@std@@UEBAPEBDXZ PROC ; std::exception::what, COMDAT
; 94 : {
$LN5:
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 248 ; 000000f8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 62 ; 0000003eH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+280]
lea rcx, OFFSET FLAT:__49CBC5C5_vcruntime_exception@h
call __CheckForDebuggerJustMyCode
; 95 : return _Data._What ? _Data._What : "Unknown exception";
mov rax, QWORD PTR this$[rbp]
cmp QWORD PTR [rax+8], 0
je SHORT $LN3@what
mov rax, QWORD PTR this$[rbp]
mov rax, QWORD PTR [rax+8]
mov QWORD PTR tv69[rbp], rax
jmp SHORT $LN4@what
$LN3@what:
lea rax, OFFSET FLAT:??_C@_0BC@EOODALEL@Unknown?5exception@
mov QWORD PTR tv69[rbp], rax
$LN4@what:
mov rax, QWORD PTR tv69[rbp]
; 96 : }
lea rsp, QWORD PTR [rbp+216]
pop rdi
pop rbp
ret 0
?what@exception@std@@UEBAPEBDXZ ENDP ; std::exception::what
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\vcruntime_exception.h
; COMDAT ??1exception@std@@UEAA@XZ
_TEXT SEGMENT
this$ = 224
??1exception@std@@UEAA@XZ PROC ; std::exception::~exception, COMDAT
; 89 : {
$LN3:
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+264]
lea rcx, OFFSET FLAT:__49CBC5C5_vcruntime_exception@h
call __CheckForDebuggerJustMyCode
mov rax, QWORD PTR this$[rbp]
lea rcx, OFFSET FLAT:??_7exception@std@@6B@
mov QWORD PTR [rax], rcx
; 90 : __std_exception_destroy(&_Data);
mov rax, QWORD PTR this$[rbp]
add rax, 8
mov rcx, rax
call __std_exception_destroy
; 91 : }
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
??1exception@std@@UEAA@XZ ENDP ; std::exception::~exception
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\vcruntime_exception.h
; COMDAT ??0exception@std@@QEAA@AEBV01@@Z
_TEXT SEGMENT
this$ = 224
_Other$ = 232
??0exception@std@@QEAA@AEBV01@@Z PROC ; std::exception::exception, COMDAT
; 72 : {
$LN3:
mov QWORD PTR [rsp+16], rdx
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+264]
lea rcx, OFFSET FLAT:__49CBC5C5_vcruntime_exception@h
call __CheckForDebuggerJustMyCode
mov rax, QWORD PTR this$[rbp]
lea rcx, OFFSET FLAT:??_7exception@std@@6B@
mov QWORD PTR [rax], rcx
; 71 : : _Data()
mov rax, QWORD PTR this$[rbp]
add rax, 8
mov rdi, rax
xor eax, eax
mov ecx, 16
rep stosb
; 73 : __std_exception_copy(&_Other._Data, &_Data);
mov rax, QWORD PTR this$[rbp]
add rax, 8
mov rcx, QWORD PTR _Other$[rbp]
add rcx, 8
mov rdx, rax
call __std_exception_copy
; 74 : }
mov rax, QWORD PTR this$[rbp]
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
??0exception@std@@QEAA@AEBV01@@Z ENDP ; std::exception::exception
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\vcruntime_exception.h
; COMDAT ??0exception@std@@QEAA@QEBDH@Z
_TEXT SEGMENT
this$ = 224
_Message$ = 232
__formal$ = 240
??0exception@std@@QEAA@QEBDH@Z PROC ; std::exception::exception, COMDAT
; 66 : {
$LN3:
mov DWORD PTR [rsp+24], r8d
mov QWORD PTR [rsp+16], rdx
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+264]
lea rcx, OFFSET FLAT:__49CBC5C5_vcruntime_exception@h
call __CheckForDebuggerJustMyCode
mov rax, QWORD PTR this$[rbp]
lea rcx, OFFSET FLAT:??_7exception@std@@6B@
mov QWORD PTR [rax], rcx
; 65 : : _Data()
mov rax, QWORD PTR this$[rbp]
add rax, 8
mov rdi, rax
xor eax, eax
mov ecx, 16
rep stosb
; 67 : _Data._What = _Message;
mov rax, QWORD PTR this$[rbp]
mov rcx, QWORD PTR _Message$[rbp]
mov QWORD PTR [rax+8], rcx
; 68 : }
mov rax, QWORD PTR this$[rbp]
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
??0exception@std@@QEAA@QEBDH@Z ENDP ; std::exception::exception
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\limits
; COMDAT ?max@?$numeric_limits@_J@std@@SA_JXZ
_TEXT SEGMENT
?max@?$numeric_limits@_J@std@@SA_JXZ PROC ; std::numeric_limits<__int64>::max, COMDAT
; 647 : _NODISCARD static constexpr long long(max)() noexcept {
$LN3:
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
lea rcx, OFFSET FLAT:__D63D5DDA_limits
call __CheckForDebuggerJustMyCode
; 648 : return LLONG_MAX;
mov rax, 9223372036854775807 ; 7fffffffffffffffH
; 649 : }
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
?max@?$numeric_limits@_J@std@@SA_JXZ ENDP ; std::numeric_limits<__int64>::max
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Windows Kits\10\Include\10.0.18362.0\ucrt\wchar.h
; COMDAT wmemcpy
_TEXT SEGMENT
_S1$ = 224
_S2$ = 232
_N$ = 240
wmemcpy PROC ; COMDAT
; 230 : {
$LN3:
mov QWORD PTR [rsp+24], r8
mov QWORD PTR [rsp+16], rdx
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+264]
lea rcx, OFFSET FLAT:__534C724A_wchar@h
call __CheckForDebuggerJustMyCode
; 231 : #pragma warning(push)
; 232 : #pragma warning(disable : 4995 4996 6386)
; 233 : return (wchar_t*)memcpy(_S1, _S2, _N*sizeof(wchar_t));
mov rax, QWORD PTR _N$[rbp]
shl rax, 1
mov r8, rax
mov rdx, QWORD PTR _S2$[rbp]
mov rcx, QWORD PTR _S1$[rbp]
call memcpy
; 234 : #pragma warning(pop)
; 235 : }
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
wmemcpy ENDP
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29333\include\vcruntime_new.h
; COMDAT ??2@YAPEAX_KPEAX@Z
_TEXT SEGMENT
_Size$ = 224
_Where$ = 232
??2@YAPEAX_KPEAX@Z PROC ; operator new, COMDAT
; 167 : {
$LN3:
mov QWORD PTR [rsp+16], rdx
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+264]
lea rcx, OFFSET FLAT:__2B31710D_vcruntime_new@h
call __CheckForDebuggerJustMyCode
; 168 : (void)_Size;
; 169 : return _Where;
mov rax, QWORD PTR _Where$[rbp]
; 170 : }
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
??2@YAPEAX_KPEAX@Z ENDP ; operator new
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Users\danhp\Documents\GitHub\CPSC-462-GROUP-2\C++ Development Root\SourceCode\TechnicalServices\External\PaymentHandler.cpp
; COMDAT ?__empty_global_delete@@YAXPEAX_KW4align_val_t@std@@@Z
_TEXT SEGMENT
__formal$ = 224
__formal$ = 232
__formal$ = 240
?__empty_global_delete@@YAXPEAX_KW4align_val_t@std@@@Z PROC ; __empty_global_delete, COMDAT
$LN3:
mov QWORD PTR [rsp+24], r8
mov QWORD PTR [rsp+16], rdx
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+264]
lea rcx, OFFSET FLAT:__3559405B_PaymentHandler@cpp
call __CheckForDebuggerJustMyCode
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
?__empty_global_delete@@YAXPEAX_KW4align_val_t@std@@@Z ENDP ; __empty_global_delete
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Users\danhp\Documents\GitHub\CPSC-462-GROUP-2\C++ Development Root\SourceCode\TechnicalServices\External\PaymentHandler.cpp
; COMDAT ?__empty_global_delete@@YAXPEAXW4align_val_t@std@@@Z
_TEXT SEGMENT
__formal$ = 224
__formal$ = 232
?__empty_global_delete@@YAXPEAXW4align_val_t@std@@@Z PROC ; __empty_global_delete, COMDAT
$LN3:
mov QWORD PTR [rsp+16], rdx
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+264]
lea rcx, OFFSET FLAT:__3559405B_PaymentHandler@cpp
call __CheckForDebuggerJustMyCode
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
?__empty_global_delete@@YAXPEAXW4align_val_t@std@@@Z ENDP ; __empty_global_delete
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Users\danhp\Documents\GitHub\CPSC-462-GROUP-2\C++ Development Root\SourceCode\TechnicalServices\External\PaymentHandler.cpp
; COMDAT ?__empty_global_delete@@YAXPEAX_K@Z
_TEXT SEGMENT
__formal$ = 224
__formal$ = 232
?__empty_global_delete@@YAXPEAX_K@Z PROC ; __empty_global_delete, COMDAT
$LN3:
mov QWORD PTR [rsp+16], rdx
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+264]
lea rcx, OFFSET FLAT:__3559405B_PaymentHandler@cpp
call __CheckForDebuggerJustMyCode
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
?__empty_global_delete@@YAXPEAX_K@Z ENDP ; __empty_global_delete
_TEXT ENDS
; Function compile flags: /Odtp /RTCsu /ZI
; File C:\Users\danhp\Documents\GitHub\CPSC-462-GROUP-2\C++ Development Root\SourceCode\TechnicalServices\External\PaymentHandler.cpp
; COMDAT ?__empty_global_delete@@YAXPEAX@Z
_TEXT SEGMENT
__formal$ = 224
?__empty_global_delete@@YAXPEAX@Z PROC ; __empty_global_delete, COMDAT
$LN3:
mov QWORD PTR [rsp+8], rcx
push rbp
push rdi
sub rsp, 232 ; 000000e8H
lea rbp, QWORD PTR [rsp+32]
mov rdi, rsp
mov ecx, 58 ; 0000003aH
mov eax, -858993460 ; ccccccccH
rep stosd
mov rcx, QWORD PTR [rsp+264]
lea rcx, OFFSET FLAT:__3559405B_PaymentHandler@cpp
call __CheckForDebuggerJustMyCode
lea rsp, QWORD PTR [rbp+200]
pop rdi
pop rbp
ret 0
?__empty_global_delete@@YAXPEAX@Z ENDP ; __empty_global_delete
_TEXT ENDS
END
|
; A152898: Periodic sequence [1,4,0,0,0] of period 5
; 1,4,0,0,0,1,4,0,0,0,1,4,0,0,0,1,4,0,0,0,1,4,0,0,0,1,4,0,0,0,1,4,0,0,0,1,4,0,0,0,1,4,0,0,0,1,4,0,0,0,1,4,0,0,0,1,4,0,0,0,1,4,0,0,0,1,4,0,0,0,1,4,0,0,0,1,4,0,0,0,1,4,0,0,0,1,4,0,0,0,1,4,0,0,0,1,4,0,0,0,1,4,0,0,0
add $0,3
bin $0,3
mod $0,5
mov $1,$0
|
//***************************************************************************
//* Copyright (c) 2015 Saint Petersburg State University
//* Copyright (c) 2011-2014 Saint Petersburg Academic University
//* All Rights Reserved
//* See file LICENSE for details.
//***************************************************************************
#pragma once
#include "pipeline/stage.hpp"
namespace debruijn_graph {
class DistanceEstimation : public spades::AssemblyStage {
public:
DistanceEstimation(bool preliminary = false)
: AssemblyStage(preliminary ? "Preliminary Distance Estimation" : "Distance Estimation",
preliminary ? "distance_estimation_preliminary" : "distance_estimation") {}
void run(GraphPack &gp, const char*) override;
};
}
|
; A027765: a(n) = (n+1)*binomial(n+1,5).
; 5,36,147,448,1134,2520,5082,9504,16731,28028,45045,69888,105196,154224,220932,310080,427329,579348,773927,1020096,1328250,1710280,2179710,2751840,3443895,4275180,5267241,6444032,7832088,9460704,11362120,13571712,16128189,19073796,22454523,26320320,30725318,35728056,41391714,47784352,54979155,63054684,72095133,82190592,93437316,105938000,119802060,135145920,152093305,170775540,191331855,213909696,238665042,265762728,295376774,327690720,362897967,401202124,442817361,487968768,536892720,589837248,647062416,708840704,775457397,847210980,924413539,1007391168,1096484382,1192048536,1294454250,1404087840,1521351755,1646665020,1780463685,1923201280,2075349276,2237397552,2409854868,2593249344,2788128945,2995061972,3214637559,3447466176,3694180138,3955434120,4231905678,4524295776,4833329319,5159755692,5504349305,5867910144,6251264328,6655264672,7080791256,7528752000,8000083245,8495750340,9016748235,9564102080
mov $1,$0
add $0,5
bin $0,$1
add $1,5
mul $0,$1
|
; A269019: a(n) = 2^n + 2*(-1)^n - 1.
; 2,-1,5,5,17,29,65,125,257,509,1025,2045,4097,8189,16385,32765,65537,131069,262145,524285,1048577,2097149,4194305,8388605,16777217,33554429,67108865,134217725,268435457,536870909,1073741825,2147483645,4294967297,8589934589
mov $2,2
mov $3,8
lpb $0,1
sub $0,1
add $2,3
mul $2,2
mul $3,-1
lpe
mov $1,$2
mul $3,2
add $1,$3
sub $1,18
div $1,24
mul $1,3
add $1,2
|
;********************************************************************************************************
; uC/OS-III
; The Real-Time Kernel
;
; Copyright 2009-2021 Silicon Laboratories Inc. www.silabs.com
;
; SPDX-License-Identifier: APACHE-2.0
;
; This software is subject to an open source license and is distributed by
; Silicon Laboratories Inc. pursuant to the terms of the Apache License,
; Version 2.0 available at www.apache.org/licenses/LICENSE-2.0.
;
;********************************************************************************************************
;********************************************************************************************************
;
; NEC 78K0R Specific code
; IAR C/C++ Compiler for NEC 78K0R 4.60A
;
; File : os_cpu_a.asm
; Version : V3.08.01
;********************************************************************************************************
;********************************************************************************************************
; PUBLIC AND EXTERNAL DECLARATIONS
;********************************************************************************************************
PUBLIC OSStartHighRdy
PUBLIC OSCtxSw
PUBLIC OSIntCtxSw
PUBLIC OSTickISR
EXTERN OSTaskSwHook
EXTERN OSTCBHighRdyPtr
EXTERN OSTCBCurPtr
EXTERN OSPrioCur
EXTERN OSPrioHighRdy
EXTERN OSIntEnter
EXTERN OSTimeTick
EXTERN OSIntExit
EXTERN OSIntNestingCtr
EXTERN Tmr_TickISR_Handler ; implement function to clear the OS tick source
;********************************************************************************************************
; MACRO DEFINITIONS
;********************************************************************************************************
PUSHALL MACRO
PUSH RP0
PUSH RP1
PUSH RP2
PUSH RP3
ENDM
POPALL MACRO
POP RP3
POP RP2
POP RP1
POP RP0
ENDM
ASEGN RCODE:CODE, 0x002C
DW OSTickISR ; Time tick vector
ASEGN RCODE:CODE, 0x007E
DW OSCtxSw ; Context Switch vector
RSEG CODE ; Program code
;********************************************************************************************************
; START HIGHEST PRIORITY READY TASK
;
; Description: This function is called by OSStart() to start the highest priority task that is ready to run.
;
; Note : OSStartHighRdy() MUST:
; a) Call OSTaskSwHook() then,
; b) Set OSRunning to TRUE,
; c) Switch to the highest priority task.
;********************************************************************************************************
OSStartHighRdy:
CALL OSTaskSwHook ; call OSTaskSwHook()
MOVW RP1, OSTCBHighRdyPtr ; address of OSTCBHighRdyPtr in RP1
MOVW RP0, 0x0000[RP1] ; RP0 = OSTCBHighRdyPtr->OSTCBStkPtr
MOVW SP, RP0 ; stack pointer = RP0
POPALL ; restore all processor registers from new task's stack
RETI ; return from interrupt
;********************************************************************************************************
; TASK LEVEL CONTEXT SWITCH
;
; Description: This function is called by OS_Sched() to perform a task level context switch.
;
; Note : OSCtxSw() MUST:
; a) Save the current task's registers onto the current task stack
; b) Save the SP into the current task's OS_TCB
; c) Call OSTaskSwHook()
; d) Copy OSPrioHighRdy to OSPrioCur
; e) Copy OSTCBHighRdyPtr to OSTCBCurPtr
; f) Load the SP with OSTCBHighRdyPtr->OSTCBStkPtr
; g) Restore all the registers from the high priority task stack
; h) Perform a return from interrupt
;********************************************************************************************************
OSCtxSw:
PUSHALL ; save processor registers on the stack
; save current task's stack pointer into current task's OS_TCB
MOVW RP2, OSTCBCurPtr ; OSTCBCurPtr in RP2
MOVW RP0, SP
MOVW [RP2], RP0 ; OSTCBCurPtr->OSTCBStkPtr = SP
CALL OSTaskSwHook ; call OSTaskSwHook
MOVW RP0, OSTCBHighRdyPtr ; get address of OSTCBHighRdyPtr
MOVW OSTCBCurPtr, RP0 ; OSTCBCurPtr = OSTCBHighRdyPtr
MOV R1, OSPrioHighRdy
MOV OSPrioCur, R1 ; OSPrioCur = OSPrioHighRdy
MOVW RP1, OSTCBHighRdyPtr ; get address of OSTCBHighRdyPtr
MOVW RP0, 0x0000[RP1] ; RP0 = OSTCBHighRdyPtr->OSTCBStkPtr
MOVW SP, RP0 ; stack pointer = RP0
POPALL ; restore all processor registers from new task's stack
RETI ; return from interrupt
;********************************************************************************************************
; ISR LEVEL CONTEXT SWITCH
;
; Description: This function is called by OSIntExit() to perform an ISR level context switch.
;
; Note : OSIntCtxSw() MUST:
; a) Call OSTaskSwHook()
; b) Copy OSPrioHighRdy to OSPrioCur
; c) Copy OSTCBHighRdyPtr to OSTCBCurPtr
; d) Load the SP with OSTCBHighRdyPtr->OSTCBStkPtr
; e) Restore all the registers from the high priority task stack
; f) Perform a return from interrupt
;********************************************************************************************************
OSIntCtxSw:
CALL OSTaskSwHook ; call OSTaskSwHook
MOVW RP0, OSTCBHighRdyPtr ; get address of OSTCBHighRdyPtr
MOVW OSTCBCurPtr, RP0 ; OSTCBCurPtr = OSTCBHighRdyPtr
MOV R1, OSPrioHighRdy
MOV OSPrioCur, R1 ; OSPrioCur = OSPrioHighRdy
MOVW RP1, OSTCBHighRdyPtr ; get address of OSTCBHighRdyPtr
MOVW RP0, 0x0000[RP1] ; RP0 = OSTCBHighRdyPtr->OSTCBStkPtr
MOVW SP, RP0 ; stack pointer = RP0
POPALL ; restore all processor registers from new task's stack
RETI ; return from interrupt
;********************************************************************************************************
; OSTickISR()
;********************************************************************************************************
OSTickISR:
PUSHALL ; Save processor registers on the stack
INC OSIntNestingCtr ; increment OSIntNestingCtr
CMP OSIntNestingCtr, #1 ; if OSIntNestingCtr != 1
BNZ OSTickISR1 ; jump to OSTickISR1
; else
MOVW RP2, OSTCBCurPtr ; OSTCBCurPtr in RP2
MOVW RP0, SP
MOVW [RP2], RP0 ; OSTCBCurPtr->OSTCBStkPtr = SP
OSTickISR1:
CALL Tmr_TickISR_Handler ; clear timer interrupt source
CALL OSTimeTick ; call OSTimeTick()
CALL OSIntExit ; call OSIntExit()
POPALL ; restore all processor registers from stack
RETI ; return from interrupt
END
|
; Test case:
macro mymacro n
if (n<=4)
[n] RRCA
else
[8-n] RLCA
endif
endmacro
mymacro 5
loop:
jp loop
|
; Copyright 1995-2011 Mersenne Research, Inc. All rights reserved
; Author: George Woltman
; Email: woltman@alum.mit.edu
;
TITLE setup
.686
.MODEL FLAT
INCLUDE unravel.mac
INCLUDE extrn.mac
INCLUDE mult.mac
INCLUDE memory.mac
INCLUDE normal.mac
_TEXT SEGMENT
flat_distances
;;
;; Add two numbers without carry propagation. Caller can use this for
;; consecutive add or subtract operations. However, the last operation
;; before a multiply must use the routine that will normalize data.
;;
PROCFL gwaddq1
ad_prolog 0,0,rsi,rdi
mov ecx, SRCARG ; Address of first number
mov edx, SRC2ARG ; Address of second number
mov esi, DESTARG ; Address of destination
mov edi, FFTLEN ; Load loop counter
uaddlp: fld QWORD PTR [ecx][edi*8-32] ; Load first number
fadd QWORD PTR [edx][edi*8-32] ; Add in second number
fld QWORD PTR [ecx][edi*8-24] ; Load first number
fadd QWORD PTR [edx][edi*8-24] ; Add in second number
fld QWORD PTR [ecx][edi*8-16] ; Load first number
fadd QWORD PTR [edx][edi*8-16] ; Add in second number
fxch st(1)
fld QWORD PTR [ecx][edi*8-8] ; Load first number
fadd QWORD PTR [edx][edi*8-8] ; Add in second number
fxch st(3)
fstp QWORD PTR [esi][edi*8-32] ; Save result
fstp QWORD PTR [esi][edi*8-24] ; Save result
fstp QWORD PTR [esi][edi*8-16] ; Save result
fstp QWORD PTR [esi][edi*8-8] ; Save result
sub edi, 4 ; Check loop counter
jnz short uaddlp ; Loop if necessary
ad_epilog 0,0,rsi,rdi
gwaddq1 ENDP
;;
;; Add two numbers with carry propagation
;;
PROCFL gwadd1
ad_prolog 0,0,rbx,rbp,rsi,rdi
mov ecx, SRCARG ; Address of first number
mov edx, SRC2ARG ; Address of second number
mov esi, DESTARG ; Address of destination
mov ebp, FFTLEN ; Load loop counter
fld BIGVAL ; Start process with no carry
fld BIGVAL
mov ebx, norm_col_mults ; Address of the multipliers
mov edi, norm_biglit_array ; Computes big vs little word flag
sub eax, eax ; Clear big/lit flags
naddlp: norm_op_1d fadd ; Add and normalize 8 values
sub ebp, 8 ; Decrement loop counter
jnz naddlp ; Loop til done
mov esi, DESTARG ; Address of squared number
mov ebx, norm_col_mults ; Address of the multipliers
norm_op_1d_cleanup
ad_epilog 0,0,rbx,rbp,rsi,rdi
gwadd1 ENDP
;;
;; Subtract two numbers without carry propagation. Caller can use this for
;; consecutive add or subtract operations. However, the last operation
;; before a multiply must use the routine that will normalize data.
;;
PROCFL gwsubq1
ad_prolog 0,0,rsi,rdi
mov ecx, SRCARG ; Address of first number
mov edx, SRC2ARG ; Address of second number
mov esi, DESTARG ; Address of destination
mov edi, FFTLEN ; Load loop counter
usublp: fld QWORD PTR [edx][edi*8-32] ; Load second number
fsub QWORD PTR [ecx][edi*8-32] ; Subtract first number
fld QWORD PTR [edx][edi*8-24] ; Load second number
fsub QWORD PTR [ecx][edi*8-24] ; Subtract first number
fld QWORD PTR [edx][edi*8-16] ; Load second number
fsub QWORD PTR [ecx][edi*8-16] ; Subtract first number
fxch st(1)
fld QWORD PTR [edx][edi*8-8] ; Load second number
fsub QWORD PTR [ecx][edi*8-8] ; Subtract first number
fxch st(3)
fstp QWORD PTR [esi][edi*8-32] ; Save result
fstp QWORD PTR [esi][edi*8-24] ; Save result
fstp QWORD PTR [esi][edi*8-16] ; Save result
fstp QWORD PTR [esi][edi*8-8] ; Save result
sub edi, 4 ; Check loop counter
jnz short usublp ; Loop if necessary
ad_epilog 0,0,rsi,rdi
gwsubq1 ENDP
;;
;; Subtract two numbers with carry propagation
;;
PROCFL gwsub1
ad_prolog 0,0,rbx,rbp,rsi,rdi
mov ecx, SRCARG ; Address of first number
mov edx, SRC2ARG ; Address of second number
mov esi, DESTARG ; Address of destination
mov ebp, FFTLEN ; Load loop counter
fld BIGVAL ; Start process with no carry
fld BIGVAL
mov ebx, norm_col_mults ; Address of the multipliers
mov edi, norm_biglit_array ; Computes big vs little word flag
sub eax, eax ; Clear big/lit flags
nsublp: norm_op_1d fsub ; Subtract and normalize 8 values
sub ebp, 8 ; Decrement loop counter
jnz nsublp ; Loop til done
mov esi, DESTARG ; Address of squared number
mov ebx, norm_col_mults ; Address of the multipliers
norm_op_1d_cleanup
ad_epilog 0,0,rbx,rbp,rsi,rdi
gwsub1 ENDP
;;
;; Add and subtract two numbers without carry propagation.
;;
PROCFL gwaddsubq1
ad_prolog 0,0,rbp,rsi,rdi
mov ecx, SRCARG ; Address of first number
mov edx, SRC2ARG ; Address of second number
mov esi, DESTARG ; Address of destination #1
mov ebp, DEST2ARG ; Address of destination #2
mov edi, FFTLEN ; Load loop counter
uaddsublp:
fld QWORD PTR [ecx][edi*8-32] ; Load first number
fld st(0) ; Dup first number
fadd QWORD PTR [edx][edi*8-32] ; Add in second number
fxch st(1) ; S0,A0
fsub QWORD PTR [edx][edi*8-32] ; Subtract out second number
fld QWORD PTR [ecx][edi*8-24] ; Load first number
fld st(0) ; Dup first number
fadd QWORD PTR [edx][edi*8-24] ; Add in second number
fxch st(1) ; S1,A1,S0,A0
fsub QWORD PTR [edx][edi*8-24] ; Subtract out second number
fld QWORD PTR [ecx][edi*8-16] ; Load first number
fld st(0) ; Dup first number
fadd QWORD PTR [edx][edi*8-16] ; Add in second number
fxch st(1) ; S2,A2,S1,A1,S0,A0
fsub QWORD PTR [edx][edi*8-16] ; Subtract out second number
fld QWORD PTR [ecx][edi*8-8] ; Load first number
fld st(0) ; Dup first number
fadd QWORD PTR [edx][edi*8-8] ; Add in second number
fxch st(7) ; A0,S3,S2,A2,S1,A1,S0,A3
fstp QWORD PTR [esi][edi*8-32] ; Save result
fsub QWORD PTR [edx][edi*8-8] ; Subtract out second number
fxch st(5) ; S0,S2,A2,S1,A1,S3,A3
fstp QWORD PTR [ebp][edi*8-32] ; Save result
fstp QWORD PTR [ebp][edi*8-16] ; Save result
fstp QWORD PTR [esi][edi*8-16] ; Save result
fstp QWORD PTR [ebp][edi*8-24] ; Save result
fstp QWORD PTR [esi][edi*8-24] ; Save result
fstp QWORD PTR [ebp][edi*8-8] ; Save result
fstp QWORD PTR [esi][edi*8-8] ; Save result
sub edi, 4 ; Check loop counter
jnz short uaddsublp ; Loop if necessary
ad_epilog 0,0,rbp,rsi,rdi
gwaddsubq1 ENDP
;;
;; Add and subtract two numbers with carry propagation
;;
loopcount1 EQU DPTR [rsp+first_local]
PROCFL gwaddsub1
ad_prolog 4,0,rbx,rbp,rsi,rdi
mov ecx, SRCARG ; Address of first number
mov edx, SRC2ARG ; Address of second number
mov esi, DESTARG ; Address of destination
mov ebp, DEST2ARG ; Address of destination #2
mov eax, FFTLEN ; Load loop counter
mov loopcount1, eax ; Save loop counter
fld BIGVAL ; Start process with no carry
fld BIGVAL
fld BIGVAL
fld BIGVAL
mov ebx, norm_col_mults ; Address of the multipliers
mov edi, norm_biglit_array ; Computes big vs little word flag
sub eax, eax ; Clear big/lit flag
naddsublp:
norm_addsub_1d ; Add/sub and normalize 4 values
sub loopcount1, 4 ; Decrement loop counter
jnz naddsublp ; Loop til done
mov esi, DESTARG ; Address of squared number
mov ebp, DEST2ARG ; Address of squared number
mov ebx, norm_col_mults ; Address of the multipliers
norm_addsub_1d_cleanup
ad_epilog 4,0,rbx,rbp,rsi,rdi
gwaddsub1 ENDP
;;
;; Copy one number and zero some low order words.
;;
PROCFL gwcopyzero1
ad_prolog 0,0,rsi,rdi
mov esi, SRCARG ; Address of first number
mov edi, DESTARG ; Address of destination
mov ecx, NUMARG ; Values to zero
mov edx, FFTLEN ; Total number of values
zlp1: fldz ; Zero low word
fstp QWORD PTR [edi]
fld QWORD PTR [esi+8] ; Copy high word
fstp QWORD PTR [edi+8]
lea esi, [esi+16]
lea edi, [edi+16]
sub edx, 2
dec ecx
jnz short zlp1
zlp2: fld QWORD PTR [esi] ; Copy low word
fstp QWORD PTR [edi]
fld QWORD PTR [esi+8] ; Copy high word
fstp QWORD PTR [edi+8]
lea esi, [esi+16]
lea edi, [edi+16]
sub edx, 2
jnz short zlp2
ad_epilog 0,0,rsi,rdi
gwcopyzero1 ENDP
;;
;; Mul by a small value with carry propagation
;;
PROCFL gwmuls1
ad_prolog 0,0,rbx,rbp,rsi,rdi
mov esi, DESTARG ; Address of destination
fld DBLARG ; Load small value
fmul NORM012_FF ; Mul by two-to-minus-phi fudge
fstp TMP5 ; Save multiplier
mov ebp, FFTLEN ; Load loop counter
fld BIGVAL ; Start process with no carry
fld BIGVAL
mov ebx, norm_col_mults ; Address of the multipliers
mov edi, norm_biglit_array ; Computes big vs little word flag
sub eax, eax ; Clear big/lit flags
nmullp: norm_smallmul_1d ; Mul and normalize 8 values
sub ebp, 8 ; Decrement loop counter
jnz nmullp ; Loop til done
mov esi, DESTARG ; Address of squared number
mov ebx, norm_col_mults ; Address of the multipliers
norm_op_1d_cleanup
ad_epilog 0,0,rbx,rbp,rsi,rdi
gwmuls1 ENDP
;;
;; Routines to do the normalization after a multiply
;;
;; When doing zero-padded FFTs, the multiplied 7 words around the halfway point
;; must be subtracted from the bottom of the FFT. This must be done before
;; normalization multiplies the FFT data by k.
sub_7_words MACRO
fld QWORD PTR [esi+0*16] ;; Subtract 1st word
fld ZPAD0 ;; Load ZPAD data
fmul NORM012_FF ;; Scale by FFTLEN/2
fsub st(1), st
faddp st(2), st ;; Adjust sumout
fstp QWORD PTR [esi+0*16]
fld QWORD PTR [esi+1*16] ;; Subtract 2nd word
fld ZPAD1 ;; Load ZPAD data
fmul NORM012_FF ;; Scale by FFTLEN/2
fsub st(1), st
faddp st(2), st ;; Adjust sumout
fstp QWORD PTR [esi+1*16]
fld QWORD PTR [esi+2*16] ;; Subtract 3rd word
fld ZPAD2 ;; Load ZPAD data
fmul NORM012_FF ;; Scale by FFTLEN/2
fsub st(1), st
faddp st(2), st ;; Adjust sumout
fstp QWORD PTR [esi+2*16]
fld QWORD PTR [esi+3*16] ;; Subtract 4th word
fld ZPAD3 ;; Load ZPAD data
fmul NORM012_FF ;; Scale by FFTLEN/2
fsub st(1), st
faddp st(2), st ;; Adjust sumout
fstp QWORD PTR [esi+3*16]
fld QWORD PTR [esi+4*16] ;; Subtract 5th word
fld ZPAD4 ;; Load ZPAD data
fmul NORM012_FF ;; Scale by FFTLEN/2
fsub st(1), st
faddp st(2), st ;; Adjust sumout
fstp QWORD PTR [esi+4*16]
fld QWORD PTR [esi+5*16] ;; Subtract 6th word
fld ZPAD5 ;; Load ZPAD data
fmul NORM012_FF ;; Scale by FFTLEN/2
fsub st(1), st
faddp st(2), st ;; Adjust sumout
fstp QWORD PTR [esi+5*16]
fld QWORD PTR [esi+6*16] ;; Subtract 7th word
fld ZPAD6 ;; Load ZPAD data
fmul NORM012_FF ;; Scale by FFTLEN/2
fsub st(1), st
faddp st(2), st ;; Adjust sumout
fstp QWORD PTR [esi+6*16]
ENDM
; Macro to loop through all the FFT values and apply the proper normalization
; routine. Used whenever we are using an irrational-base FFT.
inorm MACRO lab, ttp, zero, echk, const
LOCAL ilp
PROCFL lab
int_prolog 0,0,0
mov esi, DESTARG ;; Address of multiplied number
fld MAXERR ;; Load MAXERR
fldz ;; Init SUMOUT
no zero mov edi, ADDIN_OFFSET ;; Get address to add value into
no zero fld QWORD PTR [esi][edi] ;; Get the value
no zero fadd ADDIN_VALUE ;; Add in the requested value
no zero fstp QWORD PTR [esi][edi] ;; Save the new value
no zero fsub ADDIN_VALUE ;; Do not include addin in sumout
fld BIGVAL ;; Init carry #1
fld BIGVAL ;; Init carry #2
mov ebx, norm_col_mults ;; Address of the multipliers
mov edi, norm_biglit_array ;; Big/lit array pointer
sub eax, eax ;; Clear big/lit flag
mov ecx, FFTLEN ;; Load loop counter
ilp: norm_1d ttp, zero, echk, const ;; Normalize 8 values
lea esi, [esi+64] ;; Next source
ttp lea ebx, [ebx+128] ;; Next set of 8 multipliers
ttp lea edi, [edi+4] ;; Next big/lit array ptr
sub ecx, 8 ;; Test loop counter
jnz ilp ;; Loop til done
zero jmp zdn ;; Go to zero upper half end code
no zero jmp idn ;; Go to normal end code
&lab ENDP
ENDM
; Do a zero-padded normalization.
zpnorm MACRO lab, ttp, echk, const
LOCAL ilp
PROCFL lab
int_prolog 0,0,0
mov esi, DESTARG ;; Address of multiplied number
fld MAXERR ;; Load MAXERR
fldz ;; Init SUMOUT
sub_7_words ;; Subtract 7 ZPAD words
fld BIGVAL ;; Init traditional carry
fldz ;; Init high FFT data carry
mov ebx, norm_col_mults ;; Address of the multipliers
mov edi, norm_biglit_array ;; Big/lit array pointer
sub eax, eax ;; Clear big/lit flag
mov ecx, FFTLEN ;; Load loop counter
ilp: norm_1d_zpad ttp, echk, const ;; Normalize 4 values
lea esi, [esi+4*8] ;; Next source
ttp lea ebx, [ebx+4*16] ;; Next set of 4 multipliers
ttp lea edi, [edi+2] ;; Next big/lit array ptr
sub ecx, 4 ;; Test loop counter
jnz ilp ;; Loop til done
const jmp zpcdn ;; Go to zero padded FFT end code
no const jmp zpdn ;; Go to zero padded FFT end code
&lab ENDP
ENDM
; The 16 different normalization routines
inorm r1, noexec, noexec, noexec, noexec
inorm r1e, noexec, noexec, exec, noexec
inorm r1c, noexec, noexec, noexec, exec
inorm r1ec, noexec, noexec, exec, exec
inorm r1z, noexec, exec, noexec, noexec
inorm r1ze, noexec, exec, exec, noexec
inorm i1, exec, noexec, noexec, noexec
inorm i1e, exec, noexec, exec, noexec
inorm i1c, exec, noexec, noexec, exec
inorm i1ec, exec, noexec, exec, exec
inorm i1z, exec, exec, noexec, noexec
inorm i1ze, exec, exec, exec, noexec
zpnorm r1zp, noexec, noexec, noexec
zpnorm r1zpe, noexec, exec, noexec
zpnorm r1zpc, noexec, noexec, exec
zpnorm r1zpec, noexec, exec, exec
zpnorm i1zp, exec, noexec, noexec
zpnorm i1zpe, exec, exec, noexec
zpnorm i1zpc, exec, noexec, exec
zpnorm i1zpec, exec, exec, exec
; Common code to finish off the one-pass FFTs normalization. The
; Windows 64-bit ABI frowns on us jumping from one procedure into another.
; However, my reading of the spec is that as long as the two procedures have
; identical prologs then stack unwinding for exception handling will work OK.
; Of course, this x87 is not linked in to a Windows 64-bit executable, but
; we make the code identical to xmult1ax.asm for consistency sake.
PROCF __common_norm1_end_code
;; Dummy prolog to match normalization code
int_prolog 0,0,0
; Finish off the normalization process by adding any carry to first values.
; FPU stack is now: carry #2, carry #1, sumout, maxerr
zpcdn: mov esi, DESTARG ; Address of squared number
mov edi, norm_biglit_array ; Address of the big/little flags array
mov ebx, norm_col_mults ; Restart the column multipliers
sub eax, eax
norm012_1d_zpad exec ; Add in carries
jmp cmnend ; All done, go cleanup
zpdn: mov esi, DESTARG ; Address of squared number
mov edi, norm_biglit_array ; Address of the big/little flags array
mov ebx, norm_col_mults ; Restart the column multipliers
sub eax, eax
norm012_1d_zpad noexec ; Add in carries
jmp cmnend ; All done, go cleanup
zdn: mov esi, DESTARG ; Address of squared number
mov edi, norm_biglit_array ; Address of the big/little flags array
mov ebx, norm_col_mults ; Restart the column multipliers
norm012_1d exec ; Add in carries
jmp cmnend ; All done, go cleanup
idn: mov esi, DESTARG ; Address of squared number
norm_top_carry_1d ; Adjust top carry when k > 1
sub eax, eax ; Clear big/lit flag
mov edi, norm_biglit_array ; Big/lit array pointer
mov ebx, norm_col_mults ; Restart the column multipliers
norm012_1d noexec
; Normalize SUMOUT value by multiplying by 1 / (fftlen/2).
; FPU stack is now: sumout, maxerr
cmnend: fmul ttmp_ff_inv
fstp QWORD PTR [esi-24] ; Save sum of FFT outputs
fstp MAXERR ; Save new maximum roundoff error
; Return
int_epilog 0,0,0
__common_norm1_end_code ENDP
_TEXT ENDS
END
|
Name: kart-drive-p.asm
Type: file
Size: 39195
Last-Modified: '1992-08-06T07:16:45Z'
SHA-1: 56AC381F31757968B23E681AC0CE1E26F4640A01
Description: null
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Copyright(c) 2011-2015 Intel Corporation All rights reserved.
;
; Redistribution and use in source and binary forms, with or without
; modification, are permitted provided that the following conditions
; are met:
; * Redistributions of source code must retain the above copyright
; notice, this list of conditions and the following disclaimer.
; * Redistributions in binary form must reproduce the above copyright
; notice, this list of conditions and the following disclaimer in
; the documentation and/or other materials provided with the
; distribution.
; * Neither the name of Intel Corporation nor the names of its
; contributors may be used to endorse or promote products derived
; from this software without specific prior written permission.
;
; THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
; "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
; LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
; A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
; OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
; SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
; LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
; DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
; THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
; (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
; OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
;;; gf_5vect_mad_avx(len, vec, vec_i, mul_array, src, dest);
;;;
%include "reg_sizes.asm"
%define PS 8
%ifidn __OUTPUT_FORMAT__, win64
%define arg0 rcx
%define arg0.w ecx
%define arg1 rdx
%define arg2 r8
%define arg3 r9
%define arg4 r12
%define arg5 r15
%define tmp r11
%define tmp2 r10
%define tmp3 r13
%define tmp4 r14
%define return rax
%define return.w eax
%define stack_size 16*10 + 5*8
%define arg(x) [rsp + stack_size + PS + PS*x]
%define func(x) proc_frame x
%macro FUNC_SAVE 0
sub rsp, stack_size
movdqa [rsp+16*0],xmm6
movdqa [rsp+16*1],xmm7
movdqa [rsp+16*2],xmm8
movdqa [rsp+16*3],xmm9
movdqa [rsp+16*4],xmm10
movdqa [rsp+16*5],xmm11
movdqa [rsp+16*6],xmm12
movdqa [rsp+16*7],xmm13
movdqa [rsp+16*8],xmm14
movdqa [rsp+16*9],xmm15
save_reg r12, 10*16 + 0*8
save_reg r13, 10*16 + 1*8
save_reg r14, 10*16 + 2*8
save_reg r15, 10*16 + 3*8
end_prolog
mov arg4, arg(4)
mov arg5, arg(5)
%endmacro
%macro FUNC_RESTORE 0
movdqa xmm6, [rsp+16*0]
movdqa xmm7, [rsp+16*1]
movdqa xmm8, [rsp+16*2]
movdqa xmm9, [rsp+16*3]
movdqa xmm10, [rsp+16*4]
movdqa xmm11, [rsp+16*5]
movdqa xmm12, [rsp+16*6]
movdqa xmm13, [rsp+16*7]
movdqa xmm14, [rsp+16*8]
movdqa xmm15, [rsp+16*9]
mov r12, [rsp + 10*16 + 0*8]
mov r13, [rsp + 10*16 + 1*8]
mov r14, [rsp + 10*16 + 2*8]
mov r15, [rsp + 10*16 + 3*8]
add rsp, stack_size
%endmacro
%elifidn __OUTPUT_FORMAT__, elf64
%define arg0 rdi
%define arg0.w edi
%define arg1 rsi
%define arg2 rdx
%define arg3 rcx
%define arg4 r8
%define arg5 r9
%define tmp r11
%define tmp2 r10
%define tmp3 r12
%define tmp4 r13
%define return rax
%define return.w eax
%define func(x) x: endbranch
%macro FUNC_SAVE 0
push r12
push r13
%endmacro
%macro FUNC_RESTORE 0
pop r13
pop r12
%endmacro
%endif
;;; gf_5vect_mad_avx(len, vec, vec_i, mul_array, src, dest)
%define len arg0
%define len.w arg0.w
%define vec arg1
%define vec_i arg2
%define mul_array arg3
%define src arg4
%define dest1 arg5
%define pos return
%define pos.w return.w
%define dest2 tmp4
%define dest3 mul_array
%define dest4 tmp2
%define dest5 vec_i
%ifndef EC_ALIGNED_ADDR
;;; Use Un-aligned load/store
%define XLDR vmovdqu
%define XSTR vmovdqu
%else
;;; Use Non-temporal load/stor
%ifdef NO_NT_LDST
%define XLDR vmovdqa
%define XSTR vmovdqa
%else
%define XLDR vmovntdqa
%define XSTR vmovntdq
%endif
%endif
default rel
[bits 64]
section .text
%define xmask0f xmm15
%define xgft5_hi xmm14
%define xgft4_lo xmm13
%define xgft4_hi xmm12
%define x0 xmm0
%define xtmpa xmm1
%define xtmph1 xmm2
%define xtmpl1 xmm3
%define xtmph2 xmm4
%define xtmpl2 xmm5
%define xtmph3 xmm6
%define xtmpl3 xmm7
%define xtmph5 xmm8
%define xtmpl5 xmm9
%define xd1 xmm10
%define xd2 xmm11
%define xd3 xtmpl1
%define xd4 xtmph1
%define xd5 xtmpl2
align 16
mk_global gf_5vect_mad_avx, function
func(gf_5vect_mad_avx)
FUNC_SAVE
sub len, 16
jl .return_fail
xor pos, pos
vmovdqa xmask0f, [mask0f] ;Load mask of lower nibble in each byte
mov tmp, vec
sal vec_i, 5 ;Multiply by 32
lea tmp3, [mul_array + vec_i]
sal tmp, 6 ;Multiply by 64
vmovdqu xgft5_hi, [tmp3+2*tmp+16] ; " Ex{00}, Ex{10}, ..., Ex{f0}
sal vec, 5 ;Multiply by 32
add tmp, vec
vmovdqu xgft4_hi, [tmp3+tmp+16] ; " Dx{00}, Dx{10}, Dx{20}, ... , Dx{f0}
vmovdqu xgft4_lo, [tmp3+tmp] ;Load array Dx{00}, Dx{01}, Dx{02}, ...
mov dest3, [dest1+2*PS] ; reuse mul_array
mov dest4, [dest1+3*PS]
mov dest5, [dest1+4*PS] ; reuse vec_i
mov dest2, [dest1+PS]
mov dest1, [dest1]
.loop16:
XLDR x0, [src+pos] ;Get next source vector
vmovdqu xtmph1, [tmp3+16] ; " Ax{00}, Ax{10}, Ax{20}, ... , Ax{f0}
vmovdqu xtmpl1, [tmp3] ;Load array Ax{00}, Ax{01}, Ax{02}, ...
vmovdqu xtmph2, [tmp3+vec+16] ; " Bx{00}, Bx{10}, Bx{20}, ... , Bx{f0}
vmovdqu xtmpl2, [tmp3+vec] ;Load array Bx{00}, Bx{01}, Bx{02}, ...
vmovdqu xtmph3, [tmp3+2*vec+16] ; " Cx{00}, Cx{10}, Cx{20}, ... , Cx{f0}
vmovdqu xtmpl3, [tmp3+2*vec] ;Load array Cx{00}, Cx{01}, Cx{02}, ...
vmovdqu xtmpl5, [tmp3+4*vec] ;Load array Ex{00}, Ex{01}, ..., Ex{0f}
XLDR xd1, [dest1+pos] ;Get next dest vector
XLDR xd2, [dest2+pos] ;Get next dest vector
vpand xtmpa, x0, xmask0f ;Mask low src nibble in bits 4-0
vpsraw x0, x0, 4 ;Shift to put high nibble into bits 4-0
vpand x0, x0, xmask0f ;Mask high src nibble in bits 4-0
; dest1
vpshufb xtmph1, xtmph1, x0 ;Lookup mul table of high nibble
vpshufb xtmpl1, xtmpl1, xtmpa ;Lookup mul table of low nibble
vpxor xtmph1, xtmph1, xtmpl1 ;GF add high and low partials
vpxor xd1, xd1, xtmph1
XLDR xd3, [dest3+pos] ;Reuse xtmpl1, Get next dest vector
XLDR xd4, [dest4+pos] ;Reuse xtmph1, Get next dest vector
; dest2
vpshufb xtmph2, xtmph2, x0 ;Lookup mul table of high nibble
vpshufb xtmpl2, xtmpl2, xtmpa ;Lookup mul table of low nibble
vpxor xtmph2, xtmph2, xtmpl2 ;GF add high and low partials
vpxor xd2, xd2, xtmph2
XLDR xd5, [dest5+pos] ;Reuse xtmpl2. Get next dest vector
; dest3
vpshufb xtmph3, xtmph3, x0 ;Lookup mul table of high nibble
vpshufb xtmpl3, xtmpl3, xtmpa ;Lookup mul table of low nibble
vpxor xtmph3, xtmph3, xtmpl3 ;GF add high and low partials
vpxor xd3, xd3, xtmph3
; dest4
vpshufb xtmph2, xgft4_hi, x0 ;Lookup mul table of high nibble
vpshufb xtmpl3, xgft4_lo, xtmpa ;Lookup mul table of low nibble
vpxor xtmph2, xtmph2, xtmpl3 ;GF add high and low partials
vpxor xd4, xd4, xtmph2
; dest5
vpshufb xtmph5, xgft5_hi, x0 ;Lookup mul table of high nibble
vpshufb xtmpl5, xtmpl5, xtmpa ;Lookup mul table of low nibble
vpxor xtmph5, xtmph5, xtmpl5 ;GF add high and low partials
vpxor xd5, xd5, xtmph5
XSTR [dest1+pos], xd1 ;Store result into dest1
XSTR [dest2+pos], xd2 ;Store result into dest2
XSTR [dest3+pos], xd3 ;Store result into dest3
XSTR [dest4+pos], xd4 ;Store result into dest4
XSTR [dest5+pos], xd5 ;Store result into dest5
add pos, 16 ;Loop on 16 bytes at a time
cmp pos, len
jle .loop16
lea tmp, [len + 16]
cmp pos, tmp
je .return_pass
.lessthan16:
;; Tail len
;; Do one more overlap pass
mov tmp, len ;Overlapped offset length-16
XLDR x0, [src+tmp] ;Get next source vector
sub len, pos
vmovdqa xtmph1, [constip16] ;Load const of i + 16
vpinsrb xtmph5, len.w, 15
vpshufb xtmph5, xmask0f ;Broadcast len to all bytes
vpcmpgtb xtmph5, xtmph5, xtmph1
vmovdqu xtmph1, [tmp3+16] ; " Ax{00}, Ax{10}, Ax{20}, ... , Ax{f0}
vmovdqu xtmpl1, [tmp3] ;Load array Ax{00}, Ax{01}, Ax{02}, ...
vmovdqu xtmph2, [tmp3+vec+16] ; " Bx{00}, Bx{10}, Bx{20}, ... , Bx{f0}
vmovdqu xtmpl2, [tmp3+vec] ;Load array Bx{00}, Bx{01}, Bx{02}, ...
vmovdqu xtmph3, [tmp3+2*vec+16] ; " Cx{00}, Cx{10}, Cx{20}, ... , Cx{f0}
vmovdqu xtmpl3, [tmp3+2*vec] ;Load array Cx{00}, Cx{01}, Cx{02}, ...
vmovdqu xtmpl5, [tmp3+4*vec] ;Load array Ex{00}, Ex{01}, ..., Ex{0f}
XLDR xd1, [dest1+tmp] ;Get next dest vector
XLDR xd2, [dest2+tmp] ;Get next dest vector
vpand xtmpa, x0, xmask0f ;Mask low src nibble in bits 4-0
vpsraw x0, x0, 4 ;Shift to put high nibble into bits 4-0
vpand x0, x0, xmask0f ;Mask high src nibble in bits 4-0
; dest1
vpshufb xtmph1, xtmph1, x0 ;Lookup mul table of high nibble
vpshufb xtmpl1, xtmpl1, xtmpa ;Lookup mul table of low nibble
vpxor xtmph1, xtmph1, xtmpl1 ;GF add high and low partials
vpand xtmph1, xtmph1, xtmph5
vpxor xd1, xd1, xtmph1
XLDR xd3, [dest3+tmp] ;Reuse xtmpl1, Get next dest vector
XLDR xd4, [dest4+tmp] ;Reuse xtmph1, Get next dest vector
; dest2
vpshufb xtmph2, xtmph2, x0 ;Lookup mul table of high nibble
vpshufb xtmpl2, xtmpl2, xtmpa ;Lookup mul table of low nibble
vpxor xtmph2, xtmph2, xtmpl2 ;GF add high and low partials
vpand xtmph2, xtmph2, xtmph5
vpxor xd2, xd2, xtmph2
XLDR xd5, [dest5+tmp] ;Reuse xtmpl2. Get next dest vector
; dest3
vpshufb xtmph3, xtmph3, x0 ;Lookup mul table of high nibble
vpshufb xtmpl3, xtmpl3, xtmpa ;Lookup mul table of low nibble
vpxor xtmph3, xtmph3, xtmpl3 ;GF add high and low partials
vpand xtmph3, xtmph3, xtmph5
vpxor xd3, xd3, xtmph3
; dest4
vpshufb xgft4_hi, xgft4_hi, x0 ;Lookup mul table of high nibble
vpshufb xgft4_lo, xgft4_lo, xtmpa ;Lookup mul table of low nibble
vpxor xgft4_hi, xgft4_hi, xgft4_lo ;GF add high and low partials
vpand xgft4_hi, xgft4_hi, xtmph5
vpxor xd4, xd4, xgft4_hi
; dest5
vpshufb xgft5_hi, xgft5_hi, x0 ;Lookup mul table of high nibble
vpshufb xtmpl5, xtmpl5, xtmpa ;Lookup mul table of low nibble
vpxor xgft5_hi, xgft5_hi, xtmpl5 ;GF add high and low partials
vpand xgft5_hi, xgft5_hi, xtmph5
vpxor xd5, xd5, xgft5_hi
XSTR [dest1+tmp], xd1 ;Store result into dest1
XSTR [dest2+tmp], xd2 ;Store result into dest2
XSTR [dest3+tmp], xd3 ;Store result into dest3
XSTR [dest4+tmp], xd4 ;Store result into dest4
XSTR [dest5+tmp], xd5 ;Store result into dest5
.return_pass:
FUNC_RESTORE
mov return, 0
ret
.return_fail:
FUNC_RESTORE
mov return, 1
ret
endproc_frame
section .data
align 16
mask0f: dq 0x0f0f0f0f0f0f0f0f, 0x0f0f0f0f0f0f0f0f
constip16:
dq 0xf8f9fafbfcfdfeff, 0xf0f1f2f3f4f5f6f7
;;; func core, ver, snum
slversion gf_5vect_mad_avx, 02, 01, 020d
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.