tabbed.o:     формат файла elf64-x86-64


Дизассемблирование раздела .text:

<focusonce>:
	movl   $0x1,0x0(%rip)        # <focusonce+0xa>
	retq   

<getclient>:
	mov    0x0(%rip),%edx        # <getclient+0x6>
	mov    0x0(%rip),%rcx        # <getclient+0xd>
	xor    %eax,%eax
	mov    %eax,%r8d
	cmp    %eax,%edx
	jle    <getclient+0x28>
	mov    (%rcx,%rax,8),%rsi
	inc    %rax
	cmp    %rdi,0x100(%rsi)
	jne    <getclient+0xf>
	jmp    <getclient+0x2c>
	or     $0xffffffff,%r8d
	mov    %r8d,%eax
	retq   

<toggle>:
	mov    (%rdi),%rax
	xor    %edx,%edx
	cmpl   $0x0,(%rax)
	sete   %dl
	mov    %edx,(%rax)
	retq   

<die>:
	sub    $0xd8,%rsp
	mov    %rdi,%r10
	mov    %rsi,0x28(%rsp)
	mov    %rdx,0x30(%rsp)
	mov    %rcx,0x38(%rsp)
	mov    %r8,0x40(%rsp)
	mov    %r9,0x48(%rsp)
	test   %al,%al
	je     <die+0x5e>
	movaps %xmm0,0x50(%rsp)
	movaps %xmm1,0x60(%rsp)
	movaps %xmm2,0x70(%rsp)
	movaps %xmm3,0x80(%rsp)
	movaps %xmm4,0x90(%rsp)
	movaps %xmm5,0xa0(%rsp)
	movaps %xmm6,0xb0(%rsp)
	movaps %xmm7,0xc0(%rsp)
	mov    %fs:0x28,%rax
	mov    %rax,0x18(%rsp)
	xor    %eax,%eax
	mov    0x0(%rip),%rdi        # <die+0x75>
	mov    %rsp,%rcx
	mov    %r10,%rdx
	lea    0xe0(%rsp),%rax
	mov    $0x1,%esi
	movl   $0x8,(%rsp)
	mov    %rax,0x8(%rsp)
	lea    0x20(%rsp),%rax
	movl   $0x30,0x4(%rsp)
	mov    %rax,0x10(%rsp)
	callq  <die+0xab>
	mov    $0x1,%edi
	callq  <xerror>

<xerror>:
	movzbl 0x20(%rsi),%r9d
	cmp    $0x3,%r9b
	je     <xerror+0x99>
	push   %r12
	push   %rbp
	mov    %rsi,%rbp
	push   %r8
	mov    0x20(%rsi),%eax
	cmp    $0x2a08,%ax
	sete   %dl
	cmp    $0x4a09,%ax
	sete   %cl
	or     %ecx,%edx
	cmp    $0xc08,%ax
	sete   %cl
	or     %ecx,%edx
	cmp    $0x1c0a,%ax
	sete   %cl
	or     %ecx,%edx
	cmp    $0x210a,%ax
	sete   %cl
	or     %ecx,%edx
	cmp    $0x3e09,%ax
	sete   %cl
	or     %cl,%dl
	jne    <xerror+0x92>
	and    $0xfb,%ah
	cmp    $0x4209,%ax
	je     <xerror+0x92>
	mov    %rdi,%r12
	movzbl 0x21(%rsi),%r8d
	xor    %eax,%eax
	mov    0x0(%rip),%rcx        # <xerror+0x6a>
	mov    0x0(%rip),%rdi        # <xerror+0x71>
	mov    $0x1,%esi
	lea    0x0(%rip),%rdx        # <xerror+0x7d>
	callq  <xerror+0x82>
	pop    %rcx
	mov    %rbp,%rsi
	mov    %r12,%rdi
	pop    %rbp
	pop    %r12
	jmpq   *0x0(%rip)        # <xerror+0x92>
	pop    %rdx
	xor    %eax,%eax
	pop    %rbp
	pop    %r12
	retq   
	xor    %eax,%eax
	retq   

<configurerequest>:
	sub    $0x38,%rsp
	mov    %rdi,%r9
	mov    0x28(%rdi),%rdi
	mov    %fs:0x28,%rax
	mov    %rax,0x28(%rsp)
	xor    %eax,%eax
	callq  <getclient>
	test   %eax,%eax
	js     <configurerequest+0x8b>
	mov    0x0(%rip),%edx        # <configurerequest+0x2a>
	mov    0x0(%rip),%ecx        # <configurerequest+0x30>
	cltq   
	movl   $0x0,(%rsp)
	mov    0x0(%rip),%rsi        # <configurerequest+0x40>
	mov    0x0(%rip),%rdi        # <configurerequest+0x47>
	movl   $0x0,0x10(%rsp)
	mov    %edx,0x8(%rsp)
	mov    0x0(%rip),%edx        # <configurerequest+0x59>
	mov    (%rsi,%rax,8),%rax
	mov    %ecx,0x4(%rsp)
	sub    %ecx,%edx
	mov    %rsp,%rcx
	mov    %edx,0xc(%rsp)
	mov    0x48(%r9),%rdx
	mov    0x100(%rax),%rsi
	mov    %rdx,0x18(%rsp)
	mov    0x50(%r9),%edx
	mov    %edx,0x20(%rsp)
	mov    0x58(%r9),%rdx
	callq  <configurerequest+0x8b>
	mov    0x28(%rsp),%rax
	sub    %fs:0x28,%rax
	je     <configurerequest+0xa0>
	callq  <configurerequest+0xa0>
	add    $0x38,%rsp
	retq   

<resize>:
	push   %rbx
	movslq %edi,%rbx
	sub    $0x90,%rsp
	mov    0x0(%rip),%r8        # <resize+0x12>
	mov    %fs:0x28,%rax
	mov    %rax,0x88(%rsp)
	xor    %eax,%eax
	mov    0x0(%rip),%eax        # <resize+0x2b>
	mov    %esi,0x10(%rsp)
	lea    0x8(%rsp),%rcx
	mov    %esi,0x68(%rsp)
	mov    %r8,%rdi
	mov    %eax,0xc(%rsp)
	mov    %eax,0x64(%rsp)
	mov    0x0(%rip),%rax        # <resize+0x4a>
	mov    %edx,0x14(%rsp)
	mov    (%rax,%rbx,8),%rax
	mov    %edx,0x6c(%rsp)
	mov    $0xe,%edx
	mov    %r8,0x48(%rsp)
	mov    0x100(%rax),%rsi
	movl   $0x0,0x60(%rsp)
	movl   $0x16,0x30(%rsp)
	mov    %rsi,0x50(%rsp)
	mov    %rsi,0x58(%rsp)
	movq   $0x0,0x78(%rsp)
	movl   $0x0,0x80(%rsp)
	movl   $0x0,0x70(%rsp)
	callq  <resize+0xa2>
	mov    0x0(%rip),%rax        # <resize+0xa9>
	xor    %edx,%edx
	mov    0x0(%rip),%rdi        # <resize+0xb2>
	lea    0x30(%rsp),%r8
	mov    $0x20000,%ecx
	mov    (%rax,%rbx,8),%rax
	mov    0x100(%rax),%rsi
	callq  <resize+0xcc>
	mov    0x88(%rsp),%rax
	sub    %fs:0x28,%rax
	je     <resize+0xe4>
	callq  <resize+0xe4>
	add    $0x90,%rsp
	pop    %rbx
	retq   

<fullscreen>:
	sub    $0xd8,%rsp
	mov    0x0(%rip),%rsi        # <fullscreen+0xe>
	xor    %edx,%edx
	mov    0x0(%rip),%rdi        # <fullscreen+0x17>
	mov    %fs:0x28,%rax
	mov    %rax,0xc8(%rsp)
	xor    %eax,%eax
	mov    0x0(%rip),%rax        # <fullscreen+0x31>
	lea    0x8(%rsp),%r8
	mov    $0x80000,%ecx
	movl   $0x21,0x8(%rsp)
	mov    %rax,0x28(%rsp)
	mov    0x0(%rip),%rax        # <fullscreen+0x4f>
	movl   $0x20,0x38(%rsp)
	mov    %rax,0x30(%rsp)
	mov    0x0(%rip),%rax        # <fullscreen+0x63>
	movq   $0x2,0x40(%rsp)
	mov    %rax,0x48(%rsp)
	movq   $0x0,0x50(%rsp)
	callq  <fullscreen+0x7f>
	mov    0xc8(%rsp),%rax
	sub    %fs:0x28,%rax
	je     <fullscreen+0x97>
	callq  <fullscreen+0x97>
	add    $0xd8,%rsp
	retq   

<xsettitle>:
	push   %r13
	mov    $0x4,%ecx
	mov    $0x1,%edx
	push   %r12
	push   %rbp
	mov    %rdi,%rbp
	sub    $0x40,%rsp
	mov    0x0(%rip),%rdi        # <xsettitle+0x1d>
	mov    %rsi,0x8(%rsp)
	lea    0x18(%rsp),%r12
	lea    0x8(%rsp),%r13
	mov    %r12,%r8
	mov    %r13,%rsi
	mov    %fs:0x28,%rax
	mov    %rax,0x38(%rsp)
	xor    %eax,%eax
	callq  <xsettitle+0x47>
	test   %eax,%eax
	jne    <xsettitle+0x6e>
	mov    0x0(%rip),%rdi        # <xsettitle+0x52>
	mov    0x0(%rip),%rcx        # <xsettitle+0x59>
	mov    %r12,%rdx
	mov    %rbp,%rsi
	callq  <xsettitle+0x64>
	mov    0x18(%rsp),%rdi
	callq  <xsettitle+0x6e>
	mov    %r12,%r8
	mov    $0x1,%ecx
	mov    $0x1,%edx
	mov    %r13,%rsi
	mov    0x0(%rip),%rdi        # <xsettitle+0x85>
	callq  <xsettitle+0x8a>
	test   %eax,%eax
	jne    <xsettitle+0xaf>
	mov    0x0(%rip),%rdi        # <xsettitle+0x95>
	mov    $0x27,%ecx
	mov    %r12,%rdx
	mov    %rbp,%rsi
	callq  <xsettitle+0xa5>
	mov    0x18(%rsp),%rdi
	callq  <xsettitle+0xaf>
	mov    0x38(%rsp),%rax
	sub    %fs:0x28,%rax
	je     <xsettitle+0xc4>
	callq  <xsettitle+0xc4>
	add    $0x40,%rsp
	pop    %rbp
	pop    %r12
	pop    %r13
	retq   

<textnw>:
	sub    $0x28,%rsp
	mov    %rdi,%rdx
	mov    %esi,%ecx
	mov    0x0(%rip),%rdi        # <textnw+0x10>
	mov    %fs:0x28,%rax
	mov    %rax,0x18(%rsp)
	xor    %eax,%eax
	mov    0x0(%rip),%rsi        # <textnw+0x27>
	lea    0xc(%rsp),%r8
	callq  <textnw+0x31>
	movswl 0x14(%rsp),%eax
	mov    0x18(%rsp),%rdx
	sub    %fs:0x28,%rdx
	je     <textnw+0x4b>
	callq  <textnw+0x4b>
	add    $0x28,%rsp
	retq   

<getfirsttab>:
	cmpl   $0x0,0x0(%rip)        # <getfirsttab+0x7>
	js     <getfirsttab+0xa4>
	push   %rbp
	mov    $0xc8,%ebp
	push   %rbx
	push   %rcx
	mov    0x0(%rip),%ebx        # <getfirsttab+0x1b>
	mov    %ebx,%eax
	cltd   
	idiv   %ebp
	cmp    %eax,0x0(%rip)        # <getfirsttab+0x26>
	mov    %eax,%esi
	jle    <getfirsttab+0x65>
	mov    $0x1,%esi
	lea    0x0(%rip),%rdi        # <getfirsttab+0x36>
	callq  <textnw>
	mov    $0x1,%esi
	add    0x0(%rip),%eax        # <getfirsttab+0x46>
	lea    0x0(%rip),%rdi        # <getfirsttab+0x4d>
	sub    %eax,%ebx
	callq  <textnw>
	add    0x0(%rip),%eax        # <getfirsttab+0x5a>
	mov    %eax,%edx
	mov    %ebx,%eax
	sub    %edx,%eax
	cltd   
	idiv   %ebp
	mov    %eax,%esi
	mov    %esi,%eax
	mov    $0x2,%edi
	mov    0x0(%rip),%ecx        # <getfirsttab+0x72>
	cltd   
	idiv   %edi
	sub    %eax,%ecx
	lea    0x1(%rsi),%eax
	cltd   
	idiv   %edi
	mov    %ecx,%eax
	add    %edx,%eax
	jns    <getfirsttab+0x87>
	xor    %eax,%eax
	jmp    <getfirsttab+0xa0>
	mov    0x0(%rip),%edx        # <getfirsttab+0x8d>
	lea    (%rsi,%rax,1),%ecx
	cmp    %edx,%ecx
	jle    <getfirsttab+0xa0>
	mov    %edx,%eax
	mov    $0x0,%edx
	sub    %esi,%eax
	cmovs  %edx,%eax
	pop    %rdx
	pop    %rbx
	pop    %rbp
	retq   
	xor    %eax,%eax
	retq   

