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


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

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

<toggle>:
	mov    (%rdi),%rax
	xor    %edx,%edx
	mov    (%rax),%ecx
	test   %ecx,%ecx
	sete   %dl
	mov    %edx,(%rax)
	retq   
	nop

<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  <die+0xb5>
	data16 nopw %cs:0x0(%rax,%rax,1)

<xerror>:
	movzbl 0x20(%rsi),%r9d
	cmp    $0x3,%r9b
	je     <xerror+0xb0>
	push   %r12
	push   %rbp
	mov    %rsi,%rbp
	sub    $0x8,%rsp
	movzwl 0x20(%rsi),%edx
	cmp    $0x2a08,%dx
	sete   %al
	cmp    $0x4a09,%dx
	sete   %cl
	or     %ecx,%eax
	cmp    $0xc08,%dx
	sete   %cl
	or     %ecx,%eax
	cmp    $0x1c0a,%dx
	sete   %cl
	or     %ecx,%eax
	cmp    $0x210a,%dx
	sete   %cl
	or     %ecx,%eax
	cmp    $0x3e09,%dx
	sete   %cl
	or     %cl,%al
	jne    <xerror+0x63>
	and    $0xfb,%dh
	cmp    $0x4209,%dx
	jne    <xerror+0x70>
	add    $0x8,%rsp
	xor    %eax,%eax
	pop    %rbp
	pop    %r12
	retq   
	nopl   (%rax)
	mov    %rdi,%r12
	movzbl 0x21(%rsi),%r8d
	xor    %eax,%eax
	mov    0x0(%rip),%rdi        # <xerror+0x81>
	mov    0x0(%rip),%rcx        # <xerror+0x88>
	mov    $0x1,%esi
	lea    0x0(%rip),%rdx        # <xerror+0x94>
	callq  <xerror+0x99>
	add    $0x8,%rsp
	mov    %rbp,%rsi
	mov    %r12,%rdi
	pop    %rbp
	pop    %r12
	jmpq   *0x0(%rip)        # <xerror+0xac>
	nopl   0x0(%rax)
	xor    %eax,%eax
	retq   
	data16 nopw %cs:0x0(%rax,%rax,1)
	xchg   %ax,%ax

