#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */
typedef size_t int64_t;

/* Variables and functions */
void sort_forests(const int64_t ntrees, int64_t *forests, int64_t *tree_roots) {
  {
    int64_t _i_, _j_, _p_, _stacki_, _start_, _end_;
    int64_t _startStack_[64];
    int64_t _endStack_[64];
    _startStack_[0] = 0;
    _endStack_[0] = (ntrees);
    _stacki_ = 1;
    while (_stacki_ > 0) {
      _stacki_--;
      _start_ = _startStack_[_stacki_];
      _end_ = _endStack_[_stacki_];
      while (_end_ - _start_ > 2) {
        _p_ = _start_;
        _i_ = _start_ + 1;
        _j_ = _end_ - 1;
        while (_i_ < _j_) {
          for (; _i_ <= _j_ &&
                 (((((tree_roots)[_i_])) > (((tree_roots)[_p_]))
                       ? 1
                       : ((((tree_roots)[_i_])) < (((tree_roots)[_p_]))
                              ? -1
                              : 0))) <= 0;
               _i_++)
            ;
          if (_i_ > _j_) {
            {
              {
                int64_t _sgl_aee_tmp_;
                _sgl_aee_tmp_ = (tree_roots)[(_j_)];
                (tree_roots)[(_j_)] = (tree_roots)[(_p_)];
                (tree_roots)[(_p_)] = _sgl_aee_tmp_;
              };
              {
                int64_t _sgl_aee_tmp_;
                _sgl_aee_tmp_ = (forests)[(_j_)];
                (forests)[(_j_)] = (forests)[(_p_)];
                (forests)[(_p_)] = _sgl_aee_tmp_;
              }
            };
            _i_ = _j_;
          } else {
            for (; _i_ <= _j_ &&
                   (((((tree_roots)[_j_])) > (((tree_roots)[_p_]))
                         ? 1
                         : ((((tree_roots)[_j_])) < (((tree_roots)[_p_]))
                                ? -1
                                : 0))) >= 0;
                 _j_--)
              ;
            if (_i_ > _j_) {
              {
                {
                  int64_t _sgl_aee_tmp_;
                  _sgl_aee_tmp_ = (tree_roots)[(_j_)];
                  (tree_roots)[(_j_)] = (tree_roots)[(_p_)];
                  (tree_roots)[(_p_)] = _sgl_aee_tmp_;
                };
                {
                  int64_t _sgl_aee_tmp_;
                  _sgl_aee_tmp_ = (forests)[(_j_)];
                  (forests)[(_j_)] = (forests)[(_p_)];
                  (forests)[(_p_)] = _sgl_aee_tmp_;
                }
              };
              _i_ = _j_;
            } else if (_i_ < _j_) {
              {
                {
                  int64_t _sgl_aee_tmp_;
                  _sgl_aee_tmp_ = (tree_roots)[(_i_)];
                  (tree_roots)[(_i_)] = (tree_roots)[(_j_)];
                  (tree_roots)[(_j_)] = _sgl_aee_tmp_;
                };
                {
                  int64_t _sgl_aee_tmp_;
                  _sgl_aee_tmp_ = (forests)[(_i_)];
                  (forests)[(_i_)] = (forests)[(_j_)];
                  (forests)[(_j_)] = _sgl_aee_tmp_;
                }
              };
              if (_i_ + 2 < _j_) {
                _i_++;
                _j_--;
              } else if (_i_ + 1 < _j_)
                _i_++;
            }
          }
        }
        if (_i_ - _start_ > 1 && _end_ - _j_ > 1) {
          if (_i_ - _start_ < _end_ - _j_ - 1) {
            _startStack_[_stacki_] = _j_ + 1;
            _endStack_[_stacki_] = _end_;
            _stacki_++;
            _end_ = _i_;
          } else {
            _startStack_[_stacki_] = _start_;
            _endStack_[_stacki_] = _i_;
            _stacki_++;
            _start_ = _j_ + 1;
          }
        } else {
          if (_i_ - _start_ > 1) {
            _end_ = _i_;
          } else {
            _start_ = _j_ + 1;
          }
        }
      }
      if (_end_ - _start_ == 2) {
        if ((((((tree_roots)[_start_])) > (((tree_roots)[_end_ - 1]))
                  ? 1
                  : ((((tree_roots)[_start_])) < (((tree_roots)[_end_ - 1]))
                         ? -1
                         : 0))) > 0) {
          {
            {
              int64_t _sgl_aee_tmp_;
              _sgl_aee_tmp_ = (tree_roots)[(_start_)];
              (tree_roots)[(_start_)] = (tree_roots)[(_end_ - 1)];
              (tree_roots)[(_end_ - 1)] = _sgl_aee_tmp_;
            };
            {
              int64_t _sgl_aee_tmp_;
              _sgl_aee_tmp_ = (forests)[(_start_)];
              (forests)[(_start_)] = (forests)[(_end_ - 1)];
              (forests)[(_end_ - 1)] = _sgl_aee_tmp_;
            }
          };
        }
      }
    }
  };
}


