LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: force_exportsize(ConstructTpl*)
static bool force_exportsize(ConstructTpl *ct)

{				// Look for zero size temps in export statement
  HandleTpl *result = ct->getResult();
  if (result == (HandleTpl *)0) return true;

  VarnodeTpl *vt;

  if (result->getPtrSpace().isUniqueSpace()&&result->getPtrSize().isZero()) {
    vt = find_size(result->getPtrOffset(),ct);
    if (vt == (VarnodeTpl *)0) return false;
    result->setPtrSize(vt->getSize());
  }
  else if (result->getSpace().isUniqueSpace()&&result->getSize().isZero()) {
    vt = find_size(result->getPtrOffset(),ct);
    if (vt == (VarnodeTpl *)0) return false;
    result->setSize(vt->getSize());
  }
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x52ef0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x67979
movb $0x1, -0x1(%rbp)
jmp 0x67a66
movq -0x18(%rbp), %rdi
callq 0x6abb0
movq %rax, %rdi
callq 0x4a000
testb $0x1, %al
jne 0x67990
jmp 0x679ef
movq -0x18(%rbp), %rdi
callq 0x70da0
movq %rax, %rdi
callq 0x40c90
testb $0x1, %al
jne 0x679a7
jmp 0x679ef
movq -0x18(%rbp), %rdi
callq 0x4e1b0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x6a010
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x679d0
movb $0x0, -0x1(%rbp)
jmp 0x67a66
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x3fbf0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x70dc0
jmp 0x67a62
movq -0x18(%rbp), %rdi
callq 0x4e1a0
movq %rax, %rdi
callq 0x4a000
testb $0x1, %al
jne 0x67a06
jmp 0x67a60
movq -0x18(%rbp), %rdi
callq 0x4e1d0
movq %rax, %rdi
callq 0x40c90
testb $0x1, %al
jne 0x67a1d
jmp 0x67a60
movq -0x18(%rbp), %rdi
callq 0x4e1b0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x6a010
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x67a43
movb $0x0, -0x1(%rbp)
jmp 0x67a66
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
callq 0x3fbf0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x70e00
jmp 0x67a62
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: SleighCompile::shiftUniqueVn(VarnodeTpl*, int)
void SleighCompile::shiftUniqueVn(VarnodeTpl *vn,int4 sa)

{ // If the varnode is in the unique space, shift its offset up by -sa- bits
  if (vn->getSpace().isUniqueSpace() && (vn->getOffset().getType() == ConstTpl::real)) {
    uintb val = vn->getOffset().getReal();
    val <<= sa;
    vn->setOffset(val);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x40220
movq %rax, %rdi
callq 0x4a000
testb $0x1, %al
jne 0x67aa6
jmp 0x67aee
movq -0x8(%rbp), %rdi
callq 0x3fca0
movq %rax, %rdi
callq 0x3fc10
cmpl $0x0, %eax
jne 0x67aee
movq -0x8(%rbp), %rdi
callq 0x3fca0
movq %rax, %rdi
callq 0x3fc20
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, %ecx
shlq %cl, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4e7f0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: SleighCompile::shiftUniqueOp(OpTpl*, int)
void SleighCompile::shiftUniqueOp(OpTpl *op,int4 sa)

{ // Shift the offset up by -sa- bits for any varnode used by this -op- in the unique space
  VarnodeTpl *outvn = op->getOut();
  if (outvn != (VarnodeTpl *)0)
    shiftUniqueVn(outvn,sa);
  for(int4 i=0;i<op->numInput();++i)
    shiftUniqueVn(op->getIn(i),sa);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3f7a0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x67b2f
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x67a80
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3fcc0
movl %eax, %ecx
movl -0x20(%rbp), %eax
cmpl %ecx, %eax
jge 0x67b70
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x3fce0
movq %rax, %rdi
movl -0xc(%rbp), %esi
callq 0x67a80
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x67b36
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: SleighCompile::shiftUniqueHandle(HandleTpl*, int)
void SleighCompile::shiftUniqueHandle(HandleTpl *hand,int4 sa)

{ // Shift the offset up by -sa- bits, for either the dynamic or static varnode aspects that are in the unique space
  if (hand->getSpace().isUniqueSpace() && (hand->getPtrSpace().getType() == ConstTpl::real)
      && (hand->getPtrOffset().getType() == ConstTpl::real)) {
    uintb val = hand->getPtrOffset().getReal();
    val <<= sa;
    hand->setPtrOffset(val);
  }
  else if (hand->getPtrSpace().isUniqueSpace() && (hand->getPtrOffset().getType() == ConstTpl::real)) {
    uintb val = hand->getPtrOffset().getReal();
    val <<= sa;
    hand->setPtrOffset(val);
  }
  
  if (hand->getTempSpace().isUniqueSpace() && (hand->getTempOffset().getType() == ConstTpl::real)) {
    uintb val = hand->getTempOffset().getReal();
    val <<= sa;
    hand->setTempOffset(val);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4e1a0
movq %rax, %rdi
callq 0x4a000
testb $0x1, %al
jne 0x67ba6
jmp 0x67c06
movq -0x8(%rbp), %rdi
callq 0x6abb0
movq %rax, %rdi
callq 0x3fc10
cmpl $0x0, %eax
jne 0x67c06
movq -0x8(%rbp), %rdi
callq 0x4e1b0
movq %rax, %rdi
callq 0x3fc10
cmpl $0x0, %eax
jne 0x67c06
movq -0x8(%rbp), %rdi
callq 0x4e1b0
movq %rax, %rdi
callq 0x3fc20
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, %ecx
shlq %cl, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x6c930
jmp 0x67c67
movq -0x8(%rbp), %rdi
callq 0x6abb0
movq %rax, %rdi
callq 0x4a000
testb $0x1, %al
jne 0x67c1d
jmp 0x67c65
movq -0x8(%rbp), %rdi
callq 0x4e1b0
movq %rax, %rdi
callq 0x3fc10
cmpl $0x0, %eax
jne 0x67c65
movq -0x8(%rbp), %rdi
callq 0x4e1b0
movq %rax, %rdi
callq 0x3fc20
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, %ecx
shlq %cl, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x6c930
jmp 0x67c67
movq -0x8(%rbp), %rdi
callq 0x6c980
movq %rax, %rdi
callq 0x4a000
testb $0x1, %al
jne 0x67c7e
jmp 0x67cc6
movq -0x8(%rbp), %rdi
callq 0x6c9a0
movq %rax, %rdi
callq 0x3fc10
cmpl $0x0, %eax
jne 0x67cc6
movq -0x8(%rbp), %rdi
callq 0x6c9a0
movq %rax, %rdi
callq 0x3fc20
movq %rax, -0x28(%rbp)
movl -0xc(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, %ecx
shlq %cl, %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x6c9c0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: SleighCompile::shiftUniqueConstruct(ConstructTpl*, int)
void SleighCompile::shiftUniqueConstruct(ConstructTpl *tpl,int4 sa)

{ // Shift the offset up by -sa- bits, for any varnode in the unique space associated with this template
  HandleTpl *result = tpl->getResult();
  if (result != (HandleTpl *)0)
    shiftUniqueHandle(result,sa);
  const vector<OpTpl *> &vec( tpl->getOpvec() );
  for(int4 i=0;i<vec.size();++i)
    shiftUniqueOp(vec[i],sa);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x52ef0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x67cff
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x67b80
movq -0x8(%rbp), %rdi
callq 0x3fd80
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movslq -0x24(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
callq 0x3f7c0
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x67d53
movq -0x20(%rbp), %rdi
movslq -0x24(%rbp), %rsi
callq 0x3fc80
movq (%rax), %rdi
movl -0xc(%rbp), %esi
callq 0x67b00
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x67d13
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: SleighCompile::buildMacro(MacroSymbol*, ConstructTpl*)
void SleighCompile::buildMacro(MacroSymbol *sym,ConstructTpl *rtl)

{
  string errstring = checkSymbols(symtab.getCurrentScope());
  if (errstring.size() != 0) {
    reportError(" in definition of macro "+sym->getName(),false);
    cerr << errstring;
    return;
  }
  if (!expandMacros(rtl,macrotable)) {
    reportError("Could not expand submacro in definition of macro "+sym->getName(),true);
    return;
  }
  PcodeCompile::propagateSize(rtl); // Propagate size information (as much as possible)
  sym->setConstruct(rtl);
  symtab.popScope();		// Pop local variables used to define macro
  macrotable.push_back(rtl);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x90(%rbp)
addq $0x198, %rdi            # imm = 0x198
callq 0x6c600
movq -0x90(%rbp), %rsi
movq %rax, %rdx
leaq -0x38(%rbp), %rdi
callq 0x62ef0
leaq -0x38(%rbp), %rdi
callq 0x11340
cmpq $0x0, %rax
je 0x680a5
movq -0x10(%rbp), %rdi
callq 0x401a0
movq %rax, -0x98(%rbp)
jmp 0x68026
movq -0x98(%rbp), %rdx
leaq 0x7199d(%rip), %rsi     # 0xd99d1
leaq -0x58(%rbp), %rdi
callq 0x147f0
jmp 0x6803f
movq -0x90(%rbp), %rdi
leaq -0x58(%rbp), %rsi
xorl %edx, %edx
callq 0x603b0
jmp 0x68053
leaq -0x58(%rbp), %rdi
callq 0x11300
movq 0xc9f85(%rip), %rdi     # 0x131fe8
leaq -0x38(%rbp), %rsi
callq 0x113e0
jmp 0x6806e
movl $0x1, -0x68(%rbp)
jmp 0x68199
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x681ab
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x11300
jmp 0x681ab
movq -0x90(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq %rdi, %rdx
addq $0x258, %rdx            # imm = 0x258
callq 0x66c50
movb %al, -0x99(%rbp)
jmp 0x680c7
movb -0x99(%rbp), %al
testb $0x1, %al
jne 0x6814a
jmp 0x680d3
movq -0x10(%rbp), %rdi
callq 0x401a0
movq %rax, -0xa8(%rbp)
jmp 0x680e5
movq -0xa8(%rbp), %rdx
leaq 0x718c5(%rip), %rsi     # 0xd99b8
leaq -0x88(%rbp), %rdi
callq 0x147f0
jmp 0x68101
movq -0x90(%rbp), %rdi
leaq -0x88(%rbp), %rsi
movl $0x1, %edx
callq 0x603b0
jmp 0x6811b
leaq -0x88(%rbp), %rdi
callq 0x11300
movl $0x1, -0x68(%rbp)
jmp 0x68199
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x11300
jmp 0x681ab
movq -0x18(%rbp), %rdi
callq 0x3c800
jmp 0x68155
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x6cbd0
jmp 0x68164
movq -0x90(%rbp), %rdi
addq $0x198, %rdi            # imm = 0x198
callq 0xa2c00
jmp 0x68179
movq -0x90(%rbp), %rdi
addq $0x258, %rdi            # imm = 0x258
leaq -0x18(%rbp), %rsi
callq 0x6cbf0
jmp 0x68192
movl $0x0, -0x68(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x11300
addq $0xb0, %rsp
popq %rbp
retq
leaq -0x38(%rbp), %rdi
callq 0x11300
movq -0x60(%rbp), %rdi
callq 0x118b0
nopl (%rax)
// File: jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: findSlaSpecs(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
static void findSlaSpecs(vector<string> &res, const string &dir, const string &suffix)

{
  FileManage::matchListDir(res, suffix, true, dir, false);
  
  vector<string> dirs;
  FileManage::directoryList(dirs, dir);
  vector<string>::const_iterator iter;
  for(iter = dirs.begin();iter!=dirs.end();++iter) {
    const string &nextdir( *iter );
    findSlaSpecs(res, nextdir,suffix);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rcx
movl $0x1, %edx
xorl %r8d, %r8d
movl %r8d, -0x6c(%rbp)
callq 0x20e70
leaq -0x30(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x1ba90
movq -0x78(%rbp), %rdi
movl -0x6c(%rbp), %edx
movq -0x10(%rbp), %rsi
callq 0x212f0
jmp 0x693e3
leaq -0x48(%rbp), %rdi
callq 0x224e0
leaq -0x30(%rbp), %rdi
callq 0x226c0
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x226f0
movq -0x50(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x22770
movq %rax, -0x60(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x22730
testb $0x1, %al
jne 0x6942e
jmp 0x69472
leaq -0x48(%rbp), %rdi
callq 0x22620
movq %rax, -0x68(%rbp)
movq -0x8(%rbp), %rdi
movq -0x68(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x69390
jmp 0x6944e
jmp 0x69450
leaq -0x48(%rbp), %rdi
callq 0x22640
jmp 0x6940e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1bc40
jmp 0x69484
leaq -0x30(%rbp), %rdi
callq 0x1bc40
addq $0x80, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x118b0
nopl (%rax)
// File: jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: find_size(ConstTpl const&, ConstructTpl const*)
static VarnodeTpl *find_size(const ConstTpl &offset,const ConstructTpl *ct)

{				// Find a defining instance of the local variable
				// with given -offset-
  const vector<OpTpl *> &ops(ct->getOpvec());
  VarnodeTpl *vn;
  OpTpl *op;
  
  for(int4 i=0;i<ops.size();++i) {
    op = ops[i];
    vn = op->getOut();
    if ((vn!=(VarnodeTpl *)0)&&(vn->isLocalTemp())) {
      if (vn->getOffset() == offset)
	return vn;
    }
    for(int4 j=0;j<op->numInput();++j) {
      vn = op->getIn(j);
      if (vn->isLocalTemp()&&(vn->getOffset()==offset))
	return vn;
    }
  }
  return (VarnodeTpl *)0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3fd80
movq %rax, -0x20(%rbp)
movl $0x0, -0x34(%rbp)
movslq -0x34(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rdi
callq 0x3f7c0
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jae 0x6a136
movq -0x20(%rbp), %rdi
movslq -0x34(%rbp), %rsi
callq 0x3fc80
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x3f7a0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x6a0b6
movq -0x28(%rbp), %rdi
callq 0x4bb90
testb $0x1, %al
jne 0x6a08c
jmp 0x6a0b6
movq -0x28(%rbp), %rdi
callq 0x3fca0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x4a050
testb $0x1, %al
jne 0x6a0a7
jmp 0x6a0b4
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x6a13e
jmp 0x6a0b6
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
movl %eax, -0x44(%rbp)
movq -0x30(%rbp), %rdi
callq 0x3fcc0
movl %eax, %ecx
movl -0x44(%rbp), %eax
cmpl %ecx, %eax
jge 0x6a126
movq -0x30(%rbp), %rdi
movl -0x38(%rbp), %esi
callq 0x3fce0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x4bb90
testb $0x1, %al
jne 0x6a0f4
jmp 0x6a119
movq -0x28(%rbp), %rdi
callq 0x3fca0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x4a050
testb $0x1, %al
jne 0x6a10f
jmp 0x6a119
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x6a13e
jmp 0x6a11b
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x6a0bd
jmp 0x6a128
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x6a034
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: lotuskip[P]yuxtapa/client/base.cpp
// Function: (anonymous namespace)::update_screen_size(int)
void update_screen_size(const int sig)
{
	signal(SIGWINCH, SIG_IGN);
	endwin();
	refresh();
	signal(SIGWINCH, update_screen_size);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x1c, %edi
movl $0x1, %esi
callq 0x55d0
callq 0x5890
callq 0x5100
movl $0x1c, %edi
leaq -0x30(%rip), %rsi       # 0x9360
callq 0x55d0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: lotuskip[P]yuxtapa/client/base.cpp
// Function: Base::deinit_ncurses()
void Base::deinit_ncurses()
{
	int i;
	if(colmode == CM_FULL)
	{
		// restore original colours: (this gives a nice shutdown "animation", too)
		for(i = 0; i < MAX_PREDEF_COLOUR-BASE_COLOURS; ++i)
			init_color(i+BASE_COLOURS, term_colours[3*i], term_colours[3*i+1],
				term_colours[3*i+2]);
		delete[] term_colours;
	}
	for(i = 0; i < MAX_WIN; ++i)
		delwin(windows[i]);
	echo();
	endwin();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpl $0x0, 0x1f70d(%rip)     # 0x28abc
jne 0x943c
movl $0x0, -0x4(%rbp)
cmpl $0x40, -0x4(%rbp)
jge 0x9420
movl -0x4(%rbp), %eax
addl $0x10, %eax
movw %ax, %di
movq 0x1f6ee(%rip), %rax     # 0x28ac0
imull $0x3, -0x4(%rbp), %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %si
movq 0x1f6dc(%rip), %rax     # 0x28ac0
imull $0x3, -0x4(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %dx
movq 0x1f6c7(%rip), %rax     # 0x28ac0
imull $0x3, -0x4(%rbp), %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
movswl %di, %edi
movswl %si, %esi
movswl %dx, %edx
movswl (%rax,%rcx,2), %ecx
callq 0x5740
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x93bc
movq 0x1f699(%rip), %rax     # 0x28ac0
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x943a
movq -0x10(%rbp), %rdi
callq 0x5680
jmp 0x943c
movl $0x0, -0x4(%rbp)
cmpl $0x4, -0x4(%rbp)
jge 0x9468
movslq -0x4(%rbp), %rcx
leaq 0x1f67c(%rip), %rax     # 0x28ad0
movq (%rax,%rcx,8), %rdi
callq 0x54f0
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x9443
callq 0x5580
callq 0x5890
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: lotuskip[P]yuxtapa/client/base.cpp
// Function: Base::print_str(char const*, unsigned char, char, char, e_Win, bool)
void Base::print_str(const char *cs, const unsigned char cpair, const char x,
	const char y, const e_Win targetwin, const bool cteol)
{
	wmove(windows[targetwin], y, x);
	change_colour(windows[targetwin], cpair);
	waddstr(windows[targetwin], cs);
	if(cteol)
		wclrtoeol(windows[targetwin]);
	wrefresh(windows[targetwin]);
	return_cursor(cursor_in_view);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %r9b, %al
movq %rdi, -0x8(%rbp)
movb %sil, -0x9(%rbp)
movb %dl, -0xa(%rbp)
movb %cl, -0xb(%rbp)
movl %r8d, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movl -0x10(%rbp), %eax
movl %eax, %ecx
leaq 0x1f622(%rip), %rax     # 0x28ad0
movq (%rax,%rcx,8), %rdi
movsbl -0xb(%rbp), %esi
movsbl -0xa(%rbp), %edx
callq 0x5300
movl -0x10(%rbp), %eax
movl %eax, %ecx
leaq 0x1f605(%rip), %rax     # 0x28ad0
movq (%rax,%rcx,8), %rdi
movzbl -0x9(%rbp), %esi
callq 0x9540
movl -0x10(%rbp), %eax
movl %eax, %ecx
leaq 0x1f5ec(%rip), %rax     # 0x28ad0
movq (%rax,%rcx,8), %rdi
movq -0x8(%rbp), %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x5860
testb $0x1, -0x11(%rbp)
je 0x9511
movl -0x10(%rbp), %eax
movl %eax, %ecx
leaq 0x1f5c8(%rip), %rax     # 0x28ad0
movq (%rax,%rcx,8), %rdi
callq 0x56e0
movl -0x10(%rbp), %eax
movl %eax, %ecx
leaq 0x1f5b3(%rip), %rax     # 0x28ad0
movq (%rax,%rcx,8), %rdi
callq 0x55a0
movb 0x1ef94(%rip), %al      # 0x284c0
andb $0x1, %al
movzbl %al, %edi
callq 0x9690
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: lotuskip[P]yuxtapa/client/base.cpp
// Function: (anonymous namespace)::change_colour(_win_st*, unsigned char)
void change_colour(WINDOW* const w, unsigned char cpair)
{
	if(colmode != CM_FEW)
	{
		if(cpair >= 8 && cpair <= 15) // make second 8 base colours "light"
			wattrset(w, A_BOLD|COLOR_PAIR(cpair));
		else
			wattrset(w, COLOR_PAIR(cpair));
	}
	else
	{
		// Reduce the colours to the base 16:
		if(cpair >= BASE_COLOURS)
		{
			if(cpair < C_BG_HEAL)
				cpair = col_remap[cpair - BASE_COLOURS]; // (and goto set_colour)
			else // background is not black
			{
				// check the cases that require light foreground:
				if(cpair == C_BROWN_ON_TRAP || cpair == C_YELLOW_ON_TRAP
					|| cpair == C_GREEN_ON_POIS || cpair == C_RED_ON_HIT
					|| cpair == C_BLUE_ON_HEAL)
					wattrset(w, (A_BOLD
						| (COLOR_PAIR(cpair - C_BG_HEAL + BASE_COLOURS))));
				else
					wattrset(w, COLOR_PAIR(cpair - C_BG_HEAL + BASE_COLOURS));
				return;
			}
		}
		// set_colour:
		if(cpair >= BASE_COLOURS/2)
			wattrset(w, (A_BOLD | (COLOR_PAIR(cpair))));
		else
			wattrset(w, COLOR_PAIR(cpair));
	} // only few colours
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
cmpl $0x2, 0x1f563(%rip)     # 0x28abc
je 0x95a6
movzbl -0x9(%rbp), %eax
cmpl $0x8, %eax
jl 0x958b
movzbl -0x9(%rbp), %eax
cmpl $0xf, %eax
jg 0x958b
movq -0x8(%rbp), %rdi
movzbl -0x9(%rbp), %esi
shll $0x8, %esi
andl $0xff00, %esi           # imm = 0xFF00
orl $0x200000, %esi         # imm = 0x200000
callq 0x5260
jmp 0x95a1
movq -0x8(%rbp), %rdi
movzbl -0x9(%rbp), %esi
shll $0x8, %esi
andl $0xff00, %esi           # imm = 0xFF00
callq 0x5260
jmp 0x9685
movzbl -0x9(%rbp), %eax
cmpl $0x10, %eax
jl 0x9646
movzbl -0x9(%rbp), %eax
cmpl $0x43, %eax
jge 0x95d5
movzbl -0x9(%rbp), %eax
subl $0x10, %eax
movslq %eax, %rcx
leaq 0x12d23(%rip), %rax     # 0x1c2f0
movb (%rax,%rcx), %al
movb %al, -0x9(%rbp)
jmp 0x9644
movzbl -0x9(%rbp), %eax
cmpl $0x4c, %eax
je 0x9602
movzbl -0x9(%rbp), %eax
cmpl $0x50, %eax
je 0x9602
movzbl -0x9(%rbp), %eax
cmpl $0x51, %eax
je 0x9602
movzbl -0x9(%rbp), %eax
cmpl $0x64, %eax
je 0x9602
movzbl -0x9(%rbp), %eax
cmpl $0x47, %eax
jne 0x9626
movq -0x8(%rbp), %rdi
movzbl -0x9(%rbp), %esi
subl $0x43, %esi
addl $0x10, %esi
shll $0x8, %esi
andl $0xff00, %esi           # imm = 0xFF00
orl $0x200000, %esi         # imm = 0x200000
callq 0x5260
jmp 0x9642
movq -0x8(%rbp), %rdi
movzbl -0x9(%rbp), %esi
subl $0x43, %esi
addl $0x10, %esi
shll $0x8, %esi
andl $0xff00, %esi           # imm = 0xFF00
callq 0x5260
jmp 0x9685
jmp 0x9646
movzbl -0x9(%rbp), %eax
cmpl $0x8, %eax
jl 0x966d
movq -0x8(%rbp), %rdi
movzbl -0x9(%rbp), %esi
shll $0x8, %esi
andl $0xff00, %esi           # imm = 0xFF00
orl $0x200000, %esi         # imm = 0x200000
callq 0x5260
jmp 0x9683
movq -0x8(%rbp), %rdi
movzbl -0x9(%rbp), %esi
shll $0x8, %esi
andl $0xff00, %esi           # imm = 0xFF00
callq 0x5260
jmp 0x9685
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: lotuskip[P]yuxtapa/client/base.cpp
// Function: (anonymous namespace)::return_cursor(bool)
void return_cursor(const bool def)
{
	if(def) // cursor in the view
	{
		wmove(windows[VIEW_WIN], VIEWSIZE/2, VIEWSIZE/2);
		wrefresh(windows[VIEW_WIN]);
	}
	else
	{
		wmove(windows[MSG_WIN], MSG_WIN_Y-1, cursor_x);
		wrefresh(windows[MSG_WIN]);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
testb $0x1, -0x1(%rbp)
je 0x96c7
movq 0x1f43b(%rip), %rdi     # 0x28ae8
movl $0xb, %edx
movl %edx, %esi
callq 0x5300
movq 0x1f428(%rip), %rdi     # 0x28ae8
callq 0x55a0
jmp 0x96eb
movq 0x1f412(%rip), %rdi     # 0x28ae0
movsbl 0x1f41b(%rip), %edx     # 0x28af0
movl $0xe, %esi
callq 0x5300
movq 0x1f3fa(%rip), %rdi     # 0x28ae0
callq 0x55a0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: lotuskip[P]yuxtapa/client/base.cpp
// Function: Base::incr_print_end(e_Win, bool)
void Base::incr_print_end(const e_Win targetwin, const bool cteol)
{
	if(cteol)
		wclrtoeol(windows[targetwin]);
	wrefresh(windows[targetwin]);
	return_cursor(cursor_in_view);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %sil, %al
movl %edi, -0x4(%rbp)
andb $0x1, %al
movb %al, -0x5(%rbp)
testb $0x1, -0x5(%rbp)
je 0x97ce
movl -0x4(%rbp), %eax
movl %eax, %ecx
leaq 0x1f30b(%rip), %rax     # 0x28ad0
movq (%rax,%rcx,8), %rdi
callq 0x56e0
movl -0x4(%rbp), %eax
movl %eax, %ecx
leaq 0x1f2f6(%rip), %rax     # 0x28ad0
movq (%rax,%rcx,8), %rdi
callq 0x55a0
movb 0x1ecd7(%rip), %al      # 0x284c0
andb $0x1, %al
movzbl %al, %edi
callq 0x9690
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: lotuskip[P]yuxtapa/client/base.cpp
// Function: Base::more_chat_ind()
void Base::more_chat_ind()
{
	wmove(windows[CHAT_WIN], scr_y - VIEWSIZE - 1, scr_x - 4);
	change_colour(windows[CHAT_WIN], BASE_BLUE);
	waddstr(windows[CHAT_WIN], "[+]");
	wrefresh(windows[CHAT_WIN]);
	return_cursor(cursor_in_view);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x1f2cd(%rip), %rdi     # 0x28ad8
movzwl 0x1f2a6(%rip), %esi     # 0x28ab8
subl $0x17, %esi
subl $0x1, %esi
movzwl 0x1f29b(%rip), %edx     # 0x28aba
subl $0x4, %edx
callq 0x5300
movq 0x1f2aa(%rip), %rdi     # 0x28ad8
movl $0x4, %esi
callq 0x9540
movq 0x1f299(%rip), %rdi     # 0x28ad8
leaq 0x12820(%rip), %rsi     # 0x1c066
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x5860
movq 0x1f281(%rip), %rdi     # 0x28ad8
callq 0x55a0
movb 0x1ec5e(%rip), %al      # 0x284c0
andb $0x1, %al
movzbl %al, %edi
callq 0x9690
popq %rbp
retq
nop
// File: lotuskip[P]yuxtapa/client/base.cpp
// Function: Base::less_chat_ind()
void Base::less_chat_ind()
{
	wmove(windows[CHAT_WIN], 0, scr_x - 4);
	change_colour(windows[CHAT_WIN], BASE_BLUE);
	waddstr(windows[CHAT_WIN], "[-]");
	wrefresh(windows[CHAT_WIN]);
	return_cursor(cursor_in_view);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x1f25d(%rip), %rdi     # 0x28ad8
movzwl 0x1f238(%rip), %edx     # 0x28aba
subl $0x4, %edx
xorl %esi, %esi
callq 0x5300
movq 0x1f245(%rip), %rdi     # 0x28ad8
movl $0x4, %esi
callq 0x9540
movq 0x1f234(%rip), %rdi     # 0x28ad8
leaq 0x127bf(%rip), %rsi     # 0x1c06a
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x5860
movq 0x1f21c(%rip), %rdi     # 0x28ad8
callq 0x55a0
movb 0x1ebf9(%rip), %al      # 0x284c0
andb $0x1, %al
movzbl %al, %edi
callq 0x9690
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: lotuskip[P]yuxtapa/client/base.cpp
// Function: Base::print_view(char const*)
void Base::print_view(const char *source)
{
	// The view has a sequence of pairs (colour, symbol):
	char x, y;
	for(y = 0; y < VIEWSIZE; ++y)
	{
		wmove(windows[VIEW_WIN], y, 0);
		for(x = 0; x < VIEWSIZE; ++x)
		{
			change_colour(windows[VIEW_WIN], *source);
			waddch(windows[VIEW_WIN], *(++source));
			++source;
		}
	}
	wrefresh(windows[VIEW_WIN]);
	return_cursor(cursor_in_view);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movb $0x0, -0xa(%rbp)
movsbl -0xa(%rbp), %eax
cmpl $0x17, %eax
jge 0x998c
movq 0x1f1c8(%rip), %rdi     # 0x28ae8
movsbl -0xa(%rbp), %esi
xorl %edx, %edx
callq 0x5300
movb $0x0, -0x9(%rbp)
movsbl -0x9(%rbp), %eax
cmpl $0x17, %eax
jge 0x9980
movq 0x1f1a9(%rip), %rdi     # 0x28ae8
movq -0x8(%rbp), %rax
movzbl (%rax), %esi
callq 0x9540
movq 0x1f196(%rip), %rdi     # 0x28ae8
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movsbl 0x1(%rax), %esi
callq 0x5770
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
movb -0x9(%rbp), %al
addb $0x1, %al
movb %al, -0x9(%rbp)
jmp 0x992f
jmp 0x9982
movb -0xa(%rbp), %al
addb $0x1, %al
movb %al, -0xa(%rbp)
jmp 0x9910
movq 0x1f155(%rip), %rdi     # 0x28ae8
callq 0x55a0
movb 0x1eb22(%rip), %al      # 0x284c0
andb $0x1, %al
movzbl %al, %edi
callq 0x9690
addq $0x10, %rsp
popq %rbp
retq
nop
// File: lotuskip[P]yuxtapa/client/base.cpp
// Function: Base::viewtick()
void Base::viewtick()
{
	wmove(windows[STAT_WIN], 4, 53);
	change_colour(windows[STAT_WIN], C_WALL_LIT);
	waddstr(windows[STAT_WIN], anim_syms[animind].c_str());
	wrefresh(windows[STAT_WIN]);
	if(++animind == anim_syms.size())
		animind = 0;
	return_cursor(cursor_in_view);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x1f0c1(%rip), %rdi     # 0x28ad0
movl $0x4, %esi
movl $0x35, %edx
callq 0x5300
movq 0x1f0ab(%rip), %rdi     # 0x28ad0
movl $0x2e, %esi
callq 0x9540
movq 0x1f09a(%rip), %rax     # 0x28ad0
movq %rax, -0x10(%rbp)
movzbl 0x1f0b0(%rip), %eax     # 0x28af1
movl %eax, %esi
leaq 0x1f056(%rip), %rdi     # 0x28aa0
callq 0xa190
movq %rax, %rdi
callq 0x5200
movq -0x10(%rbp), %rdi
movq %rax, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x5860
movq 0x1f061(%rip), %rdi     # 0x28ad0
callq 0x55a0
movb 0x1f077(%rip), %al      # 0x28af1
addb $0x1, %al
movb %al, 0x1f06f(%rip)      # 0x28af1
movzbl %al, %eax
movq %rax, -0x8(%rbp)
leaq 0x1f010(%rip), %rdi     # 0x28aa0
callq 0xa1b0
movq %rax, %rcx
movq -0x8(%rbp), %rax
cmpq %rcx, %rax
jne 0x9aa8
movb $0x0, 0x1f049(%rip)     # 0x28af1
movb 0x1ea12(%rip), %al      # 0x284c0
andb $0x1, %al
movzbl %al, %edi
callq 0x9690
addq $0x10, %rsp
popq %rbp
retq
nop
// File: lotuskip[P]yuxtapa/client/base.cpp
// Function: Base::print_walk(bool)
void Base::print_walk(const bool w)
{
	wmove(windows[STAT_WIN], 4, 55);
	change_colour(windows[STAT_WIN], C_WALL_LIT);
	waddch(windows[STAT_WIN], walk_syms[w]);
	wrefresh(windows[STAT_WIN]);
	return_cursor(cursor_in_view);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movq 0x1eff9(%rip), %rdi     # 0x28ad0
movl $0x4, %esi
movl $0x37, %edx
callq 0x5300
movq 0x1efe3(%rip), %rdi     # 0x28ad0
movl $0x2e, %esi
callq 0x9540
movq 0x1efd2(%rip), %rdi     # 0x28ad0
movb -0x1(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, %ecx
leaq 0x127be(%rip), %rax     # 0x1c2cd
movsbl (%rax,%rcx), %esi
callq 0x5770
movq 0x1efb1(%rip), %rdi     # 0x28ad0
callq 0x55a0
movb 0x1e996(%rip), %al      # 0x284c0
andb $0x1, %al
movzbl %al, %edi
callq 0x9690
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: lotuskip[P]yuxtapa/client/class_cpv.cpp
// Function: ClassCPV::move(e_Dir)
void ClassCPV::move(const e_Dir d)
{
	if(clientstate == CS_NORMAL) // regular movement
		Network::send_action(XN_MOVE, d);
	else if(clientstate == CS_AIMING) // moving the aimer
	{
		aimer = aimer.in(d);
		if(aimer.x > VIEWSIZE/2) aimer.x--;
		else if(aimer.x < -VIEWSIZE/2) aimer.x++;
		if(aimer.y > VIEWSIZE/2) aimer.y--;
		else if(aimer.y < -VIEWSIZE/2) aimer.y++;
		redraw_view();
	}
	else if(clientstate == CS_DIR) // waiting for dir input (and now got it!)
	{
		if(myclass == C_FIGHTER)
			Network::send_action(XN_CIRCLE_ATTACK, d);
		else if(myclass == C_HEALER)
			Network::send_action(XN_HEAL, d);
		else if(myclass == C_MINER)
			Network::send_action(XN_MINE, d);
		else if(myclass == C_COMBAT_MAGE)
			Network::send_action(XN_ZAP, d);
		clientstate = CS_NORMAL;
	}	
	// else ignore
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
leaq 0x1df2e(%rip), %rax     # 0x28fe0
cmpl $0x0, (%rax)
jne 0xb0ce
movl -0x4(%rbp), %eax
movl $0x4, %edi
xorl %edx, %edx
movzbl %al, %esi
callq 0x14210
jmp 0xb226
leaq 0x1df0b(%rip), %rax     # 0x28fe0
cmpl $0x6, (%rax)
jne 0xb18d
movl -0x4(%rbp), %edx
leaq -0x8(%rbp), %rdi
leaq 0x1ddb4(%rip), %rsi     # 0x28ea0
callq 0x1af30
movl -0x8(%rbp), %eax
movl %eax, 0x1dda6(%rip)     # 0x28ea0
leaq -0x8(%rbp), %rdi
callq 0x1ae40
movswl 0x1dd96(%rip), %eax     # 0x28ea0
cmpl $0xb, %eax
jle 0xb123
movw 0x1dd8a(%rip), %ax      # 0x28ea0
addw $-0x1, %ax
movw %ax, 0x1dd7f(%rip)      # 0x28ea0
jmp 0xb143
movswl 0x1dd76(%rip), %eax     # 0x28ea0
cmpl $-0xb, %eax
jge 0xb141
movw 0x1dd6a(%rip), %ax      # 0x28ea0
addw $0x1, %ax
movw %ax, 0x1dd5f(%rip)      # 0x28ea0
jmp 0xb143
movswl 0x1dd58(%rip), %eax     # 0x28ea2
cmpl $0xb, %eax
jle 0xb163
movw 0x1dd4c(%rip), %ax      # 0x28ea2
addw $-0x1, %ax
movw %ax, 0x1dd41(%rip)      # 0x28ea2
jmp 0xb183
movswl 0x1dd38(%rip), %eax     # 0x28ea2
cmpl $-0xb, %eax
jge 0xb181
movw 0x1dd2c(%rip), %ax      # 0x28ea2
addw $0x1, %ax
movw %ax, 0x1dd21(%rip)      # 0x28ea2
jmp 0xb183
callq 0x19160
jmp 0xb224
leaq 0x1de4c(%rip), %rax     # 0x28fe0
cmpl $0x7, (%rax)
jne 0xb222
cmpl $0x5, 0x1d32c(%rip)     # 0x284d0
jne 0xb1ba
movl -0x4(%rbp), %eax
movl $0xa, %edi
xorl %edx, %edx
movzbl %al, %esi
callq 0x14210
jmp 0xb215
cmpl $0x7, 0x1d30f(%rip)     # 0x284d0
jne 0xb1d7
movl -0x4(%rbp), %eax
movl $0xc, %edi
xorl %edx, %edx
movzbl %al, %esi
callq 0x14210
jmp 0xb213
cmpl $0x6, 0x1d2f2(%rip)     # 0x284d0
jne 0xb1f4
movl -0x4(%rbp), %eax
movl $0xb, %edi
xorl %edx, %edx
movzbl %al, %esi
callq 0x14210
jmp 0xb211
cmpl $0x2, 0x1d2d5(%rip)     # 0x284d0
jne 0xb20f
movl -0x4(%rbp), %eax
movl $0x7, %edi
xorl %edx, %edx
movzbl %al, %esi
callq 0x14210
jmp 0xb211
jmp 0xb213
jmp 0xb215
leaq 0x1ddc4(%rip), %rax     # 0x28fe0
movl $0x0, (%rax)
jmp 0xb224
jmp 0xb226
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: lotuskip[P]yuxtapa/client/class_cpv.cpp
// Function: ClassCPV::five()
void ClassCPV::five()
{
	if(clientstate == CS_AIMING)
	{
		if(aimer.x || aimer.y)
		{
			aimer.x = aimer.y = 0;
			redraw_view();
		}
	}	
	else if(clientstate == CS_DIR && myclass == C_HEALER) 
	{
		Network::send_action(XN_HEAL, MAX_D); // heal self
		clientstate = CS_NORMAL;
	}
	// else ignore
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x1dda5(%rip), %rax     # 0x28fe0
cmpl $0x6, (%rax)
jne 0xb26d
cmpw $0x0, 0x1dc58(%rip)     # 0x28ea0
jne 0xb254
cmpw $0x0, 0x1dc50(%rip)     # 0x28ea2
je 0xb26b
movw $0x0, 0x1dc45(%rip)     # 0x28ea2
movw $0x0, 0x1dc3a(%rip)     # 0x28ea0
callq 0x19160
jmp 0xb2a2
leaq 0x1dd6c(%rip), %rax     # 0x28fe0
cmpl $0x7, (%rax)
jne 0xb2a0
cmpl $0x7, 0x1d250(%rip)     # 0x284d0
jne 0xb2a0
movl $0xc, %edi
movl $0x8, %esi
xorl %edx, %edx
callq 0x14210
leaq 0x1dd46(%rip), %rax     # 0x28fe0
movl $0x0, (%rax)
jmp 0xb2a2
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: lotuskip[P]yuxtapa/client/class_cpv.cpp
// Function: ClassCPV::space()
void ClassCPV::space()
{
	if(!im_alive())
		Network::send_action(XN_FOLLOW_SWITCH);
	else
	{
		switch(myclass)
		{
		case C_ARCHER:
			if(clientstate == CS_AIMING)
			{
				if(aimer.x || aimer.y) // aiming *somewhere*
					Network::send_action(XN_SHOOT, aimer.x, aimer.y);
				clientstate = CS_NORMAL;
			}
			else
			{
				aimer.x = aimer.y = 0;
				clientstate = CS_AIMING;
			}
			redraw_view();
			break;
		case C_ASSASSIN:
			Network::send_action(XN_FLASH);
			break;
		case C_MINDCRAFTER:
			Network::send_action(XN_BLINK);
			break;
		case C_SCOUT:
			Network::send_action(XN_DISGUISE);
			break;
		case C_TRAPPER:
			Network::send_action(XN_SET_TRAP);
			break;
		case C_WIZARD:
			Network::send_action(XN_MM);
			break;
		case C_PLANEWALKER:
			Network::send_action(XN_MINDS_EYE);
			break;
		default: //C_FIGHTER, C_HEALER, C_MINER, C_COMBAT_MAGE
			clientstate = CS_DIR;
			break;
		}
	} // not spectator or dead
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0xb3f0
testb $0x1, %al
jne 0xb2d4
movl $0x10, %edi
xorl %edx, %edx
movl %edx, %esi
callq 0x14210
jmp 0xb3e0
movl 0x1d1f6(%rip), %eax     # 0x284d0
movq %rax, -0x8(%rbp)
subq $0xa, %rax
ja 0xb3d1
movq -0x8(%rbp), %rax
leaq 0x1103d(%rip), %rcx     # 0x1c330
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x1dcdd(%rip), %rax     # 0x28fe0
cmpl $0x6, (%rax)
jne 0xb34b
cmpw $0x0, 0x1db90(%rip)     # 0x28ea0
jne 0xb31c
cmpw $0x0, 0x1db88(%rip)     # 0x28ea2
je 0xb33c
movw 0x1db7d(%rip), %ax      # 0x28ea0
movb %al, %cl
movw 0x1db76(%rip), %ax      # 0x28ea2
movl $0x5, %edi
movzbl %cl, %esi
movzbl %al, %edx
callq 0x14210
leaq 0x1dc9d(%rip), %rax     # 0x28fe0
movl $0x0, (%rax)
jmp 0xb36a
movw $0x0, 0x1db4e(%rip)     # 0x28ea2
movw $0x0, 0x1db43(%rip)     # 0x28ea0
leaq 0x1dc7c(%rip), %rax     # 0x28fe0
movl $0x6, (%rax)
callq 0x19160
jmp 0xb3de
movl $0x6, %edi
xorl %edx, %edx
movl %edx, %esi
callq 0x14210
jmp 0xb3de
movl $0x8, %edi
xorl %edx, %edx
movl %edx, %esi
callq 0x14210
jmp 0xb3de
movl $0x9, %edi
xorl %edx, %edx
movl %edx, %esi
callq 0x14210
jmp 0xb3de
movl $0xe, %edi
xorl %edx, %edx
movl %edx, %esi
callq 0x14210
jmp 0xb3de
movl $0xd, %edi
xorl %edx, %edx
movl %edx, %esi
callq 0x14210
jmp 0xb3de
movl $0xf, %edi
xorl %edx, %edx
movl %edx, %esi
callq 0x14210
jmp 0xb3de
leaq 0x1dc08(%rip), %rax     # 0x28fe0
movl $0x7, (%rax)
jmp 0xb3e0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: lotuskip[P]yuxtapa/client/class_cpv.cpp
// Function: ClassCPV::state_change(unsigned char, unsigned char)
void ClassCPV::state_change(const unsigned char cl, const unsigned char t)
{
	myteam = e_Team(t);
	hp = 0; // we are dead until further notice (the further notice being a status update)

	// print PC info:
	if((myclass = e_Class(cl)) == NO_CLASS) // spectator
		Base::print_str("Spectator  ", team_colour[T_SPEC], PC_INFO_X, 3, STAT_WIN, false);
	else // actual class 
	{
		Base::print_str(pcview_classname[myclass].c_str(), team_colour[myteam],
			PC_INFO_X, 3, STAT_WIN, false);
		dam_die = classes[myclass].dam_die;
		dv = classes[myclass].dv;
		pv = classes[myclass].pv;
	}
	// Clear the rest:
	for(char y = 4; y < 7; ++y)
		Base::print_str("          ", team_colour[T_SPEC], PC_INFO_X, y, STAT_WIN, false);
	Base::print_str("    ", team_colour[T_SPEC], 52, 3, STAT_WIN, false); // map area

	// class/team change requires any class-specific action to end:
	if(clientstate >= CS_AIMING)
	{
		clientstate = CS_NORMAL;
		redraw_view();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %sil, %al
movb %dil, %cl
movb %cl, -0x1(%rbp)
movb %al, -0x2(%rbp)
movzbl -0x2(%rbp), %eax
movl %eax, 0x1d046(%rip)     # 0x284d4
movb $0x0, 0x1da0f(%rip)     # 0x28ea4
movzbl -0x1(%rbp), %eax
movl %eax, 0x1d031(%rip)     # 0x284d0
cmpl $0xb, %eax
jne 0xb4cc
leaq 0x10fc8(%rip), %rdi     # 0x1c473
movl $0x25, %edx
movl $0x3, %ecx
xorl %r9d, %r9d
movzbl 0x10e9f(%rip), %esi     # 0x1c35e
movl %r9d, %r8d
callq 0x9480
jmp 0xb56d
movl 0x1cffe(%rip), %eax     # 0x284d0
leaq 0x1d867(%rip), %rdi     # 0x28d40
shlq $0x5, %rax
addq %rax, %rdi
callq 0x5200
movq %rax, %rdi
movl 0x1cfe6(%rip), %eax     # 0x284d4
movl %eax, %esi
movl $0x25, %edx
movl $0x3, %ecx
xorl %r9d, %r9d
leaq 0x10e58(%rip), %rax     # 0x1c35c
movzbl (%rax,%rsi), %esi
movl %r9d, %r8d
callq 0x9480
movl 0x1cfba(%rip), %eax     # 0x284d0
movl %eax, %ecx
leaq 0x10e41(%rip), %rax     # 0x1c360
imulq $0xd, %rcx, %rcx
addq %rcx, %rax
movb 0x6(%rax), %al
movb %al, 0x1d976(%rip)      # 0x28ea5
movl 0x1cf9b(%rip), %eax     # 0x284d0
movl %eax, %ecx
leaq 0x10e22(%rip), %rax     # 0x1c360
imulq $0xd, %rcx, %rcx
addq %rcx, %rax
movb 0x8(%rax), %al
movb %al, 0x1d958(%rip)      # 0x28ea6
movl 0x1cf7c(%rip), %eax     # 0x284d0
movl %eax, %ecx
leaq 0x10e03(%rip), %rax     # 0x1c360
imulq $0xd, %rcx, %rcx
addq %rcx, %rax
movb 0x9(%rax), %al
movb %al, 0x1d93a(%rip)      # 0x28ea7
movb $0x4, -0x3(%rbp)
movsbl -0x3(%rbp), %eax
cmpl $0x7, %eax
jge 0xb5a8
movb 0x10dde(%rip), %al      # 0x1c35e
leaq 0x10ef8(%rip), %rdi     # 0x1c47f
movl $0x25, %edx
xorl %r9d, %r9d
movzbl %al, %esi
movsbl -0x3(%rbp), %ecx
movl %r9d, %r8d
callq 0x9480
movb -0x3(%rbp), %al
addb $0x1, %al
movb %al, -0x3(%rbp)
jmp 0xb571
leaq 0x10ed6(%rip), %rdi     # 0x1c485
movl $0x34, %edx
movl $0x3, %ecx
xorl %r9d, %r9d
movzbl 0x10d9b(%rip), %esi     # 0x1c35e
movl %r9d, %r8d
callq 0x9480
leaq 0x1da0e(%rip), %rax     # 0x28fe0
cmpl $0x6, (%rax)
jl 0xb5e9
leaq 0x1da02(%rip), %rax     # 0x28fe0
movl $0x0, (%rax)
callq 0x19160
addq $0x10, %rsp
popq %rbp
retq
nop
// File: lotuskip[P]yuxtapa/client/class_cpv.cpp
// Function: ClassCPV::state_upd(SerialBuffer&)
void ClassCPV::state_upd(SerialBuffer &data)
{
	char oldhp = hp;
	hp = static_cast<char>(data.read_ch());
	// if got hurt but not dead and ouch is defined, send ouch:
	if(hp > 0 && hp < oldhp && Config::do_ouch())
		Network::send_line(Config::get_ouch(), false);
	tohit = static_cast<char>(data.read_ch());
	dam_add = static_cast<char>(data.read_ch());
	dv = data.read_ch();
	poisoned = bool(data.read_ch());
	sector = e_Dir(data.read_ch());
	torch_sym[0] = data.read_ch();

	reprint_pcinfo();

	// if died, abort any action in the client end:
	if(hp <= 0)
	{
		if(clientstate == CS_AIMING || clientstate == CS_DIR)
			clientstate = CS_NORMAL;
		Base::print_walk((walkmode = false));
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movb 0x1d8a2(%rip), %al      # 0x28ea4
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
callq 0x19ea0
movb %al, 0x1d890(%rip)      # 0x28ea4
movsbl 0x1d889(%rip), %eax     # 0x28ea4
cmpl $0x0, %eax
jle 0xb649
movsbl 0x1d87d(%rip), %eax     # 0x28ea4
movsbl -0x9(%rbp), %ecx
cmpl %ecx, %eax
jge 0xb649
callq 0x161b0
testb $0x1, %al
jne 0xb63a
jmp 0xb649
callq 0x161a0
movq %rax, %rdi
xorl %esi, %esi
callq 0x14360
movq -0x8(%rbp), %rdi
callq 0x19ea0
movb %al, 0x1d850(%rip)      # 0x28ea8
movq -0x8(%rbp), %rdi
callq 0x19ea0
movb %al, 0x1d842(%rip)      # 0x28ea9
movq -0x8(%rbp), %rdi
callq 0x19ea0
movb %al, 0x1d830(%rip)      # 0x28ea6
movq -0x8(%rbp), %rdi
callq 0x19ea0
cmpb $0x0, %al
setne %al
andb $0x1, %al
movb %al, 0x1d81e(%rip)      # 0x28eaa
movq -0x8(%rbp), %rdi
callq 0x19ea0
movzbl %al, %eax
movl %eax, 0x1d80e(%rip)     # 0x28eac
movq -0x8(%rbp), %rdi
callq 0x19ea0
movb %al, 0x1ce2b(%rip)      # 0x284d8
callq 0xb700
movsbl 0x1d7eb(%rip), %eax     # 0x28ea4
cmpl $0x0, %eax
jg 0xb6f4
leaq 0x1d91b(%rip), %rax     # 0x28fe0
cmpl $0x6, (%rax)
je 0xb6d6
leaq 0x1d90f(%rip), %rax     # 0x28fe0
cmpl $0x7, (%rax)
jne 0xb6e3
leaq 0x1d903(%rip), %rax     # 0x28fe0
movl $0x0, (%rax)
leaq 0x1d8fa(%rip), %rax     # 0x28fe4
movb $0x0, (%rax)
xorl %edi, %edi
callq 0x9ac0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: lotuskip[P]yuxtapa/client/input.cpp
// Function: (anonymous namespace)::init_type()
void init_type()
{
	typed_str.clear();
	viewn_str.clear();
	Base::type_cursor((type_pos = str_syms = 0));
	printb_pos = 0;
	prev_str_it = prev_strs.end();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x1bfb1(%rip), %rdi     # 0x29000
callq 0x56c0
leaq 0x1bfc5(%rip), %rdi     # 0x29020
callq 0x56c0
movw $0x0, 0x1bfe9(%rip)     # 0x29052
movw $0x0, 0x1bfce(%rip)     # 0x29040
xorl %edi, %edi
callq 0x99d0
movw $0x0, 0x1bfce(%rip)     # 0x29050
leaq 0x1bf5f(%rip), %rdi     # 0x28fe8
callq 0xa9f0
movq %rax, -0x10(%rbp)
leaq -0x8(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0xd400
movq -0x8(%rbp), %rax
movq %rax, 0x1bf9e(%rip)     # 0x29048
addq $0x10, %rsp
popq %rbp
retq
// File: lotuskip[P]yuxtapa/client/input.cpp
// Function: (anonymous namespace)::typing_done()
void typing_done()
{
	if(!viewn_str.empty())
	{
		if(prev_strs.empty() || viewn_str != prev_strs.back())
		{
			prev_strs.push_back(viewn_str);
			if(prev_strs.size() > 1000)
				prev_strs.erase(prev_strs.begin());
		}
		Config::do_aliasing(viewn_str);
		Network::send_line(viewn_str, clientstate == CS_TYPE_CHAT);
	}
	Base::print_str("", 0, 0, MSG_WIN_Y-1, MSG_WIN, true);
	Base::def_cursor();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x1bf61(%rip), %rdi     # 0x29020
callq 0x57f0
testb $0x1, %al
jne 0xd17f
leaq 0x1bf15(%rip), %rdi     # 0x28fe8
callq 0xd4f0
testb $0x1, %al
jne 0xd0fd
leaq 0x1bf05(%rip), %rdi     # 0x28fe8
callq 0xaa20
movq %rax, %rsi
leaq 0x1bf2e(%rip), %rdi     # 0x29020
callq 0xd480
testb $0x1, %al
jne 0xd0fd
jmp 0xd157
leaq 0x1bee4(%rip), %rdi     # 0x28fe8
leaq 0x1bf15(%rip), %rsi     # 0x29020
callq 0xd530
leaq 0x1bed1(%rip), %rdi     # 0x28fe8
callq 0xa1b0
cmpq $0x3e8, %rax            # imm = 0x3E8
jbe 0xd155
leaq 0x1bebd(%rip), %rdi     # 0x28fe8
callq 0xabb0
movq %rax, -0x10(%rbp)
leaq -0x8(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0xd400
movq -0x8(%rbp), %rsi
leaq 0x1be9c(%rip), %rdi     # 0x28fe8
callq 0xd5a0
movq %rax, -0x18(%rbp)
jmp 0xd157
leaq 0x1bec2(%rip), %rdi     # 0x29020
callq 0x16220
cmpl $0x1, 0x1be76(%rip)     # 0x28fe0
sete %al
movzbl %al, %esi
andl $0x1, %esi
leaq 0x1bea6(%rip), %rdi     # 0x29020
callq 0x14360
leaq 0xf303(%rip), %rdi      # 0x1c489
xorl %edx, %edx
movl $0xe, %ecx
movl $0x2, %r8d
movl $0x1, %r9d
movl %edx, %esi
callq 0x9480
callq 0x99b0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: lotuskip[P]yuxtapa/client/input.cpp
// Function: (anonymous namespace)::loop_up()
void loop_up()
{
	if(prev_str_it == prev_strs.begin())
	{
		set_viewn_str(typed_str);
		prev_str_it = prev_strs.end();
	}
	else
	{
		while(prev_str_it != prev_strs.begin())
		{
			if((*(--prev_str_it)).find(typed_str) == 0)
			{
				set_viewn_str(*prev_str_it);
				return;
			}
		}
		// if here, no matches found; recursive call to reset:
		loop_up();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x1be29(%rip), %rdi     # 0x28fe8
callq 0xabb0
movq %rax, -0x8(%rbp)
leaq 0x1be79(%rip), %rdi     # 0x29048
leaq -0x8(%rbp), %rsi
callq 0xdd90
testb $0x1, %al
jne 0xd1de
jmp 0xd214
leaq 0x1be1b(%rip), %rdi     # 0x29000
callq 0xd390
leaq 0x1bdf7(%rip), %rdi     # 0x28fe8
callq 0xa9f0
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0xd400
movq -0x10(%rbp), %rax
movq %rax, 0x1be36(%rip)     # 0x29048
jmp 0xd286
jmp 0xd216
leaq 0x1bdcb(%rip), %rdi     # 0x28fe8
callq 0xabb0
movq %rax, -0x20(%rbp)
leaq 0x1be1b(%rip), %rdi     # 0x29048
leaq -0x20(%rbp), %rsi
callq 0xddd0
testb $0x1, %al
jne 0xd23c
jmp 0xd281
leaq 0x1be05(%rip), %rdi     # 0x29048
callq 0xde10
movq %rax, %rdi
callq 0xde30
movq %rax, %rdi
leaq 0x1bda6(%rip), %rsi     # 0x29000
xorl %eax, %eax
movl %eax, %edx
callq 0x5940
cmpq $0x0, %rax
jne 0xd27f
leaq 0x1bdd8(%rip), %rdi     # 0x29048
callq 0xde30
movq %rax, %rdi
callq 0xd390
jmp 0xd286
jmp 0xd216
callq 0xd1b0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: lotuskip[P]yuxtapa/client/input.cpp
// Function: (anonymous namespace)::loop_down()
void loop_down()
{
	if(prev_strs.empty())
		return;
	if(prev_str_it == prev_strs.end())
		prev_str_it = prev_strs.begin();
	else
		++prev_str_it;
	while(prev_str_it != prev_strs.end())
	{
		if((*prev_str_it).find(typed_str) == 0)
		{
			set_viewn_str(*prev_str_it);
			return;
		}
		++prev_str_it;
	}
	// if here, no matches found:
	set_viewn_str(typed_str);	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x1bd49(%rip), %rdi     # 0x28fe8
callq 0xd4f0
testb $0x1, %al
jne 0xd2aa
jmp 0xd2af
jmp 0xd388
leaq 0x1bd32(%rip), %rdi     # 0x28fe8
callq 0xa9f0
movq %rax, -0x8(%rbp)
leaq 0x1bd82(%rip), %rdi     # 0x29048
leaq -0x8(%rbp), %rsi
callq 0xdd90
testb $0x1, %al
jne 0xd2d5
jmp 0xd2ff
leaq 0x1bd0c(%rip), %rdi     # 0x28fe8
callq 0xabb0
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0xd400
movq -0x10(%rbp), %rax
movq %rax, 0x1bd4b(%rip)     # 0x29048
jmp 0xd30b
leaq 0x1bd42(%rip), %rdi     # 0x29048
callq 0xde50
jmp 0xd30d
leaq 0x1bcd4(%rip), %rdi     # 0x28fe8
callq 0xa9f0
movq %rax, -0x20(%rbp)
leaq 0x1bd24(%rip), %rdi     # 0x29048
leaq -0x20(%rbp), %rsi
callq 0xddd0
testb $0x1, %al
jne 0xd333
jmp 0xd37c
leaq 0x1bd0e(%rip), %rdi     # 0x29048
callq 0xde30
movq %rax, %rdi
leaq 0x1bcb7(%rip), %rsi     # 0x29000
xorl %eax, %eax
movl %eax, %edx
callq 0x5940
cmpq $0x0, %rax
jne 0xd36e
leaq 0x1bce9(%rip), %rdi     # 0x29048
callq 0xde30
movq %rax, %rdi
callq 0xd390
jmp 0xd388
leaq 0x1bcd3(%rip), %rdi     # 0x29048
callq 0xde50
jmp 0xd30d
leaq 0x1bc7d(%rip), %rdi     # 0x29000
callq 0xd390
addq $0x20, %rsp
popq %rbp
retq
nop
// File: lotuskip[P]yuxtapa/client/msg.cpp
// Function: add_msg(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned char)
void add_msg(const string &s, const unsigned char cp)
{
	/* First check if this new message is identical with the previous (this
	 * happens especially if someone keeps shouting something */
	if(check_repeat_msg(s, cp))
		return;

	// The rest goes for non-repeating messages:

	if(bottom_idx == MSG_WIN_Y-1) // screen buffer full
	{
		// check if STAY_TIME has passed:
		if(reference.update() - last_add < STAY_TIME)
		{
			// time not passed, put the message in queue to be displayed later
			msgavail.push_back(MsgBufferLine(s,cp));
			return;
		}
		else
			move_msgs();
	}
	msgbuffer[bottom_idx].text = s;
	msgbuffer[bottom_idx].cpair = cp;
	++bottom_idx;
	redraw_msgs();
	last_add.update();
	last_move.update(); // also delay moving
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
movzbl -0x9(%rbp), %esi
callq 0xe2b0
testb $0x1, %al
jne 0xe1a5
jmp 0xe1aa
jmp 0xe2a1
movsbl 0x1afc7(%rip), %eax     # 0x29178
cmpl $0xe, %eax
jne 0xe22e
leaq 0x1afc3(%rip), %rdi     # 0x29180
callq 0x19b60
movq %rax, %rdi
leaq 0x1af8c(%rip), %rsi     # 0x29158
callq 0x19b90
cmpl $0x2ee, %eax            # imm = 0x2EE
jae 0xe227
movq -0x8(%rbp), %rsi
movzbl -0x9(%rbp), %edx
leaq -0x38(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0xe400
movq -0x50(%rbp), %rsi
leaq 0x1aeb0(%rip), %rdi     # 0x290a8
callq 0xe3d0
jmp 0xe1ff
leaq -0x38(%rbp), %rdi
callq 0xe460
jmp 0xe2a1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xe460
jmp 0xe2a7
callq 0xe480
jmp 0xe22e
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movsbq 0x1af3a(%rip), %rsi     # 0x29178
leaq 0x1ae13(%rip), %rdi     # 0x29058
callq 0xe5c0
movq -0x60(%rbp), %rsi
movq %rax, %rdi
callq 0x5060
movb -0x9(%rbp), %al
movb %al, -0x51(%rbp)
movsbq 0x1af14(%rip), %rsi     # 0x29178
leaq 0x1aded(%rip), %rdi     # 0x29058
callq 0xe5c0
movb -0x51(%rbp), %cl
movb %cl, 0x20(%rax)
movb 0x1aefc(%rip), %al      # 0x29178
addb $0x1, %al
movb %al, 0x1aef4(%rip)      # 0x29178
callq 0xe5f0
leaq 0x1aec8(%rip), %rdi     # 0x29158
callq 0x19b60
leaq 0x1aeac(%rip), %rdi     # 0x29148
callq 0x19b60
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x5830