<drawtext>:
	push   %r15
	push   %r14
	push   %r13
	mov    %rsi,%r13
	push   %r12
	push   %rbp
	mov    %rdi,%rbp
	push   %rbx
	sub    $0x128,%rsp
	mov    0x10(%rsi),%rdx
	mov    0x0(%rip),%rdi        # <drawtext+0x22>
	mov    %fs:0x28,%rax
	mov    %rax,0x118(%rsp)
	mov    0x0(%rip),%eax        # <drawtext+0x39>
	mov    0x0(%rip),%rsi        # <drawtext+0x40>
	mov    %ax,0x10(%rsp)
	mov    0x0(%rip),%eax        # <drawtext+0x4b>
	mov    %ax,0x12(%rsp)
	mov    0x0(%rip),%eax        # <drawtext+0x56>
	mov    %ax,0x14(%rsp)
	mov    0x0(%rip),%eax        # <drawtext+0x61>
	mov    %ax,0x16(%rsp)
	callq  <drawtext+0x6b>
	lea    0x10(%rsp),%rcx
	mov    $0x1,%r8d
	mov    0x0(%rip),%rdx        # <drawtext+0x7d>
	mov    0x0(%rip),%rsi        # <drawtext+0x84>
	mov    0x0(%rip),%rdi        # <drawtext+0x8b>
	callq  <drawtext+0x90>
	test   %rbp,%rbp
	je     <drawtext+0x1c0>
	mov    %rbp,%rdi
	callq  <drawtext+0xa1>
	mov    0x0(%rip),%r14d        # <drawtext+0xa8>
	mov    $0x100,%r8d
	mov    %rax,%r12
	mov    0x0(%rip),%eax        # <drawtext+0xb7>
	mov    %r8d,%ebx
	add    %r14d,%eax
	cmp    $0x100,%r12d
	mov    %eax,(%rsp)
	mov    0x0(%rip),%eax        # <drawtext+0xcd>
	cmovb  %r12d,%ebx
	mov    %eax,0x4(%rsp)
	mov    0x0(%rip),%eax        # <drawtext+0xdb>
	mov    %eax,0x8(%rsp)
	mov    0x0(%rip),%eax        # <drawtext+0xe5>
	mov    %eax,0xc(%rsp)
	test   %ebx,%ebx
	je     <drawtext+0x1c0>
	mov    %ebx,%esi
	mov    %rbp,%rdi
	callq  <textnw>
	mov    0x0(%rip),%edx        # <drawtext+0x101>
	sub    (%rsp),%edx
	cmp    %edx,%eax
	jle    <drawtext+0x10c>
	dec    %ebx
	jmp    <drawtext+0xe9>
	lea    0x18(%rsp),%r15
	movslq %ebx,%rdx
	mov    $0x100,%ecx
	mov    %rbp,%rsi
	mov    %r15,%rdi
	callq  <drawtext+0x124>
	cmp    %r12d,%ebx
	jge    <drawtext+0x151>
	lea    -0x1(%rbx),%eax
	movslq %eax,%rdx
	movb   $0xa6,0x18(%rsp,%rdx,1)
	test   %eax,%eax
	je     <drawtext+0x151>
	lea    -0x2(%rbx),%eax
	movslq %eax,%rdx
	movb   $0x80,0x18(%rsp,%rdx,1)
	test   %eax,%eax
	je     <drawtext+0x151>
	lea    -0x3(%rbx),%eax
	cltq   
	movb   $0xe2,0x18(%rsp,%rax,1)
	mov    0x0(%rip),%rcx        # <drawtext+0x158>
	mov    0x0(%rip),%rdx        # <drawtext+0x15f>
	mov    0x0(%rip),%rsi        # <drawtext+0x166>
	mov    0x0(%rip),%rdi        # <drawtext+0x16d>
	callq  <drawtext+0x172>
	mov    $0x2,%ecx
	mov    0x4(%rsp),%esi
	mov    %r15,%r9
	mov    %rax,%rbp
	mov    0x8(%rsp),%eax
	mov    %rbp,%rdi
	cltd   
	idiv   %ecx
	add    %eax,%esi
	mov    (%rsp),%eax
	cltd   
	idiv   %ecx
	sub    %eax,%esi
	mov    (%rsp),%eax
	lea    (%rsi,%r14,1),%r8d
	mov    %r13,%rsi
	cltd   
	idiv   %ecx
	mov    0xc(%rsp),%ecx
	mov    0x0(%rip),%rdx        # <drawtext+0x1ad>
	add    %eax,%ecx
	push   %rax
	push   %rbx
	callq  <drawtext+0x1b6>
	mov    %rbp,%rdi
	callq  <drawtext+0x1be>
	pop    %rdx
	pop    %rcx
	mov    0x118(%rsp),%rax
	sub    %fs:0x28,%rax
	je     <drawtext+0x1d8>
	callq  <drawtext+0x1d8>
	add    $0x128,%rsp
	pop    %rbx
	pop    %rbp
	pop    %r12
	pop    %r13
	pop    %r14
	pop    %r15
	retq   

<drawbar>:
	push   %r15
	push   %r14
	push   %r13
	push   %r12
	push   %rbp
	push   %rbx
	sub    $0x18,%rsp
	mov    0x0(%rip),%ecx        # <drawbar+0x14>
	mov    0x0(%rip),%ebp        # <drawbar+0x1a>
	mov    %fs:0x28,%rax
	mov    %rax,0x8(%rsp)
	xor    %eax,%eax
	movq   $0x0,(%rsp)
	test   %ecx,%ecx
	jne    <drawbar+0x7d>
	mov    0x0(%rip),%rdi        # <drawbar+0x3d>
	mov    %rsp,%rdx
	mov    0x0(%rip),%rsi        # <drawbar+0x47>
	movl   $0x0,0x0(%rip)        # <drawbar+0x51>
	mov    %ebp,0x0(%rip)        # <drawbar+0x57>
	callq  <drawbar+0x5c>
	mov    (%rsp),%rdi
	test   %rdi,%rdi
	jne    <drawbar+0x6c>
	lea    0x0(%rip),%rdi        # <drawbar+0x6c>
	lea    0x0(%rip),%rsi        # <drawbar+0x73>
	callq  <drawtext>
	jmpq   <drawbar+0x204>
	mov    %ebp,%eax
	mov    $0xc8,%r12d
	cltd   
	idiv   %r12d
	mov    %eax,%ebx
	cmp    %eax,%ecx
	jle    <drawbar+0xcb>
	mov    $0x1,%esi
	lea    0x0(%rip),%rdi        # <drawbar+0x9b>
	mov    %ebp,%ebx
	callq  <textnw>
	mov    $0x1,%esi
	add    0x0(%rip),%eax        # <drawbar+0xad>
	lea    0x0(%rip),%rdi        # <drawbar+0xb4>
	sub    %eax,%ebx
	callq  <textnw>
	add    0x0(%rip),%eax        # <drawbar+0xc1>
	sub    %eax,%ebx
	mov    %ebx,%eax
	cltd   
	idiv   %r12d
	mov    %eax,%ebx
	callq  <getfirsttab>
	mov    %eax,%r12d
	add    %ebx,%eax
	cmp    0x0(%rip),%eax        # <drawbar+0xdb>
	jge    <drawbar+0x11d>
	mov    $0x1,%esi
	lea    0x0(%rip),%rdi        # <drawbar+0xe9>
	callq  <textnw>
	mov    %ebp,%edx
	add    0x0(%rip),%eax        # <drawbar+0xf6>
	lea    0x0(%rip),%rsi        # <drawbar+0xfd>
	sub    %eax,%edx
	lea    0x0(%rip),%rdi        # <drawbar+0x106>
	mov    %eax,0x0(%rip)        # <drawbar+0x10c>
	mov    %edx,0x0(%rip)        # <drawbar+0x112>
	callq  <drawtext>
	sub    0x0(%rip),%ebp        # <drawbar+0x11d>
	movl   $0x0,0x0(%rip)        # <drawbar+0x127>
	test   %r12d,%r12d
	jle    <drawbar+0x16a>
	mov    $0x1,%esi
	lea    0x0(%rip),%rdi        # <drawbar+0x138>
	callq  <textnw>
	lea    0x0(%rip),%rsi        # <drawbar+0x144>
	add    0x0(%rip),%eax        # <drawbar+0x14a>
	lea    0x0(%rip),%rdi        # <drawbar+0x151>
	mov    %eax,0x0(%rip)        # <drawbar+0x157>
	callq  <drawtext>
	mov    0x0(%rip),%eax        # <drawbar+0x162>
	add    %eax,0x0(%rip)        # <drawbar+0x168>
	sub    %eax,%ebp
	movslq %r12d,%r14
	cmp    %ebx,0x0(%rip)        # <drawbar+0x173>
	mov    %r12d,%r15d
	cmovle 0x0(%rip),%ebx        # <drawbar+0x17d>
	lea    0x0(%rip),%r13        # <drawbar+0x184>
	shl    $0x3,%r14
	lea    (%r12,%rbx,1),%eax
	cmp    %r15d,%eax
	jle    <drawbar+0x204>
	mov    %ebp,%eax
	mov    0x0(%rip),%rcx        # <drawbar+0x19a>
	cltd   
	idiv   %ebx
	mov    (%rcx,%r14,1),%rdi
	cmp    %r15d,0x0(%rip)        # <drawbar+0x1a8>
	mov    %eax,0x0(%rip)        # <drawbar+0x1ae>
	jne    <drawbar+0x1c1>
	add    %eax,%edx
	lea    0x0(%rip),%rsi        # <drawbar+0x1b9>
	mov    %edx,0x0(%rip)        # <drawbar+0x1bf>
	jmp    <drawbar+0x1d3>
	cmpl   $0x0,0x10c(%rdi)
	lea    0x0(%rip),%rsi        # <drawbar+0x1cf>
	cmovne %r13,%rsi
	callq  <drawtext>
	mov    0x0(%rip),%rdx        # <drawbar+0x1df>
	mov    0x0(%rip),%eax        # <drawbar+0x1e5>
	inc    %r15d
	add    0x0(%rip),%eax        # <drawbar+0x1ee>
	mov    (%rdx,%r14,1),%rdx
	mov    %eax,0x0(%rip)        # <drawbar+0x1f8>
	add    $0x8,%r14
	mov    %eax,0x108(%rdx)
	jmp    <drawbar+0x188>
	mov    0x0(%rip),%eax        # <drawbar+0x20a>
	pushq  $0x0
	xor    %r9d,%r9d
	xor    %r8d,%r8d
	mov    0x0(%rip),%rsi        # <drawbar+0x219>
	mov    0x0(%rip),%rdi        # <drawbar+0x220>
	pushq  $0x0
	mov    0x0(%rip),%rcx        # <drawbar+0x229>
	mov    0x0(%rip),%rdx        # <drawbar+0x230>
	push   %rax
	mov    0x0(%rip),%eax        # <drawbar+0x237>
	push   %rax
	callq  <drawbar+0x23d>
	mov    0x0(%rip),%rdi        # <drawbar+0x244>
	add    $0x20,%rsp
	xor    %esi,%esi
	callq  <drawbar+0x24f>
	mov    0x8(%rsp),%rax
	sub    %fs:0x28,%rax
	je     <drawbar+0x264>
	callq  <drawbar+0x264>
	add    $0x18,%rsp
	pop    %rbx
	pop    %rbp
	pop    %r12
	pop    %r13
	pop    %r14
	pop    %r15
	retq   

<killclient>:
	push   %r12
	push   %rbp
	push   %rbx
	sub    $0xe0,%rsp
	mov    %fs:0x28,%rax
	mov    %rax,0xd8(%rsp)
	xor    %eax,%eax
	test   %rdi,%rdi
	je     <killclient+0x28>
	movslq (%rdi),%rbx
	jmp    <killclient+0x37>
	movslq 0x0(%rip),%rbx        # <killclient+0x2f>
	test   %ebx,%ebx
	js     <killclient+0x172>
	mov    0x0(%rip),%rax        # <killclient+0x3e>
	lea    0xc(%rsp),%rcx
	mov    0x0(%rip),%rdi        # <killclient+0x4a>
	lea    0x10(%rsp),%rdx
	lea    0x0(,%rbx,8),%rbp
	mov    (%rax,%rbx,8),%rax
	mov    0x100(%rax),%rsi
	callq  <killclient+0x67>
	test   %eax,%eax
	je     <killclient+0x136>
	mov    0xc(%rsp),%edx
	mov    0x10(%rsp),%rdi
	xor    %eax,%eax
	mov    0x0(%rip),%rcx        # <killclient+0x81>
	cmp    %eax,%edx
	jle    <killclient+0x99>
	mov    (%rdi,%rax,8),%rsi
	inc    %rax
	cmp    %rcx,%rsi
	jne    <killclient+0x81>
	mov    $0x1,%r12d
	jmp    <killclient+0x9c>
	xor    %r12d,%r12d
	callq  <killclient+0xa1>
	test   %r12d,%r12d
	je     <killclient+0x136>
	mov    0x0(%rip),%rax        # <killclient+0xb1>
	add    %rbp,%rax
	mov    (%rax),%rdx
	cmpl   $0x0,0x110(%rdx)
	jne    <killclient+0x136>
	movl   $0x21,0x18(%rsp)
	mov    (%rax),%rdx
	lea    0x18(%rsp),%r8
	xor    %ecx,%ecx
	movl   $0x20,0x48(%rsp)
	mov    0x0(%rip),%rdi        # <killclient+0xe1>
	movq   $0x0,0x58(%rsp)
	mov    0x100(%rdx),%rdx
	mov    %rdx,0x38(%rsp)
	mov    0x0(%rip),%rdx        # <killclient+0xfd>
	mov    %rdx,0x40(%rsp)
	mov    0x0(%rip),%rdx        # <killclient+0x109>
	mov    %rdx,0x50(%rsp)
	mov    (%rax),%rax
	xor    %edx,%edx
	mov    0x100(%rax),%rsi
	callq  <killclient+0x11f>
	mov    0x0(%rip),%rax        # <killclient+0x126>
	mov    (%rax,%rbx,8),%rax
	movl   $0x1,0x110(%rax)
	jmp    <killclient+0x172>
	mov    0xd8(%rsp),%rax
	sub    %fs:0x28,%rax
	jne    <killclient+0x185>
	mov    0x0(%rip),%rax        # <killclient+0x150>
	mov    0x0(%rip),%rdi        # <killclient+0x157>
	mov    (%rax,%rbx,8),%rax
	mov    0x100(%rax),%rsi
	add    $0xe0,%rsp
	pop    %rbx
	pop    %rbp
	pop    %r12
	jmpq   <killclient+0x172>
	mov    0xd8(%rsp),%rax
	sub    %fs:0x28,%rax
	je     <killclient+0x18a>
	callq  <killclient+0x18a>
	add    $0xe0,%rsp
	pop    %rbx
	pop    %rbp
	pop    %r12
	retq   