<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,0x8(%rsp)
	mov    %rsp,%rcx
	mov    %esi,0x68(%rsp)
	mov    %r8,%rdi
	mov    %eax,0x4(%rsp)
	mov    %eax,0x64(%rsp)
	mov    0x0(%rip),%rax        # <resize+0x48>
	mov    %edx,0xc(%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+0xa0>
	mov    0x0(%rip),%rax        # <resize+0xa7>
	xor    %edx,%edx
	mov    0x0(%rip),%rdi        # <resize+0xb0>
	lea    0x30(%rsp),%r8
	mov    $0x20000,%ecx
	mov    (%rax,%rbx,8),%rax
	mov    0x100(%rax),%rsi
	callq  <resize+0xca>
	mov    0x88(%rsp),%rax
	sub    %fs:0x28,%rax
	jne    <resize+0xe6>
	add    $0x90,%rsp
	pop    %rbx
	retq   
	callq  <resize+0xeb>
	nopl   0x0(%rax,%rax,1)

<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>
	mov    %rsp,%r8
	mov    $0x80000,%ecx
	movl   $0x21,(%rsp)
	mov    %rax,0x20(%rsp)
	mov    0x0(%rip),%rax        # <fullscreen+0x4c>
	movl   $0x20,0x30(%rsp)
	mov    %rax,0x28(%rsp)
	mov    0x0(%rip),%rax        # <fullscreen+0x60>
	movq   $0x2,0x38(%rsp)
	mov    %rax,0x40(%rsp)
	movq   $0x0,0x48(%rsp)
	callq  <fullscreen+0x7c>
	mov    0xc8(%rsp),%rax
	sub    %fs:0x28,%rax
	jne    <fullscreen+0x97>
	add    $0xd8,%rsp
	retq   
	callq  <fullscreen+0x9c>
	nopl   0x0(%rax)

<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    0x10(%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
	je     <xsettitle+0x88>
	mov    %r12,%r8
	mov    $0x1,%ecx
	mov    $0x1,%edx
	mov    %r13,%rsi
	mov    0x0(%rip),%rdi        # <xsettitle+0x62>
	callq  <xsettitle+0x67>
	test   %eax,%eax
	je     <xsettitle+0xb0>
	mov    0x38(%rsp),%rax
	sub    %fs:0x28,%rax
	jne    <xsettitle+0xd3>
	add    $0x40,%rsp
	pop    %rbp
	pop    %r12
	pop    %r13
	retq   
	nopl   (%rax)
	mov    0x0(%rip),%rcx        # <xsettitle+0x8f>
	mov    0x0(%rip),%rdi        # <xsettitle+0x96>
	mov    %r12,%rdx
	mov    %rbp,%rsi
	callq  <xsettitle+0xa1>
	mov    0x10(%rsp),%rdi
	callq  <xsettitle+0xab>
	jmp    <xsettitle+0x4b>
	nopl   (%rax)
	mov    0x0(%rip),%rdi        # <xsettitle+0xb7>
	mov    $0x27,%ecx
	mov    %r12,%rdx
	mov    %rbp,%rsi
	callq  <xsettitle+0xc7>
	mov    0x10(%rsp),%rdi
	callq  <xsettitle+0xd1>
	jmp    <xsettitle+0x6b>
	callq  <xsettitle+0xd8>
	nopl   0x0(%rax,%rax,1)

<killclient>:
	push   %rbp
	push   %rbx
	sub    $0xe8,%rsp
	mov    %fs:0x28,%rax
	mov    %rax,0xd8(%rsp)
	xor    %eax,%eax
	test   %rdi,%rdi
	je     <killclient+0x190>
	movslq (%rdi),%rbx
	mov    0x0(%rip),%rax        # <killclient+0x2f>
	lea    0x4(%rsp),%rcx
	mov    0x0(%rip),%rdi        # <killclient+0x3b>
	lea    0x8(%rsp),%rdx
	lea    0x0(,%rbx,8),%rbp
	mov    (%rax,%rbx,8),%rax
	mov    0x100(%rax),%rsi
	callq  <killclient+0x58>
	test   %eax,%eax
	jne    <killclient+0xa0>
	mov    0x0(%rip),%rax        # <killclient+0x63>
	mov    (%rax,%rbx,8),%rax
	mov    0xd8(%rsp),%rsi
	sub    %fs:0x28,%rsi
	jne    <killclient+0x1b2>
	mov    0x100(%rax),%rsi
	mov    0x0(%rip),%rdi        # <killclient+0x8c>
	add    $0xe8,%rsp
	pop    %rbx
	pop    %rbp
	jmpq   <killclient+0x9a>
	nopw   0x0(%rax,%rax,1)
	mov    0x4(%rsp),%ecx
	mov    0x8(%rsp),%rdi
	test   %ecx,%ecx
	jle    <killclient+0x1a8>
	sub    $0x1,%ecx
	mov    0x0(%rip),%rdx        # <killclient+0xbb>
	mov    %rdi,%rax
	lea    0x8(%rdi,%rcx,8),%rcx
	jmp    <killclient+0xd5>
	nopl   (%rax)
	add    $0x8,%rax
	cmp    %rax,%rcx
	je     <killclient+0x1a8>
	cmp    %rdx,(%rax)
	jne    <killclient+0xc8>
	callq  <killclient+0xdf>
	mov    0x0(%rip),%rdx        # <killclient+0xe6>
	add    %rbp,%rdx
	mov    (%rdx),%rax
	mov    0x110(%rax),%ecx
	test   %ecx,%ecx
	jne    <killclient+0x67>
	movl   $0x21,0x10(%rsp)
	mov    (%rdx),%rax
	lea    0x10(%rsp),%r8
	xor    %ecx,%ecx
	movl   $0x20,0x40(%rsp)
	mov    0x0(%rip),%rdi        # <killclient+0x11b>
	movq   $0x0,0x50(%rsp)
	mov    0x100(%rax),%rax
	mov    %rax,0x30(%rsp)
	mov    0x0(%rip),%rax        # <killclient+0x137>
	mov    %rax,0x38(%rsp)
	mov    0x0(%rip),%rax        # <killclient+0x143>
	mov    %rax,0x48(%rsp)
	mov    (%rdx),%rax
	xor    %edx,%edx
	mov    0x100(%rax),%rsi
	callq  <killclient+0x159>
	mov    0x0(%rip),%rax        # <killclient+0x160>
	mov    (%rax,%rbx,8),%rax
	movl   $0x1,0x110(%rax)
	mov    0xd8(%rsp),%rax
	sub    %fs:0x28,%rax
	jne    <killclient+0x1b2>
	add    $0xe8,%rsp
	pop    %rbx
	pop    %rbp
	retq   
	nopl   0x0(%rax,%rax,1)
	movslq 0x0(%rip),%rbx        # <killclient+0x197>
	test   %ebx,%ebx
	jns    <killclient+0x28>
	jmp    <killclient+0x16e>
	nopl   0x0(%rax)
	callq  <killclient+0x1ad>
	jmpq   <killclient+0x5c>
	callq  <killclient+0x1b7>
	nopw   0x0(%rax,%rax,1)

<keypress>:
	push   %r13
	mov    %rdi,%r13
	xor    %ecx,%ecx
	xor    %edx,%edx
	push   %r12
	push   %rbp
	push   %rbx
	lea    0x0(%rip),%rbx        # <keypress+0x14>
	lea    0x2c0(%rbx),%r12
	sub    $0x8,%rsp
	movzbl 0x54(%rdi),%esi
	mov    0x0(%rip),%rdi        # <keypress+0x2a>
	callq  <keypress+0x2f>
	mov    %rax,%rbp
	jmp    <keypress+0x41>
	nopl   0x0(%rax)
	add    $0x20,%rbx
	cmp    %r12,%rbx
	je     <keypress+0x74>
	cmp    %rbp,-0x10(%rbx)
	jne    <keypress+0x38>
	mov    0x0(%rip),%eax        # <keypress+0x4d>
	mov    -0x18(%rbx),%edx
	xor    0x50(%r13),%edx
	or     $0x2,%eax
	not    %eax
	test   %eax,%edx
	jne    <keypress+0x38>
	mov    -0x8(%rbx),%rax
	test   %rax,%rax
	je     <keypress+0x38>
	mov    %rbx,%rdi
	add    $0x20,%rbx
	callq  *%rax
	cmp    %r12,%rbx
	jne    <keypress+0x41>
	add    $0x8,%rsp
	pop    %rbx
	pop    %rbp
	pop    %r12
	pop    %r13
	retq   
	nop

<spawn>:
	push   %r12
	push   %rbp
	push   %rbx
	mov    %rdi,%rbx
	sub    $0x40,%rsp
	mov    %fs:0x28,%rax
	mov    %rax,0x38(%rsp)
	xor    %eax,%eax
	movslq 0x0(%rip),%rax        # <spawn+0x22>
	cmp    $0xffffffff,%eax
	jne    <spawn+0xd0>
	callq  <spawn+0x30>
	test   %eax,%eax
	jne    <spawn+0x180>
	mov    0x0(%rip),%rax        # <spawn+0x3f>
	test   %rax,%rax
	je     <spawn+0x4c>
	mov    0x10(%rax),%edi
	callq  <spawn+0x4c>
	callq  <spawn+0x51>
	test   %rbx,%rbx
	je     <spawn+0xa8>
	mov    (%rbx),%rax
	test   %rax,%rax
	je     <spawn+0xa8>
	mov    (%rax),%rdi
	mov    %rax,%rsi
	callq  <spawn+0x69>
	mov    (%rbx),%rax
	mov    (%rax),%r8
	mov    0x0(%rip),%rcx        # <spawn+0x76>
	mov    0x0(%rip),%rdi        # <spawn+0x7d>
	lea    0x0(%rip),%rdx        # <spawn+0x84>
	xor    %eax,%eax
	mov    $0x1,%esi
	callq  <spawn+0x90>
	lea    0x0(%rip),%rdi        # <spawn+0x97>
	callq  <spawn+0x9c>
	xor    %edi,%edi
	callq  <spawn+0xa3>
	nopl   0x0(%rax,%rax,1)
	mov    0x0(%rip),%rbx        # <spawn+0xaf>
	movslq 0x0(%rip),%rax        # <spawn+0xb6>
	movq   $0x0,(%rbx,%rax,8)
	mov    (%rbx),%rdi
	mov    %rbx,%rsi
	callq  <spawn+0xc9>
	mov    (%rbx),%r8
	jmp    <spawn+0x6f>
	xchg   %ax,%ax
	mov    0x0(%rip),%rdx        # <spawn+0xd7>
	mov    0x0(%rip),%rcx        # <spawn+0xde>
	lea    0x10(%rsp),%r12
	mov    0x0(%rip),%rdi        # <spawn+0xea>
	mov    (%rdx,%rax,8),%rax
	mov    %r12,%rdx
	movq   $0x0,0x8(%rsp)
	mov    0x100(%rax),%rsi
	callq  <spawn+0x106>
	cmpq   $0x0,0x28(%rsp)
	je     <spawn+0x2b>
	mov    0x18(%rsp),%rax
	cmp    $0x1f,%rax
	je     <spawn+0x1b0>
	cmp    0x0(%rip),%rax        # <spawn+0x128>
	je     <spawn+0x1c8>
	cmp    %rax,0x0(%rip)        # <spawn+0x135>
	je     <spawn+0x220>
	mov    0x10(%rsp),%rdi
	callq  <spawn+0x145>
	callq  <spawn+0x14a>
	test   %eax,%eax
	jne    <spawn+0x182>
	test   %rbp,%rbp
	je     <spawn+0x38>
	mov    %rbp,%rdi
	callq  <spawn+0x15f>
	mov    %rbp,%rdi
	callq  <spawn+0x167>
	mov    0x0(%rip),%rax        # <spawn+0x16e>
	test   %rax,%rax
	jne    <spawn+0x44>
	jmpq   <spawn+0x4c>
	nopl   0x0(%rax)
	xor    %ebp,%ebp
	mov    0x38(%rsp),%rax
	sub    %fs:0x28,%rax
	jne    <spawn+0x252>
	add    $0x40,%rsp
	mov    %rbp,%rdi
	pop    %rbx
	pop    %rbp
	pop    %r12
	jmpq   <spawn+0x1a6>
	nopw   %cs:0x0(%rax,%rax,1)
	mov    0x10(%rsp),%rdi
	callq  <spawn+0x1ba>
	mov    %rax,%rbp
	jmpq   <spawn+0x13b>
	nopw   0x0(%rax,%rax,1)
	mov    0x0(%rip),%rdi        # <spawn+0x1cf>
	lea    0x4(%rsp),%rcx
	lea    0x8(%rsp),%rdx
	mov    %r12,%rsi
	callq  <spawn+0x1e1>
	test   %eax,%eax
	js     <spawn+0x248>
	mov    0x4(%rsp),%eax
	test   %eax,%eax
	jle    <spawn+0x13b>
	mov    0x8(%rsp),%rax
	mov    (%rax),%rdi
	test   %rdi,%rdi
	je     <spawn+0x13b>
	callq  <spawn+0x207>
	mov    0x8(%rsp),%rdi
	mov    %rax,%rbp
	callq  <spawn+0x214>
	jmpq   <spawn+0x13b>
	nopl   0x0(%rax)
	mov    0x0(%rip),%rdi        # <spawn+0x227>
	lea    0x4(%rsp),%rcx
	lea    0x8(%rsp),%rdx
	mov    %r12,%rsi
	callq  <spawn+0x239>
	test   %eax,%eax
	jns    <spawn+0x1e5>
	jmpq   <spawn+0x13b>
	nopw   0x0(%rax,%rax,1)
	mov    0x18(%rsp),%rax
	jmpq   <spawn+0x12e>
	callq  <spawn+0x257>
	nopw   0x0(%rax,%rax,1)

<sigchld>:
	sub    $0x8,%rsp
	lea    -0xb(%rip),%rsi        # <sigchld>
	mov    $0x11,%edi
	callq  <sigchld+0x15>
	cmp    $0xffffffffffffffff,%rax
	je     <sigchld+0x3a>
	nopl   0x0(%rax,%rax,1)
	xor    %esi,%esi
	mov    $0x1,%edx
	mov    $0xffffffff,%edi
	callq  <sigchld+0x31>
	test   %eax,%eax
	jg     <sigchld+0x20>
	add    $0x8,%rsp
	retq   
	mov    0x0(%rip),%rsi        # <sigchld+0x41>
	lea    0x0(%rip),%rdi        # <sigchld+0x48>
	xor    %eax,%eax
	callq  <die>
	nop

<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>
	mov    %rsp,%r8
	callq  <getcolor+0x39>
	test   %eax,%eax
	je     <getcolor+0x5d>
	mov    (%rsp),%rax
	mov    0x8(%rsp),%rdx
	mov    0x18(%rsp),%rcx
	sub    %fs:0x28,%rcx
	jne    <getcolor+0x73>
	add    $0x20,%rsp
	pop    %r12
	retq   
	mov    0x0(%rip),%rsi        # <getcolor+0x64>
	mov    %r12,%rdx
	lea    0x0(%rip),%rdi        # <getcolor+0x6e>
	callq  <die>
	callq  <getcolor+0x78>
	nopl   0x0(%rax,%rax,1)

<clientmessage>:
	mov    0x0(%rip),%rax        # <clientmessage+0x7>
	cmp    %rax,0x28(%rdi)
	je     <clientmessage+0x10>
	retq   
	xchg   %ax,%ax
	mov    0x0(%rip),%rax        # <clientmessage+0x17>
	cmp    %rax,0x38(%rdi)
	jne    <clientmessage+0xd>
	cmpl   $0x1,0x0(%rip)        # <clientmessage+0x24>
	jle    <clientmessage+0x30>
	mov    0x0(%rip),%eax        # <clientmessage+0x2c>
	test   %eax,%eax
	jne    <clientmessage+0x40>
	movl   $0x0,0x0(%rip)        # <clientmessage+0x3a>
	retq   
	nopl   0x0(%rax,%rax,1)
	xor    %edi,%edi
	jmpq   <killclient>
	nopw   0x0(%rax,%rax,1)

<configurenotify>:
	mov    0x0(%rip),%rax        # <configurenotify+0x7>
	cmp    %rax,0x28(%rdi)
	je     <configurenotify+0x10>
	retq   
	xchg   %ax,%ax
	mov    0x38(%rdi),%eax
	cmp    0x0(%rip),%eax        # <configurenotify+0x19>
	mov    0x3c(%rdi),%edx
	jne    <configurenotify+0x26>
	cmp    %edx,0x0(%rip)        # <configurenotify+0x24>
	je     <configurenotify+0xd>
	sub    $0x8,%rsp
	mov    0x0(%rip),%rsi        # <configurenotify+0x31>
	mov    %edx,0x0(%rip)        # <configurenotify+0x37>
	mov    0x0(%rip),%rdi        # <configurenotify+0x3e>
	mov    %eax,0x0(%rip)        # <configurenotify+0x44>
	callq  <configurenotify+0x49>
	mov    0x0(%rip),%edx        # <configurenotify+0x4f>
	mov    0x0(%rip),%ecx        # <configurenotify+0x55>
	mov    $0x20,%r8d
	mov    0x0(%rip),%rsi        # <configurenotify+0x62>
	mov    0x0(%rip),%rdi        # <configurenotify+0x69>
	callq  <configurenotify+0x6e>
	mov    0x0(%rip),%edx        # <configurenotify+0x74>
	mov    %rax,0x0(%rip)        # <configurenotify+0x7b>
	mov    0x0(%rip),%eax        # <configurenotify+0x81>
	test   %eax,%eax
	jne    <configurenotify+0xc0>
	cmp    %edx,0x0(%rip)        # <configurenotify+0x8b>
	jg     <configurenotify+0xc0>
	mov    %edx,0x0(%rip)        # <configurenotify+0x93>
	movl   $0x0,0x0(%rip)        # <configurenotify+0x9d>
	mov    0x0(%rip),%edi        # <configurenotify+0xa3>
	test   %edi,%edi
	jns    <configurenotify+0xe0>
	mov    0x0(%rip),%rdi        # <configurenotify+0xae>
	xor    %esi,%esi
	add    $0x8,%rsp
	jmpq   <configurenotify+0xb9>
	nopl   0x0(%rax)
	test   %edx,%edx
	jne    <configurenotify+0x9d>
	cmp    0x0(%rip),%eax        # <configurenotify+0xca>
	jge    <configurenotify+0x9d>
	mov    %eax,0x0(%rip)        # <configurenotify+0xd2>
	movl   $0x0,0x0(%rip)        # <configurenotify+0xdc>
	jmp    <configurenotify+0x9d>
	xchg   %ax,%ax
	mov    0x0(%rip),%esi        # <configurenotify+0xe6>
	mov    0x0(%rip),%edx        # <configurenotify+0xec>
	sub    0x0(%rip),%edx        # <configurenotify+0xf2>
	callq  <resize>
	jmp    <configurenotify+0xa7>
	nopl   0x0(%rax)

<gettextpropn.constprop.0>:
	push   %rbp
	push   %rbx
	sub    $0x48,%rsp
	mov    %fs:0x28,%rax
	mov    %rax,0x38(%rsp)
	xor    %eax,%eax
	movq   $0x0,0x8(%rsp)
	test   %rdx,%rdx
	jne    <gettextpropn.constprop.0+0x48>
	xor    %eax,%eax
	mov    0x38(%rsp),%rcx
	sub    %fs:0x28,%rcx
	jne    <gettextpropn.constprop.0+0x152>
	add    $0x48,%rsp
	pop    %rbx
	pop    %rbp
	retq   
	nopl   0x0(%rax)
	movb   $0x0,(%rdx)
	mov    %rsi,%rcx
	lea    0x10(%rsp),%rbp
	mov    %rdi,%rsi
	mov    0x0(%rip),%rdi        # <gettextpropn.constprop.0+0x5d>
	mov    %rdx,%rbx
	mov    %rbp,%rdx
	callq  <gettextpropn.constprop.0+0x68>
	cmpq   $0x0,0x28(%rsp)
	je     <gettextpropn.constprop.0+0x24>
	mov    0x18(%rsp),%rax
	cmp    $0x1f,%rax
	je     <gettextpropn.constprop.0+0xb0>
	cmp    0x0(%rip),%rax        # <gettextpropn.constprop.0+0x82>
	je     <gettextpropn.constprop.0+0xd0>
	cmp    %rax,0x0(%rip)        # <gettextpropn.constprop.0+0x8b>
	je     <gettextpropn.constprop.0+0x120>
	mov    0x10(%rsp),%rbp
	movb   $0x0,0xff(%rbx)
	mov    %rbp,%rdi
	callq  <gettextpropn.constprop.0+0xa5>
	mov    $0x1,%eax
	jmpq   <gettextpropn.constprop.0+0x26>
	nop
	mov    0x10(%rsp),%rbp
	mov    $0xff,%edx
	mov    %rbx,%rdi
	mov    %rbp,%rsi
	callq  <gettextpropn.constprop.0+0xc5>
	jmp    <gettextpropn.constprop.0+0x96>
	nopw   0x0(%rax,%rax,1)
	mov    0x0(%rip),%rdi        # <gettextpropn.constprop.0+0xd7>
	lea    0x4(%rsp),%rcx
	lea    0x8(%rsp),%rdx
	mov    %rbp,%rsi
	callq  <gettextpropn.constprop.0+0xe9>
	test   %eax,%eax
	js     <gettextpropn.constprop.0+0x148>
	mov    0x4(%rsp),%eax
	test   %eax,%eax
	jle    <gettextpropn.constprop.0+0x91>
	mov    0x8(%rsp),%rbp
	mov    0x0(%rbp),%rsi
	test   %rsi,%rsi
	je     <gettextpropn.constprop.0+0x91>
	mov    %rbx,%rdi
	mov    $0xff,%edx
	callq  <gettextpropn.constprop.0+0x110>
	mov    %rbp,%rdi
	callq  <gettextpropn.constprop.0+0x118>
	jmpq   <gettextpropn.constprop.0+0x91>
	nopl   (%rax)
	mov    0x0(%rip),%rdi        # <gettextpropn.constprop.0+0x127>
	lea    0x4(%rsp),%rcx
	lea    0x8(%rsp),%rdx
	mov    %rbp,%rsi
	callq  <gettextpropn.constprop.0+0x139>
	test   %eax,%eax
	jns    <gettextpropn.constprop.0+0xed>
	jmpq   <gettextpropn.constprop.0+0x91>
	nopw   0x0(%rax,%rax,1)
	mov    0x18(%rsp),%rax
	jmpq   <gettextpropn.constprop.0+0x84>
	callq  <gettextpropn.constprop.0+0x157>
	nopw   0x0(%rax,%rax,1)

<sendxembed.constprop.0>:
	sub    $0xd8,%rsp
	movslq %edi,%r8
	mov    $0x18,%ecx
	mov    %fs:0x28,%rax
	mov    %rax,0xc8(%rsp)
	xor    %eax,%eax
	mov    %rsp,%rdi
	rep stos %rax,%es:(%rdi)
	mov    0x0(%rip),%rax        # <sendxembed.constprop.0+0x2f>
	mov    0x0(%rip),%rdi        # <sendxembed.constprop.0+0x36>
	lea    (%rax,%r8,8),%rax
	mov    %rsp,%r8
	mov    (%rax),%rdx
	mov    %rsi,0x40(%rsp)
	movl   $0x21,(%rsp)
	mov    0x100(%rdx),%rdx
	movl   $0x20,0x30(%rsp)
	mov    %rdx,0x20(%rsp)
	mov    0x0(%rip),%rdx        # <sendxembed.constprop.0+0x67>
	mov    %rdx,0x28(%rsp)
	mov    (%rax),%rax
	xor    %edx,%edx
	mov    0x100(%rax),%rsi
	callq  <sendxembed.constprop.0+0x7d>
	mov    0xc8(%rsp),%rax
	sub    %fs:0x28,%rax
	jne    <sendxembed.constprop.0+0x98>
	add    $0xd8,%rsp
	retq   
	callq  <sendxembed.constprop.0+0x9d>
	nopl   (%rax)

<drawtext>:
	push   %r15
	push   %r14
	mov    %rdi,%r14
	push   %r13
	push   %r12
	mov    %rsi,%r12
	push   %rbp
	push   %rbx
	sub    $0x158,%rsp
	mov    0x10(%rsi),%rdx
	mov    0x0(%rip),%rdi        # <drawtext+0x22>
	mov    %fs:0x28,%rax
	mov    %rax,0x148(%rsp)
	mov    0x0(%rip),%eax        # <drawtext+0x39>
	mov    0x0(%rip),%rsi        # <drawtext+0x40>
	mov    %ax,0x2c(%rsp)
	mov    0x0(%rip),%eax        # <drawtext+0x4b>
	mov    %ax,0x2e(%rsp)
	mov    0x0(%rip),%eax        # <drawtext+0x56>
	mov    %ax,0x30(%rsp)
	mov    0x0(%rip),%eax        # <drawtext+0x61>
	mov    %ax,0x32(%rsp)
	callq  <drawtext+0x6b>
	lea    0x2c(%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   %r14,%r14
	je     <drawtext+0x1ee>
	mov    %r14,%rdi
	callq  <drawtext+0xa1>
	mov    0x0(%rip),%ebx        # <drawtext+0xa7>
	mov    %rax,%rbp
	mov    0x0(%rip),%eax        # <drawtext+0xb0>
	mov    %eax,0x8(%rsp)
	add    %eax,%ebx
	mov    0x0(%rip),%eax        # <drawtext+0xbc>
	mov    %eax,0xc(%rsp)
	mov    0x0(%rip),%eax        # <drawtext+0xc6>
	mov    %eax,0x10(%rsp)
	mov    0x0(%rip),%eax        # <drawtext+0xd0>
	mov    %eax,0x14(%rsp)
	cmp    $0xff,%ebp
	jbe    <drawtext+0x218>
	mov    $0x100,%r15d
	lea    0x34(%rsp),%r13
	jmp    <drawtext+0xfa>
	nopl   (%rax)
	sub    $0x1,%r15d
	je     <drawtext+0x1ee>
	mov    0x0(%rip),%rsi        # <drawtext+0x101>
	mov    %r14,%rdx
	mov    %r13,%r8
	mov    %r15d,%ecx
	mov    0x0(%rip),%rdi        # <drawtext+0x111>
	callq  <drawtext+0x116>
	mov    0x0(%rip),%eax        # <drawtext+0x11c>
	movswl 0x3c(%rsp),%edx
	sub    %ebx,%eax
	cmp    %edx,%eax
	jl     <drawtext+0xf0>
	lea    0x40(%rsp),%r9
	movslq %r15d,%rdx
	mov    $0x100,%ecx
	mov    %r14,%rsi
	mov    %r9,%rdi
	callq  <drawtext+0x13f>
	mov    %rax,%r9
	cmp    %ebp,%r15d
	jge    <drawtext+0x172>
	lea    -0x1(%r15),%eax
	movslq %eax,%rdx
	movb   $0xa6,0x40(%rsp,%rdx,1)
	test   %eax,%eax
	je     <drawtext+0x172>
	lea    -0x2(%r15),%eax
	movslq %eax,%rdx
	movb   $0x80,0x40(%rsp,%rdx,1)
	test   %eax,%eax
	je     <drawtext+0x172>
	lea    -0x3(%r15),%eax
	cltq   
	movb   $0xe2,0x40(%rsp,%rax,1)
	mov    0x0(%rip),%rcx        # <drawtext+0x179>
	mov    0x0(%rip),%rdx        # <drawtext+0x180>
	mov    %r9,0x18(%rsp)
	mov    0x0(%rip),%rsi        # <drawtext+0x18c>
	mov    0x0(%rip),%rdi        # <drawtext+0x193>
	callq  <drawtext+0x198>
	mov    0x10(%rsp),%ecx
	mov    %ebx,%edx
	sub    $0x8,%rsp
	mov    %rax,%rbp
	shr    $0x1f,%edx
	mov    %r12,%rsi
	mov    %ecx,%eax
	add    %edx,%ebx
	mov    %rbp,%rdi
	shr    $0x1f,%eax
	mov    %ebx,%edx
	add    %ecx,%eax
	mov    0x1c(%rsp),%ecx
	sar    %edx
	sar    %eax
	add    0x14(%rsp),%eax
	push   %r15
	mov    0x18(%rsp),%ebx
	sub    %edx,%eax
	mov    0x28(%rsp),%r9
	add    %edx,%ecx
	mov    0x0(%rip),%rdx        # <drawtext+0x1db>
	lea    (%rax,%rbx,1),%r8d
	callq  <drawtext+0x1e4>
	mov    %rbp,%rdi
	callq  <drawtext+0x1ec>
	pop    %rax
	pop    %rdx
	mov    0x148(%rsp),%rax
	sub    %fs:0x28,%rax
	jne    <drawtext+0x224>
	add    $0x158,%rsp
	pop    %rbx
	pop    %rbp
	pop    %r12
	pop    %r13
	pop    %r14
	pop    %r15
	retq   
	nopl   0x0(%rax,%rax,1)
	test   %ebp,%ebp
	je     <drawtext+0x1ee>
	mov    %ebp,%r15d
	jmpq   <drawtext+0xe6>
	callq  <drawtext+0x229>
	nopl   0x0(%rax)

<getfirsttab>:
	push   %rbp
	push   %rbx
	sub    $0x28,%rsp
	mov    0x0(%rip),%r8d        # <getfirsttab+0xd>
	mov    %fs:0x28,%rax
	mov    %rax,0x18(%rsp)
	xor    %eax,%eax
	test   %r8d,%r8d
	js     <getfirsttab+0x88>
	movslq 0x0(%rip),%rax        # <getfirsttab+0x29>
	mov    %rax,%rbx
	imul   $0x51eb851f,%rax,%rax
	mov    %ebx,%edx
	sar    $0x1f,%edx
	sar    $0x26,%rax
	sub    %edx,%eax
	cmp    %eax,0x0(%rip)        # <getfirsttab+0x44>
	jg     <getfirsttab+0xb0>
	mov    %eax,%edx
	shr    $0x1f,%edx
	add    %eax,%edx
	sar    %edx
	sub    %edx,%r8d
	lea    0x1(%rax),%edx
	mov    %edx,%ecx
	shr    $0x1f,%ecx
	add    %ecx,%edx
	and    $0x1,%edx
	sub    %ecx,%edx
	add    %edx,%r8d
	js     <getfirsttab+0x88>
	mov    0x0(%rip),%edx        # <getfirsttab+0x6c>
	lea    (%rax,%r8,1),%ecx
	cmp    %edx,%ecx
	jle    <getfirsttab+0x8b>
	sub    %eax,%edx
	mov    $0x0,%eax
	mov    %edx,%r8d
	cmovs  %eax,%r8d
	jmp    <getfirsttab+0x8b>
	nopl   0x0(%rax)
	xor    %r8d,%r8d
	mov    0x18(%rsp),%rax
	sub    %fs:0x28,%rax
	jne    <getfirsttab+0x132>
	add    $0x28,%rsp
	mov    %r8d,%eax
	pop    %rbx
	pop    %rbp
	retq   
	nopl   0x0(%rax)
	mov    0x0(%rip),%rsi        # <getfirsttab+0xb7>
	lea    0xc(%rsp),%rbp
	mov    0x0(%rip),%rdi        # <getfirsttab+0xc3>
	mov    $0x1,%ecx
	mov    %rbp,%r8
	lea    0x0(%rip),%rdx        # <getfirsttab+0xd2>
	callq  <getfirsttab+0xd7>
	mov    0x0(%rip),%rsi        # <getfirsttab+0xde>
	movswl 0x14(%rsp),%eax
	mov    %rbp,%r8
	mov    0x0(%rip),%rdi        # <getfirsttab+0xed>
	add    0x0(%rip),%eax        # <getfirsttab+0xf3>
	mov    $0x1,%ecx
	lea    0x0(%rip),%rdx        # <getfirsttab+0xff>
	sub    %eax,%ebx
	callq  <getfirsttab+0x106>
	movswl 0x14(%rsp),%eax
	add    0x0(%rip),%eax        # <getfirsttab+0x111>
	sub    %eax,%ebx
	mov    0x0(%rip),%r8d        # <getfirsttab+0x11a>
	movslq %ebx,%rax
	sar    $0x1f,%ebx
	imul   $0x51eb851f,%rax,%rax
	sar    $0x26,%rax
	sub    %ebx,%eax
	jmpq   <getfirsttab+0x46>
	callq  <getfirsttab+0x137>
	nopw   0x0(%rax,%rax,1)

<configurerequest>:
	sub    $0x38,%rsp
	mov    0x0(%rip),%edx        # <configurerequest+0xa>
	mov    0x28(%rdi),%rsi
	mov    %fs:0x28,%rax
	mov    %rax,0x28(%rsp)
	xor    %eax,%eax
	test   %edx,%edx
	jle    <configurerequest+0x9f>
	mov    0x0(%rip),%rax        # <configurerequest+0x29>
	sub    $0x1,%edx
	lea    0x8(%rax,%rdx,8),%rcx
	jmp    <configurerequest+0x41>
	nopl   0x0(%rax,%rax,1)
	add    $0x8,%rax
	cmp    %rcx,%rax
	je     <configurerequest+0x9f>
	mov    (%rax),%rdx
	cmp    0x100(%rdx),%rsi
	jne    <configurerequest+0x38>
	mov    0x0(%rip),%eax        # <configurerequest+0x53>
	mov    0x0(%rip),%edx        # <configurerequest+0x59>
	mov    %rsp,%rcx
	movl   $0x0,(%rsp)
	movl   $0x0,0x10(%rsp)
	mov    %eax,0x8(%rsp)
	mov    0x0(%rip),%eax        # <configurerequest+0x75>
	mov    %edx,0x4(%rsp)
	sub    %edx,%eax
	mov    0x58(%rdi),%rdx
	mov    %eax,0xc(%rsp)
	mov    0x48(%rdi),%rax
	mov    %rax,0x18(%rsp)
	mov    0x50(%rdi),%eax
	mov    0x0(%rip),%rdi        # <configurerequest+0x96>
	mov    %eax,0x20(%rsp)
	callq  <configurerequest+0x9f>
	mov    0x28(%rsp),%rax
	sub    %fs:0x28,%rax
	jne    <configurerequest+0xb4>
	add    $0x38,%rsp
	retq   
	callq  <configurerequest+0xb9>
	nopl   0x0(%rax)

<drawbar>:
	push   %r15
	push   %r14
	push   %r13
	push   %r12
	push   %rbp
	push   %rbx
	sub    $0x38,%rsp
	mov    0x0(%rip),%ebx        # <drawbar+0x14>
	mov    %fs:0x28,%rax
	mov    %rax,0x28(%rsp)
	xor    %eax,%eax
	mov    0x0(%rip),%eax        # <drawbar+0x2a>
	movq   $0x0,0x10(%rsp)
	test   %eax,%eax
	je     <drawbar+0x140>
	movslq %ebx,%rbp
	mov    %ebx,%edx
	imul   $0x51eb851f,%rbp,%rbp
	sar    $0x1f,%edx
	sar    $0x26,%rbp
	sub    %edx,%ebp
	cmp    %ebp,%eax
	jg     <drawbar+0x2b8>
	callq  <getfirsttab>
	mov    %eax,%r12d
	add    %ebp,%eax
	cmp    0x0(%rip),%eax        # <drawbar+0x68>
	jl     <drawbar+0x258>
	movl   $0x0,0x0(%rip)        # <drawbar+0x78>
	test   %r12d,%r12d
	jg     <drawbar+0x1f8>
	cmp    %ebp,0x0(%rip)        # <drawbar+0x87>
	mov    %ebp,%ecx
	cmovle 0x0(%rip),%ecx        # <drawbar+0x90>
	lea    (%r12,%rcx,1),%ebp
	cmp    %ebp,%r12d
	jge    <drawbar+0x187>
	mov    %ebx,%eax
	lea    0x0(%rip),%r15        # <drawbar+0xa6>
	mov    0x0(%rip),%rsi        # <drawbar+0xad>
	cltd   
	lea    0x50(%r15),%r13
	idiv   %ecx
	movslq %r12d,%rcx
	lea    0x0(,%rcx,8),%r14
	mov    %eax,%ebx
	add    %edx,%eax
	mov    %eax,0xc(%rsp)
	jmp    <drawbar+0x112>
	nopl   0x0(%rax)
	mov    0x10c(%rdi),%eax
	lea    0x0(%rip),%rsi        # <drawbar+0xdd>
	test   %eax,%eax
	cmovne %r13,%rsi
	callq  <drawtext>
	mov    0x0(%rip),%rsi        # <drawbar+0xef>
	add    $0x1,%r12d
	mov    0x0(%rip),%eax        # <drawbar+0xf9>
	add    (%r15),%eax
	mov    (%rsi,%r14,1),%rdx
	mov    %eax,(%r15)
	add    $0x8,%r14
	mov    %eax,0x108(%rdx)
	cmp    %ebp,%r12d
	je     <drawbar+0x187>
	cmp    0x0(%rip),%r12d        # <drawbar+0x119>
	mov    (%rsi,%r14,1),%rdi
	mov    %ebx,0x0(%rip)        # <drawbar+0x123>
	jne    <drawbar+0xd0>
	mov    0xc(%rsp),%eax
	lea    0x0(%rip),%rsi        # <drawbar+0x130>
	mov    %eax,0x0(%rip)        # <drawbar+0x136>
	jmp    <drawbar+0xe3>
	nopl   0x0(%rax,%rax,1)
	mov    0x0(%rip),%rsi        # <drawbar+0x147>
	lea    0x10(%rsp),%rdx
	mov    0x0(%rip),%rdi        # <drawbar+0x153>
	movl   $0x0,0x0(%rip)        # <drawbar+0x15d>
	mov    %ebx,0x0(%rip)        # <drawbar+0x163>
	callq  <drawbar+0x168>
	mov    0x10(%rsp),%rdi
	lea    0x0(%rip),%rax        # <drawbar+0x174>
	lea    0x0(%rip),%rsi        # <drawbar+0x17b>
	test   %rdi,%rdi
	cmove  %rax,%rdi
	callq  <drawtext>
	mov    0x0(%rip),%eax        # <drawbar+0x18d>
	pushq  $0x0
	xor    %r9d,%r9d
	xor    %r8d,%r8d
	mov    0x0(%rip),%rsi        # <drawbar+0x19c>
	mov    0x0(%rip),%rdi        # <drawbar+0x1a3>
	pushq  $0x0
	mov    0x0(%rip),%rcx        # <drawbar+0x1ac>
	mov    0x0(%rip),%rdx        # <drawbar+0x1b3>
	push   %rax
	mov    0x0(%rip),%eax        # <drawbar+0x1ba>
	push   %rax
	callq  <drawbar+0x1c0>
	mov    0x0(%rip),%rdi        # <drawbar+0x1c7>
	add    $0x20,%rsp
	xor    %esi,%esi
	callq  <drawbar+0x1d2>
	mov    0x28(%rsp),%rax
	sub    %fs:0x28,%rax
	jne    <drawbar+0x337>
	add    $0x38,%rsp
	pop    %rbx
	pop    %rbp
	pop    %r12
	pop    %r13
	pop    %r14
	pop    %r15
	retq   
	nopl   (%rax)
	mov    0x0(%rip),%rsi        # <drawbar+0x1ff>
	lea    0x1c(%rsp),%r8
	mov    0x0(%rip),%rdi        # <drawbar+0x20b>
	mov    $0x1,%ecx
	lea    0x0(%rip),%rdx        # <drawbar+0x217>
	callq  <drawbar+0x21c>
	movswl 0x24(%rsp),%eax
	lea    0x0(%rip),%rsi        # <drawbar+0x228>
	add    0x0(%rip),%eax        # <drawbar+0x22e>
	lea    0x0(%rip),%rdi        # <drawbar+0x235>
	mov    %eax,0x0(%rip)        # <drawbar+0x23b>
	callq  <drawtext>
	mov    0x0(%rip),%eax        # <drawbar+0x246>
	add    %eax,0x0(%rip)        # <drawbar+0x24c>
	sub    %eax,%ebx
	jmpq   <drawbar+0x81>
	nopl   0x0(%rax,%rax,1)
	mov    0x0(%rip),%rsi        # <drawbar+0x25f>
	lea    0x1c(%rsp),%r8
	mov    0x0(%rip),%rdi        # <drawbar+0x26b>
	mov    $0x1,%ecx
	lea    0x0(%rip),%rdx        # <drawbar+0x277>
	callq  <drawbar+0x27c>
	movswl 0x24(%rsp),%eax
	mov    %ebx,%edx
	add    0x0(%rip),%eax        # <drawbar+0x289>
	sub    %eax,%edx
	lea    0x0(%rip),%rsi        # <drawbar+0x292>
	lea    0x0(%rip),%rdi        # <drawbar+0x299>
	mov    %eax,0x0(%rip)        # <drawbar+0x29f>
	mov    %edx,0x0(%rip)        # <drawbar+0x2a5>
	callq  <drawtext>
	sub    0x0(%rip),%ebx        # <drawbar+0x2b0>
	jmpq   <drawbar+0x6e>
	nopl   (%rax)
	mov    0x0(%rip),%rsi        # <drawbar+0x2bf>
	mov    0x0(%rip),%rdi        # <drawbar+0x2c6>
	mov    %ebx,%ebp
	lea    0x1c(%rsp),%r12
	mov    %r12,%r8
	mov    $0x1,%ecx
	lea    0x0(%rip),%rdx        # <drawbar+0x2dc>
	callq  <drawbar+0x2e1>
	movswl 0x24(%rsp),%eax
	mov    %r12,%r8
	add    0x0(%rip),%eax        # <drawbar+0x2ef>
	mov    0x0(%rip),%rsi        # <drawbar+0x2f6>
	mov    0x0(%rip),%rdi        # <drawbar+0x2fd>
	sub    %eax,%ebp
	lea    0x0(%rip),%rdx        # <drawbar+0x306>
	mov    $0x1,%ecx
	callq  <drawbar+0x310>
	mov    %ebp,%eax
	movswl 0x24(%rsp),%edx
	add    0x0(%rip),%edx        # <drawbar+0x31d>
	sub    %edx,%eax
	movslq %eax,%rbp
	sar    $0x1f,%eax
	imul   $0x51eb851f,%rbp,%rbp
	sar    $0x26,%rbp
	sub    %eax,%ebp
	jmpq   <drawbar+0x58>
	callq  <drawbar+0x33c>
	nopl   0x0(%rax)

<focus>:
	push   %r13
	mov    $0x3fe,%ecx
	push   %r12
	push   %rbp
	push   %rbx
	mov    %edi,%ebx
	sub    $0x2018,%rsp
	movdqa 0x0(%rip),%xmm0        # <focus+0x1c>
	mov    %fs:0x28,%rax
	mov    %rax,0x2008(%rsp)
	xor    %eax,%eax
	lea    0x10(%rsp),%rdi
	movups %xmm0,(%rsp)
	rep stos %rax,%es:(%rdi)
	mov    0x0(%rip),%eax        # <focus+0x41>
	test   %eax,%eax
	je     <focus+0x150>
	test   %ebx,%ebx
	js     <focus+0x129>
	cmp    %ebx,%eax
	jle    <focus+0x129>
	mov    0x0(%rip),%esi        # <focus+0x5f>
	mov    0x0(%rip),%edx        # <focus+0x65>
	mov    %ebx,%edi
	movslq %ebx,%rbp
	sub    0x0(%rip),%edx        # <focus+0x70>
	callq  <resize>
	mov    0x0(%rip),%rax        # <focus+0x7c>
	mov    0x0(%rip),%rdi        # <focus+0x83>
	mov    (%rax,%rbp,8),%rax
	mov    0x100(%rax),%rsi
	callq  <focus+0x93>
	mov    0x0(%rip),%rax        # <focus+0x9a>
	xor    %ecx,%ecx
	mov    0x0(%rip),%rdi        # <focus+0xa3>
	mov    $0x2,%edx
	mov    (%rax,%rbp,8),%rax
	mov    0x100(%rax),%rsi
	callq  <focus+0xb8>
	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+0xd7>
	mov    0x0(%rip),%rdi        # <focus+0xde>
	mov    (%rax,%rbp,8),%rsi
	callq  <xsettitle>
	mov    0x0(%rip),%eax        # <focus+0xed>
	cmp    %ebx,%eax
	je     <focus+0xfd>
	mov    %eax,0x0(%rip)        # <focus+0xf7>
	mov    %ebx,0x0(%rip)        # <focus+0xfd>
	mov    0x0(%rip),%rax        # <focus+0x104>
	mov    (%rax,%rbp,8),%rax
	mov    0x10c(%rax),%edx
	test   %edx,%edx
	jne    <focus+0x200>
	callq  <drawbar>
	mov    0x0(%rip),%rdi        # <focus+0x122>
	xor    %esi,%esi
	callq  <focus+0x129>
	mov    0x2008(%rsp),%rax
	sub    %fs:0x28,%rax
	jne    <focus+0x269>
	add    $0x2018,%rsp
	pop    %rbx
	pop    %rbp
	pop    %r12
	pop    %r13
	retq   
	xchg   %ax,%ax
	mov    0x0(%rip),%r12        # <focus+0x157>
	movslq 0x0(%rip),%rax        # <focus+0x15e>
	mov    %rsp,%rbp
	mov    %rbp,%rdi
	movq   $0x0,(%r12,%rax,8)
	callq  <focus+0x171>
	mov    (%r12),%r9
	mov    %rax,%rbx
	test   %r9,%r9
	je     <focus+0x1d7>
	mov    $0x8,%r13d
	mov    $0x2000,%r12d
	jmp    <focus+0x195>
	nopl   0x0(%rax,%rax,1)
	test   %r9,%r9
	je     <focus+0x1d7>
	mov    %r12,%rsi
	lea    0x0(%rbp,%rbx,1),%rdi
	mov    $0x1,%edx
	xor    %eax,%eax
	sub    %rbx,%rsi
	lea    0x0(%rip),%r8        # <focus+0x1ae>
	mov    $0xffffffffffffffff,%rcx
	callq  <focus+0x1ba>
	cltq   
	add    %rax,%rbx
	mov    0x0(%rip),%rax        # <focus+0x1c6>
	mov    (%rax,%r13,1),%r9
	add    $0x8,%r13
	cmp    $0x1fff,%rbx
	jbe    <focus+0x190>
	mov    0x0(%rip),%rdi        # <focus+0x1de>
	mov    %rbp,%rsi
	callq  <xsettitle>
	mov    0x0(%rip),%rsi        # <focus+0x1ed>
	mov    0x0(%rip),%rdi        # <focus+0x1f4>
	callq  <focus+0x1f9>
	jmpq   <focus+0x129>
	xchg   %ax,%ax
	mov    0x100(%rax),%rsi
	mov    0x0(%rip),%rdi        # <focus+0x20e>
	callq  <focus+0x213>
	mov    %rax,%r12
	test   %rax,%rax
	je     <focus+0x116>
	andq   $0xfffffffffffffeff,(%rax)
	mov    0x0(%rip),%rax        # <focus+0x22d>
	mov    %r12,%rdx
	mov    0x0(%rip),%rdi        # <focus+0x237>
	mov    (%rax,%rbp,8),%rax
	mov    0x100(%rax),%rsi
	callq  <focus+0x247>
	mov    0x0(%rip),%rax        # <focus+0x24e>
	mov    %r12,%rdi
	mov    (%rax,%rbp,8),%rax
	movl   $0x0,0x10c(%rax)
	callq  <focus+0x264>
	jmpq   <focus+0x116>
	callq  <focus+0x26e>
	xchg   %ax,%ax

<move>:
	mov    (%rdi),%edi
	test   %edi,%edi
	js     <move+0xe>
	cmp    0x0(%rip),%edi        # <move+0xc>
	jl     <move+0x10>
	retq   
	nop
	jmpq   <focus>
	data16 nopw %cs:0x0(%rax,%rax,1)

<focusurgent>:
	mov    0x0(%rip),%esi        # <focusurgent+0x6>
	test   %esi,%esi
	js     <focusurgent+0x50>
	lea    0x1(%rsi),%eax
	mov    0x0(%rip),%ecx        # <focusurgent+0x13>
	cltd   
	idiv   %ecx
	cmp    %edx,%esi
	je     <focusurgent+0x50>
	mov    0x0(%rip),%rdi        # <focusurgent+0x21>
	jmp    <focusurgent+0x32>
	nopl   0x0(%rax,%rax,1)
	lea    0x1(%rdx),%eax
	cltd   
	idiv   %ecx
	cmp    %edx,%esi
	je     <focusurgent+0x50>
	movslq %edx,%rax
	mov    (%rdi,%rax,8),%rax
	mov    0x10c(%rax),%eax
	test   %eax,%eax
	je     <focusurgent+0x28>
	mov    %edx,%edi
	jmpq   <focus>
	nopw   0x0(%rax,%rax,1)
	retq   
	data16 nopw %cs:0x0(%rax,%rax,1)
	nopl   0x0(%rax)

<rotate>:
	mov    %rdi,%rax
	mov    0x0(%rip),%edi        # <rotate+0x9>
	test   %edi,%edi
	js     <rotate+0x3a>
	mov    (%rax),%eax
	test   %eax,%eax
	je     <rotate+0x30>
	add    %eax,%edi
	mov    0x0(%rip),%eax        # <rotate+0x1b>
	cmp    %edi,%eax
	jg     <rotate+0x40>
	nop
	sub    %eax,%edi
	cmp    %edi,%eax
	jle    <rotate+0x20>
	jmpq   <focus>
	nopl   0x0(%rax,%rax,1)
	mov    0x0(%rip),%edi        # <rotate+0x36>
	test   %edi,%edi
	jns    <rotate+0x26>
	retq   
	nopl   0x0(%rax,%rax,1)
	test   %edi,%edi
	jns    <rotate+0x26>
	nopl   0x0(%rax)
	add    %eax,%edi
	js     <rotate+0x48>
	jmpq   <focus>
	data16 nopw %cs:0x0(%rax,%rax,1)
	nopl   0x0(%rax)

<buttonpress>:
	push   %r12
	push   %rbp
	push   %rbx
	sub    $0x20,%rsp
	mov    %fs:0x28,%rax
	mov    %rax,0x18(%rsp)
	mov    0x44(%rdi),%eax
	test   %eax,%eax
	js     <buttonpress+0x25>
	cmp    0x0(%rip),%eax        # <buttonpress+0x23>
	jle    <buttonpress+0x48>
	mov    0x18(%rsp),%rax
	sub    %fs:0x28,%rax
	jne    <buttonpress+0x14b>
	add    $0x20,%rsp
	pop    %rbx
	pop    %rbp
	pop    %r12
	retq   
	nopw   0x0(%rax,%rax,1)
	mov    %rdi,%rbp
	callq  <getfirsttab>
	mov    %eax,%ebx
	test   %eax,%eax
	jg     <buttonpress+0xc0>
	mov    0x40(%rbp),%edx
	test   %edx,%edx
	js     <buttonpress+0x25>
	mov    0x0(%rip),%ecx        # <buttonpress+0x63>
	cmp    %ebx,%ecx
	jle    <buttonpress+0x25>
	mov    0x0(%rip),%rsi        # <buttonpress+0x6e>
	movslq %ebx,%rdi
	jmp    <buttonpress+0x80>
	nopl   0x0(%rax,%rax,1)
	add    $0x1,%rdi
	cmp    %edi,%ecx
	jle    <buttonpress+0x25>
	mov    (%rsi,%rdi,8),%rax
	cmp    0x108(%rax),%edx
	jge    <buttonpress+0x78>
	mov    0x54(%rbp),%eax
	cmp    $0x2,%eax
	je     <buttonpress+0x138>
	ja     <buttonpress+0x108>
	cmp    $0x1,%eax
	jne    <buttonpress+0x25>
	mov    0x18(%rsp),%rax
	sub    %fs:0x28,%rax
	jne    <buttonpress+0x14b>
	add    $0x20,%rsp
	pop    %rbx
	pop    %rbp
	pop    %r12
	jmpq   <focus>
	mov    0x0(%rip),%rsi        # <buttonpress+0xc7>
	mov    0x40(%rbp),%r12d
	lea    0x8(%rsp),%r8
	mov    $0x1,%ecx
	mov    0x0(%rip),%rdi        # <buttonpress+0xdc>
	lea    0x0(%rip),%rdx        # <buttonpress+0xe3>
	callq  <buttonpress+0xe8>
	movswl 0x10(%rsp),%eax
	add    0x0(%rip),%eax        # <buttonpress+0xf3>
	cmp    %eax,%r12d
	jge    <buttonpress+0x56>
	jmpq   <buttonpress+0x25>
	nopl   0x0(%rax)
	lea    -0x4(%rax),%edx
	cmp    $0x1,%edx
	ja     <buttonpress+0x25>
	cmp    $0x4,%eax
	lea    0x8(%rsp),%rdi
	setne  %al
	movzbl %al,%eax
	lea    -0x1(%rax,%rax,1),%eax
	mov    %eax,0x8(%rsp)
	callq  <rotate>
	jmpq   <buttonpress+0x25>
	nopl   0x0(%rax)
	mov    %edi,0x8(%rsp)
	lea    0x8(%rsp),%rdi
	callq  <killclient>
	jmpq   <buttonpress+0x25>
	callq  <focusin>

<focusin>:
	sub    $0x28,%rsp
	mov    %fs:0x28,%rax
	mov    %rax,0x18(%rsp)
	xor    %eax,%eax
	cmpl   $0x2,0x28(%rdi)
	jne    <focusin+0x30>
	mov    0x18(%rsp),%rax
	sub    %fs:0x28,%rax
	jne    <focusin+0x61>
	add    $0x28,%rsp
	retq   
	nop
	mov    0x0(%rip),%rdi        # <focusin+0x37>
	lea    0xc(%rsp),%rdx
	lea    0x10(%rsp),%rsi
	callq  <focusin+0x46>
	mov    0x0(%rip),%rax        # <focusin+0x4d>
	cmp    %rax,0x10(%rsp)
	jne    <focusin+0x1a>
	mov    0x0(%rip),%edi        # <focusin+0x5a>
	callq  <focus>
	jmp    <focusin+0x1a>
	callq  <focusin+0x66>
	nopw   %cs:0x0(%rax,%rax,1)

<movetab>:
	mov    0x0(%rip),%ecx        # <movetab+0x6>
	test   %ecx,%ecx
	js     <movetab+0xa8>
	push   %r12
	push   %rbp
	push   %rbx
	mov    (%rdi),%eax
	mov    0x0(%rip),%ebx        # <movetab+0x1a>
	add    %ecx,%eax
	cltd   
	idiv   %ebx
	add    %edx,%ebx
	test   %edx,%edx
	cmovns %edx,%ebx
	cmp    %ebx,%ecx
	je     <movetab+0xa0>
	mov    0x0(%rip),%rsi        # <movetab+0x31>
	movslq %ecx,%rdx
	movslq %ebx,%rax
	shl    $0x3,%rdx
	shl    $0x3,%rax
	lea    (%rsi,%rdx,1),%rdi
	lea    (%rsi,%rax,1),%r12
	mov    (%rdi),%rbp
	cmp    %ebx,%ecx
	jl     <movetab+0x80>
	sub    %ebx,%ecx
	lea    0x8(%rsi,%rax,1),%rdi
	mov    %r12,%rsi
	movslq %ecx,%rdx
	shl    $0x3,%rdx
	callq  <movetab+0x64>
	mov    %rbp,(%r12)
	mov    %ebx,0x0(%rip)        # <movetab+0x6e>
	pop    %rbx
	pop    %rbp
	pop    %r12
	jmpq   <drawbar>
	nopw   0x0(%rax,%rax,1)
	mov    %ebx,%r8d
	lea    0x8(%rsi,%rdx,1),%rsi
	sub    %ecx,%r8d
	movslq %r8d,%r8
	shl    $0x3,%r8
	mov    %r8,%rdx
	callq  <movetab+0x9a>
	jmp    <movetab+0x64>
	nopl   0x0(%rax)
	pop    %rbx
	pop    %rbp
	pop    %r12
	retq   
	nopl   (%rax)
	retq   
	nopl   0x0(%rax)

<expose>:
	mov    0x38(%rdi),%eax
	test   %eax,%eax
	jne    <expose+0x14>
	mov    0x0(%rip),%rax        # <expose+0xe>
	cmp    %rax,0x20(%rdi)
	je     <expose+0x18>
	retq   
	nopl   (%rax)
	jmpq   <drawbar>
	nopl   (%rax)

<updatetitle>:
	push   %rbp
	movslq %edi,%rbp
	push   %rbx
	mov    %rbp,%rbx
	sub    $0x8,%rsp
	mov    0x0(%rip),%rax        # <updatetitle+0x13>
	mov    0x0(%rip),%rsi        # <updatetitle+0x1a>
	mov    (%rax,%rbp,8),%rdx
	mov    0x100(%rdx),%rdi
	callq  <gettextpropn.constprop.0>
	test   %eax,%eax
	je     <updatetitle+0x48>
	cmp    %ebx,0x0(%rip)        # <updatetitle+0x34>
	je     <updatetitle+0x6c>
	add    $0x8,%rsp
	pop    %rbx
	pop    %rbp
	jmpq   <drawbar>
	nopl   0x0(%rax)
	mov    0x0(%rip),%rax        # <updatetitle+0x4f>
	mov    $0x27,%esi
	mov    (%rax,%rbp,8),%rdx
	mov    0x100(%rdx),%rdi
	callq  <gettextpropn.constprop.0>
	cmp    %ebx,0x0(%rip)        # <updatetitle+0x6a>
	jne    <updatetitle+0x36>
	mov    0x0(%rip),%rax        # <updatetitle+0x73>
	mov    0x0(%rip),%rdi        # <updatetitle+0x7a>
	mov    (%rax,%rbp,8),%rsi
	callq  <xsettitle>
	add    $0x8,%rsp
	pop    %rbx
	pop    %rbp
	jmpq   <drawbar>
	xchg   %ax,%ax

<unmanage>:
	push   %r15
	push   %r14
	push   %r13
	push   %r12
	push   %rbp
	push   %rbx
	sub    $0x8,%rsp
	test   %edi,%edi
	js     <unmanage+0xb8>
	mov    0x0(%rip),%ebp        # <unmanage+0x1c>
	mov    %edi,%ebx
	cmp    %edi,%ebp
	jle    <unmanage+0xb8>
	mov    0x0(%rip),%r14        # <unmanage+0x2d>
	lea    -0x1(%rbp),%r12d
	test   %edi,%edi
	je     <unmanage+0x160>
	movslq %edi,%r13
	shl    $0x3,%r13
	lea    (%r14,%r13,1),%r15
	mov    (%r15),%rdi
	cmp    %ebx,%r12d
	je     <unmanage+0xe0>
	callq  <unmanage+0x55>
	lea    0x1(%rbx),%eax
	lea    0x8(%r14,%r13,1),%rsi
	mov    %r15,%rdi
	sub    %eax,%ebp
	movslq %ebp,%rdx
	shl    $0x3,%rdx
	callq  <unmanage+0x6e>
	mov    %r12d,0x0(%rip)        # <unmanage+0x75>
	test   %r12d,%r12d
	jne    <unmanage+0x107>
	movl   $0xffffffff,0x0(%rip)        # <unmanage+0x88>
	mov    0x0(%rip),%ecx        # <unmanage+0x8e>
	movl   $0xffffffff,0x0(%rip)        # <unmanage+0x98>
	test   %ecx,%ecx
	jne    <unmanage+0x1a0>
	mov    0x0(%rip),%edx        # <unmanage+0xa6>
	test   %edx,%edx
	je     <unmanage+0xb8>
	mov    0x0(%rip),%eax        # <unmanage+0xb0>
	test   %eax,%eax
	jne    <unmanage+0x1c0>
	callq  <drawbar>
	mov    0x0(%rip),%rdi        # <unmanage+0xc4>
	add    $0x8,%rsp
	xor    %esi,%esi
	pop    %rbx
	pop    %rbp
	pop    %r12
	pop    %r13
	pop    %r14
	pop    %r15
	jmpq   <unmanage+0xd9>
	nopl   0x0(%rax)
	mov    %r12d,0x0(%rip)        # <unmanage+0xe7>
	callq  <unmanage+0xec>
	mov    %r13,%rsi
	mov    %r14,%rdi
	callq  <unmanage+0xf7>
	test   %rax,%rax
	je     <unmanage+0x1e4>
	mov    %rax,0x0(%rip)        # <unmanage+0x107>
	mov    0x0(%rip),%r8d        # <unmanage+0x10e>
	mov    0x0(%rip),%edi        # <unmanage+0x114>
	cmp    %r12d,%r8d
	jge    <unmanage+0x190>
	cmp    %ebx,%r8d
	jle    <unmanage+0x1b0>
	sub    $0x1,%r8d
	mov    %r8d,0x0(%rip)        # <unmanage+0x12d>
	cmp    %edi,%ebx
	je     <unmanage+0x1d0>
	cmp    %edi,%ebx
	jge    <unmanage+0x142>
	sub    $0x1,%edi
	mov    %edi,0x0(%rip)        # <unmanage+0x142>
	cmp    %edi,%r12d
	jg     <unmanage+0x152>
	lea    -0x1(%r12),%edi
	mov    %edi,0x0(%rip)        # <unmanage+0x152>
	callq  <focus>
	jmpq   <unmanage+0xb8>
	nopl   0x0(%rax)
	mov    (%r14),%rdi
	mov    %r12d,0x0(%rip)        # <unmanage+0x16a>
	callq  <unmanage+0x16f>
	movslq %r12d,%rdx
	lea    0x8(%r14),%rsi
	mov    %r14,%rdi
	shl    $0x3,%rdx
	callq  <unmanage+0x182>
	jmpq   <unmanage+0x75>
	nopw   0x0(%rax,%rax,1)
	lea    -0x1(%r12),%eax
	mov    %eax,0x0(%rip)        # <unmanage+0x19b>
	jmp    <unmanage+0x12d>
	nopl   (%rax)
	movl   $0x0,0x0(%rip)        # <unmanage+0x1aa>
	jmpq   <unmanage+0xb8>
	nop
	cmp    %edi,%ebx
	jne    <unmanage+0x135>
	test   %r8d,%r8d
	js     <unmanage+0x142>
	jmp    <unmanage+0x1d7>
	nop
	xor    %edi,%edi
	callq  <spawn>
	jmpq   <unmanage+0xb8>
	nopl   0x0(%rax)
	mov    0x0(%rip),%r8d        # <unmanage+0x1d7>
	mov    %r8d,%edi
	callq  <focus>
	jmpq   <unmanage+0xb8>
	mov    0x0(%rip),%rsi        # <unmanage+0x1eb>
	lea    0x0(%rip),%rdi        # <unmanage+0x1f2>
	callq  <die>
	nopw   0x0(%rax,%rax,1)

<unmapnotify>:
	movslq 0x0(%rip),%rdx        # <unmapnotify+0x7>
	mov    0x28(%rdi),%rcx
	test   %edx,%edx
	jle    <unmapnotify+0x40>
	mov    0x0(%rip),%rsi        # <unmapnotify+0x16>
	xor    %edi,%edi
	jmp    <unmapnotify+0x29>
	nopw   0x0(%rax,%rax,1)
	add    $0x1,%rdi
	cmp    %rdx,%rdi
	je     <unmapnotify+0x40>
	mov    (%rsi,%rdi,8),%rax
	cmp    0x100(%rax),%rcx
	jne    <unmapnotify+0x20>
	jmpq   <unmanage>
	nopl   0x0(%rax,%rax,1)
	retq   
	data16 nopw %cs:0x0(%rax,%rax,1)
	nopl   0x0(%rax)

<destroynotify>:
	movslq 0x0(%rip),%rdx        # <destroynotify+0x7>
	mov    0x28(%rdi),%rcx
	test   %edx,%edx
	jle    <destroynotify+0x40>
	mov    0x0(%rip),%rsi        # <destroynotify+0x16>
	xor    %edi,%edi
	jmp    <destroynotify+0x29>
	nopw   0x0(%rax,%rax,1)
	add    $0x1,%rdi
	cmp    %rdx,%rdi
	je     <destroynotify+0x40>
	mov    (%rsi,%rdi,8),%rax
	cmp    0x100(%rax),%rcx
	jne    <destroynotify+0x20>
	jmpq   <unmanage>
	nopl   0x0(%rax,%rax,1)
	retq   
	data16 nopw %cs:0x0(%rax,%rax,1)
	nopl   0x0(%rax)

<propertynotify>:
	push   %r14
	push   %r13
	push   %r12
	push   %rbp
	mov    %rdi,%rbp
	push   %rbx
	sub    $0x30,%rsp
	mov    %fs:0x28,%rax
	mov    %rax,0x28(%rsp)
	mov    0x38(%rdi),%eax
	test   %eax,%eax
	jne    <propertynotify+0xe0>
	mov    0x28(%rdi),%rdx
	cmp    0x0(%rip),%rdx        # <propertynotify+0x33>
	je     <propertynotify+0x160>
	cmp    $0x23,%rdx
	je     <propertynotify+0x80>
	cmp    $0x27,%rdx
	je     <propertynotify+0xf7>
	cmp    %rdx,0x0(%rip)        # <propertynotify+0x50>
	je     <propertynotify+0xf7>
	mov    0x28(%rsp),%rax
	sub    %fs:0x28,%rax
	jne    <propertynotify+0x354>
	add    $0x30,%rsp
	pop    %rbx
	pop    %rbp
	pop    %r12
	pop    %r13
	pop    %r14
	retq   
	nopw   0x0(%rax,%rax,1)
	movslq 0x0(%rip),%rcx        # <propertynotify+0x87>
	mov    0x20(%rdi),%rsi
	test   %ecx,%ecx
	jle    <propertynotify+0x49>
	mov    0x0(%rip),%rdi        # <propertynotify+0x96>
	xor    %ebx,%ebx
	jmp    <propertynotify+0xa9>
	nopw   0x0(%rax,%rax,1)
	add    $0x1,%rbx
	cmp    %rbx,%rcx
	je     <propertynotify+0x49>
	mov    (%rdi,%rbx,8),%rax
	mov    %ebx,%r12d
	lea    0x0(,%rbx,8),%r13
	cmp    0x100(%rax),%rsi
	jne    <propertynotify+0xa0>
	mov    0x0(%rip),%rdi        # <propertynotify+0xc8>
	callq  <propertynotify+0xcd>
	mov    %rax,%r14
	test   %rax,%rax
	jne    <propertynotify+0x278>
	mov    0x38(%rbp),%eax
	nopl   0x0(%rax)
	cmp    $0x1,%eax
	je     <propertynotify+0x56>
	mov    0x28(%rbp),%rdx
	cmp    $0x27,%rdx
	jne    <propertynotify+0x49>
	movslq 0x0(%rip),%rdx        # <propertynotify+0xfe>
	mov    0x20(%rbp),%rcx
	test   %edx,%edx
	jle    <propertynotify+0x56>
	mov    0x0(%rip),%rsi        # <propertynotify+0x111>
	xor    %edi,%edi
	jmp    <propertynotify+0x125>
	nopl   (%rax)
	add    $0x1,%rdi
	cmp    %rdx,%rdi
	je     <propertynotify+0x56>
	mov    (%rsi,%rdi,8),%rax
	cmp    0x100(%rax),%rcx
	jne    <propertynotify+0x118>
	mov    0x28(%rsp),%rax
	sub    %fs:0x28,%rax
	jne    <propertynotify+0x354>
	add    $0x30,%rsp
	pop    %rbx
	pop    %rbp
	pop    %r12
	pop    %r13
	pop    %r14
	jmpq   <updatetitle>
	nopw   0x0(%rax,%rax,1)
	lea    0x20(%rsp),%r12
	xor    %r9d,%r9d
	mov    $0x2000,%r8d
	xor    %ecx,%ecx
	movq   $0x0,0x20(%rsp)
	mov    0x0(%rip),%rsi        # <propertynotify+0x180>
	push   %r12
	mov    0x0(%rip),%rdi        # <propertynotify+0x189>
	lea    0x20(%rsp),%rax
	push   %rax
	push   %rax
	lea    0x24(%rsp),%rax
	push   %rax
	lea    0x30(%rsp),%rax
	push   %rax
	pushq  $0x1f
	callq  <propertynotify+0x1a3>
	mov    0x50(%rsp),%rbp
	add    $0x30,%rsp
	test   %rbp,%rbp
	je     <propertynotify+0x2b0>
	mov    $0x1fff,%edx
	mov    %rbp,%rsi
	lea    0x0(%rip),%rdi        # <propertynotify+0x1c4>
	callq  <propertynotify+0x1c9>
	mov    %rbp,%rdi
	callq  <propertynotify+0x1d1>
	cmpb   $0x30,0x0(%rip)        # <propertynotify+0x1d8>
	lea    0x0(%rip),%rdi        # <propertynotify+0x1df>
	jne    <propertynotify+0x250>
	cmpb   $0x78,0x0(%rip)        # <propertynotify+0x1e8>
	jne    <propertynotify+0x250>
	xor    %edx,%edx
	xor    %esi,%esi
	callq  <propertynotify+0x1f3>
	mov    0x0(%rip),%r9d        # <propertynotify+0x1fa>
	mov    %rax,%rdx
	test   %r9d,%r9d
	jle    <propertynotify+0x56>
	mov    0x0(%rip),%rcx        # <propertynotify+0x20d>
	movslq %r9d,%r8
	xor    %edi,%edi
	jmp    <propertynotify+0x225>
	nopl   0x0(%rax)
	add    $0x1,%rdi
	cmp    %rdi,%r8
	je     <propertynotify+0x56>
	mov    (%rcx,%rdi,8),%rax
	cmp    0x100(%rax),%rdx
	jne    <propertynotify+0x218>
	mov    %edi,0x20(%rsp)
	cmp    %r9d,%edi
	jge    <propertynotify+0x56>
	callq  <focus>
	jmpq   <propertynotify+0x56>
	nopl   0x0(%rax)
	mov    0x0(%rip),%rax        # <propertynotify+0x257>
	movslq 0x0(%rip),%rdx        # <propertynotify+0x25e>
	mov    %rdi,(%rax,%rdx,8)
	mov    %r12,%rdi
	mov    %rax,0x20(%rsp)
	callq  <spawn>
	jmpq   <propertynotify+0x56>
	nopl   0x0(%rax)
	testq  $0x100,(%r14)
	jne    <propertynotify+0x2bc>
	mov    0x28(%rsp),%rax
	sub    %fs:0x28,%rax
	jne    <propertynotify+0x354>
	add    $0x30,%rsp
	mov    %r14,%rdi
	pop    %rbx
	pop    %rbp
	pop    %r12
	pop    %r13
	pop    %r14
	jmpq   <propertynotify+0x2a9>
	nopl   0x0(%rax)
	movb   $0x0,0x0(%rip)        # <propertynotify+0x2b7>
	jmpq   <propertynotify+0x1c9>
	mov    %r14,%rdi
	callq  <propertynotify+0x2c4>
	mov    0x0(%rip),%rsi        # <propertynotify+0x2cb>
	mov    0x0(%rip),%rdi        # <propertynotify+0x2d2>
	callq  <propertynotify+0x2d7>
	cmp    %r12d,0x0(%rip)        # <propertynotify+0x2de>
	mov    %rax,%r14
	je     <propertynotify+0x315>
	mov    0x0(%rip),%eax        # <propertynotify+0x2e9>
	test   %eax,%eax
	je     <propertynotify+0x2fb>
	test   %r14,%r14
	je     <propertynotify+0x2fb>
	testq  $0x100,(%r14)
	je     <propertynotify+0x34b>
	mov    0x0(%rip),%rax        # <propertynotify+0x302>
	mov    (%rax,%r13,1),%rax
	movl   $0x1,0x10c(%rax)
	callq  <drawbar>
	test   %r14,%r14
	je     <propertynotify+0x281>
	mov    (%r14),%rax
	test   $0x1,%ah
	jne    <propertynotify+0x281>
	or     $0x1,%ah
	mov    0x0(%rip),%rsi        # <propertynotify+0x334>
	mov    0x0(%rip),%rdi        # <propertynotify+0x33b>
	mov    %r14,%rdx
	mov    %rax,(%r14)
	callq  <propertynotify+0x346>
	jmpq   <propertynotify+0x281>
	mov    %ebx,%edi
	callq  <focus>
	jmp    <propertynotify+0x31e>
	callq  <propertynotify+0x359>
	nopl   0x0(%rax)

<manage>:
	push   %r15
	push   %r14
	push   %r13
	push   %r12
	push   %rbp
	mov    %rdi,%rbp
	push   %rbx
	xor    %ebx,%ebx
	sub    $0xe8,%rsp
	mov    0x0(%rip),%rdi        # <manage+0x1d>
	mov    %fs:0x28,%rax
	mov    %rax,0xd8(%rsp)
	xor    %eax,%eax
	movl   $0x0,0x0(%rip)        # <manage+0x3a>
	callq  <manage+0x3f>
	mov    %rax,%r13
	mov    (%rax),%eax
	nopl   0x0(%rax)
	mov    $0x1,%r12d
	mov    %ebx,%ecx
	xor    %r14d,%r14d
	shl    %cl,%r12d
	test   %eax,%eax
	je     <manage+0x99>
	nopw   0x0(%rax,%rax,1)
	imul   %ebx,%eax
	mov    0x8(%r13),%rdx
	mov    $0xff7f,%esi
	mov    0x0(%rip),%rdi        # <manage+0x73>
	add    %r14d,%eax
	movzbl (%rdx,%rax,1),%r15d
	callq  <manage+0x80>
	cmp    %al,%r15b
	jne    <manage+0x8c>
	mov    %r12d,0x0(%rip)        # <manage+0x8c>
	mov    0x0(%r13),%eax
	add    $0x1,%r14d
	cmp    %r14d,%eax
	ja     <manage+0x60>
	add    $0x1,%ebx
	cmp    $0x8,%ebx
	jne    <manage+0x48>
	mov    %r13,%rdi
	lea    0x0(%rip),%r12        # <manage+0xab>
	lea    0x10(%rsp),%r13
	callq  <manage+0xb5>
	mov    0x0(%rip),%eax        # <manage+0xbb>
	xor    %edx,%edx
	mov    %rbp,%rsi
	mov    0x0(%rip),%rdi        # <manage+0xc7>
	movl   $0x2,0x4(%rsp)
	lea    0x2c0(%r12),%r14
	mov    %eax,0x8(%rsp)
	or     $0x2,%eax
	mov    %eax,0xc(%rsp)
	callq  <manage+0xe7>
	mov    0x0(%rip),%r8d        # <manage+0xee>
	mov    0x0(%rip),%rdx        # <manage+0xf5>
	xor    %ecx,%ecx
	mov    0x0(%rip),%rdi        # <manage+0xfe>
	mov    %rbp,%rsi
	callq  <manage+0x106>
	mov    0x0(%rip),%rdi        # <manage+0x10d>
	mov    $0x420010,%edx
	mov    %rbp,%rsi
	callq  <manage+0x11a>
	mov    0x0(%rip),%rdi        # <manage+0x121>
	xor    %esi,%esi
	callq  <manage+0x128>
	jmp    <manage+0x139>
	nopw   0x0(%rax,%rax,1)
	add    $0x20,%r12
	cmp    %r12,%r14
	je     <manage+0x190>
	mov    0x8(%r12),%rsi
	mov    0x0(%rip),%rdi        # <manage+0x145>
	callq  <manage+0x14a>
	test   %al,%al
	je     <manage+0x130>
	movzbl %al,%ebx
	mov    %rsp,%r15
	xor    %edx,%edx
	sub    $0x8,%rsp
	or     (%r12),%edx
	mov    $0x1,%r8d
	mov    %ebx,%esi
	pushq  $0x1
	mov    0x0(%rip),%rdi        # <manage+0x16f>
	mov    %rbp,%rcx
	add    $0x4,%r15
	mov    $0x1,%r9d
	callq  <manage+0x181>
	pop    %rdi
	pop    %r8
	cmp    %r15,%r13
	je     <manage+0x130>
	mov    (%r15),%edx
	jmp    <manage+0x156>
	xchg   %ax,%ax
	mov    $0x118,%esi
	mov    $0x1,%edi
	callq  <manage+0x19f>
	mov    %rax,%r13
	test   %rax,%rax
	je     <manage+0x36d>
	mov    0x0(%rip),%r14d        # <manage+0x1b2>
	mov    %rbp,0x100(%rax)
	mov    0x0(%rip),%rdi        # <manage+0x1c0>
	lea    0x1(%r14),%ebx
	movslq %ebx,%rsi
	mov    %ebx,0x0(%rip)        # <manage+0x1cd>
	shl    $0x3,%rsi
	callq  <manage+0x1d6>
	mov    %rax,%rcx
	test   %rax,%rax
	je     <manage+0x387>
	mov    0x0(%rip),%esi        # <manage+0x1e8>
	mov    %rax,0x0(%rip)        # <manage+0x1ef>
	mov    0x0(%rip),%eax        # <manage+0x1f5>
	test   %esi,%esi
	jne    <manage+0x341>
	mov    %ebx,%edx
	sub    %eax,%edx
	test   %eax,%eax
	cmovs  %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+0x231>
	cmp    %r12d,%r14d
	jg     <manage+0x34c>
	mov    %r13,(%r15)
	mov    %r12d,%edi
	callq  <updatetitle>
	mov    0x0(%rip),%rdi        # <manage+0x243>
	mov    %rbp,%rsi
	callq  <manage+0x24b>
	mov    0x0(%rip),%rdi        # <manage+0x252>
	mov    %rbp,%rsi
	callq  <manage+0x25a>
	mov    0x0(%rip),%rax        # <manage+0x261>
	xor    %ecx,%ecx
	xor    %edx,%edx
	mov    0x0(%rip),%rsi        # <manage+0x26c>
	lea    0x10(%rsp),%r8
	mov    0x0(%rip),%rdi        # <manage+0x278>
	mov    %rbp,0x30(%rsp)
	mov    %rax,0x38(%rsp)
	mov    0x0(%rip),%rax        # <manage+0x289>
	movl   $0x21,0x10(%rsp)
	movl   $0x20,0x40(%rsp)
	movq   $0x0,0x48(%rsp)
	movq   $0x0,0x50(%rsp)
	movq   $0x0,0x58(%rsp)
	mov    %rax,0x60(%rsp)
	movq   $0x0,0x68(%rsp)
	callq  <manage+0x2c7>
	mov    0x0(%rip),%rdi        # <manage+0x2ce>
	xor    %esi,%esi
	callq  <manage+0x2d5>
	mov    0x0(%rip),%eax        # <manage+0x2db>
	cmp    %r12d,%eax
	jl     <manage+0x2e9>
	add    $0x1,%eax
	mov    %eax,0x0(%rip)        # <manage+0x2e9>
	mov    0x0(%rip),%edx        # <manage+0x2ef>
	test   %edx,%edx
	jne    <manage+0x30a>
	mov    0x0(%rip),%eax        # <manage+0x2f9>
	test   %eax,%eax
	mov    $0x0,%eax
	cmovns 0x0(%rip),%eax        # <manage+0x307>
	mov    %eax,%r12d
	mov    %r12d,%edi
	callq  <focus>
	movl   $0x1,0x0(%rip)        # <manage+0x31c>
	mov    0xd8(%rsp),%rax
	sub    %fs:0x28,%rax
	jne    <manage+0x382>
	add    $0xe8,%rsp
	pop    %rbx
	pop    %rbp
	pop    %r12
	pop    %r13
	pop    %r14
	pop    %r15
	retq   
	add    0x0(%rip),%eax        # <manage+0x347>
	jmpq   <manage+0x206>
	sub    %r12d,%ebx
	lea    0x8(%rcx,%rax,1),%rdi
	mov    %r15,%rsi
	mov    %ebx,%edx
	sub    $0x1,%edx
	movslq %edx,%rdx
	shl    $0x3,%rdx
	callq  <manage+0x368>
	jmpq   <manage+0x231>
	mov    0x0(%rip),%rsi        # <manage+0x374>
	lea    0x0(%rip),%rdi        # <manage+0x37b>
	xor    %eax,%eax
	callq  <die>
	callq  <manage+0x387>
	mov    0x0(%rip),%rsi        # <manage+0x38e>
	lea    0x0(%rip),%rdi        # <manage+0x395>
	xor    %eax,%eax
	callq  <die>
	nopl   0x0(%rax)

<maprequest>:
	mov    0x0(%rip),%edx        # <maprequest+0x6>
	mov    0x28(%rdi),%rdi
	test   %edx,%edx
	jle    <maprequest+0x40>
	mov    0x0(%rip),%rax        # <maprequest+0x15>
	sub    $0x1,%edx
	lea    0x8(%rax,%rdx,8),%rcx
	jmp    <maprequest+0x29>
	nop
	add    $0x8,%rax
	cmp    %rcx,%rax
	je     <maprequest+0x40>
	mov    (%rax),%rdx
	cmp    0x100(%rdx),%rdi
	jne    <maprequest+0x20>
	retq   
	nopw   %cs:0x0(%rax,%rax,1)
	jmpq   <manage>
	data16 nopw %cs:0x0(%rax,%rax,1)

<createnotify>:
	mov    0x28(%rdi),%rdi
	cmp    0x0(%rip),%rdi        # <createnotify+0xb>
	je     <createnotify+0x45>
	mov    0x0(%rip),%edx        # <createnotify+0x13>
	test   %edx,%edx
	jle    <createnotify+0x50>
	mov    0x0(%rip),%rax        # <createnotify+0x1e>
	sub    $0x1,%edx
	lea    0x8(%rax,%rdx,8),%rcx
	jmp    <createnotify+0x39>
	nopl   0x0(%rax,%rax,1)
	add    $0x8,%rax
	cmp    %rcx,%rax
	je     <createnotify+0x50>
	mov    (%rax),%rdx
	cmp    0x100(%rdx),%rdi
	jne    <createnotify+0x30>
	retq   
	nopw   %cs:0x0(%rax,%rax,1)
	jmpq   <manage>
	data16 nopw %cs:0x0(%rax,%rax,1)

<usage>:
	sub    $0x8,%rsp
	mov    0x0(%rip),%rsi        # <usage+0xb>
	lea    0x0(%rip),%rdi        # <usage+0x12>
	xor    %eax,%eax
	callq  <die>

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

<main>:
	push   %r15
	mov    %rsi,%r15
	push   %r14
	push   %r13
	push   %r12
	mov    %edi,%r12d
	push   %rbp
	push   %rbx
	sub    $0x1b8,%rsp
	mov    %fs:0x28,%rax
	mov    %rax,0x1a8(%rsp)
	mov    (%rsi),%rax
	mov    %rax,0x0(%rip)        # <main+0x32>
	test   %rax,%rax
	je     <main+0x3f>
	sub    $0x1,%r12d
	add    $0x8,%r15
	mov    (%r15),%rbx
	xor    %ebp,%ebp
	xor    %r13d,%r13d
	test   %rbx,%rbx
	je     <main+0x135>
	lea    0x0(%rip),%r14        # <main+0x57>
	nopw   0x0(%rax,%rax,1)
	cmpb   $0x2d,(%rbx)
	jne    <main+0x135>
	movzbl 0x1(%rbx),%eax
	test   %al,%al
	je     <main+0x135>
	cmp    $0x2d,%al
	je     <main+0xcd0>
	mov    0x0(%rip),%r11d        # <main+0x84>
	add    $0x1,%rbx
	xor    %r9d,%r9d
	xor    %edi,%edi
	mov    0x0(%rip),%r10d        # <main+0x94>
	mov    0x0(%rip),%esi        # <main+0x9a>
	xor    %ecx,%ecx
	xor    %edx,%edx
	mov    0x0(%rip),%r8d        # <main+0xa5>
	nopl   (%rax)
	sub    $0x4f,%eax
	cmp    $0x27,%al
	ja     <main+0xf1a>
	movzbl %al,%eax
	movslq (%r14,%rax,4),%rax
	add    %r14,%rax
	jmpq   *%rax
	nop
	test   %dl,%dl
	je     <main+0xca>
	mov    %esi,0x0(%rip)        # <main+0xca>
	test   %cl,%cl
	je     <main+0xd5>
	mov    %r8d,0x0(%rip)        # <main+0xd5>
	test   %dil,%dil
	je     <main+0xe1>
	mov    %r10d,0x0(%rip)        # <main+0xe1>
	test   %r9b,%r9b
	je     <main+0xed>
	mov    %r11d,0x0(%rip)        # <main+0xed>
	movzbl 0x1(%rbx),%eax
	add    $0x1,%rbx
	test   %al,%al
	jne    <main+0x106>
	mov    0x8(%r15),%rbx
	test   %rbx,%rbx
	je     <main+0xf47>
	mov    %rbx,0x0(%rip)        # <main+0x10d>
	lea    -0x1(%r12),%ecx
	lea    0x8(%r15),%rdx
	test   %al,%al
	jne    <main+0x91e>
	xchg   %ax,%ax
	sub    $0x2,%r12d
	add    $0x10,%r15
	mov    0x8(%rdx),%rbx
	test   %rbx,%rbx
	jne    <main+0x60>
	lea    0x3(%r12),%edi
	movslq %edi,%rdi
	test   %r12d,%r12d
	jle    <main+0xce7>
	mov    $0x8,%esi
	callq  <main+0x150>
	mov    %rax,%rcx
	test   %rax,%rax
	je     <main+0x101f>
	movslq %r12d,%rdx
	mov    %rcx,%rdi
	mov    %r15,%rsi
	mov    %rcx,0x0(%rip)        # <main+0x16c>
	shl    $0x3,%rdx
	callq  <main+0x175>
	mov    %rax,%rcx
	test   %ebp,%ebp
	jle    <main+0xf87>
	movslq %ebp,%rax
	shl    $0x3,%rax
	cmp    $0x1,%ebp
	lea    0x0(%rip),%rsi        # <main+0x191>
	adc    $0x0,%r12d
	mov    %rsi,(%rcx,%rax,1)
	mov    %r12d,0x0(%rip)        # <main+0x1a0>
	movslq %r12d,%r12
	lea    0x1(%r12),%rax
	movq   $0x0,(%rcx,%rax,8)
	movq   $0x0,-0x8(%rcx,%rax,8)
	xor    %edi,%edi
	lea    0x0(%rip),%rsi        # <main+0x1c2>
	callq  <main+0x1c7>
	test   %rax,%rax
	je     <main+0x1d5>
	callq  <main+0x1d1>
	test   %eax,%eax
	jne    <main+0x1f6>
	mov    0x0(%rip),%rcx        # <main+0x1dc>
	mov    0x0(%rip),%rdi        # <main+0x1e3>
	lea    0x0(%rip),%rdx        # <main+0x1ea>
	xor    %eax,%eax
	mov    $0x1,%esi
	callq  <main+0x1f6>
	xor    %edi,%edi
	callq  <main+0x1fd>
	mov    %rax,0x0(%rip)        # <main+0x204>
	test   %rax,%rax
	je     <main+0x105d>
	xor    %edi,%edi
	callq  <main+0x214>
	mov    0x0(%rip),%rdi        # <main+0x21b>
	lea    0x0(%rip),%rdx        # <main+0x222>
	movslq 0xe0(%rdi),%rax
	mov    %eax,0x0(%rip)        # <main+0x22f>
	mov    %rax,%rsi
	shl    $0x7,%rax
	add    0xe8(%rdi),%rax
	mov    0x10(%rax),%rax
	mov    %rax,0x0(%rip)        # <main+0x248>
	callq  <main+0x24d>
	mov    %rax,0x0(%rip)        # <main+0x254>
	test   %rax,%rax
	je     <main+0xfd7>
	mov    0x0(%rip),%rdx        # <main+0x264>
	mov    0x0(%rip),%rdi        # <main+0x26b>
	lea    0x0(%rip),%rsi        # <main+0x272>
	mov    (%rdx),%eax
	mov    0x4(%rdx),%edx
	mov    %eax,0x0(%rip)        # <main+0x27d>
	add    %edx,%eax
	mov    %edx,0x0(%rip)        # <main+0x285>
	xor    %edx,%edx
	mov    %eax,0x0(%rip)        # <main+0x28d>
	add    $0x2,%eax
	mov    %eax,0x0(%rip)        # <main+0x296>
	mov    %eax,0x0(%rip)        # <main+0x29c>
	callq  <main+0x2a1>
	mov    0x0(%rip),%rdi        # <main+0x2a8>
	xor    %edx,%edx
	lea    0x0(%rip),%rsi        # <main+0x2b1>
	mov    %rax,0x0(%rip)        # <main+0x2b8>
	callq  <main+0x2bd>
	mov    0x0(%rip),%rdi        # <main+0x2c4>
	xor    %edx,%edx
	lea    0x0(%rip),%rsi        # <main+0x2cd>
	mov    %rax,0x0(%rip)        # <main+0x2d4>
	callq  <main+0x2d9>
	mov    0x0(%rip),%rdi        # <main+0x2e0>
	xor    %edx,%edx
	lea    0x0(%rip),%rsi        # <main+0x2e9>
	mov    %rax,0x0(%rip)        # <main+0x2f0>
	callq  <main+0x2f5>
	mov    0x0(%rip),%rdi        # <main+0x2fc>
	xor    %edx,%edx
	lea    0x0(%rip),%rsi        # <main+0x305>
	mov    %rax,0x0(%rip)        # <main+0x30c>
	callq  <main+0x311>
	mov    0x0(%rip),%rdi        # <main+0x318>
	xor    %edx,%edx
	lea    0x0(%rip),%rsi        # <main+0x321>
	mov    %rax,0x0(%rip)        # <main+0x328>
	callq  <main+0x32d>
	mov    0x0(%rip),%rdi        # <main+0x334>
	xor    %edx,%edx
	lea    0x0(%rip),%rsi        # <main+0x33d>
	mov    %rax,0x0(%rip)        # <main+0x344>
	callq  <main+0x349>
	mov    0x0(%rip),%rdi        # <main+0x350>
	xor    %edx,%edx
	lea    0x0(%rip),%rsi        # <main+0x359>
	mov    %rax,0x0(%rip)        # <main+0x360>
	callq  <main+0x365>
	mov    0x0(%rip),%rdi        # <main+0x36c>
	xor    %edx,%edx
	lea    0x0(%rip),%rsi        # <main+0x375>
	mov    %rax,0x0(%rip)        # <main+0x37c>
	callq  <main+0x381>
	mov    0x0(%rip),%rdi        # <main+0x388>
	xor    %edx,%edx
	lea    0x0(%rip),%rsi        # <main+0x391>
	mov    %rax,0x0(%rip)        # <main+0x398>
	callq  <main+0x39d>
	mov    0x0(%rip),%rdi        # <main+0x3a4>
	movl   $0x0,0x0(%rip)        # <main+0x3ae>
	mov    %rax,0x0(%rip)        # <main+0x3b5>
	movl   $0x0,0x0(%rip)        # <main+0x3bf>
	movl   $0x320,0x0(%rip)        # <main+0x3c9>
	movl   $0x258,0x0(%rip)        # <main+0x3d3>
	test   %rdi,%rdi
	je     <main+0xf05>
	lea    0x14(%rsp),%rcx
	lea    0x10(%rsp),%rdx
	movl   $0x0,0x18(%rsp)
	lea    0xc(%rsp),%rsi
	lea    0x18(%rsp),%r8
	movl   $0x0,0x14(%rsp)
	movl   $0x0,0x10(%rsp)
	movl   $0x0,0xc(%rsp)
	callq  <main+0x415>
	test   $0x1,%al
	je     <main+0x423>
	mov    0xc(%rsp),%edx
	mov    %edx,0x0(%rip)        # <main+0x423>
	test   $0x2,%al
	je     <main+0x431>
	mov    0x10(%rsp),%edx
	mov    %edx,0x0(%rip)        # <main+0x431>
	test   $0x4,%al
	je     <main+0x43f>
	mov    0x14(%rsp),%edx
	mov    %edx,0x0(%rip)        # <main+0x43f>
	test   $0x8,%al
	je     <main+0x44d>
	mov    0x18(%rsp),%edx
	mov    %edx,0x0(%rip)        # <main+0x44d>
	test   $0x10,%al
	je     <main+0xd26>
	cmpl   $0x0,0x0(%rip)        # <main+0x45c>
	jne    <main+0xd26>
	movl   $0xffffffff,0x0(%rip)        # <main+0x46c>
	test   $0x20,%al
	je     <main+0xf93>
	cmpl   $0x0,0x0(%rip)        # <main+0x47b>
	jne    <main+0x487>
	movl   $0xffffffff,0x0(%rip)        # <main+0x487>
	xor    %r12d,%r12d
	mov    0x0(%rip),%rdi        # <main+0x491>
	test   $0xc,%al
	movslq 0x0(%rip),%rax        # <main+0x49a>
	mov    0x0(%rip),%edx        # <main+0x4a0>
	setne  %r12b
	mov    %rax,%rcx
	shl    $0x7,%rax
	add    0xe8(%rdi),%rax
	mov    0x1c(%rax),%esi
	test   %edx,%edx
	js     <main+0xfbe>
	mov    0x0(%rip),%eax        # <main+0x4c3>
	test   %eax,%eax
	jns    <main+0x4d8>
	add    %esi,%eax
	sub    0x0(%rip),%eax        # <main+0x4cf>
	sub    $0x1,%eax
	mov    %eax,0x0(%rip)        # <main+0x4d8>
	pxor   %xmm0,%xmm0
	lea    0x30(%rsp),%rdx
	mov    $0xe,%esi
	xor    %r14d,%r14d
	movabs $0x400000020,%rax
	movups %xmm0,0x40(%rsp)
	mov    %ecx,0x40(%rsp)
	lea    0x1c(%rsp),%rcx
	mov    %rax,0x44(%rsp)
	movups %xmm0,0x30(%rsp)
	movups %xmm0,0x50(%rsp)
	movups %xmm0,0x60(%rsp)
	callq  <main+0x51a>
	mov    0x1c(%rsp),%edx
	mov    %rax,%rbp
	mov    %rax,%rbx
	test   %edx,%edx
	jg     <main+0x53f>
	jmp    <main+0x565>
	nopw   0x0(%rax,%rax,1)
	add    $0x1,%r14d
	add    $0x40,%rbx
	cmp    0x1c(%rsp),%r14d
	jge    <main+0x565>
	mov    (%rbx),%rsi
	mov    0x0(%rip),%rdi        # <main+0x549>
	callq  <main+0x54e>
	cmpl   $0x1,0x8(%rax)
	jne    <main+0x530>
	cmpw   $0x0,0x1e(%rax)
	je     <main+0x530>
	mov    (%rbx),%rax
	mov    %rax,0x0(%rip)        # <main+0x565>
	mov    %rbp,%rdi
	callq  <main+0x56d>
	mov    0x0(%rip),%rdx        # <main+0x574>
	test   %rdx,%rdx
	je     <main+0x1039>
	mov    0x0(%rip),%rsi        # <main+0x584>
	mov    0x0(%rip),%rdi        # <main+0x58b>
	xor    %ecx,%ecx
	lea    0x70(%rsp),%r14
	callq  <main+0x597>
	mov    0x0(%rip),%rdi        # <main+0x59e>
	mov    %rax,0x0(%rip)        # <main+0x5a5>
	callq  <main+0x5aa>
	mov    0x0(%rip),%rdi        # <main+0x5b1>
	mov    %rax,0x0(%rip)        # <main+0x5b8>
	mov    %rdx,0x0(%rip)        # <main+0x5bf>
	callq  <main+0x5c4>
	mov    0x0(%rip),%rdi        # <main+0x5cb>
	mov    %rax,0x0(%rip)        # <main+0x5d2>
	mov    %rdx,0x0(%rip)        # <main+0x5d9>
	callq  <main+0x5de>
	mov    0x0(%rip),%rdi        # <main+0x5e5>
	mov    %rax,0x0(%rip)        # <main+0x5ec>
	mov    %rdx,0x0(%rip)        # <main+0x5f3>
	callq  <main+0x5f8>
	mov    0x0(%rip),%rdi        # <main+0x5ff>
	mov    %rax,0x0(%rip)        # <main+0x606>
	mov    %rdx,0x0(%rip)        # <main+0x60d>
	callq  <main+0x612>
	mov    0x0(%rip),%rdi        # <main+0x619>
	mov    %rax,0x0(%rip)        # <main+0x620>
	mov    %rdx,0x0(%rip)        # <main+0x627>
	callq  <main+0x62c>
	mov    0x0(%rip),%r9d        # <main+0x633>
	movl   $0x1,0x90(%rsp)
	mov    %rax,0x0(%rip)        # <main+0x645>
	mov    0x0(%rip),%rax        # <main+0x64c>
	movq   $0x0,0x70(%rsp)
	mov    0x0(%rip),%r8d        # <main+0x65c>
	mov    %rax,0x78(%rsp)
	mov    0x0(%rip),%rax        # <main+0x668>
	mov    %rdx,0x0(%rip)        # <main+0x66f>
	mov    0x0(%rip),%ecx        # <main+0x675>
	mov    %rax,0x88(%rsp)
	mov    0x0(%rip),%rax        # <main+0x684>
	mov    0x0(%rip),%edx        # <main+0x68a>
	mov    0x0(%rip),%rsi        # <main+0x691>
	movq   $0x23a00d,0xb8(%rsp)
	mov    %rax,0xd0(%rsp)
	mov    0x0(%rip),%rdi        # <main+0x6ac>
	push   %r14
	pushq  $0x2819
	pushq  0x0(%rip)        # <main+0x6b9>
	pushq  $0x1
	pushq  $0x20
	pushq  $0x0
	callq  <main+0x6c4>
	mov    0x0(%rip),%ecx        # <main+0x6ca>
	mov    0x0(%rip),%edx        # <main+0x6d0>
	add    $0x30,%rsp
	mov    0x0(%rip),%rdi        # <main+0x6db>
	mov    $0x20,%r8d
	mov    %rax,%rsi
	mov    %rax,0x0(%rip)        # <main+0x6eb>
	callq  <main+0x6f0>
	mov    0x0(%rip),%rdi        # <main+0x6f7>
	xor    %ecx,%ecx
	xor    %edx,%edx
	mov    %rax,%rsi
	mov    %rax,0x0(%rip)        # <main+0x705>
	callq  <main+0x70a>
	mov    0x0(%rip),%rsi        # <main+0x711>
	mov    0x0(%rip),%rdi        # <main+0x718>
	mov    %rax,0x0(%rip)        # <main+0x71f>
	callq  <main+0x724>
	mov    0x0(%rip),%rsi        # <main+0x72b>
	mov    $0x7a8005,%edx
	mov    0x0(%rip),%rdi        # <main+0x737>
	callq  <main+0x73c>
	lea    0x0(%rip),%rdi        # <main+0x743>
	callq  <main+0x748>
	mov    0x0(%rip),%rsi        # <main+0x74f>
	lea    0x20(%rsp),%rdx
	mov    0x0(%rip),%rdi        # <main+0x75b>
	mov    %rax,0x0(%rip)        # <main+0x762>
	mov    0x0(%rip),%rax        # <main+0x769>
	mov    %rax,0x20(%rsp)
	lea    0x0(%rip),%rax        # <main+0x775>
	mov    %rax,0x28(%rsp)
	callq  <main+0x77f>
	callq  <main+0x784>
	mov    %rax,%rbp
	test   %r12d,%r12d
	jne    <main+0xee1>
	movq   $0x18,(%rax)
	mov    0x0(%rip),%eax        # <main+0x79d>
	mov    %eax,0x14(%rbp)
	mov    0x0(%rip),%eax        # <main+0x7a6>
	mov    %eax,0x10(%rbp)
	mov    0x0(%rip),%eax        # <main+0x7af>
	add    $0x1,%eax
	mov    %eax,0x1c(%rbp)
	callq  <main+0x7ba>
	sub    $0x8,%rsp
	xor    %r9d,%r9d
	xor    %r8d,%r8d
	pushq  $0x0
	mov    0x0(%rip),%rsi        # <main+0x7cd>
	xor    %ecx,%ecx
	xor    %edx,%edx
	push   %rax
	mov    0x0(%rip),%rdi        # <main+0x7d9>
	mov    %rax,%r12
	push   %rbp
	callq  <main+0x7e2>
	add    $0x20,%rsp
	mov    %rbp,%rdi
	callq  <main+0x7ee>
	mov    %r12,%rdi
	callq  <main+0x7f6>
	mov    0x0(%rip),%rsi        # <main+0x7fd>
	mov    0x0(%rip),%rdi        # <main+0x804>
	mov    $0x1,%ecx
	lea    0x0(%rip),%rdx        # <main+0x810>
	callq  <main+0x815>
	mov    0x0(%rip),%r9        # <main+0x81c>
	mov    $0x40,%ecx
	xor    %eax,%eax
	lea    0x0(%rip),%r8        # <main+0x82a>
	mov    $0x1,%edx
	mov    $0x40,%esi
	lea    0x0(%rip),%rdi        # <main+0x83b>
	callq  <main+0x840>
	mov    $0x1,%edx
	lea    0x0(%rip),%rsi        # <main+0x84c>
	lea    0x0(%rip),%rdi        # <main+0x853>
	callq  <main+0x858>
	mov    $0xffffffff,%edi
	movl   $0x1,0x0(%rip)        # <main+0x867>
	callq  <main+0x86c>
	mov    0x0(%rip),%rdx        # <main+0x873>
	xor    %eax,%eax
	mov    $0x1,%edi
	lea    0x0(%rip),%rsi        # <main+0x881>
	callq  <main+0x886>
	xor    %edi,%edi
	callq  <main+0x88d>
	test   %r13d,%r13d
	je     <main+0xd3f>
	callq  <main+0x89b>
	test   %eax,%eax
	je     <main+0xd33>
	mov    0x0(%rip),%rax        # <main+0x8aa>
	test   %rax,%rax
	je     <main+0xeac>
	mov    0x10(%rax),%edi
	callq  <main+0x8bb>
	jmpq   <main+0xeac>
	test   %dl,%dl
	je     <main+0x8ca>
	mov    %esi,0x0(%rip)        # <main+0x8ca>
	test   %cl,%cl
	je     <main+0x8d5>
	mov    %r8d,0x0(%rip)        # <main+0x8d5>
	test   %dil,%dil
	je     <main+0x8e1>
	mov    %r10d,0x0(%rip)        # <main+0x8e1>
	test   %r9b,%r9b
	je     <main+0x8ed>
	mov    %r11d,0x0(%rip)        # <main+0x8ed>
	movzbl 0x1(%rbx),%eax
	add    $0x1,%rbx
	test   %al,%al
	jne    <main+0x906>
	mov    0x8(%r15),%rbx
	test   %rbx,%rbx
	je     <main+0xf47>
	mov    %rbx,0x0(%rip)        # <main+0x90d>
	lea    -0x1(%r12),%ecx
	lea    0x8(%r15),%rdx
	test   %al,%al
	je     <main+0x120>
	mov    %rdx,%rax
	mov    %ecx,%r12d
	mov    %r15,%rdx
	mov    %rax,%r15
	jmpq   <main+0x128>
	nop
	mov    $0x1,%r9d
	xor    %r11d,%r11d
	movzbl 0x1(%rbx),%eax
	add    $0x1,%rbx
	test   %al,%al
	jne    <main+0xa8>
	test   %dl,%dl
	je     <main+0x953>
	mov    %esi,0x0(%rip)        # <main+0x953>
	test   %cl,%cl
	je     <main+0x95e>
	mov    %r8d,0x0(%rip)        # <main+0x95e>
	test   %dil,%dil
	je     <main+0x96a>
	mov    %r10d,0x0(%rip)        # <main+0x96a>
	test   %r9b,%r9b
	je     <main+0x976>
	mov    %r11d,0x0(%rip)        # <main+0x976>
	mov    %r15,%rdx
	sub    $0x1,%r12d
	add    $0x8,%r15
	jmpq   <main+0x128>
	nopw   %cs:0x0(%rax,%rax,1)
	mov    $0x1,%r13d
	jmp    <main+0x939>
	nopl   0x0(%rax,%rax,1)
	test   %dl,%dl
	je     <main+0x9aa>
	mov    %esi,0x0(%rip)        # <main+0x9aa>
	test   %cl,%cl
	je     <main+0x9b5>
	mov    %r8d,0x0(%rip)        # <main+0x9b5>
	test   %dil,%dil
	je     <main+0x9c1>
	mov    %r10d,0x0(%rip)        # <main+0x9c1>
	test   %r9b,%r9b
	je     <main+0x9cd>
	mov    %r11d,0x0(%rip)        # <main+0x9cd>
	movzbl 0x1(%rbx),%eax
	add    $0x1,%rbx
	test   %al,%al
	jne    <main+0x9e6>
	mov    0x8(%r15),%rbx
	test   %rbx,%rbx
	je     <main+0xf47>
	mov    %rbx,0x0(%rip)        # <main+0x9ed>
	jmpq   <main+0x10d>
	nopw   0x0(%rax,%rax,1)
	test   %dl,%dl
	je     <main+0xa02>
	mov    %esi,0x0(%rip)        # <main+0xa02>
	test   %cl,%cl
	je     <main+0xa0d>
	mov    %r8d,0x0(%rip)        # <main+0xa0d>
	test   %dil,%dil
	je     <main+0xa19>
	mov    %r10d,0x0(%rip)        # <main+0xa19>
	test   %r9b,%r9b
	je     <main+0xa25>
	mov    %r11d,0x0(%rip)        # <main+0xa25>
	movzbl 0x1(%rbx),%eax
	add    $0x1,%rbx
	test   %al,%al
	jne    <main+0xa3e>
	mov    0x8(%r15),%rbx
	test   %rbx,%rbx
	je     <main+0xf47>
	mov    %rbx,0x0(%rip)        # <main+0xa45>
	jmpq   <main+0x10d>
	nopw   0x0(%rax,%rax,1)
	mov    $0x1,%edi
	mov    $0x1,%r10d
	jmpq   <main+0x939>
	test   %dl,%dl
	je     <main+0xa6a>
	mov    %esi,0x0(%rip)        # <main+0xa6a>
	test   %cl,%cl
	je     <main+0xa75>
	mov    %r8d,0x0(%rip)        # <main+0xa75>
	test   %dil,%dil
	je     <main+0xa81>
	mov    %r10d,0x0(%rip)        # <main+0xa81>
	test   %r9b,%r9b
	je     <main+0xa8d>
	mov    %r11d,0x0(%rip)        # <main+0xa8d>
	movzbl 0x1(%rbx),%eax
	add    $0x1,%rbx
	test   %al,%al
	jne    <main+0xaa6>
	mov    0x8(%r15),%rbx
	test   %rbx,%rbx
	je     <main+0xf47>
	mov    %rbx,0x0(%rip)        # <main+0xaad>
	jmpq   <main+0x10d>
	nopw   0x0(%rax,%rax,1)
	test   %dl,%dl
	je     <main+0xac2>
	mov    %esi,0x0(%rip)        # <main+0xac2>
	test   %cl,%cl
	je     <main+0xacd>
	mov    %r8d,0x0(%rip)        # <main+0xacd>
	test   %dil,%dil
	je     <main+0xad9>
	mov    %r10d,0x0(%rip)        # <main+0xad9>
	test   %r9b,%r9b
	je     <main+0xae5>
	mov    %r11d,0x0(%rip)        # <main+0xae5>
	cmpb   $0x0,0x1(%rbx)
	lea    0x1(%rbx),%rdi
	jne    <main+0xafc>
	mov    0x8(%r15),%rdi
	test   %rdi,%rdi
	je     <main+0xf47>
	mov    $0xa,%edx
	xor    %esi,%esi
	callq  <main+0xb08>
	mov    %eax,%ebp
	movzbl 0x1(%rbx),%eax
	jmpq   <main+0x10d>
	nopl   0x0(%rax,%rax,1)
	test   %dl,%dl
	je     <main+0xb22>
	mov    %esi,0x0(%rip)        # <main+0xb22>
	test   %cl,%cl
	je     <main+0xb2d>
	mov    %r8d,0x0(%rip)        # <main+0xb2d>
	test   %dil,%dil
	je     <main+0xb39>
	mov    %r10d,0x0(%rip)        # <main+0xb39>
	test   %r9b,%r9b
	je     <main+0xb45>
	mov    %r11d,0x0(%rip)        # <main+0xb45>
	movzbl 0x1(%rbx),%eax
	lea    0x1(%rbx),%rdi
	test   %al,%al
	jne    <main+0xb61>
	mov    0x8(%r15),%rdi
	test   %rdi,%rdi
	je     <main+0xf47>
	movzbl (%rdi),%eax
	cmp    $0x73,%al
	jne    <main+0xb73>
	movl   $0x1,0x0(%rip)        # <main+0xb6f>
	add    $0x1,%rdi
	mov    $0xa,%edx
	xor    %esi,%esi
	callq  <main+0xb7f>
	mov    %eax,0x0(%rip)        # <main+0xb85>
	movzbl 0x1(%rbx),%eax
	jmpq   <main+0x10d>
	xchg   %ax,%ax
	test   %dl,%dl
	je     <main+0xb9a>
	mov    %esi,0x0(%rip)        # <main+0xb9a>
	test   %cl,%cl
	je     <main+0xba5>
	mov    %r8d,0x0(%rip)        # <main+0xba5>
	test   %dil,%dil
	je     <main+0xbb1>
	mov    %r10d,0x0(%rip)        # <main+0xbb1>
	test   %r9b,%r9b
	je     <main+0xbbd>
	mov    %r11d,0x0(%rip)        # <main+0xbbd>
	movzbl 0x1(%rbx),%eax
	add    $0x1,%rbx
	test   %al,%al
	jne    <main+0xbd6>
	mov    0x8(%r15),%rbx
	test   %rbx,%rbx
	je     <main+0xf47>
	mov    %rbx,0x0(%rip)        # <main+0xbdd>
	jmpq   <main+0x10d>
	nopw   0x0(%rax,%rax,1)
	test   %dl,%dl
	je     <main+0xbf2>
	mov    %esi,0x0(%rip)        # <main+0xbf2>
	test   %cl,%cl
	je     <main+0xbfd>
	mov    %r8d,0x0(%rip)        # <main+0xbfd>
	test   %dil,%dil
	je     <main+0xc09>
	mov    %r10d,0x0(%rip)        # <main+0xc09>
	test   %r9b,%r9b
	je     <main+0xc15>
	mov    %r11d,0x0(%rip)        # <main+0xc15>
	movzbl 0x1(%rbx),%eax
	add    $0x1,%rbx
	test   %al,%al
	jne    <main+0xc2e>
	mov    0x8(%r15),%rbx
	test   %rbx,%rbx
	je     <main+0xf47>
	mov    %rbx,0x0(%rip)        # <main+0xc35>
	jmpq   <main+0x10d>
	nopw   0x0(%rax,%rax,1)
	test   %dl,%dl
	je     <main+0xc4a>
	mov    %esi,0x0(%rip)        # <main+0xc4a>
	test   %cl,%cl
	je     <main+0xc55>
	mov    %r8d,0x0(%rip)        # <main+0xc55>
	test   %dil,%dil
	je     <main+0xc61>
	mov    %r10d,0x0(%rip)        # <main+0xc61>
	test   %r9b,%r9b
	je     <main+0xc6d>
	mov    %r11d,0x0(%rip)        # <main+0xc6d>
	movzbl 0x1(%rbx),%eax
	add    $0x1,%rbx
	test   %al,%al
	jne    <main+0xc86>
	mov    0x8(%r15),%rbx
	test   %rbx,%rbx
	je     <main+0xf47>
	mov    %rbx,0x0(%rip)        # <main+0xc8d>
	jmpq   <main+0x10d>
	nopw   0x0(%rax,%rax,1)
	mov    $0x1,%ecx
	mov    $0x1,%r8d
	jmpq   <main+0x939>
	nopl   0x0(%rax,%rax,1)
	mov    $0x1,%ecx
	xor    %r8d,%r8d
	mov    $0x1,%edx
	mov    $0x1,%esi
	jmpq   <main+0x939>
	nopw   0x0(%rax,%rax,1)
	cmpb   $0x0,0x2(%rbx)
	jne    <main+0x7d>
	sub    $0x1,%r12d
	add    $0x8,%r15
	jmpq   <main+0x135>
	movl   $0x0,0x0(%rip)        # <main+0xcf1>
	mov    $0x8,%esi
	movl   $0x0,0x0(%rip)        # <main+0xd00>
	callq  <main+0xd05>
	mov    %rax,%rcx
	test   %rax,%rax
	je     <main+0x101f>
	mov    %rax,0x0(%rip)        # <main+0xd18>
	test   %r12d,%r12d
	je     <main+0x1b9>
	jmpq   <main+0x178>
	test   $0x20,%al
	je     <main+0x487>
	jmpq   <main+0x474>
	mov    0x0(%rip),%rdi        # <main+0xd3a>
	callq  <main+0xd3f>
	mov    0x0(%rip),%rdi        # <main+0xd46>
	xor    %esi,%esi
	callq  <main+0xd4d>
	callq  <main+0xd52>
	cmpl   $0x1,0x0(%rip)        # <main+0xd59>
	je     <main+0x1013>
	lea    0x0(%rip),%rbx        # <main+0xd66>
	jmp    <main+0xd9c>
	nopl   0x0(%rax,%rax,1)
	mov    0x0(%rip),%rdi        # <main+0xd77>
	lea    0xe0(%rsp),%rbp
	mov    %rbp,%rsi
	callq  <main+0xd87>
	movslq 0xe0(%rsp),%rax
	mov    (%rbx,%rax,8),%rax
	test   %rax,%rax
	jne    <main+0xed7>
	mov    0x0(%rip),%eax        # <main+0xda2>
	test   %eax,%eax
	jne    <main+0xd70>
	xor    %ebx,%ebx
	cmpl   $0x0,0x0(%rip)        # <main+0xdaf>
	jle    <main+0xe28>
	nopl   0x0(%rax)
	mov    %r14,%rdi
	mov    %ebx,0x70(%rsp)
	callq  <main+0xdc4>
	mov    0x0(%rip),%rax        # <main+0xdcb>
	mov    0x0(%rip),%rdi        # <main+0xdd2>
	mov    (%rax,%rbx,8),%rax
	mov    0x100(%rax),%rsi
	callq  <main+0xde2>
	mov    0x0(%rip),%rax        # <main+0xde9>
	xor    %r8d,%r8d
	xor    %ecx,%ecx
	mov    0x0(%rip),%rdx        # <main+0xdf5>
	mov    0x0(%rip),%rdi        # <main+0xdfc>
	mov    (%rax,%rbx,8),%rax
	mov    0x100(%rax),%rsi
	callq  <main+0xe0c>
	mov    0x0(%rip),%rax        # <main+0xe13>
	mov    (%rax,%rbx,8),%rdi
	add    $0x1,%rbx
	callq  <main+0xe20>
	cmp    %ebx,0x0(%rip)        # <main+0xe26>
	jg     <main+0xdb8>
	mov    0x0(%rip),%rdi        # <main+0xe2f>
	callq  <main+0xe34>
	mov    0x0(%rip),%rdi        # <main+0xe3b>
	xor    %esi,%esi
	movq   $0x0,0x0(%rip)        # <main+0xe48>
	callq  <main+0xe4d>
	mov    0x0(%rip),%rsi        # <main+0xe54>
	mov    0x0(%rip),%rdi        # <main+0xe5b>
	callq  <main+0xe60>
	mov    0x0(%rip),%rsi        # <main+0xe67>
	mov    0x0(%rip),%rdi        # <main+0xe6e>
	callq  <main+0xe73>
	mov    0x0(%rip),%rsi        # <main+0xe7a>
	mov    0x0(%rip),%rdi        # <main+0xe81>
	callq  <main+0xe86>
	mov    0x0(%rip),%rdi        # <main+0xe8d>
	xor    %esi,%esi
	callq  <main+0xe94>
	mov    0x0(%rip),%rdi        # <main+0xe9b>
	callq  <main+0xea0>
	mov    0x0(%rip),%rdi        # <main+0xea7>
	callq  <main+0xeac>
	mov    0x1a8(%rsp),%rax
	sub    %fs:0x28,%rax
	jne    <main+0x1034>
	add    $0x1b8,%rsp
	xor    %eax,%eax
	pop    %rbx
	pop    %rbp
	pop    %r12
	pop    %r13
	pop    %r14
	pop    %r15
	retq   
	mov    %rbp,%rdi
	callq  *%rax
	jmpq   <main+0xd9c>
	movq   $0x30,(%rax)
	mov    0x0(%rip),%eax        # <main+0xeee>
	mov    %eax,0x20(%rbp)
	mov    %eax,0x18(%rbp)
	mov    0x0(%rip),%eax        # <main+0xefa>
	mov    %eax,0x24(%rbp)
	mov    %eax,0x1c(%rbp)
	jmpq   <main+0x7b5>
	mov    0x0(%rip),%rdi        # <main+0xf0c>
	mov    0x0(%rip),%ecx        # <main+0xf12>
	xor    %r12d,%r12d
	jmpq   <main+0x4d8>
	test   %dl,%dl
	je     <main+0xf24>
	mov    %esi,0x0(%rip)        # <main+0xf24>
	test   %cl,%cl
	je     <main+0xf2f>
	mov    %r8d,0x0(%rip)        # <main+0xf2f>
	test   %dil,%dil
	je     <main+0xf3b>
	mov    %r10d,0x0(%rip)        # <main+0xf3b>
	test   %r9b,%r9b
	je     <main+0xf47>
	mov    %r11d,0x0(%rip)        # <main+0xf47>
	callq  <main+0xf4c>
	test   %dl,%dl
	je     <main+0xf56>
	mov    %esi,0x0(%rip)        # <main+0xf56>
	test   %cl,%cl
	je     <main+0xf61>
	mov    %r8d,0x0(%rip)        # <main+0xf61>
	test   %dil,%dil
	je     <main+0xf6d>
	mov    %r10d,0x0(%rip)        # <main+0xf6d>
	test   %r9b,%r9b
	je     <main+0xf79>
	mov    %r11d,0x0(%rip)        # <main+0xf79>
	lea    0x0(%rip),%rdi        # <main+0xf80>
	xor    %eax,%eax
	callq  <main+0xf87>
	movslq %r12d,%rax
	shl    $0x3,%rax
	jmpq   <main+0x187>
	xor    %r12d,%r12d
	mov    0x0(%rip),%rdi        # <main+0xf9d>
	test   $0xc,%al
	movslq 0x0(%rip),%rax        # <main+0xfa6>
	setne  %r12b
	or     $0xffffffff,%edx
	mov    %rax,%rcx
	shl    $0x7,%rax
	add    0xe8(%rdi),%rax
	mov    0x1c(%rax),%esi
	add    0x18(%rax),%edx
	mov    %edx,%eax
	sub    0x0(%rip),%eax        # <main+0xfc9>
	sub    $0x1,%eax
	mov    %eax,0x0(%rip)        # <main+0xfd2>
	jmpq   <main+0x4bd>
	mov    0x0(%rip),%esi        # <main+0xfdd>
	mov    0x0(%rip),%rdi        # <main+0xfe4>
	lea    0x0(%rip),%rdx        # <main+0xfeb>
	callq  <main+0xff0>
	mov    %rax,0x0(%rip)        # <main+0xff7>
	test   %rax,%rax
	jne    <main+0x25d>
	lea    0x0(%rip),%rsi        # <main+0x1007>
	lea    0x0(%rip),%rdi        # <main+0x100e>
	callq  <main+0x1013>
	xor    %edi,%edi
	callq  <main+0x101a>
	jmpq   <main+0xd5f>
	mov    0x0(%rip),%rsi        # <main+0x1026>
	lea    0x0(%rip),%rdi        # <main+0x102d>
	xor    %eax,%eax
	callq  <main+0x1034>
	callq  <main+0x1039>
	mov    0x0(%rip),%rdi        # <main+0x1040>
	lea    0x0(%rip),%rdx        # <main+0x1047>
	mov    $0x1,%esi
	xor    %eax,%eax
	callq  <main+0x1053>
	mov    $0x1,%edi
	callq  <main+0x105d>
	mov    0x0(%rip),%rsi        # <main+0x1064>
	lea    0x0(%rip),%rdi        # <main+0x106b>
	callq  <configurerequest+0x30>