API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Oct 26th, 2017
64
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
MIX Assembler 128.31 KB | None | 0 0
raw download clone embed print report
  1. operator new(unsigned long, void*):
  2.   pushq %rbp
  3.   movq %rsp, %rbp
  4.   movq %rdi, -8(%rbp)
  5.   movq %rsi, -16(%rbp)
  6.   movq -16(%rbp), %rax
  7.   popq %rbp
  8.   ret
  9. __gnu_cxx::__ops::__iter_less_iter():
  10.   pushq %rbp
  11.   movq %rsp, %rbp
  12.   popq %rbp
  13.   ret
  14. __gnu_cxx::__ops::_Iter_less_val::_Iter_less_val(__gnu_cxx::__ops::_Iter_less_iter):
  15.   pushq %rbp
  16.   movq %rsp, %rbp
  17.   movq %rdi, -8(%rbp)
  18.   nop
  19.   popq %rbp
  20.   ret
  21. __gnu_cxx::__ops::__val_comp_iter(__gnu_cxx::__ops::_Iter_less_iter):
  22.   pushq %rbp
  23.   movq %rsp, %rbp
  24.   popq %rbp
  25.   ret
  26. std::__lg(long):
  27.   pushq %rbp
  28.   movq %rsp, %rbp
  29.   movq %rdi, -8(%rbp)
  30.   movq -8(%rbp), %rax
  31.   bsrq %rax, %rax
  32.   xorq $63, %rax
  33.   cltq
  34.   movl $63, %edx
  35.   subq %rax, %rdx
  36.   movq %rdx, %rax
  37.   popq %rbp
  38.   ret
  39. std::chrono::duration<long, std::ratio<1l, 1000000000l> >::count() const:
  40.   pushq %rbp
  41.   movq %rsp, %rbp
  42.   movq %rdi, -8(%rbp)
  43.   movq -8(%rbp), %rax
  44.   movq (%rax), %rax
  45.   popq %rbp
  46.   ret
  47. GetTimeMs64():
  48.   pushq %rbp
  49.   movq %rsp, %rbp
  50.   subq $32, %rsp
  51.   leaq -32(%rbp), %rax
  52.   movl $0, %esi
  53.   movq %rax, %rdi
  54.   call gettimeofday
  55.   movq -24(%rbp), %rax
  56.   movq %rax, -8(%rbp)
  57.   movq -8(%rbp), %rax
  58.   shrq $3, %rax
  59.   movabsq $2361183241434822607, %rdx
  60.   mulq %rdx
  61.   movq %rdx, %rax
  62.   shrq $4, %rax
  63.   movq %rax, -8(%rbp)
  64.   movq -32(%rbp), %rax
  65.   imulq $1000, %rax, %rax
  66.   addq %rax, -8(%rbp)
  67.   movq -8(%rbp), %rax
  68.   leave
  69.   ret
  70. counter_vect:
  71.  .zero 24
  72. __gnu_cxx::__promote_2<int, int, __gnu_cxx::__promote<int, std::__is_integer<int>::__value>::__type, __gnu_cxx::__promote<int, std::__is_integer<int>::__value>::__type>::__type std::pow<int, int>(int, int):
  73.   pushq %rbp
  74.   movq %rsp, %rbp
  75.   subq $16, %rsp
  76.   movl %edi, -4(%rbp)
  77.   movl %esi, -8(%rbp)
  78.   cvtsi2sd -8(%rbp), %xmm1
  79.   cvtsi2sd -4(%rbp), %xmm0
  80.   call pow
  81.   movq %xmm0, %rax
  82.   movq %rax, -16(%rbp)
  83.   movsd -16(%rbp), %xmm0
  84.   leave
  85.   ret
  86. .LC2:
  87.  .string "Time to sort my sort: "
  88. .LC4:
  89.  .string "Time to sort std sort: "
  90. .LC5:
  91.  .string "Time to sort spread sort: "
  92. .LC6:
  93.  .string "pause"
  94. main:
  95.   pushq %rbp
  96.   movq %rsp, %rbp
  97.   pushq %rbx
  98.   subq $184, %rsp
  99.   call std::chrono::_V2::system_clock::now()
  100.   movq %rax, -64(%rbp)
  101.   leaq -64(%rbp), %rax
  102.   movq %rax, %rdi
  103.   call std::chrono::time_point<std::chrono::_V2::system_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l> > >::time_since_epoch() const
  104.   movq %rax, -72(%rbp)
  105.   leaq -72(%rbp), %rax
  106.   movq %rax, %rdi
  107.   call std::enable_if<std::chrono::__is_duration<std::chrono::duration<long, std::ratio<1l, 1000l> > >::value, std::chrono::duration<long, std::ratio<1l, 1000l> > >::type std::chrono::duration_cast<std::chrono::duration<long, std::ratio<1l, 1000l> >, long, std::ratio<1l, 1000000000l> >(std::chrono::duration<long, std::ratio<1l, 1000000000l> > const&)
  108.   movq %rax, -80(%rbp)
  109.   leaq -80(%rbp), %rax
  110.   movq %rax, %rdi
  111.   call std::chrono::duration<long, std::ratio<1l, 1000l> >::count() const
  112.   movq %rax, %rdx
  113.   leaq -88(%rbp), %rax
  114.   movq %rdx, %rsi
  115.   movq %rax, %rdi
  116.   call std::linear_congruential_engine<unsigned long, 16807ul, 0ul, 2147483647ul>::linear_congruential_engine(unsigned long)
  117.   movl $15, %esi
  118.   movl $2, %edi
  119.   call __gnu_cxx::__promote_2<int, int, __gnu_cxx::__promote<int, std::__is_integer<int>::__value>::__type, __gnu_cxx::__promote<int, std::__is_integer<int>::__value>::__type>::__type std::pow<int, int>(int, int)
  120.   cvttsd2si %xmm0, %edx
  121.   leaq -96(%rbp), %rax
  122.   movl $1, %esi
  123.   movq %rax, %rdi
  124.   call std::uniform_int_distribution<int>::uniform_int_distribution(int, int)
  125.   leaq -128(%rbp), %rax
  126.   movq %rax, %rdi
  127.   call std::vector<int, std::allocator<int> >::vector()
  128.   movl $15, %esi
  129.   movl $2, %edi
  130.   call __gnu_cxx::__promote_2<int, int, __gnu_cxx::__promote<int, std::__is_integer<int>::__value>::__type, __gnu_cxx::__promote<int, std::__is_integer<int>::__value>::__type>::__type std::pow<int, int>(int, int)
  131.   movapd %xmm0, %xmm1
  132.   movsd .LC0(%rip), %xmm0
  133.   addsd %xmm1, %xmm0
  134.   ucomisd .LC1(%rip), %xmm0
  135.   jnb .L17
  136.   cvttsd2siq %xmm0, %rax
  137.   jmp .L18
  138. .L17:
  139.   movsd .LC1(%rip), %xmm1
  140.   subsd %xmm1, %xmm0
  141.   cvttsd2siq %xmm0, %rax
  142.   movabsq $-9223372036854775808, %rdx
  143.   xorq %rdx, %rax
  144. .L18:
  145.   movq %rax, %rsi
  146.   movl $counter_vect, %edi
  147.   call std::vector<int, std::allocator<int> >::resize(unsigned long)
  148.   movq $0, -24(%rbp)
  149. .L20:
  150.   cmpq $49999, -24(%rbp)
  151.   ja .L19
  152.   leaq -88(%rbp), %rdx
  153.   leaq -96(%rbp), %rax
  154.   movq %rdx, %rsi
  155.   movq %rax, %rdi
  156.   call int std::uniform_int_distribution<int>::operator()<std::linear_congruential_engine<unsigned long, 16807ul, 0ul, 2147483647ul> >(std::linear_congruential_engine<unsigned long, 16807ul, 0ul, 2147483647ul>&)
  157.   movl %eax, -52(%rbp)
  158.   leaq -52(%rbp), %rdx
  159.   leaq -128(%rbp), %rax
  160.   movq %rdx, %rsi
  161.   movq %rax, %rdi
  162.   call std::vector<int, std::allocator<int> >::push_back(int&&)
  163.   addq $1, -24(%rbp)
  164.   jmp .L20
  165. .L19:
  166.   leaq -160(%rbp), %rax
  167.   movq %rax, %rdi
  168.   call std::vector<int, std::allocator<int> >::vector()
  169.   movq $0, -32(%rbp)
  170. .L22:
  171.   leaq -128(%rbp), %rax
  172.   movq %rax, %rdi
  173.   call std::vector<int, std::allocator<int> >::size() const
  174.   cmpq %rax, -32(%rbp)
  175.   setb %al
  176.   testb %al, %al
  177.   je .L21
  178.   movq -32(%rbp), %rdx
  179.   leaq -128(%rbp), %rax
  180.   movq %rdx, %rsi
  181.   movq %rax, %rdi
  182.   call std::vector<int, std::allocator<int> >::operator[](unsigned long)
  183.   movq %rax, %rdx
  184.   leaq -160(%rbp), %rax
  185.   movq %rdx, %rsi
  186.   movq %rax, %rdi
  187.   call std::vector<int, std::allocator<int> >::push_back(int const&)
  188.   addq $1, -32(%rbp)
  189.   jmp .L22
  190. .L21:
  191.   leaq -192(%rbp), %rax
  192.   movq %rax, %rdi
  193.   call std::vector<int, std::allocator<int> >::vector()
  194.   movq $0, -40(%rbp)
  195. .L24:
  196.   leaq -128(%rbp), %rax
  197.   movq %rax, %rdi
  198.   call std::vector<int, std::allocator<int> >::size() const
  199.   cmpq %rax, -40(%rbp)
  200.   setb %al
  201.   testb %al, %al
  202.   je .L23
  203.   movq -40(%rbp), %rdx
  204.   leaq -128(%rbp), %rax
  205.   movq %rdx, %rsi
  206.   movq %rax, %rdi
  207.   call std::vector<int, std::allocator<int> >::operator[](unsigned long)
  208.   movq %rax, %rdx
  209.   leaq -192(%rbp), %rax
  210.   movq %rdx, %rsi
  211.   movq %rax, %rdi
  212.   call std::vector<int, std::allocator<int> >::push_back(int const&)
  213.   addq $1, -40(%rbp)
  214.   jmp .L24
  215. .L23:
  216.   call GetTimeMs64()
  217.   movq %rax, -48(%rbp)
  218.   leaq -128(%rbp), %rax
  219.   movq %rax, %rdi
  220.   call my_sort(std::vector<int, std::allocator<int> >&)
  221.   movl $.LC2, %esi
  222.   movl std::cout, %edi
  223.   call std::basic_ostream<char, std::char_traits<char> >& std::operator<< <std::char_traits<char> >(std::basic_ostream<char, std::char_traits<char> >&, char const*)
  224.   movq %rax, %rbx
  225.   call GetTimeMs64()
  226.   subq -48(%rbp), %rax
  227.   testq %rax, %rax
  228.   js .L25
  229.   cvtsi2sdq %rax, %xmm0
  230.   jmp .L26
  231. .L25:
  232.   movq %rax, %rdx
  233.   shrq %rdx
  234.   andl $1, %eax
  235.   orq %rax, %rdx
  236.   cvtsi2sdq %rdx, %xmm0
  237.   addsd %xmm0, %xmm0
  238. .L26:
  239.   movsd .LC3(%rip), %xmm1
  240.   divsd %xmm1, %xmm0
  241.   movq %rbx, %rdi
  242.   call std::basic_ostream<char, std::char_traits<char> >::operator<<(double)
  243.   movl std::basic_ostream<char, std::char_traits<char> >& std::endl<char, std::char_traits<char> >(std::basic_ostream<char, std::char_traits<char> >&), %esi
  244.   movq %rax, %rdi
  245.   call std::basic_ostream<char, std::char_traits<char> >::operator<<(std::basic_ostream<char, std::char_traits<char> >& (*)(std::basic_ostream<char, std::char_traits<char> >&))
  246.   call GetTimeMs64()
  247.   movq %rax, -48(%rbp)
  248.   leaq -160(%rbp), %rax
  249.   movq %rax, %rdi
  250.   call std::vector<int, std::allocator<int> >::end()
  251.   movq %rax, %rbx
  252.   leaq -160(%rbp), %rax
  253.   movq %rax, %rdi
  254.   call std::vector<int, std::allocator<int> >::begin()
  255.   movq %rbx, %rsi
  256.   movq %rax, %rdi
  257.   call void std::sort<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > > >(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >)
  258.   movl $.LC4, %esi
  259.   movl std::cout, %edi
  260.   call std::basic_ostream<char, std::char_traits<char> >& std::operator<< <std::char_traits<char> >(std::basic_ostream<char, std::char_traits<char> >&, char const*)
  261.   movq %rax, %rbx
  262.   call GetTimeMs64()
  263.   subq -48(%rbp), %rax
  264.   testq %rax, %rax
  265.   js .L27
  266.   cvtsi2sdq %rax, %xmm0
  267.   jmp .L28
  268. .L27:
  269.   movq %rax, %rdx
  270.   shrq %rdx
  271.   andl $1, %eax
  272.   orq %rax, %rdx
  273.   cvtsi2sdq %rdx, %xmm0
  274.   addsd %xmm0, %xmm0
  275. .L28:
  276.   movsd .LC3(%rip), %xmm1
  277.   divsd %xmm1, %xmm0
  278.   movq %rbx, %rdi
  279.   call std::basic_ostream<char, std::char_traits<char> >::operator<<(double)
  280.   movl std::basic_ostream<char, std::char_traits<char> >& std::endl<char, std::char_traits<char> >(std::basic_ostream<char, std::char_traits<char> >&), %esi
  281.   movq %rax, %rdi
  282.   call std::basic_ostream<char, std::char_traits<char> >::operator<<(std::basic_ostream<char, std::char_traits<char> >& (*)(std::basic_ostream<char, std::char_traits<char> >&))
  283.   call GetTimeMs64()
  284.   movq %rax, -48(%rbp)
  285.   movl $.LC5, %esi
  286.   movl std::cout, %edi
  287.   call std::basic_ostream<char, std::char_traits<char> >& std::operator<< <std::char_traits<char> >(std::basic_ostream<char, std::char_traits<char> >&, char const*)
  288.   movq %rax, %rbx
  289.   call GetTimeMs64()
  290.   subq -48(%rbp), %rax
  291.   testq %rax, %rax
  292.   js .L29
  293.   cvtsi2sdq %rax, %xmm0
  294.   jmp .L30
  295. .L29:
  296.   movq %rax, %rdx
  297.   shrq %rdx
  298.   andl $1, %eax
  299.   orq %rax, %rdx
  300.   cvtsi2sdq %rdx, %xmm0
  301.   addsd %xmm0, %xmm0
  302. .L30:
  303.   movsd .LC3(%rip), %xmm1
  304.   divsd %xmm1, %xmm0
  305.   movq %rbx, %rdi
  306.   call std::basic_ostream<char, std::char_traits<char> >::operator<<(double)
  307.   movl std::basic_ostream<char, std::char_traits<char> >& std::endl<char, std::char_traits<char> >(std::basic_ostream<char, std::char_traits<char> >&), %esi
  308.   movq %rax, %rdi
  309.   call std::basic_ostream<char, std::char_traits<char> >::operator<<(std::basic_ostream<char, std::char_traits<char> >& (*)(std::basic_ostream<char, std::char_traits<char> >&))
  310.   movl $.LC6, %edi
  311.   call system
  312.   movl $0, %ebx
  313.   leaq -192(%rbp), %rax
  314.   movq %rax, %rdi
  315.   call std::vector<int, std::allocator<int> >::~vector()
  316.   leaq -160(%rbp), %rax
  317.   movq %rax, %rdi
  318.   call std::vector<int, std::allocator<int> >::~vector()
  319.   leaq -128(%rbp), %rax
  320.   movq %rax, %rdi
  321.   call std::vector<int, std::allocator<int> >::~vector()
  322.   movl %ebx, %eax
  323.   jmp .L40
  324.   movq %rax, %rdi
  325.   call _Unwind_Resume
  326.   movq %rax, %rbx
  327.   leaq -192(%rbp), %rax
  328.   movq %rax, %rdi
  329.   call std::vector<int, std::allocator<int> >::~vector()
  330.   jmp .L34
  331.   movq %rax, %rbx
  332. .L34:
  333.   leaq -160(%rbp), %rax
  334.   movq %rax, %rdi
  335.   call std::vector<int, std::allocator<int> >::~vector()
  336.   jmp .L35
  337.   movq %rax, %rbx
  338. .L35:
  339.   leaq -128(%rbp), %rax
  340.   movq %rax, %rdi
  341.   call std::vector<int, std::allocator<int> >::~vector()
  342.   movq %rbx, %rax
  343.   movq %rax, %rdi
  344.   call _Unwind_Resume
  345. .L40:
  346.   addq $184, %rsp
  347.   popq %rbx
  348.   popq %rbp
  349.   ret
  350. my_sort(std::vector<int, std::allocator<int> >&):
  351.   pushq %rbp
  352.   movq %rsp, %rbp
  353.   subq $48, %rsp
  354.   movq %rdi, -40(%rbp)
  355.   movq $0, -8(%rbp)
  356. .L43:
  357.   movq -40(%rbp), %rax
  358.   movq %rax, %rdi
  359.   call std::vector<int, std::allocator<int> >::size() const
  360.   cmpq %rax, -8(%rbp)
  361.   setb %al
  362.   testb %al, %al
  363.   je .L42
  364.   movq -8(%rbp), %rdx
  365.   movq -40(%rbp), %rax
  366.   movq %rdx, %rsi
  367.   movq %rax, %rdi
  368.   call std::vector<int, std::allocator<int> >::operator[](unsigned long)
  369.   movl (%rax), %eax
  370.   cltq
  371.   movq %rax, %rsi
  372.   movl $counter_vect, %edi
  373.   call std::vector<int, std::allocator<int> >::operator[](unsigned long)
  374.   movl (%rax), %edx
  375.   addl $1, %edx
  376.   movl %edx, (%rax)
  377.   addq $1, -8(%rbp)
  378.   jmp .L43
  379. .L42:
  380.   movl $0, -12(%rbp)
  381.   movq $0, -24(%rbp)
  382. .L47:
  383.   movl $counter_vect, %edi
  384.   call std::vector<int, std::allocator<int> >::size() const
  385.   cmpq %rax, -24(%rbp)
  386.   setb %al
  387.   testb %al, %al
  388.   je .L48
  389.   movq $0, -32(%rbp)
  390. .L46:
  391.   movq -24(%rbp), %rax
  392.   movq %rax, %rsi
  393.   movl $counter_vect, %edi
  394.   call std::vector<int, std::allocator<int> >::operator[](unsigned long)
  395.   movl (%rax), %eax
  396.   cltq
  397.   cmpq %rax, -32(%rbp)
  398.   setb %al
  399.   testb %al, %al
  400.   je .L45
  401.   movl -12(%rbp), %eax
  402.   movslq %eax, %rdx
  403.   movq -40(%rbp), %rax
  404.   movq %rdx, %rsi
  405.   movq %rax, %rdi
  406.   call std::vector<int, std::allocator<int> >::operator[](unsigned long)
  407.   movq %rax, %rdx
  408.   movq -24(%rbp), %rax
  409.   movl %eax, (%rdx)
  410.   addl $1, -12(%rbp)
  411.   addq $1, -32(%rbp)
  412.   jmp .L46
  413. .L45:
  414.   addq $1, -24(%rbp)
  415.   jmp .L47
  416. .L48:
  417.   nop
  418.   leave
  419.   ret
  420. sort_vect(std::vector<int, std::allocator<int> >&):
  421.   pushq %rbp
  422.   movq %rsp, %rbp
  423.   pushq %rbx
  424.   subq $40, %rsp
  425.   movq %rdi, -40(%rbp)
  426.   movl $1, -20(%rbp)
  427.   movl $0, -24(%rbp)
  428. .L55:
  429.   movl -20(%rbp), %eax
  430.   movslq %eax, %rbx
  431.   movq -40(%rbp), %rax
  432.   movq %rax, %rdi
  433.   call std::vector<int, std::allocator<int> >::size() const
  434.   cmpq %rax, %rbx
  435.   setb %al
  436.   testb %al, %al
  437.   je .L56
  438.   movl -20(%rbp), %eax
  439.   movl %eax, -24(%rbp)
  440. .L54:
  441.   cmpl $0, -24(%rbp)
  442.   jle .L51
  443.   movl -24(%rbp), %eax
  444.   subl $1, %eax
  445.   movslq %eax, %rdx
  446.   movq -40(%rbp), %rax
  447.   movq %rdx, %rsi
  448.   movq %rax, %rdi
  449.   call std::vector<int, std::allocator<int> >::operator[](unsigned long)
  450.   movl (%rax), %ebx
  451.   movl -24(%rbp), %eax
  452.   movslq %eax, %rdx
  453.   movq -40(%rbp), %rax
  454.   movq %rdx, %rsi
  455.   movq %rax, %rdi
  456.   call std::vector<int, std::allocator<int> >::operator[](unsigned long)
  457.   movl (%rax), %eax
  458.   cmpl %eax, %ebx
  459.   jle .L51
  460.   movl $1, %eax
  461.   jmp .L52
  462. .L51:
  463.   movl $0, %eax
  464. .L52:
  465.   testb %al, %al
  466.   je .L53
  467.   movl -24(%rbp), %eax
  468.   movslq %eax, %rdx
  469.   movq -40(%rbp), %rax
  470.   movq %rdx, %rsi
  471.   movq %rax, %rdi
  472.   call std::vector<int, std::allocator<int> >::operator[](unsigned long)
  473.   movq %rax, %rbx
  474.   movl -24(%rbp), %eax
  475.   subl $1, %eax
  476.   movslq %eax, %rdx
  477.   movq -40(%rbp), %rax
  478.   movq %rdx, %rsi
  479.   movq %rax, %rdi
  480.   call std::vector<int, std::allocator<int> >::operator[](unsigned long)
  481.   movq %rbx, %rsi
  482.   movq %rax, %rdi
  483.   call std::enable_if<std::__and_<std::__not_<std::__is_tuple_like<int> >, std::is_move_constructible<int>, std::is_move_assignable<int> >::value, void>::type std::swap<int>(int&, int&)
  484.   subl $1, -24(%rbp)
  485.   jmp .L54
  486. .L53:
  487.   addl $1, -20(%rbp)
  488.   jmp .L55
  489. .L56:
  490.   nop
  491.   addq $40, %rsp
  492.   popq %rbx
  493.   popq %rbp
  494.   ret
  495. std::chrono::time_point<std::chrono::_V2::system_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l> > >::time_since_epoch() const:
  496.   pushq %rbp
  497.   movq %rsp, %rbp
  498.   movq %rdi, -8(%rbp)
  499.   movq -8(%rbp), %rax
  500.   movq (%rax), %rax
  501.   popq %rbp
  502.   ret
  503. std::vector<int, std::allocator<int> >::vector():
  504.   pushq %rbp
  505.   movq %rsp, %rbp
  506.   subq $16, %rsp
  507.   movq %rdi, -8(%rbp)
  508.   movq -8(%rbp), %rax
  509.   movq %rax, %rdi
  510.   call std::_Vector_base<int, std::allocator<int> >::_Vector_base()
  511.   nop
  512.   leave
  513.   ret
  514. std::enable_if<std::chrono::__is_duration<std::chrono::duration<long, std::ratio<1l, 1000l> > >::value, std::chrono::duration<long, std::ratio<1l, 1000l> > >::type std::chrono::duration_cast<std::chrono::duration<long, std::ratio<1l, 1000l> >, long, std::ratio<1l, 1000000000l> >(std::chrono::duration<long, std::ratio<1l, 1000000000l> > const&):
  515.   pushq %rbp
  516.   movq %rsp, %rbp
  517.   subq $16, %rsp
  518.   movq %rdi, -8(%rbp)
  519.   movq -8(%rbp), %rax
  520.   movq %rax, %rdi
  521.   call std::chrono::duration<long, std::ratio<1l, 1000l> > std::chrono::__duration_cast_impl<std::chrono::duration<long, std::ratio<1l, 1000l> >, std::ratio<1l, 1000000l>, long, true, false>::__cast<long, std::ratio<1l, 1000000000l> >(std::chrono::duration<long, std::ratio<1l, 1000000000l> > const&)
  522.   leave
  523.   ret
  524. std::chrono::duration<long, std::ratio<1l, 1000l> >::count() const:
  525.   pushq %rbp
  526.   movq %rsp, %rbp
  527.   movq %rdi, -8(%rbp)
  528.   movq -8(%rbp), %rax
  529.   movq (%rax), %rax
  530.   popq %rbp
  531.   ret
  532. std::linear_congruential_engine<unsigned long, 16807ul, 0ul, 2147483647ul>::linear_congruential_engine(unsigned long):
  533.   pushq %rbp
  534.   movq %rsp, %rbp
  535.   subq $16, %rsp
  536.   movq %rdi, -8(%rbp)
  537.   movq %rsi, -16(%rbp)
  538.   movq -16(%rbp), %rdx
  539.   movq -8(%rbp), %rax
  540.   movq %rdx, %rsi
  541.   movq %rax, %rdi
  542.   call std::linear_congruential_engine<unsigned long, 16807ul, 0ul, 2147483647ul>::seed(unsigned long)
  543.   nop
  544.   leave
  545.   ret
  546. std::uniform_int_distribution<int>::uniform_int_distribution(int, int):
  547.   pushq %rbp
  548.   movq %rsp, %rbp
  549.   subq $16, %rsp
  550.   movq %rdi, -8(%rbp)
  551.   movl %esi, -12(%rbp)
  552.   movl %edx, -16(%rbp)
  553.   movq -8(%rbp), %rax
  554.   movl -16(%rbp), %edx
  555.   movl -12(%rbp), %ecx
  556.   movl %ecx, %esi
  557.   movq %rax, %rdi
  558.   call std::uniform_int_distribution<int>::param_type::param_type(int, int)
  559.   nop
  560.   leave
  561.   ret
  562. std::vector<int, std::allocator<int> >::~vector():
  563.   pushq %rbp
  564.   movq %rsp, %rbp
  565.   subq $16, %rsp
  566.   movq %rdi, -8(%rbp)
  567.   movq -8(%rbp), %rax
  568.   movq %rax, %rdi
  569.   call std::_Vector_base<int, std::allocator<int> >::_M_get_Tp_allocator()
  570.   movq %rax, %rdx
  571.   movq -8(%rbp), %rax
  572.   movq 8(%rax), %rcx
  573.   movq -8(%rbp), %rax
  574.   movq (%rax), %rax
  575.   movq %rcx, %rsi
  576.   movq %rax, %rdi
  577.   call void std::_Destroy<int*, int>(int*, int*, std::allocator<int>&)
  578.   movq -8(%rbp), %rax
  579.   movq %rax, %rdi
  580.   call std::_Vector_base<int, std::allocator<int> >::~_Vector_base()
  581.   nop
  582.   leave
  583.   ret
  584. std::vector<int, std::allocator<int> >::resize(unsigned long):
  585.   pushq %rbp
  586.   movq %rsp, %rbp
  587.   subq $16, %rsp
  588.   movq %rdi, -8(%rbp)
  589.   movq %rsi, -16(%rbp)
  590.   movq -8(%rbp), %rax
  591.   movq %rax, %rdi
  592.   call std::vector<int, std::allocator<int> >::size() const
  593.   cmpq %rax, -16(%rbp)
  594.   seta %al
  595.   testb %al, %al
  596.   je .L68
  597.   movq -8(%rbp), %rax
  598.   movq %rax, %rdi
  599.   call std::vector<int, std::allocator<int> >::size() const
  600.   movq %rax, %rdx
  601.   movq -16(%rbp), %rax
  602.   subq %rdx, %rax
  603.   movq %rax, %rdx
  604.   movq -8(%rbp), %rax
  605.   movq %rdx, %rsi
  606.   movq %rax, %rdi
  607.   call std::vector<int, std::allocator<int> >::_M_default_append(unsigned long)
  608.   jmp .L70
  609. .L68:
  610.   movq -8(%rbp), %rax
  611.   movq %rax, %rdi
  612.   call std::vector<int, std::allocator<int> >::size() const
  613.   cmpq %rax, -16(%rbp)
  614.   setb %al
  615.   testb %al, %al
  616.   je .L70
  617.   movq -8(%rbp), %rax
  618.   movq (%rax), %rax
  619.   movq -16(%rbp), %rdx
  620.   salq $2, %rdx
  621.   addq %rax, %rdx
  622.   movq -8(%rbp), %rax
  623.   movq %rdx, %rsi
  624.   movq %rax, %rdi
  625.   call std::vector<int, std::allocator<int> >::_M_erase_at_end(int*)
  626. .L70:
  627.   nop
  628.   leave
  629.   ret
  630. int std::uniform_int_distribution<int>::operator()<std::linear_congruential_engine<unsigned long, 16807ul, 0ul, 2147483647ul> >(std::linear_congruential_engine<unsigned long, 16807ul, 0ul, 2147483647ul>&):
  631.   pushq %rbp
  632.   movq %rsp, %rbp
  633.   subq $16, %rsp
  634.   movq %rdi, -8(%rbp)
  635.   movq %rsi, -16(%rbp)
  636.   movq -8(%rbp), %rdx
  637.   movq -16(%rbp), %rcx
  638.   movq -8(%rbp), %rax
  639.   movq %rcx, %rsi
  640.   movq %rax, %rdi
  641.   call int std::uniform_int_distribution<int>::operator()<std::linear_congruential_engine<unsigned long, 16807ul, 0ul, 2147483647ul> >(std::linear_congruential_engine<unsigned long, 16807ul, 0ul, 2147483647ul>&, std::uniform_int_distribution<int>::param_type const&)
  642.   leave
  643.   ret
  644. std::vector<int, std::allocator<int> >::push_back(int&&):
  645.   pushq %rbp
  646.   movq %rsp, %rbp
  647.   subq $16, %rsp
  648.   movq %rdi, -8(%rbp)
  649.   movq %rsi, -16(%rbp)
  650.   movq -16(%rbp), %rax
  651.   movq %rax, %rdi
  652.   call std::remove_reference<int&>::type&& std::move<int&>(int&)
  653.   movq %rax, %rdx
  654.   movq -8(%rbp), %rax
  655.   movq %rdx, %rsi
  656.   movq %rax, %rdi
  657.   call void std::vector<int, std::allocator<int> >::emplace_back<int>(int&&)
  658.   nop
  659.   leave
  660.   ret
  661. std::vector<int, std::allocator<int> >::size() const:
  662.   pushq %rbp
  663.   movq %rsp, %rbp
  664.   movq %rdi, -8(%rbp)
  665.   movq -8(%rbp), %rax
  666.   movq 8(%rax), %rax
  667.   movq %rax, %rdx
  668.   movq -8(%rbp), %rax
  669.   movq (%rax), %rax
  670.   subq %rax, %rdx
  671.   movq %rdx, %rax
  672.   sarq $2, %rax
  673.   popq %rbp
  674.   ret
  675. std::vector<int, std::allocator<int> >::operator[](unsigned long):
  676.   pushq %rbp
  677.   movq %rsp, %rbp
  678.   movq %rdi, -8(%rbp)
  679.   movq %rsi, -16(%rbp)
  680.   movq -8(%rbp), %rax
  681.   movq (%rax), %rax
  682.   movq -16(%rbp), %rdx
  683.   salq $2, %rdx
  684.   addq %rdx, %rax
  685.   popq %rbp
  686.   ret
  687. std::vector<int, std::allocator<int> >::push_back(int const&):
  688.   pushq %rbp
  689.   movq %rsp, %rbp
  690.   subq $16, %rsp
  691.   movq %rdi, -8(%rbp)
  692.   movq %rsi, -16(%rbp)
  693.   movq -8(%rbp), %rax
  694.   movq 8(%rax), %rdx
  695.   movq -8(%rbp), %rax
  696.   movq 16(%rax), %rax
  697.   cmpq %rax, %rdx
  698.   je .L79
  699.   movq -8(%rbp), %rax
  700.   movq 8(%rax), %rcx
  701.   movq -8(%rbp), %rax
  702.   movq -16(%rbp), %rdx
  703.   movq %rcx, %rsi
  704.   movq %rax, %rdi
  705.   call void std::allocator_traits<std::allocator<int> >::construct<int, int const&>(std::allocator<int>&, int*, int const&)
  706.   movq -8(%rbp), %rax
  707.   movq 8(%rax), %rax
  708.   leaq 4(%rax), %rdx
  709.   movq -8(%rbp), %rax
  710.   movq %rdx, 8(%rax)
  711.   jmp .L81
  712. .L79:
  713.   movq -8(%rbp), %rax
  714.   movq %rax, %rdi
  715.   call std::vector<int, std::allocator<int> >::end()
  716.   movq %rax, %rcx
  717.   movq -16(%rbp), %rdx
  718.   movq -8(%rbp), %rax
  719.   movq %rcx, %rsi
  720.   movq %rax, %rdi
  721.   call void std::vector<int, std::allocator<int> >::_M_realloc_insert<int const&>(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, int const&)
  722. .L81:
  723.   nop
  724.   leave
  725.   ret
  726. std::vector<int, std::allocator<int> >::begin():
  727.   pushq %rbp
  728.   movq %rsp, %rbp
  729.   subq $32, %rsp
  730.   movq %rdi, -24(%rbp)
  731.   movq -24(%rbp), %rdx
  732.   leaq -8(%rbp), %rax
  733.   movq %rdx, %rsi
  734.   movq %rax, %rdi
  735.   call __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >::__normal_iterator(int* const&)
  736.   movq -8(%rbp), %rax
  737.   leave
  738.   ret
  739. std::vector<int, std::allocator<int> >::end():
  740.   pushq %rbp
  741.   movq %rsp, %rbp
  742.   subq $32, %rsp
  743.   movq %rdi, -24(%rbp)
  744.   movq -24(%rbp), %rax
  745.   leaq 8(%rax), %rdx
  746.   leaq -8(%rbp), %rax
  747.   movq %rdx, %rsi
  748.   movq %rax, %rdi
  749.   call __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >::__normal_iterator(int* const&)
  750.   movq -8(%rbp), %rax
  751.   leave
  752.   ret
  753. void std::sort<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > > >(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >):
  754.   pushq %rbp
  755.   movq %rsp, %rbp
  756.   pushq %rbx
  757.   subq $40, %rsp
  758.   movq %rdi, -40(%rbp)
  759.   movq %rsi, -48(%rbp)
  760.   call __gnu_cxx::__ops::__iter_less_iter()
  761.   movq -48(%rbp), %rdx
  762.   movq -40(%rbp), %rax
  763.   subq $8, %rsp
  764.   pushq %rbx
  765.   movq %rdx, %rsi
  766.   movq %rax, %rdi
  767.   call void std::__sort<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__ops::_Iter_less_iter>(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__ops::_Iter_less_iter)
  768.   addq $16, %rsp
  769.   nop
  770.   movq -8(%rbp), %rbx
  771.   leave
  772.   ret
  773. std::remove_reference<int&>::type&& std::move<int&>(int&):
  774.   pushq %rbp
  775.   movq %rsp, %rbp
  776.   movq %rdi, -8(%rbp)
  777.   movq -8(%rbp), %rax
  778.   popq %rbp
  779.   ret
  780. std::enable_if<std::__and_<std::__not_<std::__is_tuple_like<int> >, std::is_move_constructible<int>, std::is_move_assignable<int> >::value, void>::type std::swap<int>(int&, int&):
  781.   pushq %rbp
  782.   movq %rsp, %rbp
  783.   subq $32, %rsp
  784.   movq %rdi, -24(%rbp)
  785.   movq %rsi, -32(%rbp)
  786.   movq -24(%rbp), %rax
  787.   movq %rax, %rdi
  788.   call std::remove_reference<int&>::type&& std::move<int&>(int&)
  789.   movl (%rax), %eax
  790.   movl %eax, -4(%rbp)
  791.   movq -32(%rbp), %rax
  792.   movq %rax, %rdi
  793.   call std::remove_reference<int&>::type&& std::move<int&>(int&)
  794.   movl (%rax), %edx
  795.   movq -24(%rbp), %rax
  796.   movl %edx, (%rax)
  797.   leaq -4(%rbp), %rax
  798.   movq %rax, %rdi
  799.   call std::remove_reference<int&>::type&& std::move<int&>(int&)
  800.   movl (%rax), %edx
  801.   movq -32(%rbp), %rax
  802.   movl %edx, (%rax)
  803.   nop
  804.   leave
  805.   ret
  806. std::_Vector_base<int, std::allocator<int> >::_Vector_impl::~_Vector_impl():
  807.   pushq %rbp
  808.   movq %rsp, %rbp
  809.   subq $16, %rsp
  810.   movq %rdi, -8(%rbp)
  811.   movq -8(%rbp), %rax
  812.   movq %rax, %rdi
  813.   call std::allocator<int>::~allocator()
  814.   nop
  815.   leave
  816.   ret
  817. std::_Vector_base<int, std::allocator<int> >::_Vector_base():
  818.   pushq %rbp
  819.   movq %rsp, %rbp
  820.   subq $16, %rsp
  821.   movq %rdi, -8(%rbp)
  822.   movq -8(%rbp), %rax
  823.   movq %rax, %rdi
  824.   call std::_Vector_base<int, std::allocator<int> >::_Vector_impl::_Vector_impl()
  825.   nop
  826.   leave
  827.   ret
  828. std::_Vector_base<int, std::allocator<int> >::~_Vector_base():
  829.   pushq %rbp
  830.   movq %rsp, %rbp
  831.   subq $16, %rsp
  832.   movq %rdi, -8(%rbp)
  833.   movq -8(%rbp), %rax
  834.   movq 16(%rax), %rax
  835.   movq %rax, %rdx
  836.   movq -8(%rbp), %rax
  837.   movq (%rax), %rax
  838.   subq %rax, %rdx
  839.   movq %rdx, %rax
  840.   sarq $2, %rax
  841.   movq %rax, %rdx
  842.   movq -8(%rbp), %rax
  843.   movq (%rax), %rcx
  844.   movq -8(%rbp), %rax
  845.   movq %rcx, %rsi
  846.   movq %rax, %rdi
  847.   call std::_Vector_base<int, std::allocator<int> >::_M_deallocate(int*, unsigned long)
  848.   movq -8(%rbp), %rax
  849.   movq %rax, %rdi
  850.   call std::_Vector_base<int, std::allocator<int> >::_Vector_impl::~_Vector_impl()
  851.   nop
  852.   leave
  853.   ret
  854. std::chrono::duration<long, std::ratio<1l, 1000l> > std::chrono::__duration_cast_impl<std::chrono::duration<long, std::ratio<1l, 1000l> >, std::ratio<1l, 1000000l>, long, true, false>::__cast<long, std::ratio<1l, 1000000000l> >(std::chrono::duration<long, std::ratio<1l, 1000000000l> > const&):
  855.   pushq %rbp
  856.   movq %rsp, %rbp
  857.   subq $32, %rsp
  858.   movq %rdi, -24(%rbp)
  859.   movq -24(%rbp), %rax
  860.   movq %rax, %rdi
  861.   call std::chrono::duration<long, std::ratio<1l, 1000000000l> >::count() const
  862.   movq %rax, %rcx
  863.   movabsq $4835703278458516699, %rdx
  864.   movq %rcx, %rax
  865.   imulq %rdx
  866.   sarq $18, %rdx
  867.   movq %rcx, %rax
  868.   sarq $63, %rax
  869.   subq %rax, %rdx
  870.   movq %rdx, %rax
  871.   movq %rax, -8(%rbp)
  872.   leaq -8(%rbp), %rdx
  873.   leaq -16(%rbp), %rax
  874.   movq %rdx, %rsi
  875.   movq %rax, %rdi
  876.   call std::chrono::duration<long, std::ratio<1l, 1000l> >::duration<long, void>(long const&)
  877.   movq -16(%rbp), %rax
  878.   leave
  879.   ret
  880. std::linear_congruential_engine<unsigned long, 16807ul, 0ul, 2147483647ul>::seed(unsigned long):
  881.   pushq %rbp
  882.   movq %rsp, %rbp
  883.   subq $16, %rsp
  884.   movq %rdi, -8(%rbp)
  885.   movq %rsi, -16(%rbp)
  886.   movl $0, %edi
  887.   call unsigned long std::__detail::__mod<unsigned long, 2147483647ul, 1ul, 0ul>(unsigned long)
  888.   testq %rax, %rax
  889.   jne .L96
  890.   movq -16(%rbp), %rax
  891.   movq %rax, %rdi
  892.   call unsigned long std::__detail::__mod<unsigned long, 2147483647ul, 1ul, 0ul>(unsigned long)
  893.   testq %rax, %rax
  894.   jne .L96
  895.   movl $1, %eax
  896.   jmp .L97
  897. .L96:
  898.   movl $0, %eax
  899. .L97:
  900.   testb %al, %al
  901.   je .L98
  902.   movq -8(%rbp), %rax
  903.   movq $1, (%rax)
  904.   jmp .L100
  905. .L98:
  906.   movq -16(%rbp), %rax
  907.   movq %rax, %rdi
  908.   call unsigned long std::__detail::__mod<unsigned long, 2147483647ul, 1ul, 0ul>(unsigned long)
  909.   movq %rax, %rdx
  910.   movq -8(%rbp), %rax
  911.   movq %rdx, (%rax)
  912. .L100:
  913.   nop
  914.   leave
  915.   ret
  916. std::uniform_int_distribution<int>::param_type::param_type(int, int):
  917.   pushq %rbp
  918.   movq %rsp, %rbp
  919.   movq %rdi, -8(%rbp)
  920.   movl %esi, -12(%rbp)
  921.   movl %edx, -16(%rbp)
  922.   movq -8(%rbp), %rax
  923.   movl -12(%rbp), %edx
  924.   movl %edx, (%rax)
  925.   movq -8(%rbp), %rax
  926.   movl -16(%rbp), %edx
  927.   movl %edx, 4(%rax)
  928.   nop
  929.   popq %rbp
  930.   ret
  931. std::_Vector_base<int, std::allocator<int> >::_M_get_Tp_allocator():
  932.   pushq %rbp
  933.   movq %rsp, %rbp
  934.   movq %rdi, -8(%rbp)
  935.   movq -8(%rbp), %rax
  936.   popq %rbp
  937.   ret
  938. void std::_Destroy<int*, int>(int*, int*, std::allocator<int>&):
  939.   pushq %rbp
  940.   movq %rsp, %rbp
  941.   subq $32, %rsp
  942.   movq %rdi, -8(%rbp)
  943.   movq %rsi, -16(%rbp)
  944.   movq %rdx, -24(%rbp)
  945.   movq -16(%rbp), %rdx
  946.   movq -8(%rbp), %rax
  947.   movq %rdx, %rsi
  948.   movq %rax, %rdi
  949.   call void std::_Destroy<int*>(int*, int*)
  950.   nop
  951.   leave
  952.   ret
  953. .LC7:
  954.  .string "vector::_M_default_append"
  955. std::vector<int, std::allocator<int> >::_M_default_append(unsigned long):
  956.   pushq %rbp
  957.   movq %rsp, %rbp
  958.   pushq %rbx
  959.   subq $56, %rsp
  960.   movq %rdi, -56(%rbp)
  961.   movq %rsi, -64(%rbp)
  962.   cmpq $0, -64(%rbp)
  963.   je .L113
  964.   movq -56(%rbp), %rax
  965.   movq 16(%rax), %rax
  966.   movq %rax, %rdx
  967.   movq -56(%rbp), %rax
  968.   movq 8(%rax), %rax
  969.   subq %rax, %rdx
  970.   movq %rdx, %rax
  971.   sarq $2, %rax
  972.   cmpq %rax, -64(%rbp)
  973.   ja .L107
  974.   movq -56(%rbp), %rax
  975.   movq %rax, %rdi
  976.   call std::_Vector_base<int, std::allocator<int> >::_M_get_Tp_allocator()
  977.   movq %rax, %rdx
  978.   movq -56(%rbp), %rax
  979.   movq 8(%rax), %rax
  980.   movq -64(%rbp), %rcx
  981.   movq %rcx, %rsi
  982.   movq %rax, %rdi
  983.   call int* std::__uninitialized_default_n_a<int*, unsigned long, int>(int*, unsigned long, std::allocator<int>&)
  984.   movq %rax, %rdx
  985.   movq -56(%rbp), %rax
  986.   movq %rdx, 8(%rax)
  987.   jmp .L113
  988. .L107:
  989.   movq -64(%rbp), %rcx
  990.   movq -56(%rbp), %rax
  991.   movl $.LC7, %edx
  992.   movq %rcx, %rsi
  993.   movq %rax, %rdi
  994.   call std::vector<int, std::allocator<int> >::_M_check_len(unsigned long, char const*) const
  995.   movq %rax, -32(%rbp)
  996.   movq -56(%rbp), %rax
  997.   movq %rax, %rdi
  998.   call std::vector<int, std::allocator<int> >::size() const
  999.   movq %rax, -40(%rbp)
  1000.   movq -56(%rbp), %rax
  1001.   movq -32(%rbp), %rdx
  1002.   movq %rdx, %rsi
  1003.   movq %rax, %rdi
  1004.   call std::_Vector_base<int, std::allocator<int> >::_M_allocate(unsigned long)
  1005.   movq %rax, -48(%rbp)
  1006.   movq -48(%rbp), %rax
  1007.   movq %rax, -24(%rbp)
  1008.   movq -56(%rbp), %rax
  1009.   movq %rax, %rdi
  1010.   call std::_Vector_base<int, std::allocator<int> >::_M_get_Tp_allocator()
  1011.   movq %rax, %rcx
  1012.   movq -56(%rbp), %rax
  1013.   movq 8(%rax), %rsi
  1014.   movq -56(%rbp), %rax
  1015.   movq (%rax), %rax
  1016.   movq -48(%rbp), %rdx
  1017.   movq %rax, %rdi
  1018.   call int* std::__uninitialized_move_if_noexcept_a<int*, int*, std::allocator<int> >(int*, int*, int*, std::allocator<int>&)
  1019.   movq %rax, -24(%rbp)
  1020.   movq -56(%rbp), %rax
  1021.   movq %rax, %rdi
  1022.   call std::_Vector_base<int, std::allocator<int> >::_M_get_Tp_allocator()
  1023.   movq %rax, %rdx
  1024.   movq -64(%rbp), %rcx
  1025.   movq -24(%rbp), %rax
  1026.   movq %rcx, %rsi
  1027.   movq %rax, %rdi
  1028.   call int* std::__uninitialized_default_n_a<int*, unsigned long, int>(int*, unsigned long, std::allocator<int>&)
  1029.   movq %rax, -24(%rbp)
  1030.   movq -56(%rbp), %rax
  1031.   movq %rax, %rdi
  1032.   call std::_Vector_base<int, std::allocator<int> >::_M_get_Tp_allocator()
  1033.   movq %rax, %rdx
  1034.   movq -56(%rbp), %rax
  1035.   movq 8(%rax), %rcx
  1036.   movq -56(%rbp), %rax
  1037.   movq (%rax), %rax
  1038.   movq %rcx, %rsi
  1039.   movq %rax, %rdi
  1040.   call void std::_Destroy<int*, int>(int*, int*, std::allocator<int>&)
  1041.   movq -56(%rbp), %rax
  1042.   movq -56(%rbp), %rdx
  1043.   movq 16(%rdx), %rdx
  1044.   movq %rdx, %rcx
  1045.   movq -56(%rbp), %rdx
  1046.   movq (%rdx), %rdx
  1047.   subq %rdx, %rcx
  1048.   movq %rcx, %rdx
  1049.   sarq $2, %rdx
  1050.   movq %rdx, %rsi
  1051.   movq -56(%rbp), %rdx
  1052.   movq (%rdx), %rcx
  1053.   movq %rsi, %rdx
  1054.   movq %rcx, %rsi
  1055.   movq %rax, %rdi
  1056.   call std::_Vector_base<int, std::allocator<int> >::_M_deallocate(int*, unsigned long)
  1057.   movq -56(%rbp), %rax
  1058.   movq -48(%rbp), %rdx
  1059.   movq %rdx, (%rax)
  1060.   movq -56(%rbp), %rax
  1061.   movq -24(%rbp), %rdx
  1062.   movq %rdx, 8(%rax)
  1063.   movq -32(%rbp), %rax
  1064.   leaq 0(,%rax,4), %rdx
  1065.   movq -48(%rbp), %rax
  1066.   addq %rax, %rdx
  1067.   movq -56(%rbp), %rax
  1068.   movq %rdx, 16(%rax)
  1069.   jmp .L113
  1070.   movq %rax, %rdi
  1071.   call __cxa_begin_catch
  1072.   movq -56(%rbp), %rax
  1073.   movq %rax, %rdi
  1074.   call std::_Vector_base<int, std::allocator<int> >::_M_get_Tp_allocator()
  1075.   movq %rax, %rdx
  1076.   movq -24(%rbp), %rcx
  1077.   movq -48(%rbp), %rax
  1078.   movq %rcx, %rsi
  1079.   movq %rax, %rdi
  1080.   call void std::_Destroy<int*, int>(int*, int*, std::allocator<int>&)
  1081.   movq -56(%rbp), %rax
  1082.   movq -32(%rbp), %rdx
  1083.   movq -48(%rbp), %rcx
  1084.   movq %rcx, %rsi
  1085.   movq %rax, %rdi
  1086.   call std::_Vector_base<int, std::allocator<int> >::_M_deallocate(int*, unsigned long)
  1087.   call __cxa_rethrow
  1088.   movq %rax, %rbx
  1089.   call __cxa_end_catch
  1090.   movq %rbx, %rax
  1091.   movq %rax, %rdi
  1092.   call _Unwind_Resume
  1093. .L113:
  1094.   nop
  1095.   addq $56, %rsp
  1096.   popq %rbx
  1097.   popq %rbp
  1098.   ret
  1099.  
  1100. std::vector<int, std::allocator<int> >::_M_erase_at_end(int*):
  1101.   pushq %rbp
  1102.   movq %rsp, %rbp
  1103.   subq $16, %rsp
  1104.   movq %rdi, -8(%rbp)
  1105.   movq %rsi, -16(%rbp)
  1106.   movq -8(%rbp), %rax
  1107.   movq %rax, %rdi
  1108.   call std::_Vector_base<int, std::allocator<int> >::_M_get_Tp_allocator()
  1109.   movq %rax, %rdx
  1110.   movq -8(%rbp), %rax
  1111.   movq 8(%rax), %rcx
  1112.   movq -16(%rbp), %rax
  1113.   movq %rcx, %rsi
  1114.   movq %rax, %rdi
  1115.   call void std::_Destroy<int*, int>(int*, int*, std::allocator<int>&)
  1116.   movq -8(%rbp), %rax
  1117.   movq -16(%rbp), %rdx
  1118.   movq %rdx, 8(%rax)
  1119.   nop
  1120.   leave
  1121.   ret
  1122. int std::uniform_int_distribution<int>::operator()<std::linear_congruential_engine<unsigned long, 16807ul, 0ul, 2147483647ul> >(std::linear_congruential_engine<unsigned long, 16807ul, 0ul, 2147483647ul>&, std::uniform_int_distribution<int>::param_type const&):
  1123.   pushq %rbp
  1124.   movq %rsp, %rbp
  1125.   pushq %rbx
  1126.   subq $136, %rsp
  1127.   movq %rdi, -120(%rbp)
  1128.   movq %rsi, -128(%rbp)
  1129.   movq %rdx, -136(%rbp)
  1130.   movq $1, -32(%rbp)
  1131.   movq $2147483646, -40(%rbp)
  1132.   movq $2147483645, -48(%rbp)
  1133.   movq -136(%rbp), %rax
  1134.   movq %rax, %rdi
  1135.   call std::uniform_int_distribution<int>::param_type::b() const
  1136.   movslq %eax, %rbx
  1137.   movq -136(%rbp), %rax
  1138.   movq %rax, %rdi
  1139.   call std::uniform_int_distribution<int>::param_type::a() const
  1140.   cltq
  1141.   subq %rax, %rbx
  1142.   movq %rbx, %rax
  1143.   movq %rax, -56(%rbp)
  1144.   cmpq $2147483644, -56(%rbp)
  1145.   ja .L116
  1146.   movq -56(%rbp), %rax
  1147.   addq $1, %rax
  1148.   movq %rax, -80(%rbp)
  1149.   movl $2147483645, %eax
  1150.   movl $0, %edx
  1151.   divq -80(%rbp)
  1152.   movq %rax, -88(%rbp)
  1153.   movq -80(%rbp), %rax
  1154.   imulq -88(%rbp), %rax
  1155.   movq %rax, -96(%rbp)
  1156. .L118:
  1157.   movq -128(%rbp), %rax
  1158.   movq %rax, %rdi
  1159.   call std::linear_congruential_engine<unsigned long, 16807ul, 0ul, 2147483647ul>::operator()()
  1160.   subq $1, %rax
  1161.   movq %rax, -24(%rbp)
  1162.   movq -24(%rbp), %rax
  1163.   cmpq -96(%rbp), %rax
  1164.   jb .L117
  1165.   jmp .L118
  1166. .L117:
  1167.   movq -24(%rbp), %rax
  1168.   movl $0, %edx
  1169.   divq -88(%rbp)
  1170.   movq %rax, -24(%rbp)
  1171.   jmp .L119
  1172. .L116:
  1173.   cmpq $2147483645, -56(%rbp)
  1174.   jbe .L120
  1175. .L123:
  1176.   movq $2147483646, -64(%rbp)
  1177.   movq -56(%rbp), %rax
  1178.   shrq %rax
  1179.   movabsq $-9223372028264841207, %rdx
  1180.   mulq %rdx
  1181.   movq %rdx, %rax
  1182.   shrq $29, %rax
  1183.   movl %eax, %edx
  1184.   leaq -104(%rbp), %rax
  1185.   movl $0, %esi
  1186.   movq %rax, %rdi
  1187.   call std::uniform_int_distribution<int>::param_type::param_type(int, int)
  1188.   leaq -104(%rbp), %rdx
  1189.   movq -128(%rbp), %rcx
  1190.   movq -120(%rbp), %rax
  1191.   movq %rcx, %rsi
  1192.   movq %rax, %rdi
  1193.   call int std::uniform_int_distribution<int>::operator()<std::linear_congruential_engine<unsigned long, 16807ul, 0ul, 2147483647ul> >(std::linear_congruential_engine<unsigned long, 16807ul, 0ul, 2147483647ul>&, std::uniform_int_distribution<int>::param_type const&)
  1194.   movslq %eax, %rdx
  1195.   movq %rdx, %rax
  1196.   salq $30, %rax
  1197.   subq %rdx, %rax
  1198.   addq %rax, %rax
  1199.   movq %rax, -72(%rbp)
  1200.   movq -128(%rbp), %rax
  1201.   movq %rax, %rdi
  1202.   call std::linear_congruential_engine<unsigned long, 16807ul, 0ul, 2147483647ul>::operator()()
  1203.   movq %rax, %rdx
  1204.   movq -72(%rbp), %rax
  1205.   addq %rdx, %rax
  1206.   subq $1, %rax
  1207.   movq %rax, -24(%rbp)
  1208.   movq -24(%rbp), %rax
  1209.   cmpq -56(%rbp), %rax
  1210.   ja .L123
  1211.   movq -24(%rbp), %rax
  1212.   cmpq -72(%rbp), %rax
  1213.   jnb .L119
  1214.   jmp .L123
  1215. .L120:
  1216.   movq -128(%rbp), %rax
  1217.   movq %rax, %rdi
  1218.   call std::linear_congruential_engine<unsigned long, 16807ul, 0ul, 2147483647ul>::operator()()
  1219.   subq $1, %rax
  1220.   movq %rax, -24(%rbp)
  1221. .L119:
  1222.   movq -136(%rbp), %rax
  1223.   movq %rax, %rdi
  1224.   call std::uniform_int_distribution<int>::param_type::a() const
  1225.   movl %eax, %edx
  1226.   movq -24(%rbp), %rax
  1227.   addl %edx, %eax
  1228.   addq $136, %rsp
  1229.   popq %rbx
  1230.   popq %rbp
  1231.   ret
  1232. void std::vector<int, std::allocator<int> >::emplace_back<int>(int&&):
  1233.   pushq %rbp
  1234.   movq %rsp, %rbp
  1235.   pushq %rbx
  1236.   subq $24, %rsp
  1237.   movq %rdi, -24(%rbp)
  1238.   movq %rsi, -32(%rbp)
  1239.   movq -24(%rbp), %rax
  1240.   movq 8(%rax), %rdx
  1241.   movq -24(%rbp), %rax
  1242.   movq 16(%rax), %rax
  1243.   cmpq %rax, %rdx
  1244.   je .L126
  1245.   movq -32(%rbp), %rax
  1246.   movq %rax, %rdi
  1247.   call int&& std::forward<int>(std::remove_reference<int>::type&)
  1248.   movq %rax, %rdx
  1249.   movq -24(%rbp), %rax
  1250.   movq 8(%rax), %rcx
  1251.   movq -24(%rbp), %rax
  1252.   movq %rcx, %rsi
  1253.   movq %rax, %rdi
  1254.   call void std::allocator_traits<std::allocator<int> >::construct<int, int>(std::allocator<int>&, int*, int&&)
  1255.   movq -24(%rbp), %rax
  1256.   movq 8(%rax), %rax
  1257.   leaq 4(%rax), %rdx
  1258.   movq -24(%rbp), %rax
  1259.   movq %rdx, 8(%rax)
  1260.   jmp .L128
  1261. .L126:
  1262.   movq -32(%rbp), %rax
  1263.   movq %rax, %rdi
  1264.   call int&& std::forward<int>(std::remove_reference<int>::type&)
  1265.   movq %rax, %rbx
  1266.   movq -24(%rbp), %rax
  1267.   movq %rax, %rdi
  1268.   call std::vector<int, std::allocator<int> >::end()
  1269.   movq %rax, %rcx
  1270.   movq -24(%rbp), %rax
  1271.   movq %rbx, %rdx
  1272.   movq %rcx, %rsi
  1273.   movq %rax, %rdi
  1274.   call void std::vector<int, std::allocator<int> >::_M_realloc_insert<int>(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, int&&)
  1275. .L128:
  1276.   nop
  1277.   addq $24, %rsp
  1278.   popq %rbx
  1279.   popq %rbp
  1280.   ret
  1281. void std::allocator_traits<std::allocator<int> >::construct<int, int const&>(std::allocator<int>&, int*, int const&):
  1282.   pushq %rbp
  1283.   movq %rsp, %rbp
  1284.   subq $32, %rsp
  1285.   movq %rdi, -8(%rbp)
  1286.   movq %rsi, -16(%rbp)
  1287.   movq %rdx, -24(%rbp)
  1288.   movq -24(%rbp), %rax
  1289.   movq %rax, %rdi
  1290.   call int const& std::forward<int const&>(std::remove_reference<int const&>::type&)
  1291.   movq %rax, %rdx
  1292.   movq -16(%rbp), %rcx
  1293.   movq -8(%rbp), %rax
  1294.   movq %rcx, %rsi
  1295.   movq %rax, %rdi
  1296.   call void __gnu_cxx::new_allocator<int>::construct<int, int const&>(int*, int const&)
  1297.   nop
  1298.   leave
  1299.   ret
  1300. .LC8:
  1301.  .string "vector::_M_realloc_insert"
  1302. void std::vector<int, std::allocator<int> >::_M_realloc_insert<int const&>(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, int const&):
  1303.   pushq %rbp
  1304.   movq %rsp, %rbp
  1305.   pushq %r12
  1306.   pushq %rbx
  1307.   subq $80, %rsp
  1308.   movq %rdi, -72(%rbp)
  1309.   movq %rsi, -80(%rbp)
  1310.   movq %rdx, -88(%rbp)
  1311.   movq -72(%rbp), %rax
  1312.   movl $.LC8, %edx
  1313.   movl $1, %esi
  1314.   movq %rax, %rdi
  1315.   call std::vector<int, std::allocator<int> >::_M_check_len(unsigned long, char const*) const
  1316.   movq %rax, -32(%rbp)
  1317.   movq -72(%rbp), %rax
  1318.   movq %rax, %rdi
  1319.   call std::vector<int, std::allocator<int> >::begin()
  1320.   movq %rax, -56(%rbp)
  1321.   leaq -56(%rbp), %rdx
  1322.   leaq -80(%rbp), %rax
  1323.   movq %rdx, %rsi
  1324.   movq %rax, %rdi
  1325.   call __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >::difference_type __gnu_cxx::operator-<int*, std::vector<int, std::allocator<int> > >(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > > const&, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > > const&)
  1326.   movq %rax, -40(%rbp)
  1327.   movq -72(%rbp), %rax
  1328.   movq -32(%rbp), %rdx
  1329.   movq %rdx, %rsi
  1330.   movq %rax, %rdi
  1331.   call std::_Vector_base<int, std::allocator<int> >::_M_allocate(unsigned long)
  1332.   movq %rax, -48(%rbp)
  1333.   movq -48(%rbp), %rax
  1334.   movq %rax, -24(%rbp)
  1335.   movq -88(%rbp), %rax
  1336.   movq %rax, %rdi
  1337.   call int const& std::forward<int const&>(std::remove_reference<int const&>::type&)
  1338.   movq %rax, %rsi
  1339.   movq -40(%rbp), %rax
  1340.   leaq 0(,%rax,4), %rdx
  1341.   movq -48(%rbp), %rax
  1342.   leaq (%rdx,%rax), %rcx
  1343.   movq -72(%rbp), %rax
  1344.   movq %rsi, %rdx
  1345.   movq %rcx, %rsi
  1346.   movq %rax, %rdi
  1347.   call void std::allocator_traits<std::allocator<int> >::construct<int, int const&>(std::allocator<int>&, int*, int const&)
  1348.   movq $0, -24(%rbp)
  1349.   movq -72(%rbp), %rax
  1350.   movq %rax, %rdi
  1351.   call std::_Vector_base<int, std::allocator<int> >::_M_get_Tp_allocator()
  1352.   movq %rax, %rbx
  1353.   leaq -80(%rbp), %rax
  1354.   movq %rax, %rdi
  1355.   call __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >::base() const
  1356.   movq (%rax), %rsi
  1357.   movq -72(%rbp), %rax
  1358.   movq (%rax), %rax
  1359.   movq -48(%rbp), %rdx
  1360.   movq %rbx, %rcx
  1361.   movq %rax, %rdi
  1362.   call int* std::__uninitialized_move_if_noexcept_a<int*, int*, std::allocator<int> >(int*, int*, int*, std::allocator<int>&)
  1363.   movq %rax, -24(%rbp)
  1364.   addq $4, -24(%rbp)
  1365.   movq -72(%rbp), %rax
  1366.   movq %rax, %rdi
  1367.   call std::_Vector_base<int, std::allocator<int> >::_M_get_Tp_allocator()
  1368.   movq %rax, %r12
  1369.   movq -72(%rbp), %rax
  1370.   movq 8(%rax), %rbx
  1371.   leaq -80(%rbp), %rax
  1372.   movq %rax, %rdi
  1373.   call __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >::base() const
  1374.   movq (%rax), %rax
  1375.   movq -24(%rbp), %rdx
  1376.   movq %r12, %rcx
  1377.   movq %rbx, %rsi
  1378.   movq %rax, %rdi
  1379.   call int* std::__uninitialized_move_if_noexcept_a<int*, int*, std::allocator<int> >(int*, int*, int*, std::allocator<int>&)
  1380.   movq %rax, -24(%rbp)
  1381.   movq -72(%rbp), %rax
  1382.   movq %rax, %rdi
  1383.   call std::_Vector_base<int, std::allocator<int> >::_M_get_Tp_allocator()
  1384.   movq %rax, %rdx
  1385.   movq -72(%rbp), %rax
  1386.   movq 8(%rax), %rcx
  1387.   movq -72(%rbp), %rax
  1388.   movq (%rax), %rax
  1389.   movq %rcx, %rsi
  1390.   movq %rax, %rdi
  1391.   call void std::_Destroy<int*, int>(int*, int*, std::allocator<int>&)
  1392.   movq -72(%rbp), %rax
  1393.   movq -72(%rbp), %rdx
  1394.   movq 16(%rdx), %rdx
  1395.   movq %rdx, %rcx
  1396.   movq -72(%rbp), %rdx
  1397.   movq (%rdx), %rdx
  1398.   subq %rdx, %rcx
  1399.   movq %rcx, %rdx
  1400.   sarq $2, %rdx
  1401.   movq %rdx, %rsi
  1402.   movq -72(%rbp), %rdx
  1403.   movq (%rdx), %rcx
  1404.   movq %rsi, %rdx
  1405.   movq %rcx, %rsi
  1406.   movq %rax, %rdi
  1407.   call std::_Vector_base<int, std::allocator<int> >::_M_deallocate(int*, unsigned long)
  1408.   movq -72(%rbp), %rax
  1409.   movq -48(%rbp), %rdx
  1410.   movq %rdx, (%rax)
  1411.   movq -72(%rbp), %rax
  1412.   movq -24(%rbp), %rdx
  1413.   movq %rdx, 8(%rax)
  1414.   movq -32(%rbp), %rax
  1415.   leaq 0(,%rax,4), %rdx
  1416.   movq -48(%rbp), %rax
  1417.   addq %rax, %rdx
  1418.   movq -72(%rbp), %rax
  1419.   movq %rdx, 16(%rax)
  1420.   jmp .L137
  1421.   movq %rax, %rdi
  1422.   call __cxa_begin_catch
  1423.   cmpq $0, -24(%rbp)
  1424.   jne .L132
  1425.   movq -40(%rbp), %rax
  1426.   leaq 0(,%rax,4), %rdx
  1427.   movq -48(%rbp), %rax
  1428.   addq %rax, %rdx
  1429.   movq -72(%rbp), %rax
  1430.   movq %rdx, %rsi
  1431.   movq %rax, %rdi
  1432.   call void std::allocator_traits<std::allocator<int> >::destroy<int>(std::allocator<int>&, int*)
  1433.   jmp .L133
  1434. .L132:
  1435.   movq -72(%rbp), %rax
  1436.   movq %rax, %rdi
  1437.   call std::_Vector_base<int, std::allocator<int> >::_M_get_Tp_allocator()
  1438.   movq %rax, %rdx
  1439.   movq -24(%rbp), %rcx
  1440.   movq -48(%rbp), %rax
  1441.   movq %rcx, %rsi
  1442.   movq %rax, %rdi
  1443.   call void std::_Destroy<int*, int>(int*, int*, std::allocator<int>&)
  1444. .L133:
  1445.   movq -72(%rbp), %rax
  1446.   movq -32(%rbp), %rdx
  1447.   movq -48(%rbp), %rcx
  1448.   movq %rcx, %rsi
  1449.   movq %rax, %rdi
  1450.   call std::_Vector_base<int, std::allocator<int> >::_M_deallocate(int*, unsigned long)
  1451.   call __cxa_rethrow
  1452.   movq %rax, %rbx
  1453.   call __cxa_end_catch
  1454.   movq %rbx, %rax
  1455.   movq %rax, %rdi
  1456.   call _Unwind_Resume
  1457. .L137:
  1458.   addq $80, %rsp
  1459.   popq %rbx
  1460.   popq %r12
  1461.   popq %rbp
  1462.   ret
  1463.  
  1464. __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >::__normal_iterator(int* const&):
  1465.   pushq %rbp
  1466.   movq %rsp, %rbp
  1467.   movq %rdi, -8(%rbp)
  1468.   movq %rsi, -16(%rbp)
  1469.   movq -16(%rbp), %rax
  1470.   movq (%rax), %rdx
  1471.   movq -8(%rbp), %rax
  1472.   movq %rdx, (%rax)
  1473.   nop
  1474.   popq %rbp
  1475.   ret
  1476. void std::__sort<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__ops::_Iter_less_iter>(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__ops::_Iter_less_iter):
  1477.   pushq %rbp
  1478.   movq %rsp, %rbp
  1479.   pushq %r12
  1480.   pushq %rbx
  1481.   subq $16, %rsp
  1482.   movq %rdi, -24(%rbp)
  1483.   movq %rsi, -32(%rbp)
  1484.   leaq -32(%rbp), %rdx
  1485.   leaq -24(%rbp), %rax
  1486.   movq %rdx, %rsi
  1487.   movq %rax, %rdi
  1488.   call bool __gnu_cxx::operator!=<int*, std::vector<int, std::allocator<int> > >(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > > const&, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > > const&)
  1489.   testb %al, %al
  1490.   je .L141
  1491.   leaq -24(%rbp), %rdx
  1492.   leaq -32(%rbp), %rax
  1493.   movq %rdx, %rsi
  1494.   movq %rax, %rdi
  1495.   call __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >::difference_type __gnu_cxx::operator-<int*, std::vector<int, std::allocator<int> > >(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > > const&, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > > const&)
  1496.   movq %rax, %rdi
  1497.   call std::__lg(long)
  1498.   leaq (%rax,%rax), %rdx
  1499.   movq -32(%rbp), %rcx
  1500.   movq -24(%rbp), %rax
  1501.   subq $8, %rsp
  1502.   pushq %r12
  1503.   movq %rcx, %rsi
  1504.   movq %rax, %rdi
  1505.   call void std::__introsort_loop<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, long, __gnu_cxx::__ops::_Iter_less_iter>(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, long, __gnu_cxx::__ops::_Iter_less_iter)
  1506.   addq $16, %rsp
  1507.   movq -32(%rbp), %rdx
  1508.   movq -24(%rbp), %rax
  1509.   subq $8, %rsp
  1510.   pushq %rbx
  1511.   movq %rdx, %rsi
  1512.   movq %rax, %rdi
  1513.   call void std::__final_insertion_sort<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__ops::_Iter_less_iter>(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__ops::_Iter_less_iter)
  1514.   addq $16, %rsp
  1515. .L141:
  1516.   nop
  1517.   leaq -16(%rbp), %rsp
  1518.   popq %rbx
  1519.   popq %r12
  1520.   popq %rbp
  1521.   ret
  1522. std::_Vector_base<int, std::allocator<int> >::_Vector_impl::_Vector_impl():
  1523.   pushq %rbp
  1524.   movq %rsp, %rbp
  1525.   subq $16, %rsp
  1526.   movq %rdi, -8(%rbp)
  1527.   movq -8(%rbp), %rax
  1528.   movq %rax, %rdi
  1529.   call std::allocator<int>::allocator()
  1530.   movq -8(%rbp), %rax
  1531.   movq $0, (%rax)
  1532.   movq -8(%rbp), %rax
  1533.   movq $0, 8(%rax)
  1534.   movq -8(%rbp), %rax
  1535.   movq $0, 16(%rax)
  1536.   nop
  1537.   leave
  1538.   ret
  1539. std::allocator<int>::~allocator():
  1540.   pushq %rbp
  1541.   movq %rsp, %rbp
  1542.   subq $16, %rsp
  1543.   movq %rdi, -8(%rbp)
  1544.   movq -8(%rbp), %rax
  1545.   movq %rax, %rdi
  1546.   call __gnu_cxx::new_allocator<int>::~new_allocator()
  1547.   nop
  1548.   leave
  1549.   ret
  1550. std::_Vector_base<int, std::allocator<int> >::_M_deallocate(int*, unsigned long):
  1551.   pushq %rbp
  1552.   movq %rsp, %rbp
  1553.   subq $32, %rsp
  1554.   movq %rdi, -8(%rbp)
  1555.   movq %rsi, -16(%rbp)
  1556.   movq %rdx, -24(%rbp)
  1557.   cmpq $0, -16(%rbp)
  1558.   je .L146
  1559.   movq -8(%rbp), %rax
  1560.   movq -24(%rbp), %rdx
  1561.   movq -16(%rbp), %rcx
  1562.   movq %rcx, %rsi
  1563.   movq %rax, %rdi
  1564.   call std::allocator_traits<std::allocator<int> >::deallocate(std::allocator<int>&, int*, unsigned long)
  1565. .L146:
  1566.   nop
  1567.   leave
  1568.   ret
  1569. std::chrono::duration<long, std::ratio<1l, 1000l> >::duration<long, void>(long const&):
  1570.   pushq %rbp
  1571.   movq %rsp, %rbp
  1572.   movq %rdi, -8(%rbp)
  1573.   movq %rsi, -16(%rbp)
  1574.   movq -16(%rbp), %rax
  1575.   movq (%rax), %rdx
  1576.   movq -8(%rbp), %rax
  1577.   movq %rdx, (%rax)
  1578.   nop
  1579.   popq %rbp
  1580.   ret
  1581. unsigned long std::__detail::__mod<unsigned long, 2147483647ul, 1ul, 0ul>(unsigned long):
  1582.   pushq %rbp
  1583.   movq %rsp, %rbp
  1584.   subq $16, %rsp
  1585.   movq %rdi, -8(%rbp)
  1586.   movq -8(%rbp), %rax
  1587.   movq %rax, %rdi
  1588.   call std::__detail::_Mod<unsigned long, 2147483647ul, 1ul, 0ul, true, true>::__calc(unsigned long)
  1589.   leave
  1590.   ret
  1591. void std::_Destroy<int*>(int*, int*):
  1592.   pushq %rbp
  1593.   movq %rsp, %rbp
  1594.   subq $16, %rsp
  1595.   movq %rdi, -8(%rbp)
  1596.   movq %rsi, -16(%rbp)
  1597.   movq -16(%rbp), %rdx
  1598.   movq -8(%rbp), %rax
  1599.   movq %rdx, %rsi
  1600.   movq %rax, %rdi
  1601.   call void std::_Destroy_aux<true>::__destroy<int*>(int*, int*)
  1602.   nop
  1603.   leave
  1604.   ret
  1605. int* std::__uninitialized_default_n_a<int*, unsigned long, int>(int*, unsigned long, std::allocator<int>&):
  1606.   pushq %rbp
  1607.   movq %rsp, %rbp
  1608.   subq $32, %rsp
  1609.   movq %rdi, -8(%rbp)
  1610.   movq %rsi, -16(%rbp)
  1611.   movq %rdx, -24(%rbp)
  1612.   movq -16(%rbp), %rdx
  1613.   movq -8(%rbp), %rax
  1614.   movq %rdx, %rsi
  1615.   movq %rax, %rdi
  1616.   call int* std::__uninitialized_default_n<int*, unsigned long>(int*, unsigned long)
  1617.   leave
  1618.   ret
  1619. std::vector<int, std::allocator<int> >::_M_check_len(unsigned long, char const*) const:
  1620.   pushq %rbp
  1621.   movq %rsp, %rbp
  1622.   pushq %rbx
  1623.   subq $56, %rsp
  1624.   movq %rdi, -40(%rbp)
  1625.   movq %rsi, -48(%rbp)
  1626.   movq %rdx, -56(%rbp)
  1627.   movq -40(%rbp), %rax
  1628.   movq %rax, %rdi
  1629.   call std::vector<int, std::allocator<int> >::max_size() const
  1630.   movq %rax, %rbx
  1631.   movq -40(%rbp), %rax
  1632.   movq %rax, %rdi
  1633.   call std::vector<int, std::allocator<int> >::size() const
  1634.   subq %rax, %rbx
  1635.   movq %rbx, %rdx
  1636.   movq -48(%rbp), %rax
  1637.   cmpq %rax, %rdx
  1638.   setb %al
  1639.   testb %al, %al
  1640.   je .L154
  1641.   movq -56(%rbp), %rax
  1642.   movq %rax, %rdi
  1643.   call std::__throw_length_error(char const*)
  1644. .L154:
  1645.   movq -40(%rbp), %rax
  1646.   movq %rax, %rdi
  1647.   call std::vector<int, std::allocator<int> >::size() const
  1648.   movq %rax, %rbx
  1649.   movq -40(%rbp), %rax
  1650.   movq %rax, %rdi
  1651.   call std::vector<int, std::allocator<int> >::size() const
  1652.   movq %rax, -32(%rbp)
  1653.   leaq -48(%rbp), %rdx
  1654.   leaq -32(%rbp), %rax
  1655.   movq %rdx, %rsi
  1656.   movq %rax, %rdi
  1657.   call unsigned long const& std::max<unsigned long>(unsigned long const&, unsigned long const&)
  1658.   movq (%rax), %rax
  1659.   addq %rbx, %rax
  1660.   movq %rax, -24(%rbp)
  1661.   movq -40(%rbp), %rax
  1662.   movq %rax, %rdi
  1663.   call std::vector<int, std::allocator<int> >::size() const
  1664.   cmpq %rax, -24(%rbp)
  1665.   jb .L155
  1666.   movq -40(%rbp), %rax
  1667.   movq %rax, %rdi
  1668.   call std::vector<int, std::allocator<int> >::max_size() const
  1669.   cmpq %rax, -24(%rbp)
  1670.   jbe .L156
  1671. .L155:
  1672.   movq -40(%rbp), %rax
  1673.   movq %rax, %rdi
  1674.   call std::vector<int, std::allocator<int> >::max_size() const
  1675.   jmp .L157
  1676. .L156:
  1677.   movq -24(%rbp), %rax
  1678. .L157:
  1679.   addq $56, %rsp
  1680.   popq %rbx
  1681.   popq %rbp
  1682.   ret
  1683. std::_Vector_base<int, std::allocator<int> >::_M_allocate(unsigned long):
  1684.   pushq %rbp
  1685.   movq %rsp, %rbp
  1686.   subq $16, %rsp
  1687.   movq %rdi, -8(%rbp)
  1688.   movq %rsi, -16(%rbp)
  1689.   cmpq $0, -16(%rbp)
  1690.   je .L160
  1691.   movq -8(%rbp), %rax
  1692.   movq -16(%rbp), %rdx
  1693.   movq %rdx, %rsi
  1694.   movq %rax, %rdi
  1695.   call std::allocator_traits<std::allocator<int> >::allocate(std::allocator<int>&, unsigned long)
  1696.   jmp .L162
  1697. .L160:
  1698.   movl $0, %eax
  1699. .L162:
  1700.   leave
  1701.   ret
  1702. int* std::__uninitialized_move_if_noexcept_a<int*, int*, std::allocator<int> >(int*, int*, int*, std::allocator<int>&):
  1703.   pushq %rbp
  1704.   movq %rsp, %rbp
  1705.   pushq %rbx
  1706.   subq $40, %rsp
  1707.   movq %rdi, -24(%rbp)
  1708.   movq %rsi, -32(%rbp)
  1709.   movq %rdx, -40(%rbp)
  1710.   movq %rcx, -48(%rbp)
  1711.   movq -32(%rbp), %rax
  1712.   movq %rax, %rdi
  1713.   call std::move_iterator<int*> std::__make_move_if_noexcept_iterator<int, std::move_iterator<int*> >(int*)
  1714.   movq %rax, %rbx
  1715.   movq -24(%rbp), %rax
  1716.   movq %rax, %rdi
  1717.   call std::move_iterator<int*> std::__make_move_if_noexcept_iterator<int, std::move_iterator<int*> >(int*)
  1718.   movq %rax, %rdi
  1719.   movq -48(%rbp), %rdx
  1720.   movq -40(%rbp), %rax
  1721.   movq %rdx, %rcx
  1722.   movq %rax, %rdx
  1723.   movq %rbx, %rsi
  1724.   call int* std::__uninitialized_copy_a<std::move_iterator<int*>, int*, int>(std::move_iterator<int*>, std::move_iterator<int*>, int*, std::allocator<int>&)
  1725.   addq $40, %rsp
  1726.   popq %rbx
  1727.   popq %rbp
  1728.   ret
  1729. std::uniform_int_distribution<int>::param_type::b() const:
  1730.   pushq %rbp
  1731.   movq %rsp, %rbp
  1732.   movq %rdi, -8(%rbp)
  1733.   movq -8(%rbp), %rax
  1734.   movl 4(%rax), %eax
  1735.   popq %rbp
  1736.   ret
  1737. std::uniform_int_distribution<int>::param_type::a() const:
  1738.   pushq %rbp
  1739.   movq %rsp, %rbp
  1740.   movq %rdi, -8(%rbp)
  1741.   movq -8(%rbp), %rax
  1742.   movl (%rax), %eax
  1743.   popq %rbp
  1744.   ret
  1745. std::linear_congruential_engine<unsigned long, 16807ul, 0ul, 2147483647ul>::operator()():
  1746.   pushq %rbp
  1747.   movq %rsp, %rbp
  1748.   subq $16, %rsp
  1749.   movq %rdi, -8(%rbp)
  1750.   movq -8(%rbp), %rax
  1751.   movq (%rax), %rax
  1752.   movq %rax, %rdi
  1753.   call unsigned long std::__detail::__mod<unsigned long, 2147483647ul, 16807ul, 0ul>(unsigned long)
  1754.   movq %rax, %rdx
  1755.   movq -8(%rbp), %rax
  1756.   movq %rdx, (%rax)
  1757.   movq -8(%rbp), %rax
  1758.   movq (%rax), %rax
  1759.   leave
  1760.   ret
  1761. int&& std::forward<int>(std::remove_reference<int>::type&):
  1762.   pushq %rbp
  1763.   movq %rsp, %rbp
  1764.   movq %rdi, -8(%rbp)
  1765.   movq -8(%rbp), %rax
  1766.   popq %rbp
  1767.   ret
  1768. void std::allocator_traits<std::allocator<int> >::construct<int, int>(std::allocator<int>&, int*, int&&):
  1769.   pushq %rbp
  1770.   movq %rsp, %rbp
  1771.   subq $32, %rsp
  1772.   movq %rdi, -8(%rbp)
  1773.   movq %rsi, -16(%rbp)
  1774.   movq %rdx, -24(%rbp)
  1775.   movq -24(%rbp), %rax
  1776.   movq %rax, %rdi
  1777.   call int&& std::forward<int>(std::remove_reference<int>::type&)
  1778.   movq %rax, %rdx
  1779.   movq -16(%rbp), %rcx
  1780.   movq -8(%rbp), %rax
  1781.   movq %rcx, %rsi
  1782.   movq %rax, %rdi
  1783.   call void __gnu_cxx::new_allocator<int>::construct<int, int>(int*, int&&)
  1784.   nop
  1785.   leave
  1786.   ret
  1787. void std::vector<int, std::allocator<int> >::_M_realloc_insert<int>(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, int&&):
  1788.   pushq %rbp
  1789.   movq %rsp, %rbp
  1790.   pushq %r12
  1791.   pushq %rbx
  1792.   subq $80, %rsp
  1793.   movq %rdi, -72(%rbp)
  1794.   movq %rsi, -80(%rbp)
  1795.   movq %rdx, -88(%rbp)
  1796.   movq -72(%rbp), %rax
  1797.   movl $.LC8, %edx
  1798.   movl $1, %esi
  1799.   movq %rax, %rdi
  1800.   call std::vector<int, std::allocator<int> >::_M_check_len(unsigned long, char const*) const
  1801.   movq %rax, -32(%rbp)
  1802.   movq -72(%rbp), %rax
  1803.   movq %rax, %rdi
  1804.   call std::vector<int, std::allocator<int> >::begin()
  1805.   movq %rax, -56(%rbp)
  1806.   leaq -56(%rbp), %rdx
  1807.   leaq -80(%rbp), %rax
  1808.   movq %rdx, %rsi
  1809.   movq %rax, %rdi
  1810.   call __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >::difference_type __gnu_cxx::operator-<int*, std::vector<int, std::allocator<int> > >(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > > const&, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > > const&)
  1811.   movq %rax, -40(%rbp)
  1812.   movq -72(%rbp), %rax
  1813.   movq -32(%rbp), %rdx
  1814.   movq %rdx, %rsi
  1815.   movq %rax, %rdi
  1816.   call std::_Vector_base<int, std::allocator<int> >::_M_allocate(unsigned long)
  1817.   movq %rax, -48(%rbp)
  1818.   movq -48(%rbp), %rax
  1819.   movq %rax, -24(%rbp)
  1820.   movq -88(%rbp), %rax
  1821.   movq %rax, %rdi
  1822.   call int&& std::forward<int>(std::remove_reference<int>::type&)
  1823.   movq %rax, %rsi
  1824.   movq -40(%rbp), %rax
  1825.   leaq 0(,%rax,4), %rdx
  1826.   movq -48(%rbp), %rax
  1827.   leaq (%rdx,%rax), %rcx
  1828.   movq -72(%rbp), %rax
  1829.   movq %rsi, %rdx
  1830.   movq %rcx, %rsi
  1831.   movq %rax, %rdi
  1832.   call void std::allocator_traits<std::allocator<int> >::construct<int, int>(std::allocator<int>&, int*, int&&)
  1833.   movq $0, -24(%rbp)
  1834.   movq -72(%rbp), %rax
  1835.   movq %rax, %rdi
  1836.   call std::_Vector_base<int, std::allocator<int> >::_M_get_Tp_allocator()
  1837.   movq %rax, %rbx
  1838.   leaq -80(%rbp), %rax
  1839.   movq %rax, %rdi
  1840.   call __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >::base() const
  1841.   movq (%rax), %rsi
  1842.   movq -72(%rbp), %rax
  1843.   movq (%rax), %rax
  1844.   movq -48(%rbp), %rdx
  1845.   movq %rbx, %rcx
  1846.   movq %rax, %rdi
  1847.   call int* std::__uninitialized_move_if_noexcept_a<int*, int*, std::allocator<int> >(int*, int*, int*, std::allocator<int>&)
  1848.   movq %rax, -24(%rbp)
  1849.   addq $4, -24(%rbp)
  1850.   movq -72(%rbp), %rax
  1851.   movq %rax, %rdi
  1852.   call std::_Vector_base<int, std::allocator<int> >::_M_get_Tp_allocator()
  1853.   movq %rax, %r12
  1854.   movq -72(%rbp), %rax
  1855.   movq 8(%rax), %rbx
  1856.   leaq -80(%rbp), %rax
  1857.   movq %rax, %rdi
  1858.   call __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >::base() const
  1859.   movq (%rax), %rax
  1860.   movq -24(%rbp), %rdx
  1861.   movq %r12, %rcx
  1862.   movq %rbx, %rsi
  1863.   movq %rax, %rdi
  1864.   call int* std::__uninitialized_move_if_noexcept_a<int*, int*, std::allocator<int> >(int*, int*, int*, std::allocator<int>&)
  1865.   movq %rax, -24(%rbp)
  1866.   movq -72(%rbp), %rax
  1867.   movq %rax, %rdi
  1868.   call std::_Vector_base<int, std::allocator<int> >::_M_get_Tp_allocator()
  1869.   movq %rax, %rdx
  1870.   movq -72(%rbp), %rax
  1871.   movq 8(%rax), %rcx
  1872.   movq -72(%rbp), %rax
  1873.   movq (%rax), %rax
  1874.   movq %rcx, %rsi
  1875.   movq %rax, %rdi
  1876.   call void std::_Destroy<int*, int>(int*, int*, std::allocator<int>&)
  1877.   movq -72(%rbp), %rax
  1878.   movq -72(%rbp), %rdx
  1879.   movq 16(%rdx), %rdx
  1880.   movq %rdx, %rcx
  1881.   movq -72(%rbp), %rdx
  1882.   movq (%rdx), %rdx
  1883.   subq %rdx, %rcx
  1884.   movq %rcx, %rdx
  1885.   sarq $2, %rdx
  1886.   movq %rdx, %rsi
  1887.   movq -72(%rbp), %rdx
  1888.   movq (%rdx), %rcx
  1889.   movq %rsi, %rdx
  1890.   movq %rcx, %rsi
  1891.   movq %rax, %rdi
  1892.   call std::_Vector_base<int, std::allocator<int> >::_M_deallocate(int*, unsigned long)
  1893.   movq -72(%rbp), %rax
  1894.   movq -48(%rbp), %rdx
  1895.   movq %rdx, (%rax)
  1896.   movq -72(%rbp), %rax
  1897.   movq -24(%rbp), %rdx
  1898.   movq %rdx, 8(%rax)
  1899.   movq -32(%rbp), %rax
  1900.   leaq 0(,%rax,4), %rdx
  1901.   movq -48(%rbp), %rax
  1902.   addq %rax, %rdx
  1903.   movq -72(%rbp), %rax
  1904.   movq %rdx, 16(%rax)
  1905.   jmp .L181
  1906.   movq %rax, %rdi
  1907.   call __cxa_begin_catch
  1908.   cmpq $0, -24(%rbp)
  1909.   jne .L176
  1910.   movq -40(%rbp), %rax
  1911.   leaq 0(,%rax,4), %rdx
  1912.   movq -48(%rbp), %rax
  1913.   addq %rax, %rdx
  1914.   movq -72(%rbp), %rax
  1915.   movq %rdx, %rsi
  1916.   movq %rax, %rdi
  1917.   call void std::allocator_traits<std::allocator<int> >::destroy<int>(std::allocator<int>&, int*)
  1918.   jmp .L177
  1919. .L176:
  1920.   movq -72(%rbp), %rax
  1921.   movq %rax, %rdi
  1922.   call std::_Vector_base<int, std::allocator<int> >::_M_get_Tp_allocator()
  1923.   movq %rax, %rdx
  1924.   movq -24(%rbp), %rcx
  1925.   movq -48(%rbp), %rax
  1926.   movq %rcx, %rsi
  1927.   movq %rax, %rdi
  1928.   call void std::_Destroy<int*, int>(int*, int*, std::allocator<int>&)
  1929. .L177:
  1930.   movq -72(%rbp), %rax
  1931.   movq -32(%rbp), %rdx
  1932.   movq -48(%rbp), %rcx
  1933.   movq %rcx, %rsi
  1934.   movq %rax, %rdi
  1935.   call std::_Vector_base<int, std::allocator<int> >::_M_deallocate(int*, unsigned long)
  1936.   call __cxa_rethrow
  1937.   movq %rax, %rbx
  1938.   call __cxa_end_catch
  1939.   movq %rbx, %rax
  1940.   movq %rax, %rdi
  1941.   call _Unwind_Resume
  1942. .L181:
  1943.   addq $80, %rsp
  1944.   popq %rbx
  1945.   popq %r12
  1946.   popq %rbp
  1947.   ret
  1948.  
  1949. int const& std::forward<int const&>(std::remove_reference<int const&>::type&):
  1950.   pushq %rbp
  1951.   movq %rsp, %rbp
  1952.   movq %rdi, -8(%rbp)
  1953.   movq -8(%rbp), %rax
  1954.   popq %rbp
  1955.   ret
  1956. void __gnu_cxx::new_allocator<int>::construct<int, int const&>(int*, int const&):
  1957.   pushq %rbp
  1958.   movq %rsp, %rbp
  1959.   pushq %rbx
  1960.   subq $40, %rsp
  1961.   movq %rdi, -24(%rbp)
  1962.   movq %rsi, -32(%rbp)
  1963.   movq %rdx, -40(%rbp)
  1964.   movq -40(%rbp), %rax
  1965.   movq %rax, %rdi
  1966.   call int const& std::forward<int const&>(std::remove_reference<int const&>::type&)
  1967.   movl (%rax), %ebx
  1968.   movq -32(%rbp), %rax
  1969.   movq %rax, %rsi
  1970.   movl $4, %edi
  1971.   call operator new(unsigned long, void*)
  1972.   testq %rax, %rax
  1973.   je .L187
  1974.   movl %ebx, (%rax)
  1975. .L187:
  1976.   nop
  1977.   addq $40, %rsp
  1978.   popq %rbx
  1979.   popq %rbp
  1980.   ret
  1981. __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >::difference_type __gnu_cxx::operator-<int*, std::vector<int, std::allocator<int> > >(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > > const&, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > > const&):
  1982.   pushq %rbp
  1983.   movq %rsp, %rbp
  1984.   pushq %rbx
  1985.   subq $24, %rsp
  1986.   movq %rdi, -24(%rbp)
  1987.   movq %rsi, -32(%rbp)
  1988.   movq -24(%rbp), %rax
  1989.   movq %rax, %rdi
  1990.   call __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >::base() const
  1991.   movq (%rax), %rax
  1992.   movq %rax, %rbx
  1993.   movq -32(%rbp), %rax
  1994.   movq %rax, %rdi
  1995.   call __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >::base() const
  1996.   movq (%rax), %rax
  1997.   subq %rax, %rbx
  1998.   movq %rbx, %rax
  1999.   sarq $2, %rax
  2000.   addq $24, %rsp
  2001.   popq %rbx
  2002.   popq %rbp
  2003.   ret
  2004. __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >::base() const:
  2005.   pushq %rbp
  2006.   movq %rsp, %rbp
  2007.   movq %rdi, -8(%rbp)
  2008.   movq -8(%rbp), %rax
  2009.   popq %rbp
  2010.   ret
  2011. void std::allocator_traits<std::allocator<int> >::destroy<int>(std::allocator<int>&, int*):
  2012.   pushq %rbp
  2013.   movq %rsp, %rbp
  2014.   subq $16, %rsp
  2015.   movq %rdi, -8(%rbp)
  2016.   movq %rsi, -16(%rbp)
  2017.   movq -16(%rbp), %rdx
  2018.   movq -8(%rbp), %rax
  2019.   movq %rdx, %rsi
  2020.   movq %rax, %rdi
  2021.   call void __gnu_cxx::new_allocator<int>::destroy<int>(int*)
  2022.   nop
  2023.   leave
  2024.   ret
  2025. bool __gnu_cxx::operator!=<int*, std::vector<int, std::allocator<int> > >(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > > const&, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > > const&):
  2026.   pushq %rbp
  2027.   movq %rsp, %rbp
  2028.   pushq %rbx
  2029.   subq $24, %rsp
  2030.   movq %rdi, -24(%rbp)
  2031.   movq %rsi, -32(%rbp)
  2032.   movq -24(%rbp), %rax
  2033.   movq %rax, %rdi
  2034.   call __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >::base() const
  2035.   movq (%rax), %rbx
  2036.   movq -32(%rbp), %rax
  2037.   movq %rax, %rdi
  2038.   call __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >::base() const
  2039.   movq (%rax), %rax
  2040.   cmpq %rax, %rbx
  2041.   setne %al
  2042.   addq $24, %rsp
  2043.   popq %rbx
  2044.   popq %rbp
  2045.   ret
  2046. void std::__introsort_loop<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, long, __gnu_cxx::__ops::_Iter_less_iter>(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, long, __gnu_cxx::__ops::_Iter_less_iter):
  2047.   pushq %rbp
  2048.   movq %rsp, %rbp
  2049.   pushq %r13
  2050.   pushq %r12
  2051.   pushq %rbx
  2052.   subq $56, %rsp
  2053.   movq %rdi, -56(%rbp)
  2054.   movq %rsi, -64(%rbp)
  2055.   movq %rdx, -72(%rbp)
  2056. .L198:
  2057.   leaq -56(%rbp), %rdx
  2058.   leaq -64(%rbp), %rax
  2059.   movq %rdx, %rsi
  2060.   movq %rax, %rdi
  2061.   call __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >::difference_type __gnu_cxx::operator-<int*, std::vector<int, std::allocator<int> > >(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > > const&, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > > const&)
  2062.   cmpq $16, %rax
  2063.   setg %al
  2064.   testb %al, %al
  2065.   je .L195
  2066.   cmpq $0, -72(%rbp)
  2067.   jne .L197
  2068.   movq -64(%rbp), %rdx
  2069.   movq -64(%rbp), %rcx
  2070.   movq -56(%rbp), %rax
  2071.   subq $8, %rsp
  2072.   pushq %r13
  2073.   movq %rcx, %rsi
  2074.   movq %rax, %rdi
  2075.   call void std::__partial_sort<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__ops::_Iter_less_iter>(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__ops::_Iter_less_iter)
  2076.   addq $16, %rsp
  2077.   jmp .L195
  2078. .L197:
  2079.   subq $1, -72(%rbp)
  2080.   movq -64(%rbp), %rdx
  2081.   movq -56(%rbp), %rax
  2082.   subq $8, %rsp
  2083.   pushq %r12
  2084.   movq %rdx, %rsi
  2085.   movq %rax, %rdi
  2086.   call __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > > std::__unguarded_partition_pivot<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__ops::_Iter_less_iter>(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__ops::_Iter_less_iter)
  2087.   addq $16, %rsp
  2088.   movq %rax, -40(%rbp)
  2089.   movq -72(%rbp), %rdx
  2090.   movq -64(%rbp), %rcx
  2091.   movq -40(%rbp), %rax
  2092.   subq $8, %rsp
  2093.   pushq %rbx
  2094.   movq %rcx, %rsi
  2095.   movq %rax, %rdi
  2096.   call void std::__introsort_loop<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, long, __gnu_cxx::__ops::_Iter_less_iter>(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, long, __gnu_cxx::__ops::_Iter_less_iter)
  2097.   addq $16, %rsp
  2098.   movq -40(%rbp), %rax
  2099.   movq %rax, -64(%rbp)
  2100.   jmp .L198
  2101. .L195:
  2102.   leaq -24(%rbp), %rsp
  2103.   popq %rbx
  2104.   popq %r12
  2105.   popq %r13
  2106.   popq %rbp
  2107.   ret
  2108. void std::__final_insertion_sort<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__ops::_Iter_less_iter>(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__ops::_Iter_less_iter):
  2109.   pushq %rbp
  2110.   movq %rsp, %rbp
  2111.   pushq %r13
  2112.   pushq %r12
  2113.   pushq %rbx
  2114.   subq $24, %rsp
  2115.   movq %rdi, -40(%rbp)
  2116.   movq %rsi, -48(%rbp)
  2117.   leaq -40(%rbp), %rdx
  2118.   leaq -48(%rbp), %rax
  2119.   movq %rdx, %rsi
  2120.   movq %rax, %rdi
  2121.   call __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >::difference_type __gnu_cxx::operator-<int*, std::vector<int, std::allocator<int> > >(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > > const&, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > > const&)
  2122.   cmpq $16, %rax
  2123.   setg %al
  2124.   testb %al, %al
  2125.   je .L200
  2126.   leaq -40(%rbp), %rax
  2127.   movl $16, %esi
  2128.   movq %rax, %rdi
  2129.   call __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >::operator+(long) const
  2130.   movq %rax, %rdx
  2131.   movq -40(%rbp), %rax
  2132.   subq $8, %rsp
  2133.   pushq %r13
  2134.   movq %rdx, %rsi
  2135.   movq %rax, %rdi
  2136.   call void std::__insertion_sort<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__ops::_Iter_less_iter>(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__ops::_Iter_less_iter)
  2137.   addq $16, %rsp
  2138.   leaq -40(%rbp), %rax
  2139.   movl $16, %esi
  2140.   movq %rax, %rdi
  2141.   call __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >::operator+(long) const
  2142.   movq %rax, %rdx
  2143.   movq -48(%rbp), %rax
  2144.   subq $8, %rsp
  2145.   pushq %r12
  2146.   movq %rax, %rsi
  2147.   movq %rdx, %rdi
  2148.   call void std::__unguarded_insertion_sort<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__ops::_Iter_less_iter>(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__ops::_Iter_less_iter)
  2149.   addq $16, %rsp
  2150.   jmp .L202
  2151. .L200:
  2152.   movq -48(%rbp), %rdx
  2153.   movq -40(%rbp), %rax
  2154.   subq $8, %rsp
  2155.   pushq %rbx
  2156.   movq %rdx, %rsi
  2157.   movq %rax, %rdi
  2158.   call void std::__insertion_sort<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__ops::_Iter_less_iter>(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__ops::_Iter_less_iter)
  2159.   addq $16, %rsp
  2160. .L202:
  2161.   nop
  2162.   leaq -24(%rbp), %rsp
  2163.   popq %rbx
  2164.   popq %r12
  2165.   popq %r13
  2166.   popq %rbp
  2167.   ret
  2168. std::allocator<int>::allocator():
  2169.   pushq %rbp
  2170.   movq %rsp, %rbp
  2171.   subq $16, %rsp
  2172.   movq %rdi, -8(%rbp)
  2173.   movq -8(%rbp), %rax
  2174.   movq %rax, %rdi
  2175.   call __gnu_cxx::new_allocator<int>::new_allocator()
  2176.   nop
  2177.   leave
  2178.   ret
  2179. __gnu_cxx::new_allocator<int>::~new_allocator():
  2180.   pushq %rbp
  2181.   movq %rsp, %rbp
  2182.   movq %rdi, -8(%rbp)
  2183.   nop
  2184.   popq %rbp
  2185.   ret
  2186. std::allocator_traits<std::allocator<int> >::deallocate(std::allocator<int>&, int*, unsigned long):
  2187.   pushq %rbp
  2188.   movq %rsp, %rbp
  2189.   subq $32, %rsp
  2190.   movq %rdi, -8(%rbp)
  2191.   movq %rsi, -16(%rbp)
  2192.   movq %rdx, -24(%rbp)
  2193.   movq -24(%rbp), %rdx
  2194.   movq -16(%rbp), %rcx
  2195.   movq -8(%rbp), %rax
  2196.   movq %rcx, %rsi
  2197.   movq %rax, %rdi
  2198.   call __gnu_cxx::new_allocator<int>::deallocate(int*, unsigned long)
  2199.   nop
  2200.   leave
  2201.   ret
  2202. std::__detail::_Mod<unsigned long, 2147483647ul, 1ul, 0ul, true, true>::__calc(unsigned long):
  2203.   pushq %rbp
  2204.   movq %rsp, %rbp
  2205.   movq %rdi, -24(%rbp)
  2206.   movq -24(%rbp), %rax
  2207.   movq %rax, -8(%rbp)
  2208.   movq -8(%rbp), %rcx
  2209.   movabsq $8589934597, %rdx
  2210.   movq %rcx, %rax
  2211.   mulq %rdx
  2212.   movq %rcx, %rax
  2213.   subq %rdx, %rax
  2214.   shrq %rax
  2215.   addq %rdx, %rax
  2216.   shrq $30, %rax
  2217.   movq %rax, %rdx
  2218.   movq %rdx, %rax
  2219.   salq $31, %rax
  2220.   subq %rdx, %rax
  2221.   subq %rax, %rcx
  2222.   movq %rcx, %rax
  2223.   movq %rax, -8(%rbp)
  2224.   movq -8(%rbp), %rax
  2225.   popq %rbp
  2226.   ret
  2227. void std::_Destroy_aux<true>::__destroy<int*>(int*, int*):
  2228.   pushq %rbp
  2229.   movq %rsp, %rbp
  2230.   movq %rdi, -8(%rbp)
  2231.   movq %rsi, -16(%rbp)
  2232.   nop
  2233.   popq %rbp
  2234.   ret
  2235. int* std::__uninitialized_default_n<int*, unsigned long>(int*, unsigned long):
  2236.   pushq %rbp
  2237.   movq %rsp, %rbp
  2238.   subq $32, %rsp
  2239.   movq %rdi, -24(%rbp)
  2240.   movq %rsi, -32(%rbp)
  2241.   movb $1, -1(%rbp)
  2242.   movq -32(%rbp), %rdx
  2243.   movq -24(%rbp), %rax
  2244.   movq %rdx, %rsi
  2245.   movq %rax, %rdi
  2246.   call int* std::__uninitialized_default_n_1<true>::__uninit_default_n<int*, unsigned long>(int*, unsigned long)
  2247.   leave
  2248.   ret
  2249. std::vector<int, std::allocator<int> >::max_size() const:
  2250.   pushq %rbp
  2251.   movq %rsp, %rbp
  2252.   subq $16, %rsp
  2253.   movq %rdi, -8(%rbp)
  2254.   movq -8(%rbp), %rax
  2255.   movq %rax, %rdi
  2256.   call std::_Vector_base<int, std::allocator<int> >::_M_get_Tp_allocator() const
  2257.   movq %rax, %rdi
  2258.   call std::allocator_traits<std::allocator<int> >::max_size(std::allocator<int> const&)
  2259.   leave
  2260.   ret
  2261. unsigned long const& std::max<unsigned long>(unsigned long const&, unsigned long const&):
  2262.   pushq %rbp
  2263.   movq %rsp, %rbp
  2264.   movq %rdi, -8(%rbp)
  2265.   movq %rsi, -16(%rbp)
  2266.   movq -8(%rbp), %rax
  2267.   movq (%rax), %rdx
  2268.   movq -16(%rbp), %rax
  2269.   movq (%rax), %rax
  2270.   cmpq %rax, %rdx
  2271.   jnb .L214
  2272.   movq -16(%rbp), %rax
  2273.   jmp .L215
  2274. .L214:
  2275.   movq -8(%rbp), %rax
  2276. .L215:
  2277.   popq %rbp
  2278.   ret
  2279. std::allocator_traits<std::allocator<int> >::allocate(std::allocator<int>&, unsigned long):
  2280.   pushq %rbp
  2281.   movq %rsp, %rbp
  2282.   subq $16, %rsp
  2283.   movq %rdi, -8(%rbp)
  2284.   movq %rsi, -16(%rbp)
  2285.   movq -16(%rbp), %rcx
  2286.   movq -8(%rbp), %rax
  2287.   movl $0, %edx
  2288.   movq %rcx, %rsi
  2289.   movq %rax, %rdi
  2290.   call __gnu_cxx::new_allocator<int>::allocate(unsigned long, void const*)
  2291.   leave
  2292.   ret
  2293. std::move_iterator<int*> std::__make_move_if_noexcept_iterator<int, std::move_iterator<int*> >(int*):
  2294.   pushq %rbp
  2295.   movq %rsp, %rbp
  2296.   subq $32, %rsp
  2297.   movq %rdi, -24(%rbp)
  2298.   movq -24(%rbp), %rdx
  2299.   leaq -8(%rbp), %rax
  2300.   movq %rdx, %rsi
  2301.   movq %rax, %rdi
  2302.   call std::move_iterator<int*>::move_iterator(int*)
  2303.   movq -8(%rbp), %rax
  2304.   leave
  2305.   ret
  2306. int* std::__uninitialized_copy_a<std::move_iterator<int*>, int*, int>(std::move_iterator<int*>, std::move_iterator<int*>, int*, std::allocator<int>&):
  2307.   pushq %rbp
  2308.   movq %rsp, %rbp
  2309.   subq $32, %rsp
  2310.   movq %rdi, -8(%rbp)
  2311.   movq %rsi, -16(%rbp)
  2312.   movq %rdx, -24(%rbp)
  2313.   movq %rcx, -32(%rbp)
  2314.   movq -24(%rbp), %rdx
  2315.   movq -16(%rbp), %rcx
  2316.   movq -8(%rbp), %rax
  2317.   movq %rcx, %rsi
  2318.   movq %rax, %rdi
  2319.   call int* std::uninitialized_copy<std::move_iterator<int*>, int*>(std::move_iterator<int*>, std::move_iterator<int*>, int*)
  2320.   leave
  2321.   ret
  2322. unsigned long std::__detail::__mod<unsigned long, 2147483647ul, 16807ul, 0ul>(unsigned long):
  2323.   pushq %rbp
  2324.   movq %rsp, %rbp
  2325.   subq $16, %rsp
  2326.   movq %rdi, -8(%rbp)
  2327.   movq -8(%rbp), %rax
  2328.   movq %rax, %rdi
  2329.   call std::__detail::_Mod<unsigned long, 2147483647ul, 16807ul, 0ul, true, true>::__calc(unsigned long)
  2330.   leave
  2331.   ret
  2332. void __gnu_cxx::new_allocator<int>::construct<int, int>(int*, int&&):
  2333.   pushq %rbp
  2334.   movq %rsp, %rbp
  2335.   pushq %rbx
  2336.   subq $40, %rsp
  2337.   movq %rdi, -24(%rbp)
  2338.   movq %rsi, -32(%rbp)
  2339.   movq %rdx, -40(%rbp)
  2340.   movq -40(%rbp), %rax
  2341.   movq %rax, %rdi
  2342.   call int&& std::forward<int>(std::remove_reference<int>::type&)
  2343.   movl (%rax), %ebx
  2344.   movq -32(%rbp), %rax
  2345.   movq %rax, %rsi
  2346.   movl $4, %edi
  2347.   call operator new(unsigned long, void*)
  2348.   testq %rax, %rax
  2349.   je .L227
  2350.   movl %ebx, (%rax)
  2351. .L227:
  2352.   nop
  2353.   addq $40, %rsp
  2354.   popq %rbx
  2355.   popq %rbp
  2356.   ret
  2357. void __gnu_cxx::new_allocator<int>::destroy<int>(int*):
  2358.   pushq %rbp
  2359.   movq %rsp, %rbp
  2360.   movq %rdi, -8(%rbp)
  2361.   movq %rsi, -16(%rbp)
  2362.   nop
  2363.   popq %rbp
  2364.   ret
  2365. void std::__partial_sort<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__ops::_Iter_less_iter>(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__ops::_Iter_less_iter):
  2366.   pushq %rbp
  2367.   movq %rsp, %rbp
  2368.   subq $32, %rsp
  2369.   movq %rdi, -8(%rbp)
  2370.   movq %rsi, -16(%rbp)
  2371.   movq %rdx, -24(%rbp)
  2372.   movq -24(%rbp), %rdx
  2373.   movq -16(%rbp), %rcx
  2374.   movq -8(%rbp), %rax
  2375.   subq $8, %rsp
  2376.   pushq %r8
  2377.   movq %rcx, %rsi
  2378.   movq %rax, %rdi
  2379.   call void std::__heap_select<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__ops::_Iter_less_iter>(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__ops::_Iter_less_iter)
  2380.   addq $16, %rsp
  2381.   movq -16(%rbp), %rcx
  2382.   movq -8(%rbp), %rax
  2383.   leaq 16(%rbp), %rdx
  2384.   movq %rcx, %rsi
  2385.   movq %rax, %rdi
  2386.   call void std::__sort_heap<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__ops::_Iter_less_iter>(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__ops::_Iter_less_iter&)
  2387.   nop
  2388.   leave
  2389.   ret
  2390. __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > > std::__unguarded_partition_pivot<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__ops::_Iter_less_iter>(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__ops::_Iter_less_iter):
  2391.   pushq %rbp
  2392.   movq %rsp, %rbp
  2393.   pushq %r13
  2394.   pushq %r12
  2395.   pushq %rbx
  2396.   subq $40, %rsp
  2397.   movq %rdi, -56(%rbp)
  2398.   movq %rsi, -64(%rbp)
  2399.   leaq -56(%rbp), %rdx
  2400.   leaq -64(%rbp), %rax
  2401.   movq %rdx, %rsi
  2402.   movq %rax, %rdi
  2403.   call __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >::difference_type __gnu_cxx::operator-<int*, std::vector<int, std::allocator<int> > >(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > > const&, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > > const&)
  2404.   movq %rax, %rdx
  2405.   shrq $63, %rdx
  2406.   addq %rdx, %rax
  2407.   sarq %rax
  2408.   movq %rax, %rdx
  2409.   leaq -56(%rbp), %rax
  2410.   movq %rdx, %rsi
  2411.   movq %rax, %rdi
  2412.   call __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >::operator+(long) const
  2413.   movq %rax, -40(%rbp)
  2414.   leaq -64(%rbp), %rax
  2415.   movl $1, %esi
  2416.   movq %rax, %rdi
  2417.   call __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >::operator-(long) const
  2418.   movq %rax, %rbx
  2419.   leaq -56(%rbp), %rax
  2420.   movl $1, %esi
  2421.   movq %rax, %rdi
  2422.   call __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >::operator+(long) const
  2423.   movq %rax, %rsi
  2424.   movq -40(%rbp), %rdx
  2425.   movq -56(%rbp), %rax
  2426.   subq $8, %rsp
  2427.   pushq %r13
  2428.   movq %rbx, %rcx
  2429.   movq %rax, %rdi
  2430.   call void std::__move_median_to_first<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__ops::_Iter_less_iter>(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__ops::_Iter_less_iter)
  2431.   addq $16, %rsp
  2432.   leaq -56(%rbp), %rax
  2433.   movl $1, %esi
  2434.   movq %rax, %rdi
  2435.   call __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >::operator+(long) const
  2436.   movq %rax, %rcx
  2437.   movq -56(%rbp), %rdx
  2438.   movq -64(%rbp), %rax
  2439.   subq $8, %rsp
  2440.   pushq %r12
  2441.   movq %rax, %rsi
  2442.   movq %rcx, %rdi
  2443.   call __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > > std::__unguarded_partition<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__ops::_Iter_less_iter>(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__ops::_Iter_less_iter)
  2444.   addq $16, %rsp
  2445.   leaq -24(%rbp), %rsp
  2446.   popq %rbx
  2447.   popq %r12
  2448.   popq %r13
  2449.   popq %rbp
  2450.   ret
  2451. __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >::operator+(long) const:
  2452.   pushq %rbp
  2453.   movq %rsp, %rbp
  2454.   subq $32, %rsp
  2455.   movq %rdi, -24(%rbp)
  2456.   movq %rsi, -32(%rbp)
  2457.   movq -24(%rbp), %rax
  2458.   movq (%rax), %rax
  2459.   movq -32(%rbp), %rdx
  2460.   salq $2, %rdx
  2461.   addq %rdx, %rax
  2462.   movq %rax, -8(%rbp)
  2463.   leaq -8(%rbp), %rdx
  2464.   leaq -16(%rbp), %rax
  2465.   movq %rdx, %rsi
  2466.   movq %rax, %rdi
  2467.   call __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >::__normal_iterator(int* const&)
  2468.   movq -16(%rbp), %rax
  2469.   leave
  2470.   ret
  2471. void std::__insertion_sort<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__ops::_Iter_less_iter>(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__ops::_Iter_less_iter):
  2472.   pushq %rbp
  2473.   movq %rsp, %rbp
  2474.   pushq %r13
  2475.   pushq %r12
  2476.   pushq %rbx
  2477.   subq $56, %rsp
  2478.   movq %rdi, -72(%rbp)
  2479.   movq %rsi, -80(%rbp)
  2480.   leaq -80(%rbp), %rdx
  2481.   leaq -72(%rbp), %rax
  2482.   movq %rdx, %rsi
  2483.   movq %rax, %rdi
  2484.   call bool __gnu_cxx::operator==<int*, std::vector<int, std::allocator<int> > >(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > > const&, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > > const&)
  2485.   testb %al, %al
  2486.   jne .L241
  2487.   leaq -72(%rbp), %rax
  2488.   movl $1, %esi
  2489.   movq %rax, %rdi
  2490.   call __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >::operator+(long) const
  2491.   movq %rax, -48(%rbp)
  2492. .L240:
  2493.   leaq -80(%rbp), %rdx
  2494.   leaq -48(%rbp), %rax
  2495.   movq %rdx, %rsi
  2496.   movq %rax, %rdi
  2497.   call bool __gnu_cxx::operator!=<int*, std::vector<int, std::allocator<int> > >(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > > const&, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > > const&)
  2498.   testb %al, %al
  2499.   je .L234
  2500.   movq -72(%rbp), %rdx
  2501.   movq -48(%rbp), %rax
  2502.   movq %rax, %rsi
  2503.   leaq 16(%rbp), %rdi
  2504.   call bool __gnu_cxx::__ops::_Iter_less_iter::operator()<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > > >(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >) const
  2505.   testb %al, %al
  2506.   je .L238
  2507.   leaq -48(%rbp), %rax
  2508.   movq %rax, %rdi
  2509.   call __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >::operator*() const
  2510.   movq %rax, %rdi
  2511.   call std::remove_reference<int&>::type&& std::move<int&>(int&)
  2512.   movl (%rax), %eax
  2513.   movl %eax, -52(%rbp)
  2514.   leaq -48(%rbp), %rax
  2515.   movl $1, %esi
  2516.   movq %rax, %rdi
  2517.   call __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >::operator+(long) const
  2518.   movq %rax, %rdx
  2519.   movq -48(%rbp), %rcx
  2520.   movq -72(%rbp), %rax
  2521.   movq %rcx, %rsi
  2522.   movq %rax, %rdi
  2523.   call __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > > std::move_backward<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > > >(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >)
  2524.   leaq -52(%rbp), %rax
  2525.   movq %rax, %rdi
  2526.   call std::remove_reference<int&>::type&& std::move<int&>(int&)
  2527.   movq %rax, %rbx
  2528.   leaq -72(%rbp), %rax
  2529.   movq %rax, %rdi
  2530.   call __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >::operator*() const
  2531.   movq %rax, %rdx
  2532.   movl (%rbx), %eax
  2533.   movl %eax, (%rdx)
  2534.   jmp .L239
  2535. .L238:
  2536.   subq $8, %rsp
  2537.   pushq %r13
  2538.   call __gnu_cxx::__ops::__val_comp_iter(__gnu_cxx::__ops::_Iter_less_iter)
  2539.   addq $16, %rsp
  2540.   movq -48(%rbp), %rax
  2541.   subq $8, %rsp
  2542.   pushq %r12
  2543.   movq %rax, %rdi
  2544.   call void std::__unguarded_linear_insert<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__ops::_Val_less_iter>(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__ops::_Val_less_iter)
  2545.   addq $16, %rsp
  2546. .L239:
  2547.   leaq -48(%rbp), %rax
  2548.   movq %rax, %rdi
  2549.   call __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >::operator++()
  2550.   jmp .L240
  2551. .L241:
  2552.   nop
  2553. .L234:
  2554.   leaq -24(%rbp), %rsp
  2555.   popq %rbx
  2556.   popq %r12
  2557.   popq %r13
  2558.   popq %rbp
  2559.   ret
  2560. void std::__unguarded_insertion_sort<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__ops::_Iter_less_iter>(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__ops::_Iter_less_iter):
  2561.   pushq %rbp
  2562.   movq %rsp, %rbp
  2563.   pushq %r12
  2564.   pushq %rbx
  2565.   subq $32, %rsp
  2566.   movq %rdi, -40(%rbp)
  2567.   movq %rsi, -48(%rbp)
  2568.   movq -40(%rbp), %rax
  2569.   movq %rax, -32(%rbp)
  2570. .L244:
  2571.   leaq -48(%rbp), %rdx
  2572.   leaq -32(%rbp), %rax
  2573.   movq %rdx, %rsi
  2574.   movq %rax, %rdi
  2575.   call bool __gnu_cxx::operator!=<int*, std::vector<int, std::allocator<int> > >(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > > const&, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > > const&)
  2576.   testb %al, %al
  2577.   je .L245
  2578.   subq $8, %rsp
  2579.   pushq %r12
  2580.   call __gnu_cxx::__ops::__val_comp_iter(__gnu_cxx::__ops::_Iter_less_iter)
  2581.   addq $16, %rsp
  2582.   movq -32(%rbp), %rax
  2583.   subq $8, %rsp
  2584.   pushq %rbx
  2585.   movq %rax, %rdi
  2586.   call void std::__unguarded_linear_insert<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__ops::_Val_less_iter>(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__ops::_Val_less_iter)
  2587.   addq $16, %rsp
  2588.   leaq -32(%rbp), %rax
  2589.   movq %rax, %rdi
  2590.   call __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >::operator++()
  2591.   jmp .L244
  2592. .L245:
  2593.   nop
  2594.   leaq -16(%rbp), %rsp
  2595.   popq %rbx
  2596.   popq %r12
  2597.   popq %rbp
  2598.   ret
  2599. __gnu_cxx::new_allocator<int>::new_allocator():
  2600.   pushq %rbp
  2601.   movq %rsp, %rbp
  2602.   movq %rdi, -8(%rbp)
  2603.   nop
  2604.   popq %rbp
  2605.   ret
  2606. __gnu_cxx::new_allocator<int>::deallocate(int*, unsigned long):
  2607.   pushq %rbp
  2608.   movq %rsp, %rbp
  2609.   subq $32, %rsp
  2610.   movq %rdi, -8(%rbp)
  2611.   movq %rsi, -16(%rbp)
  2612.   movq %rdx, -24(%rbp)
  2613.   movq -16(%rbp), %rax
  2614.   movq %rax, %rdi
  2615.   call operator delete(void*)
  2616.   nop
  2617.   leave
  2618.   ret
  2619. int* std::__uninitialized_default_n_1<true>::__uninit_default_n<int*, unsigned long>(int*, unsigned long):
  2620.   pushq %rbp
  2621.   movq %rsp, %rbp
  2622.   subq $32, %rsp
  2623.   movq %rdi, -24(%rbp)
  2624.   movq %rsi, -32(%rbp)
  2625.   movl $0, -4(%rbp)
  2626.   leaq -4(%rbp), %rdx
  2627.   movq -32(%rbp), %rcx
  2628.   movq -24(%rbp), %rax
  2629.   movq %rcx, %rsi
  2630.   movq %rax, %rdi
  2631.   call int* std::fill_n<int*, unsigned long, int>(int*, unsigned long, int const&)
  2632.   leave
  2633.   ret
  2634. std::allocator_traits<std::allocator<int> >::max_size(std::allocator<int> const&):
  2635.   pushq %rbp
  2636.   movq %rsp, %rbp
  2637.   subq $16, %rsp
  2638.   movq %rdi, -8(%rbp)
  2639.   movq -8(%rbp), %rax
  2640.   movq %rax, %rdi
  2641.   call __gnu_cxx::new_allocator<int>::max_size() const
  2642.   leave
  2643.   ret
  2644. std::_Vector_base<int, std::allocator<int> >::_M_get_Tp_allocator() const:
  2645.   pushq %rbp
  2646.   movq %rsp, %rbp
  2647.   movq %rdi, -8(%rbp)
  2648.   movq -8(%rbp), %rax
  2649.   popq %rbp
  2650.   ret
  2651. __gnu_cxx::new_allocator<int>::allocate(unsigned long, void const*):
  2652.   pushq %rbp
  2653.   movq %rsp, %rbp
  2654.   subq $32, %rsp
  2655.   movq %rdi, -8(%rbp)
  2656.   movq %rsi, -16(%rbp)
  2657.   movq %rdx, -24(%rbp)
  2658.   movq -8(%rbp), %rax
  2659.   movq %rax, %rdi
  2660.   call __gnu_cxx::new_allocator<int>::max_size() const
  2661.   cmpq %rax, -16(%rbp)
  2662.   seta %al
  2663.   testb %al, %al
  2664.   je .L255
  2665.   call std::__throw_bad_alloc()
  2666. .L255:
  2667.   movq -16(%rbp), %rax
  2668.   salq $2, %rax
  2669.   movq %rax, %rdi
  2670.   call operator new(unsigned long)
  2671.   leave
  2672.   ret
  2673. std::move_iterator<int*>::move_iterator(int*):
  2674.   pushq %rbp
  2675.   movq %rsp, %rbp
  2676.   movq %rdi, -8(%rbp)
  2677.   movq %rsi, -16(%rbp)
  2678.   movq -8(%rbp), %rax
  2679.   movq -16(%rbp), %rdx
  2680.   movq %rdx, (%rax)
  2681.   nop
  2682.   popq %rbp
  2683.   ret
  2684. int* std::uninitialized_copy<std::move_iterator<int*>, int*>(std::move_iterator<int*>, std::move_iterator<int*>, int*):
  2685.   pushq %rbp
  2686.   movq %rsp, %rbp
  2687.   subq $48, %rsp
  2688.   movq %rdi, -24(%rbp)
  2689.   movq %rsi, -32(%rbp)
  2690.   movq %rdx, -40(%rbp)
  2691.   movb $1, -1(%rbp)
  2692.   movq -40(%rbp), %rdx
  2693.   movq -32(%rbp), %rcx
  2694.   movq -24(%rbp), %rax
  2695.   movq %rcx, %rsi
  2696.   movq %rax, %rdi
  2697.   call int* std::__uninitialized_copy<true>::__uninit_copy<std::move_iterator<int*>, int*>(std::move_iterator<int*>, std::move_iterator<int*>, int*)
  2698.   leave
  2699.   ret
  2700. std::__detail::_Mod<unsigned long, 2147483647ul, 16807ul, 0ul, true, true>::__calc(unsigned long):
  2701.   pushq %rbp
  2702.   movq %rsp, %rbp
  2703.   movq %rdi, -24(%rbp)
  2704.   movq -24(%rbp), %rax
  2705.   imulq $16807, %rax, %rax
  2706.   movq %rax, -8(%rbp)
  2707.   movq -8(%rbp), %rcx
  2708.   movabsq $8589934597, %rdx
  2709.   movq %rcx, %rax
  2710.   mulq %rdx
  2711.   movq %rcx, %rax
  2712.   subq %rdx, %rax
  2713.   shrq %rax
  2714.   addq %rdx, %rax
  2715.   shrq $30, %rax
  2716.   movq %rax, %rdx
  2717.   movq %rdx, %rax
  2718.   salq $31, %rax
  2719.   subq %rdx, %rax
  2720.   subq %rax, %rcx
  2721.   movq %rcx, %rax
  2722.   movq %rax, -8(%rbp)
  2723.   movq -8(%rbp), %rax
  2724.   popq %rbp
  2725.   ret
  2726. void std::__heap_select<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__ops::_Iter_less_iter>(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__ops::_Iter_less_iter):
  2727.   pushq %rbp
  2728.   movq %rsp, %rbp
  2729.   subq $48, %rsp
  2730.   movq %rdi, -24(%rbp)
  2731.   movq %rsi, -32(%rbp)
  2732.   movq %rdx, -40(%rbp)
  2733.   movq -32(%rbp), %rcx
  2734.   movq -24(%rbp), %rax
  2735.   leaq 16(%rbp), %rdx
  2736.   movq %rcx, %rsi
  2737.   movq %rax, %rdi
  2738.   call void std::__make_heap<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__ops::_Iter_less_iter>(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__ops::_Iter_less_iter&)
  2739.   movq -32(%rbp), %rax
  2740.   movq %rax, -8(%rbp)
  2741. .L265:
  2742.   leaq -40(%rbp), %rdx
  2743.   leaq -8(%rbp), %rax
  2744.   movq %rdx, %rsi
  2745.   movq %rax, %rdi
  2746.   call bool __gnu_cxx::operator< <int*, std::vector<int, std::allocator<int> > >(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > > const&, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > > const&)
  2747.   testb %al, %al
  2748.   je .L266
  2749.   movq -24(%rbp), %rdx
  2750.   movq -8(%rbp), %rax
  2751.   movq %rax, %rsi
  2752.   leaq 16(%rbp), %rdi
  2753.   call bool __gnu_cxx::__ops::_Iter_less_iter::operator()<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > > >(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >) const
  2754.   testb %al, %al
  2755.   je .L264
  2756.   movq -8(%rbp), %rdx
  2757.   movq -32(%rbp), %rsi
  2758.   movq -24(%rbp), %rax
  2759.   leaq 16(%rbp), %rcx
  2760.   movq %rax, %rdi
  2761.   call void std::__pop_heap<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__ops::_Iter_less_iter>(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__ops::_Iter_less_iter&)
  2762. .L264:
  2763.   leaq -8(%rbp), %rax
  2764.   movq %rax, %rdi
  2765.   call __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >::operator++()
  2766.   jmp .L265
  2767. .L266:
  2768.   nop
  2769.   leave
  2770.   ret
  2771. void std::__sort_heap<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__ops::_Iter_less_iter>(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__ops::_Iter_less_iter&):
  2772.   pushq %rbp
  2773.   movq %rsp, %rbp
  2774.   subq $32, %rsp
  2775.   movq %rdi, -8(%rbp)
  2776.   movq %rsi, -16(%rbp)
  2777.   movq %rdx, -24(%rbp)
  2778. .L269:
  2779.   leaq -8(%rbp), %rdx
  2780.   leaq -16(%rbp), %rax
  2781.   movq %rdx, %rsi
  2782.   movq %rax, %rdi
  2783.   call __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >::difference_type __gnu_cxx::operator-<int*, std::vector<int, std::allocator<int> > >(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > > const&, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > > const&)
  2784.   cmpq $1, %rax
  2785.   setg %al
  2786.   testb %al, %al
  2787.   je .L270
  2788.   leaq -16(%rbp), %rax
  2789.   movq %rax, %rdi
  2790.   call __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >::operator--()
  2791.   movq -24(%rbp), %rcx
  2792.   movq -16(%rbp), %rdx
  2793.   movq -16(%rbp), %rsi
  2794.   movq -8(%rbp), %rax
  2795.   movq %rax, %rdi
  2796.   call void std::__pop_heap<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__ops::_Iter_less_iter>(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__ops::_Iter_less_iter&)
  2797.   jmp .L269
  2798. .L270:
  2799.   nop
  2800.   leave
  2801.   ret
  2802. __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >::operator-(long) const:
  2803.   pushq %rbp
  2804.   movq %rsp, %rbp
  2805.   subq $32, %rsp
  2806.   movq %rdi, -24(%rbp)
  2807.   movq %rsi, -32(%rbp)
  2808.   movq -24(%rbp), %rax
  2809.   movq (%rax), %rax
  2810.   movq -32(%rbp), %rdx
  2811.   salq $2, %rdx
  2812.   negq %rdx
  2813.   addq %rdx, %rax
  2814.   movq %rax, -8(%rbp)
  2815.   leaq -8(%rbp), %rdx
  2816.   leaq -16(%rbp), %rax
  2817.   movq %rdx, %rsi
  2818.   movq %rax, %rdi
  2819.   call __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >::__normal_iterator(int* const&)
  2820.   movq -16(%rbp), %rax
  2821.   leave
  2822.   ret
  2823. bool __gnu_cxx::__ops::_Iter_less_iter::operator()<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > > >(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >) const:
  2824.   pushq %rbp
  2825.   movq %rsp, %rbp
  2826.   pushq %rbx
  2827.   subq $40, %rsp
  2828.   movq %rdi, -24(%rbp)
  2829.   movq %rsi, -32(%rbp)
  2830.   movq %rdx, -40(%rbp)
  2831.   leaq -32(%rbp), %rax
  2832.   movq %rax, %rdi
  2833.   call __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >::operator*() const
  2834.   movl (%rax), %ebx
  2835.   leaq -40(%rbp), %rax
  2836.   movq %rax, %rdi
  2837.   call __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >::operator*() const
  2838.   movl (%rax), %eax
  2839.   cmpl %eax, %ebx
  2840.   setl %al
  2841.   addq $40, %rsp
  2842.   popq %rbx
  2843.   popq %rbp
  2844.   ret
  2845. void std::__move_median_to_first<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__ops::_Iter_less_iter>(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__ops::_Iter_less_iter):
  2846.   pushq %rbp
  2847.   movq %rsp, %rbp
  2848.   subq $32, %rsp
  2849.   movq %rdi, -8(%rbp)
  2850.   movq %rsi, -16(%rbp)
  2851.   movq %rdx, -24(%rbp)
  2852.   movq %rcx, -32(%rbp)
  2853.   movq -24(%rbp), %rdx
  2854.   movq -16(%rbp), %rax
  2855.   movq %rax, %rsi
  2856.   leaq 16(%rbp), %rdi
  2857.   call bool __gnu_cxx::__ops::_Iter_less_iter::operator()<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > > >(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >) const
  2858.   testb %al, %al
  2859.   je .L276
  2860.   movq -32(%rbp), %rdx
  2861.   movq -24(%rbp), %rax
  2862.   movq %rax, %rsi
  2863.   leaq 16(%rbp), %rdi
  2864.   call bool __gnu_cxx::__ops::_Iter_less_iter::operator()<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > > >(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >) const
  2865.   testb %al, %al
  2866.   je .L277
  2867.   movq -24(%rbp), %rdx
  2868.   movq -8(%rbp), %rax
  2869.   movq %rdx, %rsi
  2870.   movq %rax, %rdi
  2871.   call void std::iter_swap<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > > >(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >)
  2872.   jmp .L283
  2873. .L277:
  2874.   movq -32(%rbp), %rdx
  2875.   movq -16(%rbp), %rax
  2876.   movq %rax, %rsi
  2877.   leaq 16(%rbp), %rdi
  2878.   call bool __gnu_cxx::__ops::_Iter_less_iter::operator()<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > > >(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >) const
  2879.   testb %al, %al
  2880.   je .L279
  2881.   movq -32(%rbp), %rdx
  2882.   movq -8(%rbp), %rax
  2883.   movq %rdx, %rsi
  2884.   movq %rax, %rdi
  2885.   call void std::iter_swap<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > > >(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >)
  2886.   jmp .L283
  2887. .L279:
  2888.   movq -16(%rbp), %rdx
  2889.   movq -8(%rbp), %rax
  2890.   movq %rdx, %rsi
  2891.   movq %rax, %rdi
  2892.   call void std::iter_swap<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > > >(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >)
  2893.   jmp .L283
  2894. .L276:
  2895.   movq -32(%rbp), %rdx
  2896.   movq -16(%rbp), %rax
  2897.   movq %rax, %rsi
  2898.   leaq 16(%rbp), %rdi
  2899.   call bool __gnu_cxx::__ops::_Iter_less_iter::operator()<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > > >(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >) const
  2900.   testb %al, %al
  2901.   je .L281
  2902.   movq -16(%rbp), %rdx
  2903.   movq -8(%rbp), %rax
  2904.   movq %rdx, %rsi
  2905.   movq %rax, %rdi
  2906.   call void std::iter_swap<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > > >(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >)
  2907.   jmp .L283
  2908. .L281:
  2909.   movq -32(%rbp), %rdx
  2910.   movq -24(%rbp), %rax
  2911.   movq %rax, %rsi
  2912.   leaq 16(%rbp), %rdi
  2913.   call bool __gnu_cxx::__ops::_Iter_less_iter::operator()<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > > >(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >) const
  2914.   testb %al, %al
  2915.   je .L282
  2916.   movq -32(%rbp), %rdx
  2917.   movq -8(%rbp), %rax
  2918.   movq %rdx, %rsi
  2919.   movq %rax, %rdi
  2920.   call void std::iter_swap<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > > >(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >)
  2921.   jmp .L283
  2922. .L282:
  2923.   movq -24(%rbp), %rdx
  2924.   movq -8(%rbp), %rax
  2925.   movq %rdx, %rsi
  2926.   movq %rax, %rdi
  2927.   call void std::iter_swap<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > > >(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >)
  2928. .L283:
  2929.   nop
  2930.   leave
  2931.   ret
  2932. __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > > std::__unguarded_partition<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__ops::_Iter_less_iter>(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__ops::_Iter_less_iter):
  2933.   pushq %rbp
  2934.   movq %rsp, %rbp
  2935.   subq $32, %rsp
  2936.   movq %rdi, -8(%rbp)
  2937.   movq %rsi, -16(%rbp)
  2938.   movq %rdx, -24(%rbp)
  2939. .L286:
  2940.   movq -24(%rbp), %rdx
  2941.   movq -8(%rbp), %rax
  2942.   movq %rax, %rsi
  2943.   leaq 16(%rbp), %rdi
  2944.   call bool __gnu_cxx::__ops::_Iter_less_iter::operator()<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > > >(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >) const
  2945.   testb %al, %al
  2946.   je .L285
  2947.   leaq -8(%rbp), %rax
  2948.   movq %rax, %rdi
  2949.   call __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >::operator++()
  2950.   jmp .L286
  2951. .L285:
  2952.   leaq -16(%rbp), %rax
  2953.   movq %rax, %rdi
  2954.   call __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >::operator--()
  2955. .L288:
  2956.   movq -16(%rbp), %rdx
  2957.   movq -24(%rbp), %rax
  2958.   movq %rax, %rsi
  2959.   leaq 16(%rbp), %rdi
  2960.   call bool __gnu_cxx::__ops::_Iter_less_iter::operator()<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > > >(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >) const
  2961.   testb %al, %al
  2962.   je .L287
  2963.   leaq -16(%rbp), %rax
  2964.   movq %rax, %rdi
  2965.   call __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >::operator--()
  2966.   jmp .L288
  2967. .L287:
  2968.   leaq -16(%rbp), %rdx
  2969.   leaq -8(%rbp), %rax
  2970.   movq %rdx, %rsi
  2971.   movq %rax, %rdi
  2972.   call bool __gnu_cxx::operator< <int*, std::vector<int, std::allocator<int> > >(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > > const&, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > > const&)
  2973.   xorl $1, %eax
  2974.   testb %al, %al
  2975.   je .L289
  2976.   movq -8(%rbp), %rax
  2977.   jmp .L291
  2978. .L289:
  2979.   movq -16(%rbp), %rdx
  2980.   movq -8(%rbp), %rax
  2981.   movq %rdx, %rsi
  2982.   movq %rax, %rdi
  2983.   call void std::iter_swap<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > > >(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >)
  2984.   leaq -8(%rbp), %rax
  2985.   movq %rax, %rdi
  2986.   call __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >::operator++()
  2987.   jmp .L286
  2988. .L291:
  2989.   leave
  2990.   ret
  2991. bool __gnu_cxx::operator==<int*, std::vector<int, std::allocator<int> > >(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > > const&, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > > const&):
  2992.   pushq %rbp
  2993.   movq %rsp, %rbp
  2994.   pushq %rbx
  2995.   subq $24, %rsp
  2996.   movq %rdi, -24(%rbp)
  2997.   movq %rsi, -32(%rbp)
  2998.   movq -24(%rbp), %rax
  2999.   movq %rax, %rdi
  3000.   call __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >::base() const
  3001.   movq (%rax), %rbx
  3002.   movq -32(%rbp), %rax
  3003.   movq %rax, %rdi
  3004.   call __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >::base() const
  3005.   movq (%rax), %rax
  3006.   cmpq %rax, %rbx
  3007.   sete %al
  3008.   addq $24, %rsp
  3009.   popq %rbx
  3010.   popq %rbp
  3011.   ret
  3012. __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >::operator++():
  3013.   pushq %rbp
  3014.   movq %rsp, %rbp
  3015.   movq %rdi, -8(%rbp)
  3016.   movq -8(%rbp), %rax
  3017.   movq (%rax), %rax
  3018.   leaq 4(%rax), %rdx
  3019.   movq -8(%rbp), %rax
  3020.   movq %rdx, (%rax)
  3021.   movq -8(%rbp), %rax
  3022.   popq %rbp
  3023.   ret
  3024. __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >::operator*() const:
  3025.   pushq %rbp
  3026.   movq %rsp, %rbp
  3027.   movq %rdi, -8(%rbp)
  3028.   movq -8(%rbp), %rax
  3029.   movq (%rax), %rax
  3030.   popq %rbp
  3031.   ret
  3032. __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > > std::move_backward<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > > >(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >):
  3033.   pushq %rbp
  3034.   movq %rsp, %rbp
  3035.   pushq %rbx
  3036.   subq $40, %rsp
  3037.   movq %rdi, -24(%rbp)
  3038.   movq %rsi, -32(%rbp)
  3039.   movq %rdx, -40(%rbp)
  3040.   movq -32(%rbp), %rax
  3041.   movq %rax, %rdi
  3042.   call __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > > std::__miter_base<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > > >(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >)
  3043.   movq %rax, %rbx
  3044.   movq -24(%rbp), %rax
  3045.   movq %rax, %rdi
  3046.   call __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > > std::__miter_base<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > > >(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >)
  3047.   movq %rax, %rcx
  3048.   movq -40(%rbp), %rax
  3049.   movq %rax, %rdx
  3050.   movq %rbx, %rsi
  3051.   movq %rcx, %rdi
  3052.   call __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > > std::__copy_move_backward_a2<true, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > > >(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >)
  3053.   addq $40, %rsp
  3054.   popq %rbx
  3055.   popq %rbp
  3056.   ret
  3057. void std::__unguarded_linear_insert<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__ops::_Val_less_iter>(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__ops::_Val_less_iter):
  3058.   pushq %rbp
  3059.   movq %rsp, %rbp
  3060.   pushq %rbx
  3061.   subq $40, %rsp
  3062.   movq %rdi, -40(%rbp)
  3063.   leaq -40(%rbp), %rax
  3064.   movq %rax, %rdi
  3065.   call __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >::operator*() const
  3066.   movq %rax, %rdi
  3067.   call std::remove_reference<int&>::type&& std::move<int&>(int&)
  3068.   movl (%rax), %eax
  3069.   movl %eax, -20(%rbp)
  3070.   movq -40(%rbp), %rax
  3071.   movq %rax, -32(%rbp)
  3072.   leaq -32(%rbp), %rax
  3073.   movq %rax, %rdi
  3074.   call __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >::operator--()
  3075. .L302:
  3076.   movq -32(%rbp), %rdx
  3077.   leaq -20(%rbp), %rax
  3078.   movq %rax, %rsi
  3079.   leaq 16(%rbp), %rdi
  3080.   call bool __gnu_cxx::__ops::_Val_less_iter::operator()<int, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > > >(int&, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >) const
  3081.   testb %al, %al
  3082.   je .L301
  3083.   leaq -32(%rbp), %rax
  3084.   movq %rax, %rdi
  3085.   call __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >::operator*() const
  3086.   movq %rax, %rdi
  3087.   call std::remove_reference<int&>::type&& std::move<int&>(int&)
  3088.   movq %rax, %rbx
  3089.   leaq -40(%rbp), %rax
  3090.   movq %rax, %rdi
  3091.   call __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >::operator*() const
  3092.   movq %rax, %rdx
  3093.   movl (%rbx), %eax
  3094.   movl %eax, (%rdx)
  3095.   movq -32(%rbp), %rax
  3096.   movq %rax, -40(%rbp)
  3097.   leaq -32(%rbp), %rax
  3098.   movq %rax, %rdi
  3099.   call __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >::operator--()
  3100.   jmp .L302
  3101. .L301:
  3102.   leaq -20(%rbp), %rax
  3103.   movq %rax, %rdi
  3104.   call std::remove_reference<int&>::type&& std::move<int&>(int&)
  3105.   movq %rax, %rbx
  3106.   leaq -40(%rbp), %rax
  3107.   movq %rax, %rdi
  3108.   call __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >::operator*() const
  3109.   movq %rax, %rdx
  3110.   movl (%rbx), %eax
  3111.   movl %eax, (%rdx)
  3112.   nop
  3113.   addq $40, %rsp
  3114.   popq %rbx
  3115.   popq %rbp
  3116.   ret
  3117. int* std::fill_n<int*, unsigned long, int>(int*, unsigned long, int const&):
  3118.   pushq %rbp
  3119.   movq %rsp, %rbp
  3120.   subq $32, %rsp
  3121.   movq %rdi, -8(%rbp)
  3122.   movq %rsi, -16(%rbp)
  3123.   movq %rdx, -24(%rbp)
  3124.   movq -8(%rbp), %rax
  3125.   movq %rax, %rdi
  3126.   call int* std::__niter_base<int*>(int*)
  3127.   movq %rax, %rcx
  3128.   movq -24(%rbp), %rdx
  3129.   movq -16(%rbp), %rax
  3130.   movq %rax, %rsi
  3131.   movq %rcx, %rdi
  3132.   call __gnu_cxx::__enable_if<std::__is_scalar<int>::__value, int*>::__type std::__fill_n_a<int*, unsigned long, int>(int*, unsigned long, int const&)
  3133.   leave
  3134.   ret
  3135. __gnu_cxx::new_allocator<int>::max_size() const:
  3136.   pushq %rbp
  3137.   movq %rsp, %rbp
  3138.   movq %rdi, -8(%rbp)
  3139.   movabsq $4611686018427387903, %rax
  3140.   popq %rbp
  3141.   ret
  3142. int* std::__uninitialized_copy<true>::__uninit_copy<std::move_iterator<int*>, int*>(std::move_iterator<int*>, std::move_iterator<int*>, int*):
  3143.   pushq %rbp
  3144.   movq %rsp, %rbp
  3145.   subq $32, %rsp
  3146.   movq %rdi, -8(%rbp)
  3147.   movq %rsi, -16(%rbp)
  3148.   movq %rdx, -24(%rbp)
  3149.   movq -24(%rbp), %rdx
  3150.   movq -16(%rbp), %rcx
  3151.   movq -8(%rbp), %rax
  3152.   movq %rcx, %rsi
  3153.   movq %rax, %rdi
  3154.   call int* std::copy<std::move_iterator<int*>, int*>(std::move_iterator<int*>, std::move_iterator<int*>, int*)
  3155.   leave
  3156.   ret
  3157. void std::__make_heap<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__ops::_Iter_less_iter>(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__ops::_Iter_less_iter&):
  3158.   pushq %rbp
  3159.   movq %rsp, %rbp
  3160.   pushq %rbx
  3161.   subq $72, %rsp
  3162.   movq %rdi, -56(%rbp)
  3163.   movq %rsi, -64(%rbp)
  3164.   movq %rdx, -72(%rbp)
  3165.   leaq -56(%rbp), %rdx
  3166.   leaq -64(%rbp), %rax
  3167.   movq %rdx, %rsi
  3168.   movq %rax, %rdi
  3169.   call __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >::difference_type __gnu_cxx::operator-<int*, std::vector<int, std::allocator<int> > >(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > > const&, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > > const&)
  3170.   cmpq $1, %rax
  3171.   setle %al
  3172.   testb %al, %al
  3173.   jne .L314
  3174.   leaq -56(%rbp), %rdx
  3175.   leaq -64(%rbp), %rax
  3176.   movq %rdx, %rsi
  3177.   movq %rax, %rdi
  3178.   call __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >::difference_type __gnu_cxx::operator-<int*, std::vector<int, std::allocator<int> > >(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > > const&, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > > const&)
  3179.   movq %rax, -32(%rbp)
  3180.   movq -32(%rbp), %rax
  3181.   subq $2, %rax
  3182.   movq %rax, %rdx
  3183.   shrq $63, %rdx
  3184.   addq %rdx, %rax
  3185.   sarq %rax
  3186.   movq %rax, -24(%rbp)
  3187. .L313:
  3188.   movq -24(%rbp), %rdx
  3189.   leaq -56(%rbp), %rax
  3190.   movq %rdx, %rsi
  3191.   movq %rax, %rdi
  3192.   call __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >::operator+(long) const
  3193.   movq %rax, -40(%rbp)
  3194.   leaq -40(%rbp), %rax
  3195.   movq %rax, %rdi
  3196.   call __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >::operator*() const
  3197.   movq %rax, %rdi
  3198.   call std::remove_reference<int&>::type&& std::move<int&>(int&)
  3199.   movl (%rax), %eax
  3200.   movl %eax, -44(%rbp)
  3201.   leaq -44(%rbp), %rax
  3202.   movq %rax, %rdi
  3203.   call std::remove_reference<int&>::type&& std::move<int&>(int&)
  3204.   movl (%rax), %ecx
  3205.   movq -32(%rbp), %rdx
  3206.   movq -24(%rbp), %rsi
  3207.   movq -56(%rbp), %rax
  3208.   subq $8, %rsp
  3209.   pushq %rbx
  3210.   movq %rax, %rdi
  3211.   call void std::__adjust_heap<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, long, int, __gnu_cxx::__ops::_Iter_less_iter>(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, long, long, int, __gnu_cxx::__ops::_Iter_less_iter)
  3212.   addq $16, %rsp
  3213.   cmpq $0, -24(%rbp)
  3214.   je .L315
  3215.   subq $1, -24(%rbp)
  3216.   jmp .L313
  3217. .L314:
  3218.   nop
  3219.   jmp .L309
  3220. .L315:
  3221.   nop
  3222. .L309:
  3223.   movq -8(%rbp), %rbx
  3224.   leave
  3225.   ret
  3226. bool __gnu_cxx::operator< <int*, std::vector<int, std::allocator<int> > >(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > > const&, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > > const&):
  3227.   pushq %rbp
  3228.   movq %rsp, %rbp
  3229.   pushq %rbx
  3230.   subq $24, %rsp
  3231.   movq %rdi, -24(%rbp)
  3232.   movq %rsi, -32(%rbp)
  3233.   movq -24(%rbp), %rax
  3234.   movq %rax, %rdi
  3235.   call __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >::base() const
  3236.   movq (%rax), %rbx
  3237.   movq -32(%rbp), %rax
  3238.   movq %rax, %rdi
  3239.   call __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >::base() const
  3240.   movq (%rax), %rax
  3241.   cmpq %rax, %rbx
  3242.   setb %al
  3243.   addq $24, %rsp
  3244.   popq %rbx
  3245.   popq %rbp
  3246.   ret
  3247. void std::__pop_heap<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__ops::_Iter_less_iter>(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__ops::_Iter_less_iter&):
  3248.   pushq %rbp
  3249.   movq %rsp, %rbp
  3250.   pushq %r12
  3251.   pushq %rbx
  3252.   subq $48, %rsp
  3253.   movq %rdi, -40(%rbp)
  3254.   movq %rsi, -48(%rbp)
  3255.   movq %rdx, -56(%rbp)
  3256.   movq %rcx, -64(%rbp)
  3257.   leaq -56(%rbp), %rax
  3258.   movq %rax, %rdi
  3259.   call __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >::operator*() const
  3260.   movq %rax, %rdi
  3261.   call std::remove_reference<int&>::type&& std::move<int&>(int&)
  3262.   movl (%rax), %eax
  3263.   movl %eax, -20(%rbp)
  3264.   leaq -40(%rbp), %rax
  3265.   movq %rax, %rdi
  3266.   call __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >::operator*() const
  3267.   movq %rax, %rdi
  3268.   call std::remove_reference<int&>::type&& std::move<int&>(int&)
  3269.   movq %rax, %rbx
  3270.   leaq -56(%rbp), %rax
  3271.   movq %rax, %rdi
  3272.   call __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >::operator*() const
  3273.   movq %rax, %rdx
  3274.   movl (%rbx), %eax
  3275.   movl %eax, (%rdx)
  3276.   leaq -20(%rbp), %rax
  3277.   movq %rax, %rdi
  3278.   call std::remove_reference<int&>::type&& std::move<int&>(int&)
  3279.   movl (%rax), %ebx
  3280.   leaq -40(%rbp), %rdx
  3281.   leaq -48(%rbp), %rax
  3282.   movq %rdx, %rsi
  3283.   movq %rax, %rdi
  3284.   call __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >::difference_type __gnu_cxx::operator-<int*, std::vector<int, std::allocator<int> > >(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > > const&, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > > const&)
  3285.   movq %rax, %rdx
  3286.   movq -40(%rbp), %rax
  3287.   subq $8, %rsp
  3288.   pushq %r12
  3289.   movl %ebx, %ecx
  3290.   movl $0, %esi
  3291.   movq %rax, %rdi
  3292.   call void std::__adjust_heap<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, long, int, __gnu_cxx::__ops::_Iter_less_iter>(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, long, long, int, __gnu_cxx::__ops::_Iter_less_iter)
  3293.   addq $16, %rsp
  3294.   nop
  3295.   leaq -16(%rbp), %rsp
  3296.   popq %rbx
  3297.   popq %r12
  3298.   popq %rbp
  3299.   ret
  3300. __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >::operator--():
  3301.   pushq %rbp
  3302.   movq %rsp, %rbp
  3303.   movq %rdi, -8(%rbp)
  3304.   movq -8(%rbp), %rax
  3305.   movq (%rax), %rax
  3306.   leaq -4(%rax), %rdx
  3307.   movq -8(%rbp), %rax
  3308.   movq %rdx, (%rax)
  3309.   movq -8(%rbp), %rax
  3310.   popq %rbp
  3311.   ret
  3312. void std::iter_swap<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > > >(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >):
  3313.   pushq %rbp
  3314.   movq %rsp, %rbp
  3315.   pushq %rbx
  3316.   subq $24, %rsp
  3317.   movq %rdi, -24(%rbp)
  3318.   movq %rsi, -32(%rbp)
  3319.   leaq -32(%rbp), %rax
  3320.   movq %rax, %rdi
  3321.   call __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >::operator*() const
  3322.   movq %rax, %rbx
  3323.   leaq -24(%rbp), %rax
  3324.   movq %rax, %rdi
  3325.   call __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >::operator*() const
  3326.   movq %rbx, %rsi
  3327.   movq %rax, %rdi
  3328.   call std::enable_if<std::__and_<std::__not_<std::__is_tuple_like<int> >, std::is_move_constructible<int>, std::is_move_assignable<int> >::value, void>::type std::swap<int>(int&, int&)
  3329.   nop
  3330.   addq $24, %rsp
  3331.   popq %rbx
  3332.   popq %rbp
  3333.   ret
  3334. __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > > std::__miter_base<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > > >(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >):
  3335.   pushq %rbp
  3336.   movq %rsp, %rbp
  3337.   movq %rdi, -8(%rbp)
  3338.   movq -8(%rbp), %rax
  3339.   popq %rbp
  3340.   ret
  3341. __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > > std::__copy_move_backward_a2<true, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > > >(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >):
  3342.   pushq %rbp
  3343.   movq %rsp, %rbp
  3344.   pushq %r12
  3345.   pushq %rbx
  3346.   subq $48, %rsp
  3347.   movq %rdi, -40(%rbp)
  3348.   movq %rsi, -48(%rbp)
  3349.   movq %rdx, -56(%rbp)
  3350.   movq -56(%rbp), %rax
  3351.   movq %rax, %rdi
  3352.   call int* std::__niter_base<int*, std::vector<int, std::allocator<int> > >(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >)
  3353.   movq %rax, %r12
  3354.   movq -48(%rbp), %rax
  3355.   movq %rax, %rdi
  3356.   call int* std::__niter_base<int*, std::vector<int, std::allocator<int> > >(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >)
  3357.   movq %rax, %rbx
  3358.   movq -40(%rbp), %rax
  3359.   movq %rax, %rdi
  3360.   call int* std::__niter_base<int*, std::vector<int, std::allocator<int> > >(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >)
  3361.   movq %r12, %rdx
  3362.   movq %rbx, %rsi
  3363.   movq %rax, %rdi
  3364.   call int* std::__copy_move_backward_a<true, int*, int*>(int*, int*, int*)
  3365.   movq %rax, -24(%rbp)
  3366.   leaq -24(%rbp), %rdx
  3367.   leaq -32(%rbp), %rax
  3368.   movq %rdx, %rsi
  3369.   movq %rax, %rdi
  3370.   call __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >::__normal_iterator(int* const&)
  3371.   movq -32(%rbp), %rax
  3372.   addq $48, %rsp
  3373.   popq %rbx
  3374.   popq %r12
  3375.   popq %rbp
  3376.   ret
  3377. bool __gnu_cxx::__ops::_Val_less_iter::operator()<int, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > > >(int&, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >) const:
  3378.   pushq %rbp
  3379.   movq %rsp, %rbp
  3380.   pushq %rbx
  3381.   subq $40, %rsp
  3382.   movq %rdi, -24(%rbp)
  3383.   movq %rsi, -32(%rbp)
  3384.   movq %rdx, -40(%rbp)
  3385.   movq -32(%rbp), %rax
  3386.   movl (%rax), %ebx
  3387.   leaq -40(%rbp), %rax
  3388.   movq %rax, %rdi
  3389.   call __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >::operator*() const
  3390.   movl (%rax), %eax
  3391.   cmpl %eax, %ebx
  3392.   setl %al
  3393.   addq $40, %rsp
  3394.   popq %rbx
  3395.   popq %rbp
  3396.   ret
  3397. int* std::__niter_base<int*>(int*):
  3398.   pushq %rbp
  3399.   movq %rsp, %rbp
  3400.   movq %rdi, -8(%rbp)
  3401.   movq -8(%rbp), %rax
  3402.   popq %rbp
  3403.   ret
  3404. __gnu_cxx::__enable_if<std::__is_scalar<int>::__value, int*>::__type std::__fill_n_a<int*, unsigned long, int>(int*, unsigned long, int const&):
  3405.   pushq %rbp
  3406.   movq %rsp, %rbp
  3407.   movq %rdi, -24(%rbp)
  3408.   movq %rsi, -32(%rbp)
  3409.   movq %rdx, -40(%rbp)
  3410.   movq -40(%rbp), %rax
  3411.   movl (%rax), %eax
  3412.   movl %eax, -12(%rbp)
  3413.   movq -32(%rbp), %rax
  3414.   movq %rax, -8(%rbp)
  3415. .L332:
  3416.   cmpq $0, -8(%rbp)
  3417.   je .L331
  3418.   movq -24(%rbp), %rax
  3419.   movl -12(%rbp), %edx
  3420.   movl %edx, (%rax)
  3421.   subq $1, -8(%rbp)
  3422.   addq $4, -24(%rbp)
  3423.   jmp .L332
  3424. .L331:
  3425.   movq -24(%rbp), %rax
  3426.   popq %rbp
  3427.   ret
  3428. int* std::copy<std::move_iterator<int*>, int*>(std::move_iterator<int*>, std::move_iterator<int*>, int*):
  3429.   pushq %rbp
  3430.   movq %rsp, %rbp
  3431.   pushq %rbx
  3432.   subq $40, %rsp
  3433.   movq %rdi, -24(%rbp)
  3434.   movq %rsi, -32(%rbp)
  3435.   movq %rdx, -40(%rbp)
  3436.   movq -32(%rbp), %rax
  3437.   movq %rax, %rdi
  3438.   call decltype (__miter_base(({parm#1}.base)())) std::__miter_base<int*>(std::move_iterator<int*>)
  3439.   movq %rax, %rbx
  3440.   movq -24(%rbp), %rax
  3441.   movq %rax, %rdi
  3442.   call decltype (__miter_base(({parm#1}.base)())) std::__miter_base<int*>(std::move_iterator<int*>)
  3443.   movq %rax, %rcx
  3444.   movq -40(%rbp), %rax
  3445.   movq %rax, %rdx
  3446.   movq %rbx, %rsi
  3447.   movq %rcx, %rdi
  3448.   call int* std::__copy_move_a2<true, int*, int*>(int*, int*, int*)
  3449.   addq $40, %rsp
  3450.   popq %rbx
  3451.   popq %rbp
  3452.   ret
  3453. void std::__adjust_heap<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, long, int, __gnu_cxx::__ops::_Iter_less_iter>(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, long, long, int, __gnu_cxx::__ops::_Iter_less_iter):
  3454.   pushq %rbp
  3455.   movq %rsp, %rbp
  3456.   pushq %r12
  3457.   pushq %rbx
  3458.   subq $96, %rsp
  3459.   movq %rdi, -88(%rbp)
  3460.   movq %rsi, -96(%rbp)
  3461.   movq %rdx, -104(%rbp)
  3462.   movl %ecx, -108(%rbp)
  3463.   movq -96(%rbp), %rax
  3464.   movq %rax, -32(%rbp)
  3465.   movq -96(%rbp), %rax
  3466.   movq %rax, -24(%rbp)
  3467. .L339:
  3468.   movq -104(%rbp), %rax
  3469.   subq $1, %rax
  3470.   movq %rax, %rdx
  3471.   shrq $63, %rdx
  3472.   addq %rdx, %rax
  3473.   sarq %rax
  3474.   cmpq %rax, -24(%rbp)
  3475.   jge .L337
  3476.   movq -24(%rbp), %rax
  3477.   addq $1, %rax
  3478.   addq %rax, %rax
  3479.   movq %rax, -24(%rbp)
  3480.   movq -24(%rbp), %rax
  3481.   leaq -1(%rax), %rdx
  3482.   leaq -88(%rbp), %rax
  3483.   movq %rdx, %rsi
  3484.   movq %rax, %rdi
  3485.   call __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >::operator+(long) const
  3486.   movq %rax, %rbx
  3487.   movq -24(%rbp), %rdx
  3488.   leaq -88(%rbp), %rax
  3489.   movq %rdx, %rsi
  3490.   movq %rax, %rdi
  3491.   call __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >::operator+(long) const
  3492.   movq %rbx, %rdx
  3493.   movq %rax, %rsi
  3494.   leaq 16(%rbp), %rdi
  3495.   call bool __gnu_cxx::__ops::_Iter_less_iter::operator()<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > > >(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >) const
  3496.   testb %al, %al
  3497.   je .L338
  3498.   subq $1, -24(%rbp)
  3499. .L338:
  3500.   movq -24(%rbp), %rdx
  3501.   leaq -88(%rbp), %rax
  3502.   movq %rdx, %rsi
  3503.   movq %rax, %rdi
  3504.   call __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >::operator+(long) const
  3505.   movq %rax, -64(%rbp)
  3506.   leaq -64(%rbp), %rax
  3507.   movq %rax, %rdi
  3508.   call __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >::operator*() const
  3509.   movq %rax, %rdi
  3510.   call std::remove_reference<int&>::type&& std::move<int&>(int&)
  3511.   movq %rax, %rbx
  3512.   movq -96(%rbp), %rdx
  3513.   leaq -88(%rbp), %rax
  3514.   movq %rdx, %rsi
  3515.   movq %rax, %rdi
  3516.   call __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >::operator+(long) const
  3517.   movq %rax, -56(%rbp)
  3518.   leaq -56(%rbp), %rax
  3519.   movq %rax, %rdi
  3520.   call __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >::operator*() const
  3521.   movq %rax, %rdx
  3522.   movl (%rbx), %eax
  3523.   movl %eax, (%rdx)
  3524.   movq -24(%rbp), %rax
  3525.   movq %rax, -96(%rbp)
  3526.   jmp .L339
  3527. .L337:
  3528.   movq -104(%rbp), %rax
  3529.   andl $1, %eax
  3530.   testq %rax, %rax
  3531.   jne .L340
  3532.   movq -104(%rbp), %rax
  3533.   subq $2, %rax
  3534.   movq %rax, %rdx
  3535.   shrq $63, %rdx
  3536.   addq %rdx, %rax
  3537.   sarq %rax
  3538.   cmpq %rax, -24(%rbp)
  3539.   jne .L340
  3540.   movq -24(%rbp), %rax
  3541.   addq $1, %rax
  3542.   addq %rax, %rax
  3543.   movq %rax, -24(%rbp)
  3544.   movq -24(%rbp), %rax
  3545.   leaq -1(%rax), %rdx
  3546.   leaq -88(%rbp), %rax
  3547.   movq %rdx, %rsi
  3548.   movq %rax, %rdi
  3549.   call __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >::operator+(long) const
  3550.   movq %rax, -48(%rbp)
  3551.   leaq -48(%rbp), %rax
  3552.   movq %rax, %rdi
  3553.   call __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >::operator*() const
  3554.   movq %rax, %rdi
  3555.   call std::remove_reference<int&>::type&& std::move<int&>(int&)
  3556.   movq %rax, %rbx
  3557.   movq -96(%rbp), %rdx
  3558.   leaq -88(%rbp), %rax
  3559.   movq %rdx, %rsi
  3560.   movq %rax, %rdi
  3561.   call __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >::operator+(long) const
  3562.   movq %rax, -40(%rbp)
  3563.   leaq -40(%rbp), %rax
  3564.   movq %rax, %rdi
  3565.   call __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >::operator*() const
  3566.   movq %rax, %rdx
  3567.   movl (%rbx), %eax
  3568.   movl %eax, (%rdx)
  3569.   movq -24(%rbp), %rax
  3570.   subq $1, %rax
  3571.   movq %rax, -96(%rbp)
  3572. .L340:
  3573.   leaq 16(%rbp), %rdi
  3574.   call std::remove_reference<__gnu_cxx::__ops::_Iter_less_iter&>::type&& std::move<__gnu_cxx::__ops::_Iter_less_iter&>(__gnu_cxx::__ops::_Iter_less_iter&)
  3575.   leaq -65(%rbp), %rax
  3576.   subq $8, %rsp
  3577.   pushq %r12
  3578.   movq %rax, %rdi
  3579.   call __gnu_cxx::__ops::_Iter_less_val::_Iter_less_val(__gnu_cxx::__ops::_Iter_less_iter)
  3580.   addq $16, %rsp
  3581.   leaq -108(%rbp), %rax
  3582.   movq %rax, %rdi
  3583.   call std::remove_reference<int&>::type&& std::move<int&>(int&)
  3584.   movl (%rax), %ecx
  3585.   leaq -65(%rbp), %rdi
  3586.   movq -32(%rbp), %rdx
  3587.   movq -96(%rbp), %rsi
  3588.   movq -88(%rbp), %rax
  3589.   movq %rdi, %r8
  3590.   movq %rax, %rdi
  3591.   call void std::__push_heap<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, long, int, __gnu_cxx::__ops::_Iter_less_val>(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, long, long, int, __gnu_cxx::__ops::_Iter_less_val&)
  3592.   nop
  3593.   leaq -16(%rbp), %rsp
  3594.   popq %rbx
  3595.   popq %r12
  3596.   popq %rbp
  3597.   ret
  3598. int* std::__niter_base<int*, std::vector<int, std::allocator<int> > >(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >):
  3599.   pushq %rbp
  3600.   movq %rsp, %rbp
  3601.   subq $16, %rsp
  3602.   movq %rdi, -8(%rbp)
  3603.   leaq -8(%rbp), %rax
  3604.   movq %rax, %rdi
  3605.   call __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >::base() const
  3606.   movq (%rax), %rax
  3607.   leave
  3608.   ret
  3609. int* std::__copy_move_backward_a<true, int*, int*>(int*, int*, int*):
  3610.   pushq %rbp
  3611.   movq %rsp, %rbp
  3612.   subq $48, %rsp
  3613.   movq %rdi, -24(%rbp)
  3614.   movq %rsi, -32(%rbp)
  3615.   movq %rdx, -40(%rbp)
  3616.   movb $1, -1(%rbp)
  3617.   movq -40(%rbp), %rdx
  3618.   movq -32(%rbp), %rcx
  3619.   movq -24(%rbp), %rax
  3620.   movq %rcx, %rsi
  3621.   movq %rax, %rdi
  3622.   call int* std::__copy_move_backward<true, true, std::random_access_iterator_tag>::__copy_move_b<int>(int const*, int const*, int*)
  3623.   leave
  3624.   ret
  3625. decltype (__miter_base(({parm#1}.base)())) std::__miter_base<int*>(std::move_iterator<int*>):
  3626.   pushq %rbp
  3627.   movq %rsp, %rbp
  3628.   subq $16, %rsp
  3629.   movq %rdi, -8(%rbp)
  3630.   leaq -8(%rbp), %rax
  3631.   movq %rax, %rdi
  3632.   call std::move_iterator<int*>::base() const
  3633.   movq %rax, %rdi
  3634.   call int* std::__miter_base<int*>(int*)
  3635.   leave
  3636.   ret
  3637. int* std::__copy_move_a2<true, int*, int*>(int*, int*, int*):
  3638.   pushq %rbp
  3639.   movq %rsp, %rbp
  3640.   pushq %r12
  3641.   pushq %rbx
  3642.   subq $32, %rsp
  3643.   movq %rdi, -24(%rbp)
  3644.   movq %rsi, -32(%rbp)
  3645.   movq %rdx, -40(%rbp)
  3646.   movq -40(%rbp), %rax
  3647.   movq %rax, %rdi
  3648.   call int* std::__niter_base<int*>(int*)
  3649.   movq %rax, %r12
  3650.   movq -32(%rbp), %rax
  3651.   movq %rax, %rdi
  3652.   call int* std::__niter_base<int*>(int*)
  3653.   movq %rax, %rbx
  3654.   movq -24(%rbp), %rax
  3655.   movq %rax, %rdi
  3656.   call int* std::__niter_base<int*>(int*)
  3657.   movq %r12, %rdx
  3658.   movq %rbx, %rsi
  3659.   movq %rax, %rdi
  3660.   call int* std::__copy_move_a<true, int*, int*>(int*, int*, int*)
  3661.   addq $32, %rsp
  3662.   popq %rbx
  3663.   popq %r12
  3664.   popq %rbp
  3665.   ret
  3666. std::remove_reference<__gnu_cxx::__ops::_Iter_less_iter&>::type&& std::move<__gnu_cxx::__ops::_Iter_less_iter&>(__gnu_cxx::__ops::_Iter_less_iter&):
  3667.   pushq %rbp
  3668.   movq %rsp, %rbp
  3669.   movq %rdi, -8(%rbp)
  3670.   movq -8(%rbp), %rax
  3671.   popq %rbp
  3672.   ret
  3673. void std::__push_heap<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, long, int, __gnu_cxx::__ops::_Iter_less_val>(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, long, long, int, __gnu_cxx::__ops::_Iter_less_val&):
  3674.   pushq %rbp
  3675.   movq %rsp, %rbp
  3676.   pushq %rbx
  3677.   subq $88, %rsp
  3678.   movq %rdi, -56(%rbp)
  3679.   movq %rsi, -64(%rbp)
  3680.   movq %rdx, -72(%rbp)
  3681.   movl %ecx, -76(%rbp)
  3682.   movq %r8, -88(%rbp)
  3683.   movq -64(%rbp), %rax
  3684.   subq $1, %rax
  3685.   movq %rax, %rdx
  3686.   shrq $63, %rdx
  3687.   addq %rdx, %rax
  3688.   sarq %rax
  3689.   movq %rax, -24(%rbp)
  3690. .L355:
  3691.   movq -64(%rbp), %rax
  3692.   cmpq -72(%rbp), %rax
  3693.   jle .L352
  3694.   movq -24(%rbp), %rdx
  3695.   leaq -56(%rbp), %rax
  3696.   movq %rdx, %rsi
  3697.   movq %rax, %rdi
  3698.   call __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >::operator+(long) const
  3699.   movq %rax, %rcx
  3700.   leaq -76(%rbp), %rdx
  3701.   movq -88(%rbp), %rax
  3702.   movq %rcx, %rsi
  3703.   movq %rax, %rdi
  3704.   call bool __gnu_cxx::__ops::_Iter_less_val::operator()<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, int>(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, int&) const
  3705.   testb %al, %al
  3706.   je .L352
  3707.   movl $1, %eax
  3708.   jmp .L353
  3709. .L352:
  3710.   movl $0, %eax
  3711. .L353:
  3712.   testb %al, %al
  3713.   je .L354
  3714.   movq -24(%rbp), %rdx
  3715.   leaq -56(%rbp), %rax
  3716.   movq %rdx, %rsi
  3717.   movq %rax, %rdi
  3718.   call __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >::operator+(long) const
  3719.   movq %rax, -48(%rbp)
  3720.   leaq -48(%rbp), %rax
  3721.   movq %rax, %rdi
  3722.   call __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >::operator*() const
  3723.   movq %rax, %rdi
  3724.   call std::remove_reference<int&>::type&& std::move<int&>(int&)
  3725.   movq %rax, %rbx
  3726.   movq -64(%rbp), %rdx
  3727.   leaq -56(%rbp), %rax
  3728.   movq %rdx, %rsi
  3729.   movq %rax, %rdi
  3730.   call __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >::operator+(long) const
  3731.   movq %rax, -40(%rbp)
  3732.   leaq -40(%rbp), %rax
  3733.   movq %rax, %rdi
  3734.   call __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >::operator*() const
  3735.   movq %rax, %rdx
  3736.   movl (%rbx), %eax
  3737.   movl %eax, (%rdx)
  3738.   movq -24(%rbp), %rax
  3739.   movq %rax, -64(%rbp)
  3740.   movq -64(%rbp), %rax
  3741.   subq $1, %rax
  3742.   movq %rax, %rdx
  3743.   shrq $63, %rdx
  3744.   addq %rdx, %rax
  3745.   sarq %rax
  3746.   movq %rax, -24(%rbp)
  3747.   jmp .L355
  3748. .L354:
  3749.   leaq -76(%rbp), %rax
  3750.   movq %rax, %rdi
  3751.   call std::remove_reference<int&>::type&& std::move<int&>(int&)
  3752.   movq %rax, %rbx
  3753.   movq -64(%rbp), %rdx
  3754.   leaq -56(%rbp), %rax
  3755.   movq %rdx, %rsi
  3756.   movq %rax, %rdi
  3757.   call __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >::operator+(long) const
  3758.   movq %rax, -32(%rbp)
  3759.   leaq -32(%rbp), %rax
  3760.   movq %rax, %rdi
  3761.   call __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >::operator*() const
  3762.   movq %rax, %rdx
  3763.   movl (%rbx), %eax
  3764.   movl %eax, (%rdx)
  3765.   nop
  3766.   addq $88, %rsp
  3767.   popq %rbx
  3768.   popq %rbp
  3769.   ret
  3770. int* std::__copy_move_backward<true, true, std::random_access_iterator_tag>::__copy_move_b<int>(int const*, int const*, int*):
  3771.   pushq %rbp
  3772.   movq %rsp, %rbp
  3773.   subq $48, %rsp
  3774.   movq %rdi, -24(%rbp)
  3775.   movq %rsi, -32(%rbp)
  3776.   movq %rdx, -40(%rbp)
  3777.   movq -32(%rbp), %rdx
  3778.   movq -24(%rbp), %rax
  3779.   subq %rax, %rdx
  3780.   movq %rdx, %rax
  3781.   sarq $2, %rax
  3782.   movq %rax, -8(%rbp)
  3783.   cmpq $0, -8(%rbp)
  3784.   je .L357
  3785.   movq -8(%rbp), %rax
  3786.   leaq 0(,%rax,4), %rdx
  3787.   movq -8(%rbp), %rax
  3788.   salq $2, %rax
  3789.   negq %rax
  3790.   movq %rax, %rcx
  3791.   movq -40(%rbp), %rax
  3792.   addq %rax, %rcx
  3793.   movq -24(%rbp), %rax
  3794.   movq %rax, %rsi
  3795.   movq %rcx, %rdi
  3796.   call memmove
  3797. .L357:
  3798.   movq -8(%rbp), %rax
  3799.   salq $2, %rax
  3800.   negq %rax
  3801.   movq %rax, %rdx
  3802.   movq -40(%rbp), %rax
  3803.   addq %rdx, %rax
  3804.   leave
  3805.   ret
  3806. std::move_iterator<int*>::base() const:
  3807.   pushq %rbp
  3808.   movq %rsp, %rbp
  3809.   movq %rdi, -8(%rbp)
  3810.   movq -8(%rbp), %rax
  3811.   movq (%rax), %rax
  3812.   popq %rbp
  3813.   ret
  3814. int* std::__miter_base<int*>(int*):
  3815.   pushq %rbp
  3816.   movq %rsp, %rbp
  3817.   movq %rdi, -8(%rbp)
  3818.   movq -8(%rbp), %rax
  3819.   popq %rbp
  3820.   ret
  3821. int* std::__copy_move_a<true, int*, int*>(int*, int*, int*):
  3822.   pushq %rbp
  3823.   movq %rsp, %rbp
  3824.   subq $48, %rsp
  3825.   movq %rdi, -24(%rbp)
  3826.   movq %rsi, -32(%rbp)
  3827.   movq %rdx, -40(%rbp)
  3828.   movb $1, -1(%rbp)
  3829.   movq -40(%rbp), %rdx
  3830.   movq -32(%rbp), %rcx
  3831.   movq -24(%rbp), %rax
  3832.   movq %rcx, %rsi
  3833.   movq %rax, %rdi
  3834.   call int* std::__copy_move<true, true, std::random_access_iterator_tag>::__copy_m<int>(int const*, int const*, int*)
  3835.   leave
  3836.   ret
  3837. bool __gnu_cxx::__ops::_Iter_less_val::operator()<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, int>(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, int&) const:
  3838.   pushq %rbp
  3839.   movq %rsp, %rbp
  3840.   subq $32, %rsp
  3841.   movq %rdi, -8(%rbp)
  3842.   movq %rsi, -16(%rbp)
  3843.   movq %rdx, -24(%rbp)
  3844.   leaq -16(%rbp), %rax
  3845.   movq %rax, %rdi
  3846.   call __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >::operator*() const
  3847.   movl (%rax), %edx
  3848.   movq -24(%rbp), %rax
  3849.   movl (%rax), %eax
  3850.   cmpl %eax, %edx
  3851.   setl %al
  3852.   leave
  3853.   ret
  3854. int* std::__copy_move<true, true, std::random_access_iterator_tag>::__copy_m<int>(int const*, int const*, int*):
  3855.   pushq %rbp
  3856.   movq %rsp, %rbp
  3857.   subq $48, %rsp
  3858.   movq %rdi, -24(%rbp)
  3859.   movq %rsi, -32(%rbp)
  3860.   movq %rdx, -40(%rbp)
  3861.   movq -32(%rbp), %rdx
  3862.   movq -24(%rbp), %rax
  3863.   subq %rax, %rdx
  3864.   movq %rdx, %rax
  3865.   sarq $2, %rax
  3866.   movq %rax, -8(%rbp)
  3867.   cmpq $0, -8(%rbp)
  3868.   je .L368
  3869.   movq -8(%rbp), %rax
  3870.   leaq 0(,%rax,4), %rdx
  3871.   movq -24(%rbp), %rcx
  3872.   movq -40(%rbp), %rax
  3873.   movq %rcx, %rsi
  3874.   movq %rax, %rdi
  3875.   call memmove
  3876. .L368:
  3877.   movq -8(%rbp), %rax
  3878.   leaq 0(,%rax,4), %rdx
  3879.   movq -40(%rbp), %rax
  3880.   addq %rdx, %rax
  3881.   leave
  3882.   ret
  3883. __static_initialization_and_destruction_0(int, int):
  3884.   pushq %rbp
  3885.   movq %rsp, %rbp
  3886.   subq $16, %rsp
  3887.   movl %edi, -4(%rbp)
  3888.   movl %esi, -8(%rbp)
  3889.   cmpl $1, -4(%rbp)
  3890.   jne .L372
  3891.   cmpl $65535, -8(%rbp)
  3892.   jne .L372
  3893.   movl std::__ioinit, %edi
  3894.   call std::ios_base::Init::Init()
  3895.   movl $__dso_handle, %edx
  3896.   movl std::__ioinit, %esi
  3897.   movl std::ios_base::Init::~Init(), %edi
  3898.   call __cxa_atexit
  3899.   movl $counter_vect, %edi
  3900.   call std::vector<int, std::allocator<int> >::vector()
  3901.   movl $__dso_handle, %edx
  3902.   movl $counter_vect, %esi
  3903.   movl std::vector<int, std::allocator<int> >::~vector(), %edi
  3904.   call __cxa_atexit
  3905. .L372:
  3906.   nop
  3907.   leave
  3908.   ret
  3909. _GLOBAL__sub_I__Z11GetTimeMs64v:
  3910.   pushq %rbp
  3911.   movq %rsp, %rbp
  3912.   movl $65535, %esi
  3913.   movl $1, %edi
  3914.   call __static_initialization_and_destruction_0(int, int)
  3915.   popq %rbp
  3916.   ret
  3917. .LC0:
  3918.  .long 0
  3919.  .long 1072693248
  3920. .LC1:
  3921.  .long 0
  3922.  .long 1138753536
  3923. .LC3:
  3924.  .long 0
  3925.  .long 1093567616
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!