<movetab>:
	mov    0x0(%rip),%ecx        # <movetab+0x6>
	test   %ecx,%ecx
	js     <movetab+0x98>
	push   %r12
	mov    0x0(%rip),%esi        # <movetab+0x16>
	push   %rbp
	push   %rbx
	mov    (%rdi),%eax
	add    %ecx,%eax
	cltd   
	idiv   %esi
	mov    %edx,%r12d
	test   %edx,%edx
	jns    <movetab+0x29>
	add    %esi,%r12d
	cmp    %r12d,%ecx
	je     <movetab+0x93>
	mov    0x0(%rip),%rsi        # <movetab+0x35>
	movslq %ecx,%rdi
	movslq %r12d,%rax
	shl    $0x3,%rdi
	shl    $0x3,%rax
	lea    (%rsi,%rdi,1),%r8
	lea    (%rsi,%rax,1),%rbx
	mov    (%r8),%rbp
	cmp    %r12d,%ecx
	jge    <movetab+0x69>
	mov    %r12d,%edx
	lea    0x8(%rsi,%rdi,1),%rsi
	mov    %r8,%rdi
	sub    %ecx,%edx
	movslq %edx,%rdx
	shl    $0x3,%rdx
	jmp    <movetab+0x7b>
	sub    %r12d,%ecx
	lea    0x8(%rsi,%rax,1),%rdi
	mov    %rbx,%rsi
	movslq %ecx,%rdx
	shl    $0x3,%rdx
	callq  <movetab+0x80>
	mov    %rbp,(%rbx)
	pop    %rbx
	mov    %r12d,0x0(%rip)        # <movetab+0x8b>
	pop    %rbp
	pop    %r12
	jmpq   <drawbar>
	pop    %rbx
	pop    %rbp
	pop    %r12
	retq   
	retq   

<keypress>:
	push   %r13
	xor    %ecx,%ecx
	push   %r12
	push   %rbp
	mov    %rdi,%rbp
	push   %rbx
	lea    0x0(%rip),%rbx        # <keypress+0x12>
	push   %rdx
	movzbl 0x54(%rdi),%esi
	xor    %edx,%edx
	lea    0x2c0(%rbx),%r13
	mov    0x0(%rip),%rdi        # <keypress+0x27>
	callq  <keypress+0x2c>
	mov    %rax,%r12
	cmp    %r12,0x8(%rbx)
	jne    <keypress+0x58>
	mov    0x0(%rip),%eax        # <keypress+0x3b>
	mov    (%rbx),%edx
	xor    0x50(%rbp),%edx
	or     $0x2,%eax
	not    %eax
	test   %eax,%edx
	jne    <keypress+0x58>
	mov    0x10(%rbx),%rax
	test   %rax,%rax
	je     <keypress+0x58>
	lea    0x18(%rbx),%rdi
	callq  *%rax
	add    $0x20,%rbx
	cmp    %r13,%rbx
	jne    <keypress+0x2f>
	pop    %rax
	pop    %rbx
	pop    %rbp
	pop    %r12
	pop    %r13
	retq   

<spawn>:
	push   %r12
	push   %rbp
	xor    %ebp,%ebp
	push   %rbx
	mov    %rdi,%rbx
	sub    $0x40,%rsp
	mov    %fs:0x28,%rax
	mov    %rax,0x38(%rsp)
	xor    %eax,%eax
	movslq 0x0(%rip),%rax        # <spawn+0x24>
	cmp    $0xffffffff,%eax
	je     <spawn+0x110>
	mov    0x0(%rip),%rdx        # <spawn+0x34>
	mov    0x0(%rip),%rcx        # <spawn+0x3b>
	lea    0x18(%rsp),%r12
	mov    0x0(%rip),%rdi        # <spawn+0x47>
	mov    (%rdx,%rax,8),%rax
	mov    %r12,%rdx
	movq   $0x0,0x10(%rsp)
	mov    0x100(%rax),%rsi
	callq  <spawn+0x63>
	cmpq   $0x0,0x30(%rsp)
	je     <spawn+0x110>
	mov    0x20(%rsp),%rax
	cmp    $0x1f,%rax
	jne    <spawn+0x89>
	mov    0x18(%rsp),%rdi
	callq  <spawn+0x84>
	mov    %rax,%rbp
	jmp    <spawn+0x106>
	cmp    0x0(%rip),%rax        # <spawn+0x90>
	je     <spawn+0xa2>
	mov    0x0(%rip),%rax        # <spawn+0x99>
	cmp    %rax,0x20(%rsp)
	jne    <spawn+0x106>
	jmp    <spawn+0xc8>
	mov    0x0(%rip),%rdi        # <spawn+0xa9>
	lea    0xc(%rsp),%rcx
	lea    0x10(%rsp),%rdx
	mov    %r12,%rsi
	callq  <spawn+0xbb>
	test   %eax,%eax
	js     <spawn+0x92>
	cmpl   $0x0,0xc(%rsp)
	jg     <spawn+0xe7>
	jmp    <spawn+0x106>
	mov    0x0(%rip),%rdi        # <spawn+0xcf>
	lea    0xc(%rsp),%rcx
	lea    0x10(%rsp),%rdx
	mov    %r12,%rsi
	callq  <spawn+0xe1>
	test   %eax,%eax
	jns    <spawn+0xbf>
	jmp    <spawn+0x106>
	mov    0x10(%rsp),%rax
	mov    (%rax),%rdi
	test   %rdi,%rdi
	je     <spawn+0x106>
	callq  <spawn+0xf9>
	mov    0x10(%rsp),%rdi
	mov    %rax,%rbp
	callq  <spawn+0x106>
	mov    0x18(%rsp),%rdi
	callq  <spawn+0x110>
	callq  <spawn+0x115>
	test   %eax,%eax
	jne    <spawn+0x1c3>
	test   %rbp,%rbp
	je     <spawn+0x132>
	mov    %rbp,%rdi
	callq  <spawn+0x12a>
	mov    %rbp,%rdi
	callq  <spawn+0x132>
	mov    0x0(%rip),%rax        # <spawn+0x139>
	test   %rax,%rax
	je     <spawn+0x146>
	mov    0x10(%rax),%edi
	callq  <spawn+0x146>
	callq  <spawn+0x14b>
	test   %rbx,%rbx
	je     <spawn+0x16b>
	mov    (%rbx),%rax
	test   %rax,%rax
	je     <spawn+0x16b>
	mov    (%rax),%rdi
	mov    %rax,%rsi
	callq  <spawn+0x163>
	mov    (%rbx),%rax
	mov    (%rax),%r8
	jmp    <spawn+0x18f>
	mov    0x0(%rip),%rbx        # <spawn+0x172>
	movslq 0x0(%rip),%rax        # <spawn+0x179>
	movq   $0x0,(%rbx,%rax,8)
	mov    (%rbx),%rdi
	mov    %rbx,%rsi
	callq  <spawn+0x18c>
	mov    (%rbx),%r8
	mov    0x0(%rip),%rcx        # <spawn+0x196>
	mov    0x0(%rip),%rdi        # <spawn+0x19d>
	lea    0x0(%rip),%rdx        # <spawn+0x1a4>
	xor    %eax,%eax
	mov    $0x1,%esi
	callq  <spawn+0x1b0>
	lea    0x0(%rip),%rdi        # <spawn+0x1b7>
	callq  <spawn+0x1bc>
	xor    %edi,%edi
	callq  <spawn+0x1c3>
	mov    0x38(%rsp),%rax
	sub    %fs:0x28,%rax
	je     <spawn+0x1d8>
	callq  <spawn+0x1d8>
	add    $0x40,%rsp
	mov    %rbp,%rdi
	pop    %rbx
	pop    %rbp
	pop    %r12
	jmpq   <sigchld>

<sigchld>:
	push   %rdx
	lea    -0x8(%rip),%rsi        # <sigchld>
	mov    $0x11,%edi
	callq  <sigchld+0x12>
	inc    %rax
	jne    <sigchld+0x2c>
	mov    0x0(%rip),%rsi        # <sigchld+0x1e>
	lea    0x0(%rip),%rdi        # <sigchld+0x25>
	xor    %eax,%eax
	callq  <die>
	xor    %esi,%esi
	or     $0xffffffff,%edi
	mov    $0x1,%edx
	callq  <sigchld+0x3b>
	test   %eax,%eax
	jg     <sigchld+0x2c>
	pop    %rax
	retq   

<getcolor>:
	push   %r12
	mov    %rdi,%rcx
	mov    %rdi,%r12
	sub    $0x20,%rsp
	mov    0x0(%rip),%rdx        # <getcolor+0x13>
	mov    0x0(%rip),%rsi        # <getcolor+0x1a>
	mov    %fs:0x28,%rax
	mov    %rax,0x18(%rsp)
	xor    %eax,%eax
	mov    0x0(%rip),%rdi        # <getcolor+0x31>
	lea    0x8(%rsp),%r8
	callq  <getcolor+0x3b>
	test   %eax,%eax
	jne    <getcolor+0x55>
	mov    0x0(%rip),%rsi        # <getcolor+0x46>
	mov    %r12,%rdx
	lea    0x0(%rip),%rdi        # <getcolor+0x50>
	callq  <die>
	mov    0x8(%rsp),%rax
	mov    0x10(%rsp),%rdx
	mov    0x18(%rsp),%rcx
	sub    %fs:0x28,%rcx
	je     <getcolor+0x74>
	callq  <getcolor+0x74>
	add    $0x20,%rsp
	pop    %r12
	retq   

<expose>:
	cmpl   $0x0,0x38(%rdi)
	jne    <expose+0x18>
	mov    0x0(%rip),%rax        # <expose+0xd>
	cmp    %rax,0x20(%rdi)
	jne    <expose+0x18>
	jmpq   <drawbar>
	retq   

<clientmessage>:
	mov    0x0(%rip),%rax        # <clientmessage+0x7>
	cmp    %rax,0x28(%rdi)
	jne    <clientmessage+0x3d>
	mov    0x0(%rip),%rax        # <clientmessage+0x14>
	cmp    %rax,0x38(%rdi)
	jne    <clientmessage+0x3d>
	cmpl   $0x1,0x0(%rip)        # <clientmessage+0x21>
	jle    <clientmessage+0x33>
	cmpl   $0x0,0x0(%rip)        # <clientmessage+0x2a>
	je     <clientmessage+0x33>
	xor    %edi,%edi
	jmpq   <killclient>
	movl   $0x0,0x0(%rip)        # <clientmessage+0x3d>
	retq   

<configurenotify>:
	mov    0x0(%rip),%rax        # <configurenotify+0x7>
	cmp    %rax,0x28(%rdi)
	jne    <configurenotify+0xf2>
	mov    0x38(%rdi),%edx
	cmp    0x0(%rip),%edx        # <configurenotify+0x1a>
	mov    0x3c(%rdi),%eax
	jne    <configurenotify+0x2b>
	cmp    %eax,0x0(%rip)        # <configurenotify+0x25>
	je     <configurenotify+0xf2>
	push   %rcx
	mov    0x0(%rip),%rsi        # <configurenotify+0x33>
	mov    0x0(%rip),%rdi        # <configurenotify+0x3a>
	mov    %edx,0x0(%rip)        # <configurenotify+0x40>
	mov    %eax,0x0(%rip)        # <configurenotify+0x46>
	callq  <configurenotify+0x4b>
	mov    0x0(%rip),%ecx        # <configurenotify+0x51>
	mov    0x0(%rip),%edx        # <configurenotify+0x57>
	mov    $0x20,%r8d
	mov    0x0(%rip),%rsi        # <configurenotify+0x64>
	mov    0x0(%rip),%rdi        # <configurenotify+0x6b>
	callq  <configurenotify+0x70>
	mov    %rax,0x0(%rip)        # <configurenotify+0x77>
	mov    0x0(%rip),%eax        # <configurenotify+0x7d>
	test   %eax,%eax
	jne    <configurenotify+0xa1>
	mov    0x0(%rip),%edx        # <configurenotify+0x87>
	cmp    %edx,0x0(%rip)        # <configurenotify+0x8d>
	jg     <configurenotify+0xa1>
	mov    %edx,0x0(%rip)        # <configurenotify+0x95>
	movl   $0x0,0x0(%rip)        # <configurenotify+0x9f>
	jmp    <configurenotify+0xc2>
	cmpl   $0x0,0x0(%rip)        # <configurenotify+0xa8>
	jne    <configurenotify+0xc2>
	cmp    0x0(%rip),%eax        # <configurenotify+0xb0>
	jge    <configurenotify+0xc2>
	mov    %eax,0x0(%rip)        # <configurenotify+0xb8>
	movl   $0x0,0x0(%rip)        # <configurenotify+0xc2>
	mov    0x0(%rip),%edi        # <configurenotify+0xc8>
	test   %edi,%edi
	js     <configurenotify+0xe3>
	mov    0x0(%rip),%esi        # <configurenotify+0xd2>
	mov    0x0(%rip),%edx        # <configurenotify+0xd8>
	sub    0x0(%rip),%edx        # <configurenotify+0xde>
	callq  <resize>
	mov    0x0(%rip),%rdi        # <configurenotify+0xea>
	xor    %esi,%esi
	pop    %rax
	jmpq   <configurenotify+0xf2>
	retq   