x86 assembly (clang, -O0):
<sort_forests>:
push   %rbp
mov    %rsp,%rbp
sub    $0x430,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
movq   $0x0,-0x250(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x450(%rbp)
movq   $0x1,-0x38(%rbp)
cmpq   $0x0,-0x38(%rbp)
jbe    1730 <sort_forests+0x630>
mov    -0x38(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rax
mov    -0x250(%rbp,%rax,8),%rax
ff
mov    %rax,-0x40(%rbp)
mov    -0x38(%rbp),%rax
mov    -0x450(%rbp,%rax,8),%rax
ff
mov    %rax,-0x48(%rbp)
mov    -0x48(%rbp),%rax
sub    -0x40(%rbp),%rax
cmp    $0x2,%rax
jbe    1618 <sort_forests+0x518>
mov    -0x40(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
mov    -0x48(%rbp),%rax
sub    $0x1,%rax
mov    %rax,-0x28(%rbp)
mov    -0x20(%rbp),%rax
cmp    -0x28(%rbp),%rax
jae    1528 <sort_forests+0x428>
jmp    11b1 <sort_forests+0xb1>
mov    -0x20(%rbp),%rcx
xor    %eax,%eax
cmp    -0x28(%rbp),%rcx
mov    %al,-0x491(%rbp)
ja     1232 <sort_forests+0x132>
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x18(%rbp),%rcx
mov    -0x30(%rbp),%rdx
cmp    (%rcx,%rdx,8),%rax
jbe    11f5 <sort_forests+0xf5>
mov    $0x1,%eax
mov    %eax,-0x498(%rbp)
jmp    1220 <sort_forests+0x120>
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rsi
xor    %eax,%eax
mov    $0xffffffff,%ecx
cmp    %rsi,%rdx
cmovb  %ecx,%eax
mov    %eax,-0x498(%rbp)
mov    -0x498(%rbp),%eax
cmp    $0x0,%eax
setle  %al
mov    %al,-0x491(%rbp)
mov    -0x491(%rbp),%al
test   $0x1,%al
jne    1245 <sort_forests+0x145>
jmp    125b <sort_forests+0x15b>
jmp    124a <sort_forests+0x14a>
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
jmp    11b1 <sort_forests+0xb1>
mov    -0x20(%rbp),%rax
cmp    -0x28(%rbp),%rax
jbe    12f2 <sort_forests+0x1f2>
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x458(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x458(%rbp),%rdx
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x460(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x460(%rbp),%rdx
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
mov    %rax,-0x20(%rbp)
jmp    1523 <sort_forests+0x423>
jmp    12f7 <sort_forests+0x1f7>
mov    -0x20(%rbp),%rcx
xor    %eax,%eax
cmp    -0x28(%rbp),%rcx
mov    %al,-0x499(%rbp)
ja     1378 <sort_forests+0x278>
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x18(%rbp),%rcx
mov    -0x30(%rbp),%rdx
cmp    (%rcx,%rdx,8),%rax
jbe    133b <sort_forests+0x23b>
mov    $0x1,%eax
mov    %eax,-0x4a0(%rbp)
jmp    1366 <sort_forests+0x266>
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rsi
xor    %eax,%eax
mov    $0xffffffff,%ecx
cmp    %rsi,%rdx
cmovb  %ecx,%eax
mov    %eax,-0x4a0(%rbp)
mov    -0x4a0(%rbp),%eax
cmp    $0x0,%eax
setge  %al
mov    %al,-0x499(%rbp)
mov    -0x499(%rbp),%al
test   $0x1,%al
jne    138b <sort_forests+0x28b>
jmp    13a1 <sort_forests+0x2a1>
jmp    1390 <sort_forests+0x290>
mov    -0x28(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x28(%rbp)
jmp    12f7 <sort_forests+0x1f7>
mov    -0x20(%rbp),%rax
cmp    -0x28(%rbp),%rax
jbe    1438 <sort_forests+0x338>
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x468(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x468(%rbp),%rdx
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x470(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x470(%rbp),%rdx
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
mov    %rax,-0x20(%rbp)
jmp    151e <sort_forests+0x41e>
mov    -0x20(%rbp),%rax
cmp    -0x28(%rbp),%rax
jae    1519 <sort_forests+0x419>
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x478(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x478(%rbp),%rdx
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x480(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x480(%rbp),%rdx
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
add    $0x2,%rax
cmp    -0x28(%rbp),%rax
jae    14f1 <sort_forests+0x3f1>
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x28(%rbp)
jmp    1514 <sort_forests+0x414>
mov    -0x20(%rbp),%rax
add    $0x1,%rax
cmp    -0x28(%rbp),%rax
jae    150f <sort_forests+0x40f>
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
jmp    1514 <sort_forests+0x414>
jmp    1519 <sort_forests+0x419>
jmp    151e <sort_forests+0x41e>
jmp    1523 <sort_forests+0x423>
jmp    119e <sort_forests+0x9e>
mov    -0x20(%rbp),%rax
sub    -0x40(%rbp),%rax
cmp    $0x1,%rax
jbe    15e3 <sort_forests+0x4e3>
mov    -0x48(%rbp),%rax
sub    -0x28(%rbp),%rax
cmp    $0x1,%rax
jbe    15e3 <sort_forests+0x4e3>
mov    -0x20(%rbp),%rax
sub    -0x40(%rbp),%rax
mov    -0x48(%rbp),%rcx
sub    -0x28(%rbp),%rcx
sub    $0x1,%rcx
cmp    %rcx,%rax
jae    15a6 <sort_forests+0x4a6>
mov    -0x28(%rbp),%rcx
add    $0x1,%rcx
mov    -0x38(%rbp),%rax
mov    %rcx,-0x250(%rbp,%rax,8)
ff
mov    -0x48(%rbp),%rcx
mov    -0x38(%rbp),%rax
mov    %rcx,-0x450(%rbp,%rax,8)
ff
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x48(%rbp)
jmp    15de <sort_forests+0x4de>
mov    -0x40(%rbp),%rcx
mov    -0x38(%rbp),%rax
mov    %rcx,-0x250(%rbp,%rax,8)
ff
mov    -0x20(%rbp),%rcx
mov    -0x38(%rbp),%rax
mov    %rcx,-0x450(%rbp,%rax,8)
ff
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    1613 <sort_forests+0x513>
mov    -0x20(%rbp),%rax
sub    -0x40(%rbp),%rax
cmp    $0x1,%rax
jbe    1602 <sort_forests+0x502>
mov    -0x20(%rbp),%rax
mov    %rax,-0x48(%rbp)
jmp    160e <sort_forests+0x50e>
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    1613 <sort_forests+0x513>
jmp    116c <sort_forests+0x6c>
mov    -0x48(%rbp),%rax
sub    -0x40(%rbp),%rax
cmp    $0x2,%rax
jne    172b <sort_forests+0x62b>
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x18(%rbp),%rcx
mov    -0x48(%rbp),%rdx
sub    $0x1,%rdx
cmp    (%rcx,%rdx,8),%rax
jbe    165c <sort_forests+0x55c>
mov    $0x1,%eax
mov    %eax,-0x4a4(%rbp)
jmp    168b <sort_forests+0x58b>
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
mov    -0x18(%rbp),%rax
mov    -0x48(%rbp),%rcx
sub    $0x1,%rcx
mov    (%rax,%rcx,8),%rsi
xor    %eax,%eax
mov    $0xffffffff,%ecx
cmp    %rsi,%rdx
cmovb  %ecx,%eax
mov    %eax,-0x4a4(%rbp)
mov    -0x4a4(%rbp),%eax
cmp    $0x0,%eax
jle    1726 <sort_forests+0x626>
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x488(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x48(%rbp),%rcx
sub    $0x1,%rcx
mov    (%rax,%rcx,8),%rdx
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x488(%rbp),%rdx
mov    -0x18(%rbp),%rax
mov    -0x48(%rbp),%rcx
sub    $0x1,%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x490(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%rcx
sub    $0x1,%rcx
mov    (%rax,%rcx,8),%rdx
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x490(%rbp),%rdx
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%rcx
sub    $0x1,%rcx
mov    %rdx,(%rax,%rcx,8)
jmp    172b <sort_forests+0x62b>
jmp    1135 <sort_forests+0x35>
add    $0x430,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<sort_forests>:
push   %rbx
sub    $0x380,%rsp
movq   $0x0,0x180(%rsp)
mov    %rdi,-0x80(%rsp)
mov    $0x1,%r8d
jmp    1139 <sort_forests+0x39>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
test   %r8,%r8
je     12d6 <sort_forests+0x1d6>
mov    0x178(%rsp,%r8,8),%r9
mov    -0x88(%rsp,%r8,8),%r10
ff
add    $0xffffffffffffffff,%r8
mov    %r10,%rcx
sub    %r9,%rcx
cmp    $0x3,%rcx
jae    11b9 <sort_forests+0xb9>
mov    %r10,%rax
cmp    $0x2,%rcx
jne    1130 <sort_forests+0x30>
mov    (%rdx,%r9,8),%rcx
mov    -0x8(%rdx,%rax,8),%rdi
cmp    %rdi,%rcx
jbe    1130 <sort_forests+0x30>
mov    %rdi,(%rdx,%r9,8)
mov    %rcx,-0x8(%rdx,%rax,8)
mov    (%rsi,%r9,8),%rcx
mov    -0x8(%rsi,%rax,8),%rdi
mov    %rdi,(%rsi,%r9,8)
mov    %rcx,-0x8(%rsi,%rax,8)
jmp    1130 <sort_forests+0x30>
mov    %r9,0x180(%rsp,%r8,8)
mov    %rax,-0x80(%rsp,%r8,8)
add    $0x1,%r8
xchg   %ax,%ax
add    $0x1,%rcx
mov    %r10,%rax
mov    %rcx,%r9
mov    %rax,%rcx
sub    %r9,%rcx
mov    %rax,%r10
cmp    $0x2,%rcx
jbe    115c <sort_forests+0x5c>
lea    0x1(%r9),%rdi
lea    -0x1(%r10),%rcx
cmp    %rcx,%rdi
jae    1260 <sort_forests+0x160>
mov    (%rdx,%r9,8),%r11
cmp    %rcx,%rdi
ja     1270 <sort_forests+0x170>
nopw   0x0(%rax,%rax,1)
mov    (%rdx,%rdi,8),%rax
cmp    %r11,%rax
ja     1204 <sort_forests+0x104>
add    $0x1,%rdi
cmp    %rcx,%rdi
jbe    11e0 <sort_forests+0xe0>
jmp    1270 <sort_forests+0x170>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0xffffffffffffffff,%rcx
cmp    %rcx,%rdi
ja     1270 <sort_forests+0x170>
mov    (%rdx,%rcx,8),%rbx
cmp    %r11,%rbx
jae    1200 <sort_forests+0x100>
cmp    %rcx,%rdi
jae    1242 <sort_forests+0x142>
mov    %rbx,(%rdx,%rdi,8)
mov    %rax,(%rdx,%rcx,8)
mov    (%rsi,%rdi,8),%rax
mov    (%rsi,%rcx,8),%rbx
mov    %rbx,(%rsi,%rdi,8)
mov    %rax,(%rsi,%rcx,8)
lea    0x2(%rdi),%rbx
lea    0x1(%rdi),%rax
cmp    %rcx,%rbx
jae    1247 <sort_forests+0x147>
add    $0xffffffffffffffff,%rcx
jmp    124e <sort_forests+0x14e>
mov    %rdi,%rax
jmp    124e <sort_forests+0x14e>
cmp    %rcx,%rax
cmovae %rdi,%rax
mov    %rax,%rdi
cmp    %rcx,%rax
jb     11ca <sort_forests+0xca>
jmp    128f <sort_forests+0x18f>
nopl   0x0(%rax)
mov    %rdi,%rax
jmp    128f <sort_forests+0x18f>
cs nopw 0x0(%rax,%rax,1)
nop
mov    (%rdx,%rcx,8),%rax
mov    %r11,(%rdx,%rcx,8)
mov    %rax,(%rdx,%r9,8)
mov    (%rsi,%rcx,8),%rax
mov    (%rsi,%r9,8),%rdi
mov    %rdi,(%rsi,%rcx,8)
mov    %rax,(%rsi,%r9,8)
mov    %rcx,%rax
mov    %rax,%rdi
sub    %r9,%rdi
cmp    $0x2,%rdi
jb     11a0 <sort_forests+0xa0>
mov    %r10,%rbx
sub    %rcx,%rbx
cmp    $0x2,%rbx
jb     11aa <sort_forests+0xaa>
add    $0xffffffffffffffff,%rbx
cmp    %rbx,%rdi
jae    118d <sort_forests+0x8d>
add    $0x1,%rcx
mov    %rcx,0x180(%rsp,%r8,8)
mov    %r10,-0x80(%rsp,%r8,8)
add    $0x1,%r8
jmp    11aa <sort_forests+0xaa>
add    $0x380,%rsp
pop    %rbx
ret

LLVM IR (-O0):
define void @sort_forests(i64 %0, i64* %1, i64* %2) {
%4 = alloca i64
%5 = alloca i64*
%6 = alloca i64*
%7 = alloca i64
%8 = alloca i64
%9 = alloca i64
%10 = alloca i64
%11 = alloca i64
%12 = alloca i64
%13 = alloca [64 x i64]
%14 = alloca [64 x i64]
%15 = alloca i64
%16 = alloca i64
%17 = alloca i64
%18 = alloca i64
%19 = alloca i64
%20 = alloca i64
%21 = alloca i64
%22 = alloca i64
store i64 %0, i64* %4
store i64* %1, i64** %5
store i64* %2, i64** %6
%23 = getelementptr inbounds [64 x i64], [64 x i64]* %13, i64 0, i64 0
store i64 0, i64* %23
%24 = load i64, i64* %4
%25 = getelementptr inbounds [64 x i64], [64 x i64]* %14, i64 0, i64 0
store i64 %24, i64* %25
store i64 1, i64* %10
br label %26
26: ; preds = %379, %3
%27 = load i64, i64* %10
%28 = icmp ugt i64 %27, 0
br i1 %28, label %29, label %380
29: ; preds = %26
%30 = load i64, i64* %10
%31 = add i64 %30, -1
store i64 %31, i64* %10
%32 = load i64, i64* %10
%33 = getelementptr inbounds [64 x i64], [64 x i64]* %13, i64 0, i64 %32
%34 = load i64, i64* %33
store i64 %34, i64* %11
%35 = load i64, i64* %10
%36 = getelementptr inbounds [64 x i64], [64 x i64]* %14, i64 0, i64 %35
%37 = load i64, i64* %36
store i64 %37, i64* %12
br label %38
38: ; preds = %309, %29
%39 = load i64, i64* %12
%40 = load i64, i64* %11
%41 = sub i64 %39, %40
%42 = icmp ugt i64 %41, 2
br i1 %42, label %43, label %310
43: ; preds = %38
%44 = load i64, i64* %11
store i64 %44, i64* %9
%45 = load i64, i64* %11
%46 = add i64 %45, 1
store i64 %46, i64* %7
%47 = load i64, i64* %12
%48 = sub i64 %47, 1
store i64 %48, i64* %8
br label %49
49: ; preds = %255, %43
%50 = load i64, i64* %7
%51 = load i64, i64* %8
%52 = icmp ult i64 %50, %51
br i1 %52, label %53, label %256
53: ; preds = %49
br label %54
54: ; preds = %87, %53
%55 = load i64, i64* %7
%56 = load i64, i64* %8
%57 = icmp ule i64 %55, %56
br i1 %57, label %58, label %84
58: ; preds = %54
%59 = load i64*, i64** %6
%60 = load i64, i64* %7
%61 = getelementptr inbounds i64, i64* %59, i64 %60
%62 = load i64, i64* %61
%63 = load i64*, i64** %6
%64 = load i64, i64* %9
%65 = getelementptr inbounds i64, i64* %63, i64 %64
%66 = load i64, i64* %65
%67 = icmp ugt i64 %62, %66
br i1 %67, label %68, label %69
68: ; preds = %58
br label %81
69: ; preds = %58
%70 = load i64*, i64** %6
%71 = load i64, i64* %7
%72 = getelementptr inbounds i64, i64* %70, i64 %71
%73 = load i64, i64* %72
%74 = load i64*, i64** %6
%75 = load i64, i64* %9
%76 = getelementptr inbounds i64, i64* %74, i64 %75
%77 = load i64, i64* %76
%78 = icmp ult i64 %73, %77
%79 = zext i1 %78 to i64
%80 = select i1 %78, i32 -1, i32 0
br label %81
81: ; preds = %69, %68
%82 = phi i32 [ 1, %68 ], [ %80, %69 ]
%83 = icmp sle i32 %82, 0
br label %84
84: ; preds = %81, %54
%85 = phi i1 [ false, %54 ], [ %83, %81 ]
br i1 %85, label %86, label %90
86: ; preds = %84
br label %87
87: ; preds = %86
%88 = load i64, i64* %7
%89 = add i64 %88, 1
store i64 %89, i64* %7
br label %54
90: ; preds = %84
%91 = load i64, i64* %7
%92 = load i64, i64* %8
%93 = icmp ugt i64 %91, %92
br i1 %93, label %94, label %126
94: ; preds = %90
%95 = load i64*, i64** %6
%96 = load i64, i64* %8
%97 = getelementptr inbounds i64, i64* %95, i64 %96
%98 = load i64, i64* %97
store i64 %98, i64* %15
%99 = load i64*, i64** %6
%100 = load i64, i64* %9
%101 = getelementptr inbounds i64, i64* %99, i64 %100
%102 = load i64, i64* %101
%103 = load i64*, i64** %6
%104 = load i64, i64* %8
%105 = getelementptr inbounds i64, i64* %103, i64 %104
store i64 %102, i64* %105
%106 = load i64, i64* %15
%107 = load i64*, i64** %6
%108 = load i64, i64* %9
%109 = getelementptr inbounds i64, i64* %107, i64 %108
store i64 %106, i64* %109
%110 = load i64*, i64** %5
%111 = load i64, i64* %8
%112 = getelementptr inbounds i64, i64* %110, i64 %111
%113 = load i64, i64* %112
store i64 %113, i64* %16
%114 = load i64*, i64** %5
%115 = load i64, i64* %9
%116 = getelementptr inbounds i64, i64* %114, i64 %115
%117 = load i64, i64* %116
%118 = load i64*, i64** %5
%119 = load i64, i64* %8
%120 = getelementptr inbounds i64, i64* %118, i64 %119
store i64 %117, i64* %120
%121 = load i64, i64* %16
%122 = load i64*, i64** %5
%123 = load i64, i64* %9
%124 = getelementptr inbounds i64, i64* %122, i64 %123
store i64 %121, i64* %124
%125 = load i64, i64* %8
store i64 %125, i64* %7
br label %255
126: ; preds = %90
br label %127
127: ; preds = %160, %126
%128 = load i64, i64* %7
%129 = load i64, i64* %8
%130 = icmp ule i64 %128, %129
br i1 %130, label %131, label %157
131: ; preds = %127
%132 = load i64*, i64** %6
%133 = load i64, i64* %8
%134 = getelementptr inbounds i64, i64* %132, i64 %133
%135 = load i64, i64* %134
%136 = load i64*, i64** %6
%137 = load i64, i64* %9
%138 = getelementptr inbounds i64, i64* %136, i64 %137
%139 = load i64, i64* %138
%140 = icmp ugt i64 %135, %139
br i1 %140, label %141, label %142
141: ; preds = %131
br label %154
142: ; preds = %131
%143 = load i64*, i64** %6
%144 = load i64, i64* %8
%145 = getelementptr inbounds i64, i64* %143, i64 %144
%146 = load i64, i64* %145
%147 = load i64*, i64** %6
%148 = load i64, i64* %9
%149 = getelementptr inbounds i64, i64* %147, i64 %148
%150 = load i64, i64* %149
%151 = icmp ult i64 %146, %150
%152 = zext i1 %151 to i64
%153 = select i1 %151, i32 -1, i32 0
br label %154
154: ; preds = %142, %141
%155 = phi i32 [ 1, %141 ], [ %153, %142 ]
%156 = icmp sge i32 %155, 0
br label %157
157: ; preds = %154, %127
%158 = phi i1 [ false, %127 ], [ %156, %154 ]
br i1 %158, label %159, label %163
159: ; preds = %157
br label %160
160: ; preds = %159
%161 = load i64, i64* %8
%162 = add i64 %161, -1
store i64 %162, i64* %8
br label %127
163: ; preds = %157
%164 = load i64, i64* %7
%165 = load i64, i64* %8
%166 = icmp ugt i64 %164, %165
br i1 %166, label %167, label %199
167: ; preds = %163
%168 = load i64*, i64** %6
%169 = load i64, i64* %8
%170 = getelementptr inbounds i64, i64* %168, i64 %169
%171 = load i64, i64* %170
store i64 %171, i64* %17
%172 = load i64*, i64** %6
%173 = load i64, i64* %9
%174 = getelementptr inbounds i64, i64* %172, i64 %173
%175 = load i64, i64* %174
%176 = load i64*, i64** %6
%177 = load i64, i64* %8
%178 = getelementptr inbounds i64, i64* %176, i64 %177
store i64 %175, i64* %178
%179 = load i64, i64* %17
%180 = load i64*, i64** %6
%181 = load i64, i64* %9
%182 = getelementptr inbounds i64, i64* %180, i64 %181
store i64 %179, i64* %182
%183 = load i64*, i64** %5
%184 = load i64, i64* %8
%185 = getelementptr inbounds i64, i64* %183, i64 %184
%186 = load i64, i64* %185
store i64 %186, i64* %18
%187 = load i64*, i64** %5
%188 = load i64, i64* %9
%189 = getelementptr inbounds i64, i64* %187, i64 %188
%190 = load i64, i64* %189
%191 = load i64*, i64** %5
%192 = load i64, i64* %8
%193 = getelementptr inbounds i64, i64* %191, i64 %192
store i64 %190, i64* %193
%194 = load i64, i64* %18
%195 = load i64*, i64** %5
%196 = load i64, i64* %9
%197 = getelementptr inbounds i64, i64* %195, i64 %196
store i64 %194, i64* %197
%198 = load i64, i64* %8
store i64 %198, i64* %7
br label %254
199: ; preds = %163
%200 = load i64, i64* %7
%201 = load i64, i64* %8
%202 = icmp ult i64 %200, %201
br i1 %202, label %203, label %253
203: ; preds = %199
%204 = load i64*, i64** %6
%205 = load i64, i64* %7
%206 = getelementptr inbounds i64, i64* %204, i64 %205
%207 = load i64, i64* %206
store i64 %207, i64* %19
%208 = load i64*, i64** %6
%209 = load i64, i64* %8
%210 = getelementptr inbounds i64, i64* %208, i64 %209
%211 = load i64, i64* %210
%212 = load i64*, i64** %6
%213 = load i64, i64* %7
%214 = getelementptr inbounds i64, i64* %212, i64 %213
store i64 %211, i64* %214
%215 = load i64, i64* %19
%216 = load i64*, i64** %6
%217 = load i64, i64* %8
%218 = getelementptr inbounds i64, i64* %216, i64 %217
store i64 %215, i64* %218
%219 = load i64*, i64** %5
%220 = load i64, i64* %7
%221 = getelementptr inbounds i64, i64* %219, i64 %220
%222 = load i64, i64* %221
store i64 %222, i64* %20
%223 = load i64*, i64** %5
%224 = load i64, i64* %8
%225 = getelementptr inbounds i64, i64* %223, i64 %224
%226 = load i64, i64* %225
%227 = load i64*, i64** %5
%228 = load i64, i64* %7
%229 = getelementptr inbounds i64, i64* %227, i64 %228
store i64 %226, i64* %229
%230 = load i64, i64* %20
%231 = load i64*, i64** %5
%232 = load i64, i64* %8
%233 = getelementptr inbounds i64, i64* %231, i64 %232
store i64 %230, i64* %233
%234 = load i64, i64* %7
%235 = add i64 %234, 2
%236 = load i64, i64* %8
%237 = icmp ult i64 %235, %236
br i1 %237, label %238, label %243
238: ; preds = %203
%239 = load i64, i64* %7
%240 = add i64 %239, 1
store i64 %240, i64* %7
%241 = load i64, i64* %8
%242 = add i64 %241, -1
store i64 %242, i64* %8
br label %252
243: ; preds = %203
%244 = load i64, i64* %7
%245 = add i64 %244, 1
%246 = load i64, i64* %8
%247 = icmp ult i64 %245, %246
br i1 %247, label %248, label %251
248: ; preds = %243
%249 = load i64, i64* %7
%250 = add i64 %249, 1
store i64 %250, i64* %7
br label %251
251: ; preds = %248, %243
br label %252
252: ; preds = %251, %238
br label %253
253: ; preds = %252, %199
br label %254
254: ; preds = %253, %167
br label %255
255: ; preds = %254, %94
br label %49
256: ; preds = %49
%257 = load i64, i64* %7
%258 = load i64, i64* %11
%259 = sub i64 %257, %258
%260 = icmp ugt i64 %259, 1
br i1 %260, label %261, label %298
261: ; preds = %256
%262 = load i64, i64* %12
%263 = load i64, i64* %8
%264 = sub i64 %262, %263
%265 = icmp ugt i64 %264, 1
br i1 %265, label %266, label %298
266: ; preds = %261
%267 = load i64, i64* %7
%268 = load i64, i64* %11
%269 = sub i64 %267, %268
%270 = load i64, i64* %12
%271 = load i64, i64* %8
%272 = sub i64 %270, %271
%273 = sub i64 %272, 1
%274 = icmp ult i64 %269, %273
br i1 %274, label %275, label %286
275: ; preds = %266
%276 = load i64, i64* %8
%277 = add i64 %276, 1
%278 = load i64, i64* %10
%279 = getelementptr inbounds [64 x i64], [64 x i64]* %13, i64 0, i64 %278
store i64 %277, i64* %279
%280 = load i64, i64* %12
%281 = load i64, i64* %10
%282 = getelementptr inbounds [64 x i64], [64 x i64]* %14, i64 0, i64 %281
store i64 %280, i64* %282
%283 = load i64, i64* %10
%284 = add i64 %283, 1
store i64 %284, i64* %10
%285 = load i64, i64* %7
store i64 %285, i64* %12
br label %297
286: ; preds = %266
%287 = load i64, i64* %11
%288 = load i64, i64* %10
%289 = getelementptr inbounds [64 x i64], [64 x i64]* %13, i64 0, i64 %288
store i64 %287, i64* %289
%290 = load i64, i64* %7
%291 = load i64, i64* %10
%292 = getelementptr inbounds [64 x i64], [64 x i64]* %14, i64 0, i64 %291
store i64 %290, i64* %292
%293 = load i64, i64* %10
%294 = add i64 %293, 1
store i64 %294, i64* %10
%295 = load i64, i64* %8
%296 = add i64 %295, 1
store i64 %296, i64* %11
br label %297
297: ; preds = %286, %275
br label %309
298: ; preds = %261, %256
%299 = load i64, i64* %7
%300 = load i64, i64* %11
%301 = sub i64 %299, %300
%302 = icmp ugt i64 %301, 1
br i1 %302, label %303, label %305
303: ; preds = %298
%304 = load i64, i64* %7
store i64 %304, i64* %12
br label %308
305: ; preds = %298
%306 = load i64, i64* %8
%307 = add i64 %306, 1
store i64 %307, i64* %11
br label %308
308: ; preds = %305, %303
br label %309
309: ; preds = %308, %297
br label %38
310: ; preds = %38
%311 = load i64, i64* %12
%312 = load i64, i64* %11
%313 = sub i64 %311, %312
%314 = icmp eq i64 %313, 2
br i1 %314, label %315, label %379
315: ; preds = %310
%316 = load i64*, i64** %6
%317 = load i64, i64* %11
%318 = getelementptr inbounds i64, i64* %316, i64 %317
%319 = load i64, i64* %318
%320 = load i64*, i64** %6
%321 = load i64, i64* %12
%322 = sub i64 %321, 1
%323 = getelementptr inbounds i64, i64* %320, i64 %322
%324 = load i64, i64* %323
%325 = icmp ugt i64 %319, %324
br i1 %325, label %326, label %327
326: ; preds = %315
br label %340
327: ; preds = %315
%328 = load i64*, i64** %6
%329 = load i64, i64* %11
%330 = getelementptr inbounds i64, i64* %328, i64 %329
%331 = load i64, i64* %330
%332 = load i64*, i64** %6
%333 = load i64, i64* %12
%334 = sub i64 %333, 1
%335 = getelementptr inbounds i64, i64* %332, i64 %334
%336 = load i64, i64* %335
%337 = icmp ult i64 %331, %336
%338 = zext i1 %337 to i64
%339 = select i1 %337, i32 -1, i32 0
br label %340
340: ; preds = %327, %326
%341 = phi i32 [ 1, %326 ], [ %339, %327 ]
%342 = icmp sgt i32 %341, 0
br i1 %342, label %343, label %378
343: ; preds = %340
%344 = load i64*, i64** %6
%345 = load i64, i64* %11
%346 = getelementptr inbounds i64, i64* %344, i64 %345
%347 = load i64, i64* %346
store i64 %347, i64* %21
%348 = load i64*, i64** %6
%349 = load i64, i64* %12
%350 = sub i64 %349, 1
%351 = getelementptr inbounds i64, i64* %348, i64 %350
%352 = load i64, i64* %351
%353 = load i64*, i64** %6
%354 = load i64, i64* %11
%355 = getelementptr inbounds i64, i64* %353, i64 %354
store i64 %352, i64* %355
%356 = load i64, i64* %21
%357 = load i64*, i64** %6
%358 = load i64, i64* %12
%359 = sub i64 %358, 1
%360 = getelementptr inbounds i64, i64* %357, i64 %359
store i64 %356, i64* %360
%361 = load i64*, i64** %5
%362 = load i64, i64* %11
%363 = getelementptr inbounds i64, i64* %361, i64 %362
%364 = load i64, i64* %363
store i64 %364, i64* %22
%365 = load i64*, i64** %5
%366 = load i64, i64* %12
%367 = sub i64 %366, 1
%368 = getelementptr inbounds i64, i64* %365, i64 %367
%369 = load i64, i64* %368
%370 = load i64*, i64** %5
%371 = load i64, i64* %11
%372 = getelementptr inbounds i64, i64* %370, i64 %371
store i64 %369, i64* %372
%373 = load i64, i64* %22
%374 = load i64*, i64** %5
%375 = load i64, i64* %12
%376 = sub i64 %375, 1
%377 = getelementptr inbounds i64, i64* %374, i64 %376
store i64 %373, i64* %377
br label %378
378: ; preds = %343, %340
br label %379
379: ; preds = %378, %310
br label %26
380: ; preds = %26
ret void
}

LLVM IR (-O2):
define void @sort_forests(i64 %0, i64* nocapture %1, i64* nocapture %2) {
%4 = alloca [64 x i64]
%5 = alloca [64 x i64]
%6 = bitcast [64 x i64]* %4 to i8*
%7 = bitcast [64 x i64]* %5 to i8*
%8 = getelementptr inbounds [64 x i64], [64 x i64]* %4, i64 0, i64 0
store i64 0, i64* %8
%9 = getelementptr inbounds [64 x i64], [64 x i64]* %5, i64 0, i64 0
store i64 %0, i64* %9
br label %10
10: ; preds = %133, %3
%11 = phi i64 [ 1, %3 ], [ %118, %133 ]
%12 = add i64 %11, -1
%13 = getelementptr inbounds [64 x i64], [64 x i64]* %4, i64 0, i64 %12
%14 = load i64, i64* %13
%15 = getelementptr inbounds [64 x i64], [64 x i64]* %5, i64 0, i64 %12
%16 = load i64, i64* %15
%17 = sub i64 %16, %14
%18 = icmp ugt i64 %17, 2
br i1 %18, label %19, label %115
19: ; preds = %10, %109
%20 = phi i64 [ %112, %109 ], [ %12, %10 ]
%21 = phi i64 [ %111, %109 ], [ %14, %10 ]
%22 = phi i64 [ %110, %109 ], [ %16, %10 ]
%23 = add i64 %21, 1
%24 = add i64 %22, -1
%25 = icmp ult i64 %23, %24
br i1 %25, label %26, label %86
26: ; preds = %19
%27 = getelementptr inbounds i64, i64* %2, i64 %21
%28 = getelementptr inbounds i64, i64* %1, i64 %21
br label %29
29: ; preds = %26, %76
%30 = phi i64 [ %23, %26 ], [ %78, %76 ]
%31 = phi i64 [ %24, %26 ], [ %77, %76 ]
%32 = icmp ugt i64 %30, %31
%33 = load i64, i64* %27
br i1 %32, label %45, label %34
34: ; preds = %29, %42
%35 = phi i64 [ %43, %42 ], [ %30, %29 ]
%36 = getelementptr inbounds i64, i64* %2, i64 %35
%37 = load i64, i64* %36
%38 = icmp ugt i64 %37, %33
br i1 %38, label %39, label %42
39: ; preds = %34
%40 = getelementptr inbounds i64, i64* %2, i64 %35
%41 = icmp ugt i64 %35, %31
br i1 %41, label %56, label %48
42: ; preds = %34
%43 = add i64 %35, 1
%44 = icmp ugt i64 %43, %31
br i1 %44, label %45, label %34
45: ; preds = %29, %42
%46 = getelementptr inbounds i64, i64* %2, i64 %31
%47 = load i64, i64* %46
store i64 %33, i64* %46
br label %80
48: ; preds = %39, %53
%49 = phi i64 [ %54, %53 ], [ %31, %39 ]
%50 = getelementptr inbounds i64, i64* %2, i64 %49
%51 = load i64, i64* %50
%52 = icmp ult i64 %51, %33
br i1 %52, label %60, label %53
53: ; preds = %48
%54 = add i64 %49, -1
%55 = icmp ugt i64 %35, %54
br i1 %55, label %56, label %48
56: ; preds = %39, %53
%57 = phi i64 [ %54, %53 ], [ %31, %39 ]
%58 = getelementptr inbounds i64, i64* %2, i64 %57
%59 = load i64, i64* %58
store i64 %33, i64* %58
br label %80
60: ; preds = %48
%61 = icmp ult i64 %35, %49
br i1 %61, label %62, label %76
62: ; preds = %60
%63 = getelementptr inbounds i64, i64* %2, i64 %49
store i64 %51, i64* %40
store i64 %37, i64* %63
%64 = getelementptr inbounds i64, i64* %1, i64 %35
%65 = load i64, i64* %64
%66 = getelementptr inbounds i64, i64* %1, i64 %49
%67 = load i64, i64* %66
store i64 %67, i64* %64
store i64 %65, i64* %66
%68 = add i64 %35, 2
%69 = icmp ult i64 %68, %49
%70 = add nuw i64 %35, 1
br i1 %69, label %71, label %73
71: ; preds = %62
%72 = add i64 %49, -1
br label %76
73: ; preds = %62
%74 = icmp ult i64 %70, %49
%75 = select i1 %74, i64 %70, i64 %35
br label %76
76: ; preds = %73, %71, %60
%77 = phi i64 [ %72, %71 ], [ %49, %60 ], [ %49, %73 ]
%78 = phi i64 [ %70, %71 ], [ %35, %60 ], [ %75, %73 ]
%79 = icmp ult i64 %78, %77
br i1 %79, label %29, label %86
80: ; preds = %45, %56
%81 = phi i64 [ %47, %45 ], [ %59, %56 ]
%82 = phi i64 [ %31, %45 ], [ %57, %56 ]
store i64 %81, i64* %27
%83 = getelementptr inbounds i64, i64* %1, i64 %82
%84 = load i64, i64* %83
%85 = load i64, i64* %28
store i64 %85, i64* %83
store i64 %84, i64* %28
br label %86
86: ; preds = %76, %80, %19
%87 = phi i64 [ %24, %19 ], [ %82, %80 ], [ %77, %76 ]
%88 = phi i64 [ %23, %19 ], [ %82, %80 ], [ %78, %76 ]
%89 = sub i64 %88, %21
%90 = icmp ugt i64 %89, 1
br i1 %90, label %91, label %107
91: ; preds = %86
%92 = sub i64 %22, %87
%93 = icmp ugt i64 %92, 1
br i1 %93, label %94, label %109
94: ; preds = %91
%95 = add i64 %92, -1
%96 = icmp ult i64 %89, %95
br i1 %96, label %97, label %102
97: ; preds = %94
%98 = add i64 %87, 1
%99 = getelementptr inbounds [64 x i64], [64 x i64]* %4, i64 0, i64 %20
store i64 %98, i64* %99
%100 = getelementptr inbounds [64 x i64], [64 x i64]* %5, i64 0, i64 %20
store i64 %22, i64* %100
%101 = add i64 %20, 1
br label %109
102: ; preds = %94
%103 = getelementptr inbounds [64 x i64], [64 x i64]* %4, i64 0, i64 %20
store i64 %21, i64* %103
%104 = getelementptr inbounds [64 x i64], [64 x i64]* %5, i64 0, i64 %20
store i64 %88, i64* %104
%105 = add i64 %20, 1
%106 = add i64 %87, 1
br label %109
107: ; preds = %86
%108 = add i64 %87, 1
br label %109
109: ; preds = %91, %107, %97, %102
%110 = phi i64 [ %88, %97 ], [ %22, %102 ], [ %22, %107 ], [ %88, %91 ]
%111 = phi i64 [ %21, %97 ], [ %106, %102 ], [ %108, %107 ], [ %21, %91 ]
%112 = phi i64 [ %101, %97 ], [ %105, %102 ], [ %20, %107 ], [ %20, %91 ]
%113 = sub i64 %110, %111
%114 = icmp ugt i64 %113, 2
br i1 %114, label %19, label %115
115: ; preds = %109, %10
%116 = phi i64 [ %16, %10 ], [ %110, %109 ]
%117 = phi i64 [ %14, %10 ], [ %111, %109 ]
%118 = phi i64 [ %12, %10 ], [ %112, %109 ]
%119 = phi i64 [ %17, %10 ], [ %113, %109 ]
%120 = icmp eq i64 %119, 2
br i1 %120, label %121, label %133
121: ; preds = %115
%122 = getelementptr inbounds i64, i64* %2, i64 %117
%123 = load i64, i64* %122
%124 = add i64 %116, -1
%125 = getelementptr inbounds i64, i64* %2, i64 %124
%126 = load i64, i64* %125
%127 = icmp ugt i64 %123, %126
br i1 %127, label %128, label %133
128: ; preds = %121
store i64 %126, i64* %122
store i64 %123, i64* %125
%129 = getelementptr inbounds i64, i64* %1, i64 %117
%130 = load i64, i64* %129
%131 = getelementptr inbounds i64, i64* %1, i64 %124
%132 = load i64, i64* %131
store i64 %132, i64* %129
store i64 %130, i64* %131
br label %133
133: ; preds = %121, %128, %115
%134 = icmp eq i64 %118, 0
br i1 %134, label %135, label %10
135: ; preds = %133
ret void
}