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+0x4ea>
	cmpb   $0x2d,(%rbx)
	jne    <main+0x4ea>
	mov    0x1(%rbx),%al
	test   %al,%al
	je     <main+0x4ea>
	cmp    $0x2d,%al
	jne    <main+0x89>
	cmpb   $0x0,0x2(%rbx)
	jne    <main+0x89>
	dec    %r12d
	add    $0x8,%rbp
	jmpq   <main+0x4ea>
	mov    0x0(%rip),%ecx        # <main+0x8f>
	mov    0x0(%rip),%edi        # <main+0x95>
	xor    %esi,%esi
	xor    %edx,%edx
	mov    0x0(%rip),%r9d        # <main+0xa0>
	inc    %rbx
	xor    %r8d,%r8d
	xor    %r10d,%r10d
	mov    0x0(%rip),%eax        # <main+0xaf>
	mov    (%rbx),%r11b
	test   %r11b,%r11b
	je     <main+0x4b2>
	sub    $0x4f,%r11d
	cmp    $0x27,%r11b
	ja     <main+0x464>
	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+0x4aa>
	test   %r10b,%r10b
	je     <main+0xf5>
	mov    %r9d,0x0(%rip)        # <main+0xf5>
	test   %dl,%dl
	je     <main+0xff>
	mov    %eax,0x0(%rip)        # <main+0xff>
	test   %r8b,%r8b
	je     <main+0x10a>
	mov    %edi,0x0(%rip)        # <main+0x10a>
	test   %sil,%sil
	je     <main+0x115>
	mov    %ecx,0x0(%rip)        # <main+0x115>
	cmpb   $0x0,0x1(%rbx)
	lea    0x1(%rbx),%rax
	jne    <main+0x12d>
	mov    0x8(%rbp),%rax
	test   %rax,%rax
	jne    <main+0x12d>
	callq  <main+0x12d>
	mov    %rax,0x0(%rip)        # <main+0x134>
	jmpq   <main+0xe71>
	mov    $0x1,%r8b
	mov    $0x1,%edi
	jmpq   <main+0x4aa>
	test   %r10b,%r10b
	je     <main+0x152>
	mov    %r9d,0x0(%rip)        # <main+0x152>
	test   %dl,%dl
	je     <main+0x15c>
	mov    %eax,0x0(%rip)        # <main+0x15c>
	test   %r8b,%r8b
	je     <main+0x167>
	mov    %edi,0x0(%rip)        # <main+0x167>
	test   %sil,%sil
	je     <main+0x172>
	mov    %ecx,0x0(%rip)        # <main+0x172>
	cmpb   $0x0,0x1(%rbx)
	lea    0x1(%rbx),%rax
	jne    <main+0x185>
	mov    0x8(%rbp),%rax
	test   %rax,%rax
	je     <main+0x128>
	mov    %rax,0x0(%rip)        # <main+0x18c>
	jmpq   <main+0xe71>
	test   %r10b,%r10b
	je     <main+0x19d>
	mov    %r9d,0x0(%rip)        # <main+0x19d>
	test   %dl,%dl
	je     <main+0x1a7>
	mov    %eax,0x0(%rip)        # <main+0x1a7>
	test   %r8b,%r8b
	je     <main+0x1b2>
	mov    %edi,0x0(%rip)        # <main+0x1b2>
	test   %sil,%sil
	je     <main+0x1bd>
	mov    %ecx,0x0(%rip)        # <main+0x1bd>
	cmpb   $0x0,0x1(%rbx)
	lea    0x1(%rbx),%rax
	jne    <main+0x1d4>
	mov    0x8(%rbp),%rax
	test   %rax,%rax
	je     <main+0x128>
	mov    %rax,0x0(%rip)        # <main+0x1db>
	jmpq   <main+0xe71>
	test   %r10b,%r10b
	je     <main+0x1ec>
	mov    %r9d,0x0(%rip)        # <main+0x1ec>
	test   %dl,%dl
	je     <main+0x1f6>
	mov    %eax,0x0(%rip)        # <main+0x1f6>
	test   %r8b,%r8b
	je     <main+0x201>
	mov    %edi,0x0(%rip)        # <main+0x201>
	test   %sil,%sil
	je     <main+0x20c>
	mov    %ecx,0x0(%rip)        # <main+0x20c>
	cmpb   $0x0,0x1(%rbx)
	lea    0x1(%rbx),%rax
	jne    <main+0x223>
	mov    0x8(%rbp),%rax
	test   %rax,%rax
	je     <main+0x128>
	mov    %rax,0x0(%rip)        # <main+0x22a>
	jmpq   <main+0xe71>
	test   %r10b,%r10b
	je     <main+0x23b>
	mov    %r9d,0x0(%rip)        # <main+0x23b>
	test   %dl,%dl
	je     <main+0x245>
	mov    %eax,0x0(%rip)        # <main+0x245>
	test   %r8b,%r8b
	je     <main+0x250>
	mov    %edi,0x0(%rip)        # <main+0x250>
	test   %sil,%sil
	je     <main+0x25b>
	mov    %ecx,0x0(%rip)        # <main+0x25b>
	cmpb   $0x0,0x1(%rbx)
	lea    0x1(%rbx),%rdi
	jne    <main+0x272>
	mov    0x8(%rbp),%rdi
	test   %rdi,%rdi
	je     <main+0x128>
	cmpb   $0x73,(%rdi)
	jne    <main+0x284>
	movl   $0x1,0x0(%rip)        # <main+0x281>
	inc    %rdi
	callq  <main+0x289>
	mov    %eax,0x0(%rip)        # <main+0x28f>
	jmpq   <main+0xe71>
	test   %r10b,%r10b
	je     <main+0x2a0>
	mov    %r9d,0x0(%rip)        # <main+0x2a0>
	test   %dl,%dl
	je     <main+0x2aa>
	mov    %eax,0x0(%rip)        # <main+0x2aa>
	test   %r8b,%r8b
	je     <main+0x2b5>
	mov    %edi,0x0(%rip)        # <main+0x2b5>
	test   %sil,%sil
	je     <main+0x2c0>
	mov    %ecx,0x0(%rip)        # <main+0x2c0>
	cmpb   $0x0,0x1(%rbx)
	lea    0x1(%rbx),%rdi
	jne    <main+0x2d7>
	mov    0x8(%rbp),%rdi
	test   %rdi,%rdi
	je     <main+0x128>
	callq  <main+0x2dc>
	mov    %eax,%r13d
	jmpq   <main+0xe71>
	mov    $0x1,%sil
	xor    %ecx,%ecx
	jmpq   <main+0x4aa>
	test   %r10b,%r10b
	je     <main+0x2fa>
	mov    %r9d,0x0(%rip)        # <main+0x2fa>
	test   %dl,%dl
	je     <main+0x304>
	mov    %eax,0x0(%rip)        # <main+0x304>
	test   %r8b,%r8b
	je     <main+0x30f>
	mov    %edi,0x0(%rip)        # <main+0x30f>
	test   %sil,%sil
	je     <main+0x31a>
	mov    %ecx,0x0(%rip)        # <main+0x31a>
	cmpb   $0x0,0x1(%rbx)
	lea    0x1(%rbx),%rax
	jne    <main+0x331>
	mov    0x8(%rbp),%rax
	test   %rax,%rax
	je     <main+0x128>
	mov    %rax,0x0(%rip)        # <main+0x338>
	jmpq   <main+0xe71>
	test   %r10b,%r10b
	je     <main+0x349>
	mov    %r9d,0x0(%rip)        # <main+0x349>
	test   %dl,%dl
	je     <main+0x353>
	mov    %eax,0x0(%rip)        # <main+0x353>
	test   %r8b,%r8b
	je     <main+0x35e>
	mov    %edi,0x0(%rip)        # <main+0x35e>
	test   %sil,%sil
	je     <main+0x369>
	mov    %ecx,0x0(%rip)        # <main+0x369>
	cmpb   $0x0,0x1(%rbx)
	lea    0x1(%rbx),%rax
	jne    <main+0x380>
	mov    0x8(%rbp),%rax
	test   %rax,%rax
	je     <main+0x128>
	mov    %rax,0x0(%rip)        # <main+0x387>
	jmpq   <main+0xe71>
	test   %r10b,%r10b
	je     <main+0x398>
	mov    %r9d,0x0(%rip)        # <main+0x398>
	test   %dl,%dl
	je     <main+0x3a2>
	mov    %eax,0x0(%rip)        # <main+0x3a2>
	test   %r8b,%r8b
	je     <main+0x3ad>
	mov    %edi,0x0(%rip)        # <main+0x3ad>
	test   %sil,%sil
	je     <main+0x3b8>
	mov    %ecx,0x0(%rip)        # <main+0x3b8>
	cmpb   $0x0,0x1(%rbx)
	lea    0x1(%rbx),%rax
	jne    <main+0x3cf>
	mov    0x8(%rbp),%rax
	test   %rax,%rax
	je     <main+0x128>
	mov    %rax,0x0(%rip)        # <main+0x3d6>
	jmpq   <main+0xe71>
	test   %r10b,%r10b
	je     <main+0x3e7>
	mov    %r9d,0x0(%rip)        # <main+0x3e7>
	test   %dl,%dl
	je     <main+0x3f1>
	mov    %eax,0x0(%rip)        # <main+0x3f1>
	test   %r8b,%r8b
	je     <main+0x3fc>
	mov    %edi,0x0(%rip)        # <main+0x3fc>
	test   %sil,%sil
	je     <main+0x407>
	mov    %ecx,0x0(%rip)        # <main+0x407>
	cmpb   $0x0,0x1(%rbx)
	lea    0x1(%rbx),%rax
	jne    <main+0x41e>
	mov    0x8(%rbp),%rax
	test   %rax,%rax
	je     <main+0x128>
	mov    %rax,0x0(%rip)        # <main+0x425>
	jmpq   <main+0xe71>
	test   %r10b,%r10b
	je     <main+0x436>
	mov    %r9d,0x0(%rip)        # <main+0x436>
	test   %dl,%dl
	je     <main+0x440>
	mov    %eax,0x0(%rip)        # <main+0x440>
	test   %r8b,%r8b
	je     <main+0x44b>
	mov    %edi,0x0(%rip)        # <main+0x44b>
	test   %sil,%sil
	je     <main+0x456>
	mov    %ecx,0x0(%rip)        # <main+0x456>
	lea    0x0(%rip),%rdi        # <main+0x45d>
	xor    %eax,%eax
	callq  <main+0x464>
	test   %r10b,%r10b
	je     <main+0x470>
	mov    %r9d,0x0(%rip)        # <main+0x470>
	test   %dl,%dl
	je     <main+0x47a>
	mov    %eax,0x0(%rip)        # <main+0x47a>
	test   %r8b,%r8b
	je     <main+0x485>
	mov    %edi,0x0(%rip)        # <main+0x485>
	test   %sil,%sil
	je     <main+0x128>
	mov    %ecx,0x0(%rip)        # <main+0x494>
	jmpq   <main+0x128>
	movl   $0x1,0xc(%rsp)
	jmp    <main+0x4aa>
	mov    $0x1,%dl
	mov    $0x1,%eax
	inc    %rbx
	jmpq   <main+0xaf>
	test   %r10b,%r10b
	je     <main+0x4be>
	mov    %r9d,0x0(%rip)        # <main+0x4be>
	test   %dl,%dl
	je     <main+0x4c8>
	mov    %eax,0x0(%rip)        # <main+0x4c8>
	test   %r8b,%r8b
	je     <main+0x4d3>
	mov    %edi,0x0(%rip)        # <main+0x4d3>
	test   %sil,%sil
	je     <main+0x4de>
	mov    %ecx,0x0(%rip)        # <main+0x4de>
	dec    %r12d
	add    $0x8,%rbp
	jmpq   <main+0x52>
	test   %r12d,%r12d
	jg     <main+0x503>
	movl   $0x0,0x0(%rip)        # <main+0x4f9>
	movl   $0x0,0x0(%rip)        # <main+0x503>
	lea    0x3(%r12),%edi
	mov    $0x8,%esi
	movslq %edi,%rdi
	callq  <main+0x515>
	mov    %r14,%rsi
	lea    0x0(%rip),%rdi        # <main+0x51f>
	test   %rax,%rax
	je     <main+0x5ec>
	mov    %rax,0x0(%rip)        # <main+0x52f>
	test   %r12d,%r12d
	je     <main+0x58c>
	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+0x557>
	movslq %r12d,%rdx
	shl    $0x3,%rdx
	cmp    $0x1,%r13d
	lea    0x0(%rip),%rbx        # <main+0x566>
	adc    $0x0,%r12d
	mov    %rbx,(%rax,%rdx,1)
	mov    %r12d,0x0(%rip)        # <main+0x575>
	movslq %r12d,%r12
	inc    %r12
	movq   $0x0,(%rax,%r12,8)
	movq   $0x0,-0x8(%rax,%r12,8)
	xor    %edi,%edi
	lea    0x0(%rip),%rsi        # <main+0x595>
	callq  <main+0x59a>
	test   %rax,%rax
	jne    <main+0x5c2>
	mov    0x0(%rip),%rcx        # <main+0x5a6>
	mov    0x0(%rip),%rdi        # <main+0x5ad>
	lea    0x0(%rip),%rdx        # <main+0x5b4>
	xor    %eax,%eax
	mov    $0x1,%esi
	callq  <main+0x5c0>
	jmp    <main+0x5cb>
	callq  <main+0x5c7>
	test   %eax,%eax
	je     <main+0x59f>
	xor    %edi,%edi
	callq  <main+0x5d2>
	mov    %rax,0x0(%rip)        # <main+0x5d9>
	test   %rax,%rax
	jne    <main+0x5f1>
	mov    0x0(%rip),%rsi        # <main+0x5e5>
	lea    0x0(%rip),%rdi        # <main+0x5ec>
	callq  <main+0x5f1>
	xor    %edi,%edi
	callq  <main+0x5f8>
	mov    0x0(%rip),%rdi        # <main+0x5ff>
	lea    0x0(%rip),%rdx        # <main+0x606>
	movslq 0xe0(%rdi),%rax
	mov    %eax,0x0(%rip)        # <main+0x613>
	mov    %rax,%rsi
	shl    $0x7,%rax
	add    0xe8(%rdi),%rax
	mov    0x10(%rax),%rax
	mov    %rax,0x0(%rip)        # <main+0x62c>
	callq  <main+0x631>
	mov    %rax,0x0(%rip)        # <main+0x638>
	test   %rax,%rax
	jne    <main+0x674>
	mov    0x0(%rip),%esi        # <main+0x643>
	mov    0x0(%rip),%rdi        # <main+0x64a>
	lea    0x0(%rip),%rdx        # <main+0x651>
	callq  <main+0x656>
	lea    0x0(%rip),%rsi        # <main+0x65d>
	lea    0x0(%rip),%rdi        # <main+0x664>
	mov    %rax,0x0(%rip)        # <main+0x66b>
	test   %rax,%rax
	je     <main+0x5ec>
	mov    0x0(%rip),%rdx        # <main+0x67b>
	mov    0x0(%rip),%rdi        # <main+0x682>
	lea    0x0(%rip),%rsi        # <main+0x689>
	xor    %ebx,%ebx
	mov    (%rdx),%eax
	mov    0x4(%rdx),%edx
	mov    %eax,0x0(%rip)        # <main+0x696>
	add    %edx,%eax
	mov    %edx,0x0(%rip)        # <main+0x69e>
	xor    %edx,%edx
	mov    %eax,0x0(%rip)        # <main+0x6a6>
	add    $0x2,%eax
	mov    %eax,0x0(%rip)        # <main+0x6af>
	mov    %eax,0x0(%rip)        # <main+0x6b5>
	callq  <main+0x6ba>
	mov    0x0(%rip),%rdi        # <main+0x6c1>
	xor    %edx,%edx
	lea    0x0(%rip),%rsi        # <main+0x6ca>
	mov    %rax,0x0(%rip)        # <main+0x6d1>
	callq  <main+0x6d6>
	mov    0x0(%rip),%rdi        # <main+0x6dd>
	xor    %edx,%edx
	lea    0x0(%rip),%rsi        # <main+0x6e6>
	mov    %rax,0x0(%rip)        # <main+0x6ed>
	callq  <main+0x6f2>
	mov    0x0(%rip),%rdi        # <main+0x6f9>
	xor    %edx,%edx
	lea    0x0(%rip),%rsi        # <main+0x702>
	mov    %rax,0x0(%rip)        # <main+0x709>
	callq  <main+0x70e>
	mov    0x0(%rip),%rdi        # <main+0x715>
	xor    %edx,%edx
	lea    0x0(%rip),%rsi        # <main+0x71e>
	mov    %rax,0x0(%rip)        # <main+0x725>
	callq  <main+0x72a>
	mov    0x0(%rip),%rdi        # <main+0x731>
	xor    %edx,%edx
	lea    0x0(%rip),%rsi        # <main+0x73a>
	mov    %rax,0x0(%rip)        # <main+0x741>
	callq  <main+0x746>
	mov    0x0(%rip),%rdi        # <main+0x74d>
	xor    %edx,%edx
	lea    0x0(%rip),%rsi        # <main+0x756>
	mov    %rax,0x0(%rip)        # <main+0x75d>
	callq  <main+0x762>
	mov    0x0(%rip),%rdi        # <main+0x769>
	xor    %edx,%edx
	lea    0x0(%rip),%rsi        # <main+0x772>
	mov    %rax,0x0(%rip)        # <main+0x779>
	callq  <main+0x77e>
	mov    0x0(%rip),%rdi        # <main+0x785>
	xor    %edx,%edx
	lea    0x0(%rip),%rsi        # <main+0x78e>
	mov    %rax,0x0(%rip)        # <main+0x795>
	callq  <main+0x79a>
	mov    0x0(%rip),%rdi        # <main+0x7a1>
	xor    %edx,%edx
	lea    0x0(%rip),%rsi        # <main+0x7aa>
	mov    %rax,0x0(%rip)        # <main+0x7b1>
	callq  <main+0x7b6>
	mov    0x0(%rip),%rdi        # <main+0x7bd>
	movl   $0x0,0x0(%rip)        # <main+0x7c7>
	mov    %rax,0x0(%rip)        # <main+0x7ce>
	movl   $0x0,0x0(%rip)        # <main+0x7d8>
	movl   $0x320,0x0(%rip)        # <main+0x7e2>
	movl   $0x258,0x0(%rip)        # <main+0x7ec>
	test   %rdi,%rdi
	je     <main+0x8ec>
	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+0x82e>
	test   $0x1,%al
	je     <main+0x83c>
	mov    0x14(%rsp),%edx
	mov    %edx,0x0(%rip)        # <main+0x83c>
	test   $0x2,%al
	je     <main+0x84a>
	mov    0x18(%rsp),%edx
	mov    %edx,0x0(%rip)        # <main+0x84a>
	test   $0x4,%al
	je     <main+0x858>
	mov    0x1c(%rsp),%edx
	mov    %edx,0x0(%rip)        # <main+0x858>
	test   $0x8,%al
	je     <main+0x866>
	mov    0x20(%rsp),%edx
	mov    %edx,0x0(%rip)        # <main+0x866>
	test   $0x10,%al
	je     <main+0x87d>
	cmpl   $0x0,0x0(%rip)        # <main+0x871>
	jne    <main+0x87d>
	movl   $0xffffffff,0x0(%rip)        # <main+0x87d>
	test   $0x20,%al
	je     <main+0x894>
	cmpl   $0x0,0x0(%rip)        # <main+0x888>
	jne    <main+0x894>
	movl   $0xffffffff,0x0(%rip)        # <main+0x894>
	xor    %ebx,%ebx
	movslq 0x0(%rip),%rcx        # <main+0x89d>
	test   $0xc,%al
	mov    0x0(%rip),%rax        # <main+0x8a6>
	setne  %bl
	shl    $0x7,%rcx
	add    0xe8(%rax),%rcx
	mov    0x0(%rip),%eax        # <main+0x8ba>
	mov    0x1c(%rcx),%edx
	test   %eax,%eax
	jns    <main+0x8d2>
	add    0x18(%rcx),%eax
	sub    0x0(%rip),%eax        # <main+0x8ca>
	dec    %eax
	mov    %eax,0x0(%rip)        # <main+0x8d2>
	mov    0x0(%rip),%eax        # <main+0x8d8>
	test   %eax,%eax
	jns    <main+0x8ec>
	add    %edx,%eax
	sub    0x0(%rip),%eax        # <main+0x8e4>
	dec    %eax
	mov    %eax,0x0(%rip)        # <main+0x8ec>
	xor    %eax,%eax
	lea    0x38(%rsp),%rdi
	mov    $0x10,%ecx
	xor    %r13d,%r13d
	rep stos %eax,%es:(%rdi)
	mov    0x0(%rip),%eax        # <main+0x903>
	mov    0x0(%rip),%rdi        # <main+0x90a>
	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+0x930>
	mov    %rax,%rbp
	mov    %rax,%r12
	cmp    0x24(%rsp),%r13d
	jge    <main+0x970>
	mov    (%r12),%rsi
	mov    0x0(%rip),%rdi        # <main+0x948>
	callq  <main+0x94d>
	cmpl   $0x1,0x8(%rax)
	jne    <main+0x967>
	cmpw   $0x0,0x1e(%rax)
	je     <main+0x967>
	mov    (%r12),%rax
	mov    %rax,0x0(%rip)        # <main+0x965>
	jmp    <main+0x970>
	inc    %r13d
	add    $0x40,%r12
	jmp    <main+0x936>
	mov    %rbp,%rdi
	callq  <main+0x978>
	mov    0x0(%rip),%rdx        # <main+0x97f>
	test   %rdx,%rdx
	jne    <main+0x9a8>
	mov    0x0(%rip),%rdi        # <main+0x98b>
	lea    0x0(%rip),%rdx        # <main+0x992>
	mov    $0x1,%esi
	xor    %eax,%eax
	callq  <main+0x99e>
	mov    $0x1,%edi
	callq  <main+0x9a8>
	mov    0x0(%rip),%rsi        # <main+0x9af>
	mov    0x0(%rip),%rdi        # <main+0x9b6>
	xor    %ecx,%ecx
	lea    0x78(%rsp),%r13
	callq  <main+0x9c2>
	mov    0x0(%rip),%rdi        # <main+0x9c9>
	mov    %rax,0x0(%rip)        # <main+0x9d0>
	callq  <main+0x9d5>
	mov    0x0(%rip),%rdi        # <main+0x9dc>
	mov    %rax,0x0(%rip)        # <main+0x9e3>
	mov    %rdx,0x0(%rip)        # <main+0x9ea>
	callq  <main+0x9ef>
	mov    0x0(%rip),%rdi        # <main+0x9f6>
	mov    %rax,0x0(%rip)        # <main+0x9fd>
	mov    %rdx,0x0(%rip)        # <main+0xa04>
	callq  <main+0xa09>
	mov    0x0(%rip),%rdi        # <main+0xa10>
	mov    %rax,0x0(%rip)        # <main+0xa17>
	mov    %rdx,0x0(%rip)        # <main+0xa1e>
	callq  <main+0xa23>
	mov    0x0(%rip),%rdi        # <main+0xa2a>
	mov    %rax,0x0(%rip)        # <main+0xa31>
	mov    %rdx,0x0(%rip)        # <main+0xa38>
	callq  <main+0xa3d>
	mov    0x0(%rip),%rdi        # <main+0xa44>
	mov    %rax,0x0(%rip)        # <main+0xa4b>
	mov    %rdx,0x0(%rip)        # <main+0xa52>
	callq  <main+0xa57>
	mov    0x0(%rip),%r9d        # <main+0xa5e>
	movl   $0x1,0x98(%rsp)
	mov    %rax,0x0(%rip)        # <main+0xa70>
	mov    0x0(%rip),%rax        # <main+0xa77>
	movq   $0x0,0x78(%rsp)
	mov    0x0(%rip),%r8d        # <main+0xa87>
	mov    %rax,0x80(%rsp)
	mov    0x0(%rip),%rax        # <main+0xa96>
	mov    %rdx,0x0(%rip)        # <main+0xa9d>
	mov    0x0(%rip),%ecx        # <main+0xaa3>
	mov    %rax,0x90(%rsp)
	mov    0x0(%rip),%rax        # <main+0xab2>
	mov    0x0(%rip),%edx        # <main+0xab8>
	mov    0x0(%rip),%rsi        # <main+0xabf>
	movq   $0x23a00d,0xc0(%rsp)
	mov    %rax,0xd8(%rsp)
	mov    0x0(%rip),%rdi        # <main+0xada>
	push   %r13
	pushq  $0x2819
	pushq  0x0(%rip)        # <main+0xae7>
	pushq  $0x1
	pushq  $0x20
	pushq  $0x0
	callq  <main+0xaf2>
	mov    0x0(%rip),%ecx        # <main+0xaf8>
	mov    0x0(%rip),%edx        # <main+0xafe>
	add    $0x30,%rsp
	mov    0x0(%rip),%rdi        # <main+0xb09>
	mov    $0x20,%r8d
	mov    %rax,%rsi
	mov    %rax,0x0(%rip)        # <main+0xb19>
	callq  <main+0xb1e>
	mov    0x0(%rip),%rdi        # <main+0xb25>
	xor    %ecx,%ecx
	xor    %edx,%edx
	mov    %rax,%rsi
	mov    %rax,0x0(%rip)        # <main+0xb33>
	callq  <main+0xb38>
	mov    0x0(%rip),%rsi        # <main+0xb3f>
	mov    0x0(%rip),%rdi        # <main+0xb46>
	mov    %rax,0x0(%rip)        # <main+0xb4d>
	callq  <main+0xb52>
	mov    0x0(%rip),%rsi        # <main+0xb59>
	mov    $0x7a8005,%edx
	mov    0x0(%rip),%rdi        # <main+0xb65>
	callq  <main+0xb6a>
	lea    0x0(%rip),%rdi        # <main+0xb71>
	callq  <main+0xb76>
	mov    0x0(%rip),%rsi        # <main+0xb7d>
	lea    0x28(%rsp),%rdx
	mov    0x0(%rip),%rdi        # <main+0xb89>
	mov    %rax,0x0(%rip)        # <main+0xb90>
	mov    0x0(%rip),%rax        # <main+0xb97>
	mov    %rax,0x28(%rsp)
	lea    0x0(%rip),%rax        # <main+0xba3>
	mov    %rax,0x30(%rsp)
	callq  <main+0xbad>
	callq  <main+0xbb2>
	test   %ebx,%ebx
	mov    0x0(%rip),%edx        # <main+0xbba>
	mov    %rax,%rbp
	mov    0x0(%rip),%eax        # <main+0xbc3>
	jne    <main+0xbdd>
	mov    %eax,0x14(%rbp)
	mov    0x0(%rip),%eax        # <main+0xbce>
	movq   $0x18,0x0(%rbp)
	mov    %edx,0x10(%rbp)
	inc    %eax
	jmp    <main+0xbee>
	movq   $0x30,0x0(%rbp)
	mov    %edx,0x20(%rbp)
	mov    %edx,0x18(%rbp)
	mov    %eax,0x24(%rbp)
	mov    %eax,0x1c(%rbp)
	callq  <main+0xbf6>
	mov    0x0(%rip),%rsi        # <main+0xbfd>
	xor    %ecx,%ecx
	xor    %edx,%edx
	mov    %rax,%r12
	push   %rax
	mov    0x0(%rip),%rdi        # <main+0xc0c>
	xor    %r9d,%r9d
	pushq  $0x0
	xor    %r8d,%r8d
	push   %r12
	push   %rbp
	callq  <main+0xc1c>
	add    $0x20,%rsp
	mov    %rbp,%rdi
	callq  <main+0xc28>
	mov    %r12,%rdi
	callq  <main+0xc30>
	mov    0x0(%rip),%rsi        # <main+0xc37>
	mov    0x0(%rip),%rdi        # <main+0xc3e>
	mov    $0x1,%ecx
	lea    0x0(%rip),%rdx        # <main+0xc4a>
	callq  <main+0xc4f>
	mov    0x0(%rip),%r9        # <main+0xc56>
	mov    $0x40,%ecx
	xor    %eax,%eax
	lea    0x0(%rip),%r8        # <main+0xc64>
	mov    $0x1,%edx
	mov    $0x40,%esi
	lea    0x0(%rip),%rdi        # <main+0xc75>
	callq  <main+0xc7a>
	mov    $0x1,%edx
	lea    0x0(%rip),%rsi        # <main+0xc86>
	lea    0x0(%rip),%rdi        # <main+0xc8d>
	callq  <main+0xc92>
	or     $0xffffffff,%edi
	movl   $0x1,0x0(%rip)        # <main+0xc9f>
	callq  <main+0xca4>
	mov    0x0(%rip),%rdx        # <main+0xcab>
	lea    0x0(%rip),%rsi        # <main+0xcb2>
	xor    %eax,%eax
	mov    $0x1,%edi
	callq  <main+0xcbe>
	xor    %edi,%edi
	callq  <main+0xcc5>
	cmpl   $0x0,0xc(%rsp)
	je     <main+0xd00>
	callq  <main+0xcd1>
	test   %eax,%eax
	jne    <main+0xce3>
	mov    0x0(%rip),%rdi        # <main+0xcdc>
	callq  <main+0xce1>
	jmp    <main+0xd00>
	mov    0x0(%rip),%rax        # <main+0xcea>
	test   %rax,%rax
	je     <main+0xe59>
	mov    0x10(%rax),%edi
	callq  <main+0xcfb>
	jmpq   <main+0xe59>
	mov    0x0(%rip),%rdi        # <main+0xd07>
	xor    %esi,%esi
	callq  <main+0xd0e>
	callq  <main+0xd13>
	cmpl   $0x1,0x0(%rip)        # <main+0xd1a>
	jne    <main+0xd23>
	xor    %edi,%edi
	callq  <main+0xd23>
	lea    0x0(%rip),%rbx        # <main+0xd2a>
	cmpl   $0x0,0x0(%rip)        # <main+0xd31>
	je     <main+0xd62>
	mov    0x0(%rip),%rdi        # <main+0xd3a>
	lea    0xe8(%rsp),%rbp
	mov    %rbp,%rsi
	callq  <main+0xd4a>
	movslq 0xe8(%rsp),%rax
	mov    (%rbx,%rax,8),%rax
	test   %rax,%rax
	je     <main+0xd2a>
	mov    %rbp,%rdi
	callq  *%rax
	jmp    <main+0xd2a>
	xor    %ebx,%ebx
	cmp    %ebx,0x0(%rip)        # <main+0xd6a>
	jle    <main+0xdd5>
	mov    %r13,%rdi
	mov    %ebx,0x78(%rsp)
	callq  <main+0xd78>
	mov    0x0(%rip),%rax        # <main+0xd7f>
	mov    0x0(%rip),%rdi        # <main+0xd86>
	mov    (%rax,%rbx,8),%rax
	mov    0x100(%rax),%rsi
	callq  <main+0xd96>
	mov    0x0(%rip),%rax        # <main+0xd9d>
	xor    %r8d,%r8d
	xor    %ecx,%ecx
	mov    0x0(%rip),%rdx        # <main+0xda9>
	mov    0x0(%rip),%rdi        # <main+0xdb0>
	mov    (%rax,%rbx,8),%rax
	mov    0x100(%rax),%rsi
	callq  <main+0xdc0>
	mov    0x0(%rip),%rax        # <main+0xdc7>
	mov    (%rax,%rbx,8),%rdi
	inc    %rbx
	callq  <main+0xdd3>
	jmp    <main+0xd64>
	mov    0x0(%rip),%rdi        # <main+0xddc>
	callq  <main+0xde1>
	mov    0x0(%rip),%rdi        # <main+0xde8>
	xor    %esi,%esi
	movq   $0x0,0x0(%rip)        # <main+0xdf5>
	callq  <main+0xdfa>
	mov    0x0(%rip),%rsi        # <main+0xe01>
	mov    0x0(%rip),%rdi        # <main+0xe08>
	callq  <main+0xe0d>
	mov    0x0(%rip),%rsi        # <main+0xe14>
	mov    0x0(%rip),%rdi        # <main+0xe1b>
	callq  <main+0xe20>
	mov    0x0(%rip),%rsi        # <main+0xe27>
	mov    0x0(%rip),%rdi        # <main+0xe2e>
	callq  <main+0xe33>
	mov    0x0(%rip),%rdi        # <main+0xe3a>
	xor    %esi,%esi
	callq  <main+0xe41>
	mov    0x0(%rip),%rdi        # <main+0xe48>
	callq  <main+0xe4d>
	mov    0x0(%rip),%rdi        # <main+0xe54>
	callq  <main+0xe59>
	mov    0x1a8(%rsp),%rax
	sub    %fs:0x28,%rax
	je     <main+0xe87>
	callq  <main+0xe71>
	cmpb   $0x0,0x1(%rbx)
	jne    <main+0x4de>
	dec    %r12d
	add    $0x8,%rbp
	jmpq   <main+0x4de>
	add    $0x1b8,%rsp
	xor    %eax,%eax
	pop    %rbx
	pop    %rbp
	pop    %r12
	pop    %r13
	pop    %r14
	pop    %r15
	retq