<gettextpropn.constprop.0>:
	push   %rbp
	push   %rbx
	sub    $0x48,%rsp
	mov    %fs:0x28,%rax
	mov    %rax,0x38(%rsp)
	xor    %eax,%eax
	movq   $0x0,0x10(%rsp)
	test   %rdx,%rdx
	jne    <gettextpropn.constprop.0+0x2b>
	xor    %eax,%eax
	jmpq   <gettextpropn.constprop.0+0x10c>
	movb   $0x0,(%rdx)
	mov    %rsi,%rcx
	lea    0x18(%rsp),%rbp
	mov    %rdi,%rsi
	mov    0x0(%rip),%rdi        # <gettextpropn.constprop.0+0x40>
	mov    %rdx,%rbx
	mov    %rbp,%rdx
	callq  <gettextpropn.constprop.0+0x4b>
	cmpq   $0x0,0x30(%rsp)
	je     <gettextpropn.constprop.0+0x24>
	mov    0x20(%rsp),%rax
	cmp    $0x1f,%rax
	jne    <gettextpropn.constprop.0+0x75>
	mov    0x18(%rsp),%rsi
	mov    $0xff,%edx
	mov    %rbx,%rdi
	callq  <gettextpropn.constprop.0+0x70>
	jmpq   <gettextpropn.constprop.0+0xf6>
	cmp    0x0(%rip),%rax        # <gettextpropn.constprop.0+0x7c>
	je     <gettextpropn.constprop.0+0x8e>
	mov    0x0(%rip),%rax        # <gettextpropn.constprop.0+0x85>
	cmp    %rax,0x20(%rsp)
	jne    <gettextpropn.constprop.0+0xf6>
	jmp    <gettextpropn.constprop.0+0xb4>
	mov    0x0(%rip),%rdi        # <gettextpropn.constprop.0+0x95>
	lea    0xc(%rsp),%rcx
	lea    0x10(%rsp),%rdx
	mov    %rbp,%rsi
	callq  <gettextpropn.constprop.0+0xa7>
	test   %eax,%eax
	js     <gettextpropn.constprop.0+0x7e>
	cmpl   $0x0,0xc(%rsp)
	jg     <gettextpropn.constprop.0+0xd3>
	jmp    <gettextpropn.constprop.0+0xf6>
	mov    0x0(%rip),%rdi        # <gettextpropn.constprop.0+0xbb>
	lea    0xc(%rsp),%rcx
	lea    0x10(%rsp),%rdx
	mov    %rbp,%rsi
	callq  <gettextpropn.constprop.0+0xcd>
	test   %eax,%eax
	jns    <gettextpropn.constprop.0+0xab>
	jmp    <gettextpropn.constprop.0+0xf6>
	mov    0x10(%rsp),%rbp
	mov    0x0(%rbp),%rsi
	test   %rsi,%rsi
	je     <gettextpropn.constprop.0+0xf6>
	mov    %rbx,%rdi
	mov    $0xff,%edx
	callq  <gettextpropn.constprop.0+0xee>
	mov    %rbp,%rdi
	callq  <gettextpropn.constprop.0+0xf6>
	movb   $0x0,0xff(%rbx)
	mov    0x18(%rsp),%rdi
	callq  <gettextpropn.constprop.0+0x107>
	mov    $0x1,%eax
	mov    0x38(%rsp),%rbx
	sub    %fs:0x28,%rbx
	je     <gettextpropn.constprop.0+0x121>
	callq  <gettextpropn.constprop.0+0x121>
	add    $0x48,%rsp
	pop    %rbx
	pop    %rbp
	retq   

<updatetitle>:
	push   %rbp
	movslq %edi,%rbp
	push   %rbx
	mov    %rbp,%rbx
	push   %rdx
	mov    0x0(%rip),%rax        # <updatetitle+0x10>
	mov    0x0(%rip),%rsi        # <updatetitle+0x17>
	mov    (%rax,%rbp,8),%rdx
	mov    0x100(%rdx),%rdi
	callq  <gettextpropn.constprop.0>
	test   %eax,%eax
	jne    <updatetitle+0x47>
	mov    0x0(%rip),%rax        # <updatetitle+0x32>
	mov    $0x27,%esi
	mov    (%rax,%rbp,8),%rdx
	mov    0x100(%rdx),%rdi
	callq  <gettextpropn.constprop.0>
	cmp    %ebx,0x0(%rip)        # <updatetitle+0x4d>
	jne    <updatetitle+0x66>
	mov    0x0(%rip),%rax        # <updatetitle+0x56>
	mov    0x0(%rip),%rdi        # <updatetitle+0x5d>
	mov    (%rax,%rbp,8),%rsi
	callq  <xsettitle>
	pop    %rax
	pop    %rbx
	pop    %rbp
	jmpq   <drawbar>

<sendxembed.constprop.0>:
	sub    $0xd8,%rsp
	movslq %edi,%r8
	mov    $0x30,%ecx
	mov    %fs:0x28,%rax
	mov    %rax,0xc8(%rsp)
	xor    %eax,%eax
	lea    0x8(%rsp),%rdi
	rep stos %eax,%es:(%rdi)
	mov    0x0(%rip),%rax        # <sendxembed.constprop.0+0x30>
	mov    0x0(%rip),%rdi        # <sendxembed.constprop.0+0x37>
	lea    (%rax,%r8,8),%rax
	lea    0x8(%rsp),%r8
	mov    (%rax),%rdx
	mov    %rsi,0x48(%rsp)
	movl   $0x21,0x8(%rsp)
	mov    0x100(%rdx),%rdx
	movl   $0x20,0x38(%rsp)
	mov    %rdx,0x28(%rsp)
	mov    0x0(%rip),%rdx        # <sendxembed.constprop.0+0x6b>
	mov    %rdx,0x30(%rsp)
	mov    (%rax),%rax
	xor    %edx,%edx
	mov    0x100(%rax),%rsi
	callq  <sendxembed.constprop.0+0x81>
	mov    0xc8(%rsp),%rax
	sub    %fs:0x28,%rax
	je     <sendxembed.constprop.0+0x99>
	callq  <sendxembed.constprop.0+0x99>
	add    $0xd8,%rsp
	retq   

<focus>:
	push   %r13
	mov    $0x7fc,%ecx
	push   %r12
	push   %rbp
	push   %rbx
	mov    %edi,%ebx
	sub    $0x2018,%rsp
	movaps 0x0(%rip),%xmm0        # <focus+0x1b>
	mov    %fs:0x28,%rax
	mov    %rax,0x2008(%rsp)
	xor    %eax,%eax
	lea    0x18(%rsp),%rdi
	movups %xmm0,0x8(%rsp)
	rep stos %eax,%es:(%rdi)
	mov    0x0(%rip),%eax        # <focus+0x40>
	test   %eax,%eax
	jne    <focus+0xe4>
	movslq 0x0(%rip),%rdx        # <focus+0x4f>
	mov    0x0(%rip),%rax        # <focus+0x56>
	lea    0x8(%rsp),%rbp
	xor    %r12d,%r12d
	mov    %rbp,%rdi
	mov    $0x2000,%r13d
	movq   $0x0,(%rax,%rdx,8)
	callq  <focus+0x74>
	mov    %rax,%rbx
	mov    0x0(%rip),%rax        # <focus+0x7e>
	mov    (%rax,%r12,1),%r9
	add    $0x8,%r12
	cmp    $0x1fff,%rbx
	ja     <focus+0xbd>
	test   %r9,%r9
	je     <focus+0xbd>
	mov    %r13,%rsi
	lea    0x0(%rbp,%rbx,1),%rdi
	or     $0xffffffffffffffff,%rcx
	xor    %eax,%eax
	sub    %rbx,%rsi
	lea    0x0(%rip),%r8        # <focus+0xac>
	mov    $0x1,%edx
	callq  <focus+0xb6>
	cltq   
	add    %rax,%rbx
	jmp    <focus+0x77>
	mov    0x0(%rip),%rdi        # <focus+0xc4>
	mov    %rbp,%rsi
	callq  <xsettitle>
	mov    0x0(%rip),%rsi        # <focus+0xd3>
	mov    0x0(%rip),%rdi        # <focus+0xda>
	callq  <focus+0xdf>
	jmpq   <focus+0x21f>
	test   %ebx,%ebx
	js     <focus+0x21f>
	cmp    %ebx,%eax
	jle    <focus+0x21f>
	mov    0x0(%rip),%esi        # <focus+0xfa>
	mov    0x0(%rip),%edx        # <focus+0x100>
	mov    %ebx,%edi
	movslq %ebx,%r12
	sub    0x0(%rip),%edx        # <focus+0x10b>
	callq  <resize>
	mov    0x0(%rip),%rax        # <focus+0x117>
	mov    0x0(%rip),%rdi        # <focus+0x11e>
	mov    (%rax,%r12,8),%rax
	mov    0x100(%rax),%rsi
	callq  <focus+0x12e>
	mov    0x0(%rip),%rax        # <focus+0x135>
	xor    %ecx,%ecx
	mov    0x0(%rip),%rdi        # <focus+0x13e>
	mov    $0x2,%edx
	mov    (%rax,%r12,8),%rax
	mov    0x100(%rax),%rsi
	callq  <focus+0x153>
	mov    $0x4,%esi
	mov    %ebx,%edi
	callq  <sendxembed.constprop.0>
	mov    $0x1,%esi
	mov    %ebx,%edi
	callq  <sendxembed.constprop.0>
	mov    0x0(%rip),%rax        # <focus+0x172>
	mov    0x0(%rip),%rdi        # <focus+0x179>
	mov    (%rax,%r12,8),%rsi
	callq  <xsettitle>
	mov    0x0(%rip),%eax        # <focus+0x188>
	cmp    %ebx,%eax
	je     <focus+0x198>
	mov    %eax,0x0(%rip)        # <focus+0x192>
	mov    %ebx,0x0(%rip)        # <focus+0x198>
	mov    0x0(%rip),%rax        # <focus+0x19f>
	mov    (%rax,%r12,8),%rax
	cmpl   $0x0,0x10c(%rax)
	je     <focus+0x20c>
	mov    0x100(%rax),%rsi
	mov    0x0(%rip),%rdi        # <focus+0x1ba>
	callq  <focus+0x1bf>
	mov    %rax,%rbp
	test   %rax,%rax
	je     <focus+0x20c>
	andq   $0xfffffffffffffeff,(%rax)
	mov    0x0(%rip),%rax        # <focus+0x1d5>
	mov    %rbp,%rdx
	mov    0x0(%rip),%rdi        # <focus+0x1df>
	mov    (%rax,%r12,8),%rax
	mov    0x100(%rax),%rsi
	callq  <focus+0x1ef>
	mov    0x0(%rip),%rax        # <focus+0x1f6>
	mov    %rbp,%rdi
	mov    (%rax,%r12,8),%rax
	movl   $0x0,0x10c(%rax)
	callq  <focus+0x20c>
	callq  <drawbar>
	mov    0x0(%rip),%rdi        # <focus+0x218>
	xor    %esi,%esi
	callq  <focus+0x21f>
	mov    0x2008(%rsp),%rax
	sub    %fs:0x28,%rax
	je     <focus+0x237>
	callq  <focus+0x237>
	add    $0x2018,%rsp
	pop    %rbx
	pop    %rbp
	pop    %r12
	pop    %r13
	retq   

<move>:
	mov    (%rdi),%edi
	test   %edi,%edi
	js     <move+0x13>
	cmp    0x0(%rip),%edi        # <move+0xc>
	jge    <move+0x13>
	jmpq   <focus>
	retq   

<focusurgent>:
	mov    0x0(%rip),%esi        # <focusurgent+0x6>
	test   %esi,%esi
	js     <focusurgent+0x40>
	lea    0x1(%rsi),%eax
	mov    0x0(%rip),%ecx        # <focusurgent+0x13>
	mov    0x0(%rip),%rdi        # <focusurgent+0x1a>
	cltd   
	idiv   %ecx
	cmp    %edx,%esi
	je     <focusurgent+0x40>
	movslq %edx,%rax
	mov    (%rdi,%rax,8),%rax
	cmpl   $0x0,0x10c(%rax)
	je     <focusurgent+0x38>
	mov    %edx,%edi
	jmpq   <focus>
	lea    0x1(%rdx),%eax
	cltd   
	idiv   %ecx
	jmp    <focusurgent+0x1d>
	retq   

<rotate>:
	mov    %rdi,%rax
	mov    0x0(%rip),%edi        # <rotate+0x9>
	test   %edi,%edi
	js     <rotate+0x3c>
	mov    (%rax),%eax
	test   %eax,%eax
	jne    <rotate+0x1f>
	mov    0x0(%rip),%edi        # <rotate+0x19>
	test   %edi,%edi
	js     <rotate+0x3c>
	jmp    <rotate+0x37>
	add    %eax,%edi
	mov    0x0(%rip),%eax        # <rotate+0x27>
	cmp    %edi,%eax
	jg     <rotate+0x2f>
	sub    %eax,%edi
	jmp    <rotate+0x27>
	test   %edi,%edi
	jns    <rotate+0x37>
	add    %eax,%edi
	jmp    <rotate+0x2f>
	jmpq   <focus>
	retq   

<buttonpress>:
	push   %r12
	push   %rbp
	push   %rbx
	sub    $0x10,%rsp
	mov    %fs:0x28,%rax
	mov    %rax,0x8(%rsp)
	mov    0x44(%rdi),%eax
	test   %eax,%eax
	js     <buttonpress+0xec>
	cmp    0x0(%rip),%eax        # <buttonpress+0x27>
	jg     <buttonpress+0xec>
	mov    %rdi,%rbp
	callq  <getfirsttab>
	mov    %eax,%ebx
	test   %eax,%eax
	jg     <buttonpress+0x58>
	mov    0x40(%rbp),%edx
	test   %edx,%edx
	js     <buttonpress+0xec>
	mov    0x0(%rip),%ecx        # <buttonpress+0x4c>
	mov    0x0(%rip),%rsi        # <buttonpress+0x53>
	movslq %ebx,%rax
	jmp    <buttonpress+0x8a>
	mov    0x40(%rbp),%r12d
	mov    $0x1,%esi
	lea    0x0(%rip),%rdi        # <buttonpress+0x68>
	callq  <textnw>
	add    0x0(%rip),%eax        # <buttonpress+0x73>
	cmp    %eax,%r12d
	jge    <buttonpress+0x3b>
	jmp    <buttonpress+0xec>
	mov    (%rsi,%rax,8),%r8
	inc    %rax
	cmp    0x108(%r8),%edx
	jl     <buttonpress+0x92>
	mov    %eax,%edi
	cmp    %eax,%ecx
	jg     <buttonpress+0x7a>
	jmp    <buttonpress+0xec>
	mov    0x54(%rbp),%eax
	cmp    $0x2,%eax
	je     <buttonpress+0xe1>
	ja     <buttonpress+0xa2>
	dec    %eax
	je     <buttonpress+0xc4>
	jmp    <buttonpress+0xec>
	lea    -0x4(%rax),%edx
	cmp    $0x1,%edx
	ja     <buttonpress+0xec>
	cmp    $0x4,%eax
	mov    %rsp,%rdi
	setne  %al
	movzbl %al,%eax
	lea    -0x1(%rax,%rax,1),%eax
	mov    %eax,(%rsp)
	callq  <rotate>
	jmp    <buttonpress+0xec>
	mov    0x8(%rsp),%rax
	sub    %fs:0x28,%rax
	jne    <buttonpress+0xfc>
	add    $0x10,%rsp
	pop    %rbx
	pop    %rbp
	pop    %r12
	jmpq   <focus>
	mov    %edi,(%rsp)
	mov    %rsp,%rdi
	callq  <killclient>
	mov    0x8(%rsp),%rax
	sub    %fs:0x28,%rax
	je     <buttonpress+0x101>
	callq  <buttonpress+0x101>
	add    $0x10,%rsp
	pop    %rbx
	pop    %rbp
	pop    %r12
	retq   

<focusin>:
	sub    $0x28,%rsp
	mov    %fs:0x28,%rax
	mov    %rax,0x18(%rsp)
	xor    %eax,%eax
	cmpl   $0x2,0x28(%rdi)
	je     <focusin+0x49>
	mov    0x0(%rip),%rdi        # <focusin+0x21>
	lea    0xc(%rsp),%rdx
	lea    0x10(%rsp),%rsi
	callq  <focusin+0x30>
	mov    0x0(%rip),%rax        # <focusin+0x37>
	cmp    %rax,0x10(%rsp)
	jne    <focusin+0x49>
	mov    0x0(%rip),%edi        # <focusin+0x44>
	callq  <focus>
	mov    0x18(%rsp),%rax
	sub    %fs:0x28,%rax
	je     <focusin+0x5e>
	callq  <focusin+0x5e>
	add    $0x28,%rsp
	retq   

<propertynotify>:
	push   %r13
	push   %r12
	push   %rbp
	push   %rbx
	mov    %rdi,%rbx
	sub    $0x38,%rsp
	mov    %fs:0x28,%rax
	mov    %rax,0x28(%rsp)
	xor    %eax,%eax
	cmpl   $0x0,0x38(%rdi)
	jne    <propertynotify+0x22a>
	mov    0x28(%rdi),%rdx
	cmp    0x0(%rip),%rdx        # <propertynotify+0x32>
	jne    <propertynotify+0x11d>
	lea    0x20(%rsp),%rbp
	xor    %r9d,%r9d
	mov    $0x2000,%r8d
	xor    %ecx,%ecx
	movq   $0x0,0x20(%rsp)
	mov    0x0(%rip),%rsi        # <propertynotify+0x58>
	push   %rbp
	mov    0x0(%rip),%rdi        # <propertynotify+0x60>
	lea    0x20(%rsp),%rax
	push   %rax
	push   %rax
	lea    0x24(%rsp),%rax
	push   %rax
	lea    0x30(%rsp),%rax
	push   %rax
	pushq  $0x1f
	callq  <propertynotify+0x7a>
	mov    0x50(%rsp),%r12
	add    $0x30,%rsp
	test   %r12,%r12
	je     <propertynotify+0x9e>
	mov    $0x1fff,%edx
	mov    %r12,%rsi
	lea    0x0(%rip),%rdi        # <propertynotify+0x97>
	callq  <propertynotify+0x9c>
	jmp    <propertynotify+0xa5>
	movb   $0x0,0x0(%rip)        # <propertynotify+0xa5>
	mov    %r12,%rdi
	callq  <propertynotify+0xad>
	mov    $0x2,%edx
	lea    0x0(%rip),%rsi        # <propertynotify+0xb9>
	lea    0x0(%rip),%rdi        # <propertynotify+0xc0>
	callq  <propertynotify+0xc5>
	test   %eax,%eax
	jne    <propertynotify+0xf2>
	xor    %edx,%edx
	xor    %esi,%esi
	lea    0x0(%rip),%rdi        # <propertynotify+0xd4>
	callq  <propertynotify+0xd9>
	mov    %rax,%rdi
	callq  <getclient>
	mov    %rbp,%rdi
	mov    %eax,0x20(%rsp)
	callq  <move>
	jmpq   <propertynotify+0x26c>
	mov    0x0(%rip),%rax        # <propertynotify+0xf9>
	movslq 0x0(%rip),%rdx        # <propertynotify+0x100>
	lea    0x0(%rip),%rcx        # <propertynotify+0x107>
	mov    %rbp,%rdi
	mov    %rcx,(%rax,%rdx,8)
	mov    %rax,0x20(%rsp)
	callq  <spawn>
	jmpq   <propertynotify+0x26c>
	cmp    $0x23,%rdx
	je     <propertynotify+0x136>
	mov    0x28(%rbx),%rax
	cmp    $0x27,%rax
	jne    <propertynotify+0x235>
	jmpq   <propertynotify+0x23e>
	mov    0x20(%rdi),%rdi
	callq  <getclient>
	mov    %eax,%r12d
	test   %eax,%eax
	js     <propertynotify+0x123>
	movslq %eax,%r13
	mov    0x0(%rip),%rax        # <propertynotify+0x150>
	mov    0x0(%rip),%rdi        # <propertynotify+0x157>
	mov    (%rax,%r13,8),%rax
	mov    0x100(%rax),%rsi
	callq  <propertynotify+0x167>
	mov    %rax,%rbp
	test   %rax,%rax
	je     <propertynotify+0x22a>
	btl    $0x8,(%rax)
	jae    <propertynotify+0x208>
	mov    %rax,%rdi
	callq  <propertynotify+0x185>
	mov    0x0(%rip),%rsi        # <propertynotify+0x18c>
	mov    0x0(%rip),%rdi        # <propertynotify+0x193>
	callq  <propertynotify+0x198>
	cmp    %r12d,0x0(%rip)        # <propertynotify+0x19f>
	mov    %rax,%rbp
	je     <propertynotify+0x1dc>
	cmpl   $0x0,0x0(%rip)        # <propertynotify+0x1ab>
	je     <propertynotify+0x1c2>
	test   %rax,%rax
	je     <propertynotify+0x1c2>
	btl    $0x8,(%rax)
	jb     <propertynotify+0x1c2>
	mov    %r12d,%edi
	callq  <focus>
	jmp    <propertynotify+0x1e1>
	mov    0x0(%rip),%rax        # <propertynotify+0x1c9>
	mov    (%rax,%r13,8),%rax
	movl   $0x1,0x10c(%rax)
	callq  <drawbar>
	test   %rbp,%rbp
	je     <propertynotify+0x208>
	mov    0x0(%rbp),%rax
	bt     $0x8,%eax
	jb     <propertynotify+0x208>
	or     $0x1,%ah
	mov    0x0(%rip),%rsi        # <propertynotify+0x1f5>
	mov    0x0(%rip),%rdi        # <propertynotify+0x1fc>
	mov    %rbp,%rdx
	mov    %rax,0x0(%rbp)
	callq  <propertynotify+0x208>
	mov    0x28(%rsp),%rax
	sub    %fs:0x28,%rax
	jne    <propertynotify+0x27c>
	add    $0x38,%rsp
	mov    %rbp,%rdi
	pop    %rbx
	pop    %rbp
	pop    %r12
	pop    %r13
	jmpq   <propertynotify+0x22a>
	cmpl   $0x1,0x38(%rbx)
	je     <propertynotify+0x26c>
	jmpq   <propertynotify+0x123>
	cmp    0x0(%rip),%rax        # <propertynotify+0x23c>
	jne    <propertynotify+0x26c>
	mov    0x20(%rbx),%rdi
	callq  <getclient>
	mov    %eax,%edi
	test   %eax,%eax
	js     <propertynotify+0x26c>
	mov    0x28(%rsp),%rax
	sub    %fs:0x28,%rax
	jne    <propertynotify+0x27c>
	add    $0x38,%rsp
	pop    %rbx
	pop    %rbp
	pop    %r12
	pop    %r13
	jmpq   <updatetitle>
	mov    0x28(%rsp),%rax
	sub    %fs:0x28,%rax
	je     <propertynotify+0x281>
	callq  <propertynotify+0x281>
	add    $0x38,%rsp
	pop    %rbx
	pop    %rbp
	pop    %r12
	pop    %r13
	retq   

<unmanage>:
	push   %r15
	push   %r14
	push   %r13
	push   %r12
	push   %rbp
	push   %rbx
	push   %rdx
	test   %edi,%edi
	js     <unmanage+0x16a>
	mov    0x0(%rip),%r12d        # <unmanage+0x1a>
	mov    %edi,%ebx
	cmp    %edi,%r12d
	jle    <unmanage+0x16a>
	mov    0x0(%rip),%r14        # <unmanage+0x2c>
	lea    -0x1(%r12),%ebp
	test   %edi,%edi
	jne    <unmanage+0x58>
	mov    (%r14),%rdi
	mov    %ebp,0x0(%rip)        # <unmanage+0x3e>
	callq  <unmanage+0x43>
	movslq %ebp,%rdx
	lea    0x8(%r14),%rsi
	mov    %r14,%rdi
	shl    $0x3,%rdx
	callq  <unmanage+0x56>
	jmp    <unmanage+0xc6>
	movslq %edi,%r13
	shl    $0x3,%r13
	lea    (%r14,%r13,1),%r15
	mov    (%r15),%rdi
	cmp    %ebx,%ebp
	jne    <unmanage+0xa1>
	mov    %ebp,0x0(%rip)        # <unmanage+0x70>
	callq  <unmanage+0x75>
	mov    %r13,%rsi
	mov    %r14,%rdi
	callq  <unmanage+0x80>
	test   %rax,%rax
	jne    <unmanage+0x98>
	mov    0x0(%rip),%rsi        # <unmanage+0x8c>
	lea    0x0(%rip),%rdi        # <unmanage+0x93>
	callq  <die>
	mov    %rax,0x0(%rip)        # <unmanage+0x9f>
	jmp    <unmanage+0xc6>
	callq  <unmanage+0xa6>
	lea    0x1(%rbx),%eax
	lea    0x8(%r14,%r13,1),%rsi
	mov    %r15,%rdi
	sub    %eax,%r12d
	movslq %r12d,%rdx
	shl    $0x3,%rdx
	callq  <unmanage+0xc0>
	mov    %ebp,0x0(%rip)        # <unmanage+0xc6>
	mov    0x0(%rip),%eax        # <unmanage+0xcc>
	test   %eax,%eax
	jg     <unmanage+0x114>
	cmpl   $0x0,0x0(%rip)        # <unmanage+0xd7>
	movl   $0xffffffff,0x0(%rip)        # <unmanage+0xe1>
	movl   $0xffffffff,0x0(%rip)        # <unmanage+0xeb>
	je     <unmanage+0xf9>
	movl   $0x0,0x0(%rip)        # <unmanage+0xf7>
	jmp    <unmanage+0x16a>
	cmpl   $0x0,0x0(%rip)        # <unmanage+0x100>
	je     <unmanage+0x16a>
	cmpl   $0x0,0x0(%rip)        # <unmanage+0x109>
	je     <unmanage+0x16a>
	xor    %edi,%edi
	callq  <spawn>
	jmp    <unmanage+0x16a>
	mov    0x0(%rip),%edx        # <unmanage+0x11a>
	cmp    %edx,%eax
	jg     <unmanage+0x123>
	lea    -0x1(%rax),%edx
	jmp    <unmanage+0x129>
	cmp    %ebx,%edx
	jle    <unmanage+0x12f>
	dec    %edx
	mov    %edx,0x0(%rip)        # <unmanage+0x12f>
	mov    0x0(%rip),%edx        # <unmanage+0x135>
	cmp    %ebx,%edx
	jne    <unmanage+0x145>
	mov    0x0(%rip),%edi        # <unmanage+0x13f>
	test   %edi,%edi
	js     <unmanage+0x14f>
	jmp    <unmanage+0x165>
	jle    <unmanage+0x14f>
	dec    %edx
	mov    %edx,0x0(%rip)        # <unmanage+0x14f>
	cmp    0x0(%rip),%eax        # <unmanage+0x155>
	jg     <unmanage+0x15f>
	dec    %eax
	mov    %eax,0x0(%rip)        # <unmanage+0x15f>
	mov    0x0(%rip),%edi        # <unmanage+0x165>
	callq  <focus>
	callq  <drawbar>
	mov    0x0(%rip),%rdi        # <unmanage+0x176>
	xor    %esi,%esi
	pop    %rax
	pop    %rbx
	pop    %rbp
	pop    %r12
	pop    %r13
	pop    %r14
	pop    %r15
	jmpq   <unmapnotify>

<unmapnotify>:
	push   %rcx
	mov    0x28(%rdi),%rdi
	callq  <getclient>
	test   %eax,%eax
	js     <unmapnotify+0x16>
	mov    %eax,%edi
	pop    %rdx
	jmpq   <unmanage>
	pop    %rax
	retq   

<destroynotify>:
	push   %rcx
	mov    0x28(%rdi),%rdi
	callq  <getclient>
	test   %eax,%eax
	js     <destroynotify+0x16>
	mov    %eax,%edi
	pop    %rdx
	jmpq   <unmanage>
	pop    %rax
	retq   

<manage>:
	push   %r15
	push   %r14
	mov    $0x1,%r14d
	push   %r13
	push   %r12
	push   %rbp
	mov    %rdi,%rbp
	push   %rbx
	xor    %ebx,%ebx
	sub    $0xf8,%rsp
	mov    0x0(%rip),%rdi        # <manage+0x23>
	mov    %fs:0x28,%rax
	mov    %rax,0xe8(%rsp)
	xor    %eax,%eax
	movl   $0x0,0x0(%rip)        # <manage+0x40>
	callq  <manage+0x45>
	mov    %rax,%r12
	mov    %r14d,%eax
	mov    %ebx,%ecx
	xor    %r13d,%r13d
	shl    %cl,%eax
	mov    %eax,0xc(%rsp)
	mov    (%r12),%eax
	cmp    %r13d,%eax
	jbe    <manage+0x93>
	imul   %ebx,%eax
	mov    0x8(%r12),%rcx
	mov    $0xff7f,%esi
	mov    0x0(%rip),%rdi        # <manage+0x73>
	add    %r13d,%eax
	mov    (%rcx,%rax,1),%r15b
	callq  <manage+0x7f>
	cmp    %al,%r15b
	jne    <manage+0x8e>
	mov    0xc(%rsp),%eax
	mov    %eax,0x0(%rip)        # <manage+0x8e>
	inc    %r13d
	jmp    <manage+0x56>
	inc    %ebx
	cmp    $0x8,%ebx
	jne    <manage+0x48>
	mov    %r12,%rdi
	lea    0x0(%rip),%r14        # <manage+0xa4>
	lea    0x18(%rsp),%r13
	callq  <manage+0xae>
	mov    $0x1,%eax
	xor    %edx,%edx
	mov    %rbp,%rsi
	shl    $0x21,%rax
	mov    0x0(%rip),%rdi        # <manage+0xc3>
	lea    0x2c0(%r14),%r12
	mov    %rax,0x18(%rsp)
	mov    0x0(%rip),%eax        # <manage+0xd5>
	mov    %eax,0x20(%rsp)
	or     $0x2,%eax
	mov    %eax,0x24(%rsp)
	callq  <manage+0xe5>
	mov    0x0(%rip),%r8d        # <manage+0xec>
	mov    0x0(%rip),%rdx        # <manage+0xf3>
	xor    %ecx,%ecx
	mov    0x0(%rip),%rdi        # <manage+0xfc>
	mov    %rbp,%rsi
	callq  <manage+0x104>
	mov    0x0(%rip),%rdi        # <manage+0x10b>
	mov    $0x420010,%edx
	mov    %rbp,%rsi
	callq  <manage+0x118>
	mov    0x0(%rip),%rdi        # <manage+0x11f>
	xor    %esi,%esi
	callq  <manage+0x126>
	mov    0x8(%r14),%rsi
	mov    0x0(%rip),%rdi        # <manage+0x131>
	callq  <manage+0x136>
	test   %al,%al
	jne    <manage+0x145>
	add    $0x20,%r14
	cmp    %r14,%r12
	jne    <manage+0x126>
	jmp    <manage+0x180>
	xor    %r15d,%r15d
	movzbl %al,%ebx
	mov    (%r14),%edx
	or     0x0(%r13,%r15,4),%edx
	push   %rax
	mov    %rbp,%rcx
	pushq  $0x1
	mov    0x0(%rip),%rdi        # <manage+0x160>
	mov    %ebx,%esi
	inc    %r15
	mov    $0x1,%r9d
	mov    $0x1,%r8d
	callq  <manage+0x176>
	pop    %rdx
	pop    %rcx
	cmp    $0x4,%r15
	jne    <manage+0x14b>
	jmp    <manage+0x13a>
	mov    $0x118,%esi
	mov    $0x1,%edi
	callq  <manage+0x18f>
	mov    0x0(%rip),%rsi        # <manage+0x196>
	lea    0x0(%rip),%rdi        # <manage+0x19d>
	mov    %rax,%r13
	test   %rax,%rax
	je     <manage+0x1e6>
	mov    0x0(%rip),%r14d        # <manage+0x1ac>
	mov    %rbp,0x100(%rax)
	mov    0x0(%rip),%rdi        # <manage+0x1ba>
	lea    0x1(%r14),%ebx
	movslq %ebx,%rsi
	mov    %ebx,0x0(%rip)        # <manage+0x1c7>
	shl    $0x3,%rsi
	callq  <manage+0x1d0>
	mov    %rax,%rcx
	test   %rax,%rax
	jne    <manage+0x1ed>
	mov    0x0(%rip),%rsi        # <manage+0x1df>
	lea    0x0(%rip),%rdi        # <manage+0x1e6>
	xor    %eax,%eax
	callq  <die>
	cmpl   $0x0,0x0(%rip)        # <manage+0x1f4>
	mov    %rax,0x0(%rip)        # <manage+0x1fb>
	mov    0x0(%rip),%eax        # <manage+0x201>
	je     <manage+0x20b>
	add    0x0(%rip),%eax        # <manage+0x209>
	jmp    <manage+0x215>
	test   %eax,%eax
	jns    <manage+0x215>
	mov    %ebx,%edx
	sub    %eax,%edx
	mov    %edx,%eax
	cmp    %eax,%ebx
	mov    $0x0,%r12d
	cmovle %r14d,%eax
	test   %eax,%eax
	cmovns %eax,%r12d
	movslq %r12d,%rax
	shl    $0x3,%rax
	lea    (%rcx,%rax,1),%r15
	cmp    $0x1,%ebx
	jle    <manage+0x256>
	cmp    %r12d,%r14d
	jle    <manage+0x256>
	sub    %r12d,%ebx
	lea    0x8(%rcx,%rax,1),%rdi
	mov    %r15,%rsi
	lea    -0x1(%rbx),%edx
	movslq %edx,%rdx
	shl    $0x3,%rdx
	callq  <manage+0x256>
	mov    %r13,(%r15)
	mov    %r12d,%edi
	callq  <updatetitle>
	mov    0x0(%rip),%rdi        # <manage+0x268>
	mov    %rbp,%rsi
	callq  <manage+0x270>
	mov    0x0(%rip),%rdi        # <manage+0x277>
	mov    %rbp,%rsi
	callq  <manage+0x27f>
	mov    0x0(%rip),%rax        # <manage+0x286>
	xor    %ecx,%ecx
	xor    %edx,%edx
	mov    0x0(%rip),%rsi        # <manage+0x291>
	lea    0x28(%rsp),%r8
	mov    0x0(%rip),%rdi        # <manage+0x29d>
	mov    %rbp,0x48(%rsp)
	mov    %rax,0x50(%rsp)
	mov    0x0(%rip),%rax        # <manage+0x2ae>
	movl   $0x21,0x28(%rsp)
	movl   $0x20,0x58(%rsp)
	movq   $0x0,0x60(%rsp)
	movq   $0x0,0x68(%rsp)
	movq   $0x0,0x70(%rsp)
	mov    %rax,0x78(%rsp)
	movq   $0x0,0x80(%rsp)
	callq  <manage+0x2ef>
	mov    0x0(%rip),%rdi        # <manage+0x2f6>
	xor    %esi,%esi
	callq  <manage+0x2fd>
	mov    0x0(%rip),%eax        # <manage+0x303>
	cmp    %r12d,%eax
	jl     <manage+0x310>
	inc    %eax
	mov    %eax,0x0(%rip)        # <manage+0x310>
	cmpl   $0x0,0x0(%rip)        # <manage+0x317>
	jne    <manage+0x32f>
	cmpl   $0x0,0x0(%rip)        # <manage+0x320>
	mov    $0x0,%eax
	cmovns 0x0(%rip),%eax        # <manage+0x32c>
	mov    %eax,%r12d
	mov    %r12d,%edi
	callq  <focus>
	movl   $0x1,0x0(%rip)        # <manage+0x341>
	mov    0xe8(%rsp),%rax
	sub    %fs:0x28,%rax
	je     <manage+0x359>
	callq  <manage+0x359>
	add    $0xf8,%rsp
	pop    %rbx
	pop    %rbp
	pop    %r12
	pop    %r13
	pop    %r14
	pop    %r15
	retq   

<maprequest>:
	push   %rcx
	mov    0x28(%rdi),%rdi
	callq  <getclient>
	test   %eax,%eax
	jns    <maprequest+0x14>
	pop    %rdx
	jmpq   <manage>
	pop    %rax
	retq   

<createnotify>:
	mov    0x28(%rdi),%rdi
	cmp    0x0(%rip),%rdi        # <createnotify+0xb>
	je     <createnotify+0x1f>
	push   %rcx
	callq  <getclient>
	test   %eax,%eax
	jns    <createnotify+0x1d>
	pop    %rdx
	jmpq   <manage>
	pop    %rax
	retq   
	retq   

<usage>:
	push   %rax
	mov    0x0(%rip),%rsi        # <usage+0x8>
	lea    0x0(%rip),%rdi        # <usage+0xf>
	xor    %eax,%eax
	callq  <die>

Дизассемблирование раздела .text.startup:

<main>:
	push   %r15
	push   %r14
	push   %r13
	push   %r12
	mov    %edi,%r12d
	push   %rbp
	mov    %rsi,%rbp
	push   %rbx
	sub    $0x1b8,%rsp
	mov    (%rsi),%r14
	mov    %fs:0x28,%rax
	mov    %rax,0x1a8(%rsp)
	xor    %eax,%eax
	mov    %r14,0x0(%rip)        # <main+0x34>
	test   %r14,%r14
	je     <main+0x40>
	dec    %r12d
	add    $0x8,%rbp
	movl   $0x0,0xc(%rsp)
	xor    %r13d,%r13d
	lea    0x0(%rip),%r15        # <main+0x52>
	mov    0x0(%rbp),%rbx
	test   %rbx,%rbx
	je     <main+0x4ef>
	cmpb   $0x2d,(%rbx)
	jne    <main+0x4ef>
	mov    0x1(%rbx),%al
	cmp    $0x2d,%al
	jne    <main+0x4e7>
	cmpb   $0x0,0x2(%rbx)
	je     <main+0x4de>
	mov    0x0(%rip),%ecx        # <main+0x83>
	mov    0x0(%rip),%edi        # <main+0x89>
	xor    %esi,%esi
	xor    %edx,%edx
	mov    0x0(%rip),%r9d        # <main+0x94>
	inc    %rbx
	xor    %r8d,%r8d
	xor    %r10d,%r10d
	mov    0x0(%rip),%eax        # <main+0xa3>
	mov    (%rbx),%r11b
	test   %r11b,%r11b
	je     <main+0x4a6>
	sub    $0x4f,%r11d
	cmp    $0x27,%r11b
	ja     <main+0x458>
	movzbl %r11b,%r11d
	movslq (%r15,%r11,4),%r11
	add    %r15,%r11
	jmpq   *%r11
	mov    $0x1,%dl
	xor    %eax,%eax
	mov    $0x1,%r10b
	mov    $0x1,%r9d
	jmpq   <main+0x49e>
	test   %r10b,%r10b
	je     <main+0xe9>
	mov    %r9d,0x0(%rip)        # <main+0xe9>
	test   %dl,%dl
	je     <main+0xf3>
	mov    %eax,0x0(%rip)        # <main+0xf3>
	test   %r8b,%r8b
	je     <main+0xfe>
	mov    %edi,0x0(%rip)        # <main+0xfe>
	test   %sil,%sil
	je     <main+0x109>
	mov    %ecx,0x0(%rip)        # <main+0x109>
	cmpb   $0x0,0x1(%rbx)
	lea    0x1(%rbx),%rax
	jne    <main+0x121>
	mov    0x8(%rbp),%rax
	test   %rax,%rax
	jne    <main+0x121>
	callq  <main+0x121>
	mov    %rax,0x0(%rip)        # <main+0x128>
	jmpq   <main+0xe76>
	mov    $0x1,%r8b
	mov    $0x1,%edi
	jmpq   <main+0x49e>
	test   %r10b,%r10b
	je     <main+0x146>
	mov    %r9d,0x0(%rip)        # <main+0x146>
	test   %dl,%dl
	je     <main+0x150>
	mov    %eax,0x0(%rip)        # <main+0x150>
	test   %r8b,%r8b
	je     <main+0x15b>
	mov    %edi,0x0(%rip)        # <main+0x15b>
	test   %sil,%sil
	je     <main+0x166>
	mov    %ecx,0x0(%rip)        # <main+0x166>
	cmpb   $0x0,0x1(%rbx)
	lea    0x1(%rbx),%rax
	jne    <main+0x179>
	mov    0x8(%rbp),%rax
	test   %rax,%rax
	je     <main+0x11c>
	mov    %rax,0x0(%rip)        # <main+0x180>
	jmpq   <main+0xe76>
	test   %r10b,%r10b
	je     <main+0x191>
	mov    %r9d,0x0(%rip)        # <main+0x191>
	test   %dl,%dl
	je     <main+0x19b>
	mov    %eax,0x0(%rip)        # <main+0x19b>
	test   %r8b,%r8b
	je     <main+0x1a6>
	mov    %edi,0x0(%rip)        # <main+0x1a6>
	test   %sil,%sil
	je     <main+0x1b1>
	mov    %ecx,0x0(%rip)        # <main+0x1b1>
	cmpb   $0x0,0x1(%rbx)
	lea    0x1(%rbx),%rax
	jne    <main+0x1c8>
	mov    0x8(%rbp),%rax
	test   %rax,%rax
	je     <main+0x11c>
	mov    %rax,0x0(%rip)        # <main+0x1cf>
	jmpq   <main+0xe76>
	test   %r10b,%r10b
	je     <main+0x1e0>
	mov    %r9d,0x0(%rip)        # <main+0x1e0>
	test   %dl,%dl
	je     <main+0x1ea>
	mov    %eax,0x0(%rip)        # <main+0x1ea>
	test   %r8b,%r8b
	je     <main+0x1f5>
	mov    %edi,0x0(%rip)        # <main+0x1f5>
	test   %sil,%sil
	je     <main+0x200>
	mov    %ecx,0x0(%rip)        # <main+0x200>
	cmpb   $0x0,0x1(%rbx)
	lea    0x1(%rbx),%rax
	jne    <main+0x217>
	mov    0x8(%rbp),%rax
	test   %rax,%rax
	je     <main+0x11c>
	mov    %rax,0x0(%rip)        # <main+0x21e>
	jmpq   <main+0xe76>
	test   %r10b,%r10b
	je     <main+0x22f>
	mov    %r9d,0x0(%rip)        # <main+0x22f>
	test   %dl,%dl
	je     <main+0x239>
	mov    %eax,0x0(%rip)        # <main+0x239>
	test   %r8b,%r8b
	je     <main+0x244>
	mov    %edi,0x0(%rip)        # <main+0x244>
	test   %sil,%sil
	je     <main+0x24f>
	mov    %ecx,0x0(%rip)        # <main+0x24f>
	cmpb   $0x0,0x1(%rbx)
	lea    0x1(%rbx),%rdi
	jne    <main+0x266>
	mov    0x8(%rbp),%rdi
	test   %rdi,%rdi
	je     <main+0x11c>
	cmpb   $0x73,(%rdi)
	jne    <main+0x278>
	movl   $0x1,0x0(%rip)        # <main+0x275>
	inc    %rdi
	callq  <main+0x27d>
	mov    %eax,0x0(%rip)        # <main+0x283>
	jmpq   <main+0xe76>
	test   %r10b,%r10b
	je     <main+0x294>
	mov    %r9d,0x0(%rip)        # <main+0x294>
	test   %dl,%dl
	je     <main+0x29e>
	mov    %eax,0x0(%rip)        # <main+0x29e>
	test   %r8b,%r8b
	je     <main+0x2a9>
	mov    %edi,0x0(%rip)        # <main+0x2a9>
	test   %sil,%sil
	je     <main+0x2b4>
	mov    %ecx,0x0(%rip)        # <main+0x2b4>
	cmpb   $0x0,0x1(%rbx)
	lea    0x1(%rbx),%rdi
	jne    <main+0x2cb>
	mov    0x8(%rbp),%rdi
	test   %rdi,%rdi
	je     <main+0x11c>
	callq  <main+0x2d0>
	mov    %eax,%r13d
	jmpq   <main+0xe76>
	mov    $0x1,%sil
	xor    %ecx,%ecx
	jmpq   <main+0x49e>
	test   %r10b,%r10b
	je     <main+0x2ee>
	mov    %r9d,0x0(%rip)        # <main+0x2ee>
	test   %dl,%dl
	je     <main+0x2f8>
	mov    %eax,0x0(%rip)        # <main+0x2f8>
	test   %r8b,%r8b
	je     <main+0x303>
	mov    %edi,0x0(%rip)        # <main+0x303>
	test   %sil,%sil
	je     <main+0x30e>
	mov    %ecx,0x0(%rip)        # <main+0x30e>
	cmpb   $0x0,0x1(%rbx)
	lea    0x1(%rbx),%rax
	jne    <main+0x325>
	mov    0x8(%rbp),%rax
	test   %rax,%rax
	je     <main+0x11c>
	mov    %rax,0x0(%rip)        # <main+0x32c>
	jmpq   <main+0xe76>
	test   %r10b,%r10b
	je     <main+0x33d>
	mov    %r9d,0x0(%rip)        # <main+0x33d>
	test   %dl,%dl
	je     <main+0x347>
	mov    %eax,0x0(%rip)        # <main+0x347>
	test   %r8b,%r8b
	je     <main+0x352>
	mov    %edi,0x0(%rip)        # <main+0x352>
	test   %sil,%sil
	je     <main+0x35d>
	mov    %ecx,0x0(%rip)        # <main+0x35d>
	cmpb   $0x0,0x1(%rbx)
	lea    0x1(%rbx),%rax
	jne    <main+0x374>
	mov    0x8(%rbp),%rax
	test   %rax,%rax
	je     <main+0x11c>
	mov    %rax,0x0(%rip)        # <main+0x37b>
	jmpq   <main+0xe76>
	test   %r10b,%r10b
	je     <main+0x38c>
	mov    %r9d,0x0(%rip)        # <main+0x38c>
	test   %dl,%dl
	je     <main+0x396>
	mov    %eax,0x0(%rip)        # <main+0x396>
	test   %r8b,%r8b
	je     <main+0x3a1>
	mov    %edi,0x0(%rip)        # <main+0x3a1>
	test   %sil,%sil
	je     <main+0x3ac>
	mov    %ecx,0x0(%rip)        # <main+0x3ac>
	cmpb   $0x0,0x1(%rbx)
	lea    0x1(%rbx),%rax
	jne    <main+0x3c3>
	mov    0x8(%rbp),%rax
	test   %rax,%rax
	je     <main+0x11c>
	mov    %rax,0x0(%rip)        # <main+0x3ca>
	jmpq   <main+0xe76>
	test   %r10b,%r10b
	je     <main+0x3db>
	mov    %r9d,0x0(%rip)        # <main+0x3db>
	test   %dl,%dl
	je     <main+0x3e5>
	mov    %eax,0x0(%rip)        # <main+0x3e5>
	test   %r8b,%r8b
	je     <main+0x3f0>
	mov    %edi,0x0(%rip)        # <main+0x3f0>
	test   %sil,%sil
	je     <main+0x3fb>
	mov    %ecx,0x0(%rip)        # <main+0x3fb>
	cmpb   $0x0,0x1(%rbx)
	lea    0x1(%rbx),%rax
	jne    <main+0x412>
	mov    0x8(%rbp),%rax
	test   %rax,%rax
	je     <main+0x11c>
	mov    %rax,0x0(%rip)        # <main+0x419>
	jmpq   <main+0xe76>
	test   %r10b,%r10b
	je     <main+0x42a>
	mov    %r9d,0x0(%rip)        # <main+0x42a>
	test   %dl,%dl
	je     <main+0x434>
	mov    %eax,0x0(%rip)        # <main+0x434>
	test   %r8b,%r8b
	je     <main+0x43f>
	mov    %edi,0x0(%rip)        # <main+0x43f>
	test   %sil,%sil
	je     <main+0x44a>
	mov    %ecx,0x0(%rip)        # <main+0x44a>
	lea    0x0(%rip),%rdi        # <main+0x451>
	xor    %eax,%eax
	callq  <main+0x458>
	test   %r10b,%r10b
	je     <main+0x464>
	mov    %r9d,0x0(%rip)        # <main+0x464>
	test   %dl,%dl
	je     <main+0x46e>
	mov    %eax,0x0(%rip)        # <main+0x46e>
	test   %r8b,%r8b
	je     <main+0x479>
	mov    %edi,0x0(%rip)        # <main+0x479>
	test   %sil,%sil
	je     <main+0x11c>
	mov    %ecx,0x0(%rip)        # <main+0x488>
	jmpq   <main+0x11c>
	movl   $0x1,0xc(%rsp)
	jmp    <main+0x49e>
	mov    $0x1,%dl
	mov    $0x1,%eax
	inc    %rbx
	jmpq   <main+0xa3>
	test   %r10b,%r10b
	je     <main+0x4b2>
	mov    %r9d,0x0(%rip)        # <main+0x4b2>
	test   %dl,%dl
	je     <main+0x4bc>
	mov    %eax,0x0(%rip)        # <main+0x4bc>
	test   %r8b,%r8b
	je     <main+0x4c7>
	mov    %edi,0x0(%rip)        # <main+0x4c7>
	test   %sil,%sil
	je     <main+0x4d2>
	mov    %ecx,0x0(%rip)        # <main+0x4d2>
	dec    %r12d
	add    $0x8,%rbp
	jmpq   <main+0x52>
	dec    %r12d
	add    $0x8,%rbp
	jmp    <main+0x4ef>
	test   %al,%al
	jne    <main+0x7d>
	test   %r12d,%r12d
	jg     <main+0x508>
	movl   $0x0,0x0(%rip)        # <main+0x4fe>
	movl   $0x0,0x0(%rip)        # <main+0x508>
	lea    0x3(%r12),%edi
	mov    $0x8,%esi
	movslq %edi,%rdi
	callq  <main+0x51a>
	mov    %r14,%rsi
	lea    0x0(%rip),%rdi        # <main+0x524>
	test   %rax,%rax
	je     <main+0x5f1>
	mov    %rax,0x0(%rip)        # <main+0x534>
	test   %r12d,%r12d
	je     <main+0x591>
	mov    $0x0,%ecx
	mov    %rax,%rdi
	mov    %rbp,%rsi
	movslq %r13d,%rdx
	cmovns %r12d,%ecx
	movslq %ecx,%rcx
	shl    $0x3,%rcx
	rep movsb %ds:(%rsi),%es:(%rdi)
	test   %r13d,%r13d
	jg     <main+0x55c>
	movslq %r12d,%rdx
	shl    $0x3,%rdx
	cmp    $0x1,%r13d
	lea    0x0(%rip),%rbx        # <main+0x56b>
	adc    $0x0,%r12d
	mov    %rbx,(%rax,%rdx,1)
	mov    %r12d,0x0(%rip)        # <main+0x57a>
	movslq %r12d,%r12
	inc    %r12
	movq   $0x0,(%rax,%r12,8)
	movq   $0x0,-0x8(%rax,%r12,8)
	xor    %edi,%edi
	lea    0x0(%rip),%rsi        # <main+0x59a>
	callq  <main+0x59f>
	test   %rax,%rax
	jne    <main+0x5c7>
	mov    0x0(%rip),%rcx        # <main+0x5ab>
	mov    0x0(%rip),%rdi        # <main+0x5b2>
	lea    0x0(%rip),%rdx        # <main+0x5b9>
	xor    %eax,%eax
	mov    $0x1,%esi
	callq  <main+0x5c5>
	jmp    <main+0x5d0>
	callq  <main+0x5cc>
	test   %eax,%eax
	je     <main+0x5a4>
	xor    %edi,%edi
	callq  <main+0x5d7>
	mov    %rax,0x0(%rip)        # <main+0x5de>
	test   %rax,%rax
	jne    <main+0x5f6>
	mov    0x0(%rip),%rsi        # <main+0x5ea>
	lea    0x0(%rip),%rdi        # <main+0x5f1>
	callq  <main+0x5f6>
	xor    %edi,%edi
	callq  <main+0x5fd>
	mov    0x0(%rip),%rdi        # <main+0x604>
	lea    0x0(%rip),%rdx        # <main+0x60b>
	movslq 0xe0(%rdi),%rax
	mov    %eax,0x0(%rip)        # <main+0x618>
	mov    %rax,%rsi
	shl    $0x7,%rax
	add    0xe8(%rdi),%rax
	mov    0x10(%rax),%rax
	mov    %rax,0x0(%rip)        # <main+0x631>
	callq  <main+0x636>
	mov    %rax,0x0(%rip)        # <main+0x63d>
	test   %rax,%rax
	jne    <main+0x679>
	mov    0x0(%rip),%esi        # <main+0x648>
	mov    0x0(%rip),%rdi        # <main+0x64f>
	lea    0x0(%rip),%rdx        # <main+0x656>
	callq  <main+0x65b>
	lea    0x0(%rip),%rsi        # <main+0x662>
	lea    0x0(%rip),%rdi        # <main+0x669>
	mov    %rax,0x0(%rip)        # <main+0x670>
	test   %rax,%rax
	je     <main+0x5f1>
	mov    0x0(%rip),%rdx        # <main+0x680>
	mov    0x0(%rip),%rdi        # <main+0x687>
	lea    0x0(%rip),%rsi        # <main+0x68e>
	xor    %ebx,%ebx
	mov    (%rdx),%eax
	mov    0x4(%rdx),%edx
	mov    %eax,0x0(%rip)        # <main+0x69b>
	add    %edx,%eax
	mov    %edx,0x0(%rip)        # <main+0x6a3>
	xor    %edx,%edx
	mov    %eax,0x0(%rip)        # <main+0x6ab>
	add    $0x2,%eax
	mov    %eax,0x0(%rip)        # <main+0x6b4>
	mov    %eax,0x0(%rip)        # <main+0x6ba>
	callq  <main+0x6bf>
	mov    0x0(%rip),%rdi        # <main+0x6c6>
	xor    %edx,%edx
	lea    0x0(%rip),%rsi        # <main+0x6cf>
	mov    %rax,0x0(%rip)        # <main+0x6d6>
	callq  <main+0x6db>
	mov    0x0(%rip),%rdi        # <main+0x6e2>
	xor    %edx,%edx
	lea    0x0(%rip),%rsi        # <main+0x6eb>
	mov    %rax,0x0(%rip)        # <main+0x6f2>
	callq  <main+0x6f7>
	mov    0x0(%rip),%rdi        # <main+0x6fe>
	xor    %edx,%edx
	lea    0x0(%rip),%rsi        # <main+0x707>
	mov    %rax,0x0(%rip)        # <main+0x70e>
	callq  <main+0x713>
	mov    0x0(%rip),%rdi        # <main+0x71a>
	xor    %edx,%edx
	lea    0x0(%rip),%rsi        # <main+0x723>
	mov    %rax,0x0(%rip)        # <main+0x72a>
	callq  <main+0x72f>
	mov    0x0(%rip),%rdi        # <main+0x736>
	xor    %edx,%edx
	lea    0x0(%rip),%rsi        # <main+0x73f>
	mov    %rax,0x0(%rip)        # <main+0x746>
	callq  <main+0x74b>
	mov    0x0(%rip),%rdi        # <main+0x752>
	xor    %edx,%edx
	lea    0x0(%rip),%rsi        # <main+0x75b>
	mov    %rax,0x0(%rip)        # <main+0x762>
	callq  <main+0x767>
	mov    0x0(%rip),%rdi        # <main+0x76e>
	xor    %edx,%edx
	lea    0x0(%rip),%rsi        # <main+0x777>
	mov    %rax,0x0(%rip)        # <main+0x77e>
	callq  <main+0x783>
	mov    0x0(%rip),%rdi        # <main+0x78a>
	xor    %edx,%edx
	lea    0x0(%rip),%rsi        # <main+0x793>
	mov    %rax,0x0(%rip)        # <main+0x79a>
	callq  <main+0x79f>
	mov    0x0(%rip),%rdi        # <main+0x7a6>
	xor    %edx,%edx
	lea    0x0(%rip),%rsi        # <main+0x7af>
	mov    %rax,0x0(%rip)        # <main+0x7b6>
	callq  <main+0x7bb>
	mov    0x0(%rip),%rdi        # <main+0x7c2>
	movl   $0x0,0x0(%rip)        # <main+0x7cc>
	mov    %rax,0x0(%rip)        # <main+0x7d3>
	movl   $0x0,0x0(%rip)        # <main+0x7dd>
	movl   $0x320,0x0(%rip)        # <main+0x7e7>
	movl   $0x258,0x0(%rip)        # <main+0x7f1>
	test   %rdi,%rdi
	je     <main+0x8f1>
	lea    0x1c(%rsp),%rcx
	lea    0x18(%rsp),%rdx
	movl   $0x0,0x20(%rsp)
	lea    0x14(%rsp),%rsi
	lea    0x20(%rsp),%r8
	movl   $0x0,0x1c(%rsp)
	movl   $0x0,0x18(%rsp)
	movl   $0x0,0x14(%rsp)
	callq  <main+0x833>
	test   $0x1,%al
	je     <main+0x841>
	mov    0x14(%rsp),%edx
	mov    %edx,0x0(%rip)        # <main+0x841>
	test   $0x2,%al
	je     <main+0x84f>
	mov    0x18(%rsp),%edx
	mov    %edx,0x0(%rip)        # <main+0x84f>
	test   $0x4,%al
	je     <main+0x85d>
	mov    0x1c(%rsp),%edx
	mov    %edx,0x0(%rip)        # <main+0x85d>
	test   $0x8,%al
	je     <main+0x86b>
	mov    0x20(%rsp),%edx
	mov    %edx,0x0(%rip)        # <main+0x86b>
	test   $0x10,%al
	je     <main+0x882>
	cmpl   $0x0,0x0(%rip)        # <main+0x876>
	jne    <main+0x882>
	movl   $0xffffffff,0x0(%rip)        # <main+0x882>
	test   $0x20,%al
	je     <main+0x899>
	cmpl   $0x0,0x0(%rip)        # <main+0x88d>
	jne    <main+0x899>
	movl   $0xffffffff,0x0(%rip)        # <main+0x899>
	xor    %ebx,%ebx
	movslq 0x0(%rip),%rcx        # <main+0x8a2>
	test   $0xc,%al
	mov    0x0(%rip),%rax        # <main+0x8ab>
	setne  %bl
	shl    $0x7,%rcx
	add    0xe8(%rax),%rcx
	mov    0x0(%rip),%eax        # <main+0x8bf>
	mov    0x1c(%rcx),%edx
	test   %eax,%eax
	jns    <main+0x8d7>
	add    0x18(%rcx),%eax
	sub    0x0(%rip),%eax        # <main+0x8cf>
	dec    %eax
	mov    %eax,0x0(%rip)        # <main+0x8d7>
	mov    0x0(%rip),%eax        # <main+0x8dd>
	test   %eax,%eax
	jns    <main+0x8f1>
	add    %edx,%eax
	sub    0x0(%rip),%eax        # <main+0x8e9>
	dec    %eax
	mov    %eax,0x0(%rip)        # <main+0x8f1>
	xor    %eax,%eax
	lea    0x38(%rsp),%rdi
	mov    $0x10,%ecx
	xor    %r13d,%r13d
	rep stos %eax,%es:(%rdi)
	mov    0x0(%rip),%eax        # <main+0x908>
	mov    0x0(%rip),%rdi        # <main+0x90f>
	lea    0x24(%rsp),%rcx
	lea    0x38(%rsp),%rdx
	mov    $0xe,%esi
	mov    %eax,0x48(%rsp)
	mov    $0x20000001,%eax
	shl    $0x5,%rax
	mov    %rax,0x4c(%rsp)
	callq  <main+0x935>
	mov    %rax,%rbp
	mov    %rax,%r12
	cmp    0x24(%rsp),%r13d
	jge    <main+0x975>
	mov    (%r12),%rsi
	mov    0x0(%rip),%rdi        # <main+0x94d>
	callq  <main+0x952>
	cmpl   $0x1,0x8(%rax)
	jne    <main+0x96c>
	cmpw   $0x0,0x1e(%rax)
	je     <main+0x96c>
	mov    (%r12),%rax
	mov    %rax,0x0(%rip)        # <main+0x96a>
	jmp    <main+0x975>
	inc    %r13d
	add    $0x40,%r12
	jmp    <main+0x93b>
	mov    %rbp,%rdi
	callq  <main+0x97d>
	mov    0x0(%rip),%rdx        # <main+0x984>
	test   %rdx,%rdx
	jne    <main+0x9ad>
	mov    0x0(%rip),%rdi        # <main+0x990>
	lea    0x0(%rip),%rdx        # <main+0x997>
	mov    $0x1,%esi
	xor    %eax,%eax
	callq  <main+0x9a3>
	mov    $0x1,%edi
	callq  <main+0x9ad>
	mov    0x0(%rip),%rsi        # <main+0x9b4>
	mov    0x0(%rip),%rdi        # <main+0x9bb>
	xor    %ecx,%ecx
	lea    0x78(%rsp),%r13
	callq  <main+0x9c7>
	mov    0x0(%rip),%rdi        # <main+0x9ce>
	mov    %rax,0x0(%rip)        # <main+0x9d5>
	callq  <main+0x9da>
	mov    0x0(%rip),%rdi        # <main+0x9e1>
	mov    %rax,0x0(%rip)        # <main+0x9e8>
	mov    %rdx,0x0(%rip)        # <main+0x9ef>
	callq  <main+0x9f4>
	mov    0x0(%rip),%rdi        # <main+0x9fb>
	mov    %rax,0x0(%rip)        # <main+0xa02>
	mov    %rdx,0x0(%rip)        # <main+0xa09>
	callq  <main+0xa0e>
	mov    0x0(%rip),%rdi        # <main+0xa15>
	mov    %rax,0x0(%rip)        # <main+0xa1c>
	mov    %rdx,0x0(%rip)        # <main+0xa23>
	callq  <main+0xa28>
	mov    0x0(%rip),%rdi        # <main+0xa2f>
	mov    %rax,0x0(%rip)        # <main+0xa36>
	mov    %rdx,0x0(%rip)        # <main+0xa3d>
	callq  <main+0xa42>
	mov    0x0(%rip),%rdi        # <main+0xa49>
	mov    %rax,0x0(%rip)        # <main+0xa50>
	mov    %rdx,0x0(%rip)        # <main+0xa57>
	callq  <main+0xa5c>
	mov    0x0(%rip),%r9d        # <main+0xa63>
	movl   $0x1,0x98(%rsp)
	mov    %rax,0x0(%rip)        # <main+0xa75>
	mov    0x0(%rip),%rax        # <main+0xa7c>
	movq   $0x0,0x78(%rsp)
	mov    0x0(%rip),%r8d        # <main+0xa8c>
	mov    %rax,0x80(%rsp)
	mov    0x0(%rip),%rax        # <main+0xa9b>
	mov    %rdx,0x0(%rip)        # <main+0xaa2>
	mov    0x0(%rip),%ecx        # <main+0xaa8>
	mov    %rax,0x90(%rsp)
	mov    0x0(%rip),%rax        # <main+0xab7>
	mov    0x0(%rip),%edx        # <main+0xabd>
	mov    0x0(%rip),%rsi        # <main+0xac4>
	movq   $0x23a00d,0xc0(%rsp)
	mov    %rax,0xd8(%rsp)
	mov    0x0(%rip),%rdi        # <main+0xadf>
	push   %r13
	pushq  $0x2819
	pushq  0x0(%rip)        # <main+0xaec>
	pushq  $0x1
	pushq  $0x20
	pushq  $0x0
	callq  <main+0xaf7>
	mov    0x0(%rip),%ecx        # <main+0xafd>
	mov    0x0(%rip),%edx        # <main+0xb03>
	add    $0x30,%rsp
	mov    0x0(%rip),%rdi        # <main+0xb0e>
	mov    $0x20,%r8d
	mov    %rax,%rsi
	mov    %rax,0x0(%rip)        # <main+0xb1e>
	callq  <main+0xb23>
	mov    0x0(%rip),%rdi        # <main+0xb2a>
	xor    %ecx,%ecx
	xor    %edx,%edx
	mov    %rax,%rsi
	mov    %rax,0x0(%rip)        # <main+0xb38>
	callq  <main+0xb3d>
	mov    0x0(%rip),%rsi        # <main+0xb44>
	mov    0x0(%rip),%rdi        # <main+0xb4b>
	mov    %rax,0x0(%rip)        # <main+0xb52>
	callq  <main+0xb57>
	mov    0x0(%rip),%rsi        # <main+0xb5e>
	mov    $0x7a8005,%edx
	mov    0x0(%rip),%rdi        # <main+0xb6a>
	callq  <main+0xb6f>
	lea    0x0(%rip),%rdi        # <main+0xb76>
	callq  <main+0xb7b>
	mov    0x0(%rip),%rsi        # <main+0xb82>
	lea    0x28(%rsp),%rdx
	mov    0x0(%rip),%rdi        # <main+0xb8e>
	mov    %rax,0x0(%rip)        # <main+0xb95>
	mov    0x0(%rip),%rax        # <main+0xb9c>
	mov    %rax,0x28(%rsp)
	lea    0x0(%rip),%rax        # <main+0xba8>
	mov    %rax,0x30(%rsp)
	callq  <main+0xbb2>
	callq  <main+0xbb7>
	test   %ebx,%ebx
	mov    0x0(%rip),%edx        # <main+0xbbf>
	mov    %rax,%rbp
	mov    0x0(%rip),%eax        # <main+0xbc8>
	jne    <main+0xbe2>
	mov    %eax,0x14(%rbp)
	mov    0x0(%rip),%eax        # <main+0xbd3>
	movq   $0x18,0x0(%rbp)
	mov    %edx,0x10(%rbp)
	inc    %eax
	jmp    <main+0xbf3>
	movq   $0x30,0x0(%rbp)
	mov    %edx,0x20(%rbp)
	mov    %edx,0x18(%rbp)
	mov    %eax,0x24(%rbp)
	mov    %eax,0x1c(%rbp)
	callq  <main+0xbfb>
	mov    0x0(%rip),%rsi        # <main+0xc02>
	xor    %ecx,%ecx
	xor    %edx,%edx
	mov    %rax,%r12
	push   %rax
	mov    0x0(%rip),%rdi        # <main+0xc11>
	xor    %r9d,%r9d
	pushq  $0x0
	xor    %r8d,%r8d
	push   %r12
	push   %rbp
	callq  <main+0xc21>
	add    $0x20,%rsp
	mov    %rbp,%rdi
	callq  <main+0xc2d>
	mov    %r12,%rdi
	callq  <main+0xc35>
	mov    0x0(%rip),%rsi        # <main+0xc3c>
	mov    0x0(%rip),%rdi        # <main+0xc43>
	mov    $0x1,%ecx
	lea    0x0(%rip),%rdx        # <main+0xc4f>
	callq  <main+0xc54>
	mov    0x0(%rip),%r9        # <main+0xc5b>
	mov    $0x40,%ecx
	xor    %eax,%eax
	lea    0x0(%rip),%r8        # <main+0xc69>
	mov    $0x1,%edx
	mov    $0x40,%esi
	lea    0x0(%rip),%rdi        # <main+0xc7a>
	callq  <main+0xc7f>
	mov    $0x1,%edx
	lea    0x0(%rip),%rsi        # <main+0xc8b>
	lea    0x0(%rip),%rdi        # <main+0xc92>
	callq  <main+0xc97>
	or     $0xffffffff,%edi
	movl   $0x1,0x0(%rip)        # <main+0xca4>
	callq  <main+0xca9>
	mov    0x0(%rip),%rdx        # <main+0xcb0>
	lea    0x0(%rip),%rsi        # <main+0xcb7>
	xor    %eax,%eax
	mov    $0x1,%edi
	callq  <main+0xcc3>
	xor    %edi,%edi
	callq  <main+0xcca>
	cmpl   $0x0,0xc(%rsp)
	je     <main+0xd05>
	callq  <main+0xcd6>
	test   %eax,%eax
	jne    <main+0xce8>
	mov    0x0(%rip),%rdi        # <main+0xce1>
	callq  <main+0xce6>
	jmp    <main+0xd05>
	mov    0x0(%rip),%rax        # <main+0xcef>
	test   %rax,%rax
	je     <main+0xe5e>
	mov    0x10(%rax),%edi
	callq  <main+0xd00>
	jmpq   <main+0xe5e>
	mov    0x0(%rip),%rdi        # <main+0xd0c>
	xor    %esi,%esi
	callq  <main+0xd13>
	callq  <main+0xd18>
	cmpl   $0x1,0x0(%rip)        # <main+0xd1f>
	jne    <main+0xd28>
	xor    %edi,%edi
	callq  <main+0xd28>
	lea    0x0(%rip),%rbx        # <main+0xd2f>
	cmpl   $0x0,0x0(%rip)        # <main+0xd36>
	je     <main+0xd67>
	mov    0x0(%rip),%rdi        # <main+0xd3f>
	lea    0xe8(%rsp),%rbp
	mov    %rbp,%rsi
	callq  <main+0xd4f>
	movslq 0xe8(%rsp),%rax
	mov    (%rbx,%rax,8),%rax
	test   %rax,%rax
	je     <main+0xd2f>
	mov    %rbp,%rdi
	callq  *%rax
	jmp    <main+0xd2f>
	xor    %ebx,%ebx
	cmp    %ebx,0x0(%rip)        # <main+0xd6f>
	jle    <main+0xdda>
	mov    %r13,%rdi
	mov    %ebx,0x78(%rsp)
	callq  <main+0xd7d>
	mov    0x0(%rip),%rax        # <main+0xd84>
	mov    0x0(%rip),%rdi        # <main+0xd8b>
	mov    (%rax,%rbx,8),%rax
	mov    0x100(%rax),%rsi
	callq  <main+0xd9b>
	mov    0x0(%rip),%rax        # <main+0xda2>
	xor    %r8d,%r8d
	xor    %ecx,%ecx
	mov    0x0(%rip),%rdx        # <main+0xdae>
	mov    0x0(%rip),%rdi        # <main+0xdb5>
	mov    (%rax,%rbx,8),%rax
	mov    0x100(%rax),%rsi
	callq  <main+0xdc5>
	mov    0x0(%rip),%rax        # <main+0xdcc>
	mov    (%rax,%rbx,8),%rdi
	inc    %rbx
	callq  <main+0xdd8>
	jmp    <main+0xd69>
	mov    0x0(%rip),%rdi        # <main+0xde1>
	callq  <main+0xde6>
	mov    0x0(%rip),%rdi        # <main+0xded>
	xor    %esi,%esi
	movq   $0x0,0x0(%rip)        # <main+0xdfa>
	callq  <main+0xdff>
	mov    0x0(%rip),%rsi        # <main+0xe06>
	mov    0x0(%rip),%rdi        # <main+0xe0d>
	callq  <main+0xe12>
	mov    0x0(%rip),%rsi        # <main+0xe19>
	mov    0x0(%rip),%rdi        # <main+0xe20>
	callq  <main+0xe25>
	mov    0x0(%rip),%rsi        # <main+0xe2c>
	mov    0x0(%rip),%rdi        # <main+0xe33>
	callq  <main+0xe38>
	mov    0x0(%rip),%rdi        # <main+0xe3f>
	xor    %esi,%esi
	callq  <main+0xe46>
	mov    0x0(%rip),%rdi        # <main+0xe4d>
	callq  <main+0xe52>
	mov    0x0(%rip),%rdi        # <main+0xe59>
	callq  <main+0xe5e>
	mov    0x1a8(%rsp),%rax
	sub    %fs:0x28,%rax
	je     <main+0xe8c>
	callq  <main+0xe76>
	cmpb   $0x0,0x1(%rbx)
	jne    <main+0x4d2>
	dec    %r12d
	add    $0x8,%rbp
	jmpq   <main+0x4d2>
	add    $0x1b8,%rsp
	xor    %eax,%eax
	pop    %rbx
	pop    %rbp
	pop    %r12
	pop    %r13
	pop    %r14
	pop    %r15
	retq