#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 */

/* Variables and functions */
int /*<<< orphan*/ complement(int *, int, int *, int, int, int *, int *);
int /*<<< orphan*/ copy_list(int *, int *, int);
int /*<<< orphan*/ free(int *);
int /*<<< orphan*/ inverse(int *, int *, int);
int /*<<< orphan*/ isid(int *, int);
scalar_t__ malloc(int);
int /*<<< orphan*/ one_schreier_orbit(int, int *, int, int, int *, int *, int *,
                                      int *, int);
int onpoints(int, int *, int);
int /*<<< orphan*/ perm_member(int *, int *, int, int *, int, int);
scalar_t__ position(int, int *, int);
int /*<<< orphan*/ product(int *, int *, int *, int);
scalar_t__ realloc(int *, int);
int /*<<< orphan*/ stabilizer(int *, int, int *, int, int, int *, int *);
int /*<<< orphan*/ stable_points(int *, int, int *, int *);
int /*<<< orphan*/ trace_schreier(int, int *, int *, int *, int);
void schreier_sims_step(int *base, int bl, int *GS, int m, int n, int i, int *T,
                        int mm, int *newbase, int *nbl, int **newGS, int *nm,
                        int *num) {
  int c, j, jj, level;
  int *p = (int *)malloc(n * sizeof(int));
  int *ip = (int *)malloc(n * sizeof(int));
  int *pp = (int *)malloc(n * sizeof(int));
  int *ppp = (int *)malloc(n * sizeof(int));
  int *Si = (int *)malloc(m * n * sizeof(int)), Sil;
  int *oldSi = (int *)malloc(m * n * sizeof(int)), oldSil;
  int *Deltai = (int *)malloc(n * sizeof(int)), Deltail;
  int *w = (int *)malloc(n * sizeof(int));
  int *nu = (int *)malloc(n * n * sizeof(int));
  int *oldDeltai = (int *)malloc(n * sizeof(int)), oldDeltail;
  int *oldw = (int *)malloc(n * sizeof(int));
  int *oldnu = (int *)malloc(n * n * sizeof(int));
  int *genset = (int *)malloc(m * n * sizeof(int)), gensetl;
  int gamma, gn, sn;
  int *s = (int *)malloc(n * sizeof(int));
  int *g = (int *)malloc(n * sizeof(int));
  int *stab = (int *)malloc(m * n * sizeof(int)), stabl;
  int *stabps = (int *)malloc(n * sizeof(int)), stabpsl;
  copy_list(base, newbase, bl);
  *nbl = bl;
  copy_list(GS, *newGS, m * n);
  *nm = m;
  stabilizer(base, i - 1, GS, m, n, Si, &Sil);
  complement(Si, Sil, T, mm, n, oldSi, &oldSil);
  one_schreier_orbit(base[i - 1], Si, Sil, n, Deltai, &Deltail, nu, w, 1);
  one_schreier_orbit(base[i - 1], oldSi, oldSil, n, oldDeltai, &oldDeltail,
                     oldnu, oldw, 1);
  for (c = 0; c < n; c++) {
    if (w[c] != oldw[c] && oldw[c] != 0) {
      copy_list(oldnu + c * n, nu + c * n, n);
      w[c] = oldw[c];
    }
  }
  for (gn = 0; gn < Deltail; gn++) {
    gamma = Deltai[gn];
    if (position(gamma, oldDeltai, oldDeltail)) {
      copy_list(T, genset, mm * n);
      gensetl = mm;
    } else {
      copy_list(Si, genset, Sil * n);
      gensetl = Sil;
    }
    for (sn = 0; sn < gensetl; sn++) {
      copy_list(genset + sn * n, s, n);
      (*num)++;
      trace_schreier(gamma, nu, w, p, n);
      trace_schreier(onpoints(gamma, s, n), nu, w, pp, n);
      inverse(pp, ip, n);
      product(p, s, ppp, n);
      product(ppp, ip, g, n);
      stab = (int *)realloc(stab, (*nm) * n * sizeof(int));
      stabilizer(newbase, i, *newGS, *nm, n, stab, &stabl);
      if (!isid(g, n)) {
        if ((stabl == 0) ||
            (!perm_member(g, newbase + i, *nbl - i, stab, stabl, n))) {
          *newGS = (int *)realloc(*newGS, ((*nm) + 1) * n * sizeof(int));
          copy_list(g, (*newGS) + (*nm) * n, n);
          (*nm)++;
          stable_points(g, n, stabps, &stabpsl);
          for (jj = 0; jj < *nbl; jj++) {
            if (!position(newbase[jj], stabps, stabpsl)) {
              j = jj + 1;
              break;
            }
            j = *nbl + 1;
          }
          if (j == *nbl + 1) {
            for (jj = 1; jj <= n; jj++) {
              if (!position(jj, stabps, stabpsl) &&
                  !position(jj, newbase, *nbl)) {
                newbase[*nbl] = jj;
                (*nbl)++;
                break;
              }
            }
          }
          for (level = j; level > i; level--) {
            schreier_sims_step(newbase, *nbl, *newGS, *nm, n, level, g, 1,
                               newbase, nbl, newGS, nm, num);
          }
        }
      }
    }
  }
  free(p);
  free(ip);
  free(pp);
  free(ppp);
  free(Si);
  free(oldSi);
  free(Deltai);
  free(w);
  free(nu);
  free(oldDeltai);
  free(oldw);
  free(oldnu);
  free(genset);
  free(s);
  free(g);
  free(stab);
  free(stabps);
}


x86 assembly (clang, -O0):
<schreier_sims_step>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %rbx
sub    $0x138,%rsp
mov    0x40(%rbp),%rax
mov    0x38(%rbp),%rax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%rax
mov    %rdi,-0x20(%rbp)
mov    %esi,-0x24(%rbp)
mov    %rdx,-0x30(%rbp)
mov    %ecx,-0x34(%rbp)
mov    %r8d,-0x38(%rbp)
mov    %r9d,-0x3c(%rbp)
movslq -0x38(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1070 <malloc@plt>
mov    %rax,-0x58(%rbp)
movslq -0x38(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1070 <malloc@plt>
mov    %rax,-0x60(%rbp)
movslq -0x38(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1070 <malloc@plt>
mov    %rax,-0x68(%rbp)
movslq -0x38(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1070 <malloc@plt>
mov    %rax,-0x70(%rbp)
mov    -0x34(%rbp),%eax
imul   -0x38(%rbp),%eax
cltq
shl    $0x2,%rax
mov    %eax,%edi
call   1070 <malloc@plt>
mov    %rax,-0x78(%rbp)
mov    -0x34(%rbp),%eax
imul   -0x38(%rbp),%eax
cltq
shl    $0x2,%rax
mov    %eax,%edi
call   1070 <malloc@plt>
mov    %rax,-0x88(%rbp)
movslq -0x38(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1070 <malloc@plt>
mov    %rax,-0x98(%rbp)
movslq -0x38(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1070 <malloc@plt>
mov    %rax,-0xa8(%rbp)
mov    -0x38(%rbp),%eax
imul   -0x38(%rbp),%eax
cltq
shl    $0x2,%rax
mov    %eax,%edi
call   1070 <malloc@plt>
mov    %rax,-0xb0(%rbp)
movslq -0x38(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1070 <malloc@plt>
mov    %rax,-0xb8(%rbp)
movslq -0x38(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1070 <malloc@plt>
mov    %rax,-0xc8(%rbp)
mov    -0x38(%rbp),%eax
imul   -0x38(%rbp),%eax
cltq
shl    $0x2,%rax
mov    %eax,%edi
call   1070 <malloc@plt>
mov    %rax,-0xd0(%rbp)
mov    -0x34(%rbp),%eax
imul   -0x38(%rbp),%eax
cltq
shl    $0x2,%rax
mov    %eax,%edi
call   1070 <malloc@plt>
mov    %rax,-0xd8(%rbp)
movslq -0x38(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1070 <malloc@plt>
mov    %rax,-0xf0(%rbp)
movslq -0x38(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1070 <malloc@plt>
mov    %rax,-0xf8(%rbp)
mov    -0x34(%rbp),%eax
imul   -0x38(%rbp),%eax
cltq
shl    $0x2,%rax
mov    %eax,%edi
call   1070 <malloc@plt>
mov    %rax,-0x100(%rbp)
movslq -0x38(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1070 <malloc@plt>
mov    %rax,-0x110(%rbp)
mov    -0x20(%rbp),%rdi
mov    0x20(%rbp),%rsi
mov    -0x24(%rbp),%edx
call   10e0 <copy_list@plt>
mov    -0x24(%rbp),%ecx
mov    0x28(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x30(%rbp),%rdi
mov    0x30(%rbp),%rax
mov    (%rax),%rsi
mov    -0x34(%rbp),%edx
imul   -0x38(%rbp),%edx
call   10e0 <copy_list@plt>
mov    -0x34(%rbp),%ecx
mov    0x38(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x20(%rbp),%rdi
mov    -0x3c(%rbp),%esi
sub    $0x1,%esi
mov    -0x30(%rbp),%rdx
mov    -0x34(%rbp),%ecx
mov    -0x38(%rbp),%r8d
mov    -0x78(%rbp),%r9
lea    -0x7c(%rbp),%rax
mov    %rax,(%rsp)
call   10c0 <stabilizer@plt>
mov    -0x78(%rbp),%rdi
mov    -0x7c(%rbp),%esi
mov    0x10(%rbp),%rdx
mov    0x18(%rbp),%ecx
mov    -0x38(%rbp),%r8d
mov    -0x88(%rbp),%r9
lea    -0x8c(%rbp),%rax
mov    %rax,(%rsp)
call   1040 <complement@plt>
mov    -0x20(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edi
mov    -0x78(%rbp),%rsi
mov    -0x7c(%rbp),%edx
mov    -0x38(%rbp),%ecx
mov    -0x98(%rbp),%r8
mov    -0xb0(%rbp),%r10
mov    -0xa8(%rbp),%rax
lea    -0x9c(%rbp),%r9
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
movl   $0x1,0x10(%rsp)
call   10d0 <one_schreier_orbit@plt>
mov    -0x20(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edi
mov    -0x88(%rbp),%rsi
mov    -0x8c(%rbp),%edx
mov    -0x38(%rbp),%ecx
mov    -0xb8(%rbp),%r8
mov    -0xd0(%rbp),%r10
mov    -0xc8(%rbp),%rax
lea    -0xbc(%rbp),%r9
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
movl   $0x1,0x10(%rsp)
call   10d0 <one_schreier_orbit@plt>
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    159b <schreier_sims_step+0x39b>
mov    -0xa8(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0xc8(%rbp),%rcx
movslq -0x40(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
je     1588 <schreier_sims_step+0x388>
mov    -0xc8(%rbp),%rax
movslq -0x40(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     1588 <schreier_sims_step+0x388>
mov    -0xd0(%rbp),%rdi
mov    -0x40(%rbp),%eax
imul   -0x38(%rbp),%eax
cltq
shl    $0x2,%rax
add    %rax,%rdi
mov    -0xb0(%rbp),%rsi
mov    -0x40(%rbp),%eax
imul   -0x38(%rbp),%eax
cltq
shl    $0x2,%rax
add    %rax,%rsi
mov    -0x38(%rbp),%edx
call   10e0 <copy_list@plt>
mov    -0xc8(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0xa8(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    158d <schreier_sims_step+0x38d>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    14f3 <schreier_sims_step+0x2f3>
movl   $0x0,-0xe4(%rbp)
mov    -0xe4(%rbp),%eax
cmp    -0x9c(%rbp),%eax
jge    1a0a <schreier_sims_step+0x80a>
mov    -0x98(%rbp),%rax
movslq -0xe4(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xe0(%rbp)
mov    -0xe0(%rbp),%edi
mov    -0xb8(%rbp),%rsi
mov    -0xbc(%rbp),%edx
call   1050 <position@plt>
cmp    $0x0,%rax
je     1615 <schreier_sims_step+0x415>
mov    0x10(%rbp),%rdi
mov    -0xd8(%rbp),%rsi
mov    0x18(%rbp),%edx
imul   -0x38(%rbp),%edx
call   10e0 <copy_list@plt>
mov    0x18(%rbp),%eax
mov    %eax,-0xdc(%rbp)
jmp    1635 <schreier_sims_step+0x435>
mov    -0x78(%rbp),%rdi
mov    -0xd8(%rbp),%rsi
mov    -0x7c(%rbp),%edx
imul   -0x38(%rbp),%edx
call   10e0 <copy_list@plt>
mov    -0x7c(%rbp),%eax
mov    %eax,-0xdc(%rbp)
movl   $0x0,-0xe8(%rbp)
mov    -0xe8(%rbp),%eax
cmp    -0xdc(%rbp),%eax
jge    19f1 <schreier_sims_step+0x7f1>
mov    -0xd8(%rbp),%rdi
mov    -0xe8(%rbp),%eax
imul   -0x38(%rbp),%eax
cltq
shl    $0x2,%rax
add    %rax,%rdi
mov    -0xf0(%rbp),%rsi
mov    -0x38(%rbp),%edx
call   10e0 <copy_list@plt>
mov    0x40(%rbp),%rax
mov    (%rax),%ecx
add    $0x1,%ecx
mov    %ecx,(%rax)
mov    -0xe0(%rbp),%edi
mov    -0xb0(%rbp),%rsi
mov    -0xa8(%rbp),%rdx
mov    -0x58(%rbp),%rcx
mov    -0x38(%rbp),%r8d
call   1060 <trace_schreier@plt>
mov    -0xe0(%rbp),%edi
mov    -0xf0(%rbp),%rsi
mov    -0x38(%rbp),%edx
call   1120 <onpoints@plt>
mov    %eax,%edi
mov    -0xb0(%rbp),%rsi
mov    -0xa8(%rbp),%rdx
mov    -0x68(%rbp),%rcx
mov    -0x38(%rbp),%r8d
call   1060 <trace_schreier@plt>
mov    -0x68(%rbp),%rdi
mov    -0x60(%rbp),%rsi
mov    -0x38(%rbp),%edx
call   1090 <inverse@plt>
mov    -0x58(%rbp),%rdi
mov    -0xf0(%rbp),%rsi
mov    -0x70(%rbp),%rdx
mov    -0x38(%rbp),%ecx
call   1080 <product@plt>
mov    -0x70(%rbp),%rdi
mov    -0x60(%rbp),%rsi
mov    -0xf8(%rbp),%rdx
mov    -0x38(%rbp),%ecx
call   1080 <product@plt>
mov    -0x100(%rbp),%rdi
mov    0x38(%rbp),%rax
mov    (%rax),%eax
imul   -0x38(%rbp),%eax
cltq
shl    $0x2,%rax
mov    %eax,%esi
call   10a0 <realloc@plt>
mov    %rax,-0x100(%rbp)
mov    0x20(%rbp),%rdi
mov    -0x3c(%rbp),%esi
mov    0x30(%rbp),%rax
mov    (%rax),%rdx
mov    0x38(%rbp),%rax
mov    (%rax),%ecx
mov    -0x38(%rbp),%r8d
mov    -0x100(%rbp),%r9
lea    -0x104(%rbp),%rax
mov    %rax,(%rsp)
call   10c0 <stabilizer@plt>
mov    -0xf8(%rbp),%rdi
mov    -0x38(%rbp),%esi
call   10f0 <isid@plt>
cmp    $0x0,%eax
jne    19d8 <schreier_sims_step+0x7d8>
cmpl   $0x0,-0x104(%rbp)
je     17ce <schreier_sims_step+0x5ce>
mov    -0xf8(%rbp),%rdi
mov    0x20(%rbp),%rsi
movslq -0x3c(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rsi
mov    0x28(%rbp),%rax
mov    (%rax),%edx
sub    -0x3c(%rbp),%edx
mov    -0x100(%rbp),%rcx
mov    -0x104(%rbp),%r8d
mov    -0x38(%rbp),%r9d
call   10b0 <perm_member@plt>
cmp    $0x0,%eax
jne    19d3 <schreier_sims_step+0x7d3>
mov    0x30(%rbp),%rax
mov    (%rax),%rdi
mov    0x38(%rbp),%rax
mov    (%rax),%eax
add    $0x1,%eax
imul   -0x38(%rbp),%eax
cltq
shl    $0x2,%rax
mov    %eax,%esi
call   10a0 <realloc@plt>
mov    %rax,%rcx
mov    0x30(%rbp),%rax
mov    %rcx,(%rax)
mov    -0xf8(%rbp),%rdi
mov    0x30(%rbp),%rax
mov    (%rax),%rsi
mov    0x38(%rbp),%rax
mov    (%rax),%eax
imul   -0x38(%rbp),%eax
cltq
shl    $0x2,%rax
add    %rax,%rsi
mov    -0x38(%rbp),%edx
call   10e0 <copy_list@plt>
mov    0x38(%rbp),%rax
mov    (%rax),%ecx
add    $0x1,%ecx
mov    %ecx,(%rax)
mov    -0xf8(%rbp),%rdi
mov    -0x38(%rbp),%esi
mov    -0x110(%rbp),%rdx
lea    -0x114(%rbp),%rcx
call   1100 <stable_points@plt>
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
mov    0x28(%rbp),%rcx
cmp    (%rcx),%eax
jge    18af <schreier_sims_step+0x6af>
mov    0x20(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,4),%edi
mov    -0x110(%rbp),%rsi
mov    -0x114(%rbp),%edx
call   1050 <position@plt>
cmp    $0x0,%rax
jne    1895 <schreier_sims_step+0x695>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    18af <schreier_sims_step+0x6af>
mov    0x28(%rbp),%rax
mov    (%rax),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1851 <schreier_sims_step+0x651>
mov    -0x44(%rbp),%eax
mov    0x28(%rbp),%rcx
mov    (%rcx),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jne    194a <schreier_sims_step+0x74a>
movl   $0x1,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x38(%rbp),%eax
jg     1945 <schreier_sims_step+0x745>
mov    -0x48(%rbp),%edi
mov    -0x110(%rbp),%rsi
mov    -0x114(%rbp),%edx
call   1050 <position@plt>
cmp    $0x0,%rax
jne    1932 <schreier_sims_step+0x732>
mov    -0x48(%rbp),%edi
mov    0x20(%rbp),%rsi
mov    0x28(%rbp),%rax
mov    (%rax),%edx
call   1050 <position@plt>
cmp    $0x0,%rax
jne    1932 <schreier_sims_step+0x732>
mov    -0x48(%rbp),%edx
mov    0x20(%rbp),%rax
mov    0x28(%rbp),%rcx
movslq (%rcx),%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x28(%rbp),%rax
mov    (%rax),%ecx
add    $0x1,%ecx
mov    %ecx,(%rax)
jmp    1945 <schreier_sims_step+0x745>
jmp    1937 <schreier_sims_step+0x737>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    18ca <schreier_sims_step+0x6ca>
jmp    194a <schreier_sims_step+0x74a>
mov    -0x44(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jle    19ce <schreier_sims_step+0x7ce>
mov    0x20(%rbp),%rdi
mov    0x28(%rbp),%rax
mov    (%rax),%esi
mov    0x30(%rbp),%rax
mov    (%rax),%rdx
mov    0x38(%rbp),%rax
mov    (%rax),%ecx
mov    -0x38(%rbp),%r8d
mov    -0x4c(%rbp),%r9d
mov    -0xf8(%rbp),%r15
mov    0x20(%rbp),%r14
mov    0x28(%rbp),%rbx
mov    0x30(%rbp),%r11
mov    0x38(%rbp),%r10
mov    0x40(%rbp),%rax
mov    %r15,(%rsp)
movl   $0x1,0x8(%rsp)
mov    %r14,0x10(%rsp)
mov    %rbx,0x18(%rsp)
mov    %r11,0x20(%rsp)
mov    %r10,0x28(%rsp)
mov    %rax,0x30(%rsp)
call   1110 <schreier_sims_step@plt>
mov    -0x4c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x4c(%rbp)
jmp    1950 <schreier_sims_step+0x750>
jmp    19d3 <schreier_sims_step+0x7d3>
jmp    19d8 <schreier_sims_step+0x7d8>
jmp    19dd <schreier_sims_step+0x7dd>
mov    -0xe8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xe8(%rbp)
jmp    163f <schreier_sims_step+0x43f>
jmp    19f6 <schreier_sims_step+0x7f6>
mov    -0xe4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xe4(%rbp)
jmp    15a5 <schreier_sims_step+0x3a5>
mov    -0x58(%rbp),%rdi
call   1030 <free@plt>
mov    -0x60(%rbp),%rdi
call   1030 <free@plt>
mov    -0x68(%rbp),%rdi
call   1030 <free@plt>
mov    -0x70(%rbp),%rdi
call   1030 <free@plt>
mov    -0x78(%rbp),%rdi
call   1030 <free@plt>
mov    -0x88(%rbp),%rdi
call   1030 <free@plt>
mov    -0x98(%rbp),%rdi
call   1030 <free@plt>
mov    -0xa8(%rbp),%rdi
call   1030 <free@plt>
mov    -0xb0(%rbp),%rdi
call   1030 <free@plt>
mov    -0xb8(%rbp),%rdi
call   1030 <free@plt>
mov    -0xc8(%rbp),%rdi
call   1030 <free@plt>
mov    -0xd0(%rbp),%rdi
call   1030 <free@plt>
mov    -0xd8(%rbp),%rdi
call   1030 <free@plt>
mov    -0xf0(%rbp),%rdi
call   1030 <free@plt>
mov    -0xf8(%rbp),%rdi
call   1030 <free@plt>
mov    -0x100(%rbp),%rdi
call   1030 <free@plt>
mov    -0x110(%rbp),%rdi
call   1030 <free@plt>
add    $0x138,%rsp
pop    %rbx
pop    %r14
pop    %r15
pop    %rbp
ret

x86 assembly (clang, -O2):
<schreier_sims_step>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xf8,%rsp
mov    %r9,0x50(%rsp)
mov    %ecx,%r14d
mov    %ecx,0x90(%rsp)
mov    %rdx,0x18(%rsp)
mov    %esi,0x14(%rsp)
mov    %rdi,0x8(%rsp)
lea    0x0(,%r8,4),%ebx
mov    %r8,%rbp
mov    %ebx,%edi
call   1070 <malloc@plt>
mov    %rax,0xe0(%rsp)
mov    %ebx,%edi
call   1070 <malloc@plt>
mov    %rax,0xd8(%rsp)
mov    %ebx,%edi
call   1070 <malloc@plt>
mov    %rax,0xd0(%rsp)
mov    %ebx,%edi
call   1070 <malloc@plt>
mov    %rax,0xc8(%rsp)
mov    %ebp,%eax
mov    %rbp,%r15
mov    %rbp,(%rsp)
imul   %r14d,%eax
lea    0x0(,%rax,4),%r13d
mov    %rax,%r14
mov    %r13d,%edi
call   1070 <malloc@plt>
mov    %rax,0x68(%rsp)
mov    %r13d,%edi
call   1070 <malloc@plt>
mov    %rax,0x60(%rsp)
mov    %ebx,%edi
call   1070 <malloc@plt>
mov    %rax,0x80(%rsp)
mov    %ebx,%edi
call   1070 <malloc@plt>
mov    %rax,0x20(%rsp)
mov    %ebx,%ebp
imul   %r15d,%ebp
mov    %ebp,%edi
call   1070 <malloc@plt>
mov    %rax,0x38(%rsp)
mov    %ebx,%edi
call   1070 <malloc@plt>
mov    %rax,0x78(%rsp)
mov    %ebx,%edi
call   1070 <malloc@plt>
mov    %rax,0x70(%rsp)
mov    %ebp,%edi
call   1070 <malloc@plt>
mov    %rax,0x58(%rsp)
mov    %r13d,%edi
call   1070 <malloc@plt>
mov    %rax,0x40(%rsp)
mov    %ebx,%edi
call   1070 <malloc@plt>
mov    %rax,0xc0(%rsp)
mov    %ebx,%edi
call   1070 <malloc@plt>
mov    %rax,%r15
mov    %r13d,%edi
call   1070 <malloc@plt>
mov    %rax,0x98(%rsp)
mov    %ebx,0x2c(%rsp)
mov    %ebx,%edi
call   1070 <malloc@plt>
mov    %rax,%r12
mov    0x8(%rsp),%rbx
mov    %rbx,%rdi
mov    0x140(%rsp),%rsi
mov    0x14(%rsp),%ebp
mov    %ebp,%edx
call   10e0 <copy_list@plt>
mov    0x148(%rsp),%rax
mov    %ebp,(%rax)
mov    0x150(%rsp),%rax
mov    (%rax),%rsi
mov    0x18(%rsp),%rbp
mov    %rbp,%rdi
mov    %r14d,%edx
call   10e0 <copy_list@plt>
mov    0x90(%rsp),%ecx
mov    0x158(%rsp),%rax
mov    %ecx,(%rax)
mov    0x50(%rsp),%r14
lea    -0x1(%r14),%esi
sub    $0x8,%rsp
lea    0x18(%rsp),%rax
mov    %rbx,%rdi
mov    %rbp,%rdx
mov    0x8(%rsp),%r13
mov    %r13d,%r8d
mov    0x70(%rsp),%rbp
mov    %rbp,%r9
push   %rax
call   10c0 <stabilizer@plt>
add    $0x10,%rsp
mov    0x10(%rsp),%esi
sub    $0x8,%rsp
lea    0xbc(%rsp),%rax
mov    %rbp,%rdi
mov    0x138(%rsp),%rdx
mov    0x140(%rsp),%ecx
mov    %r13d,%r8d
mov    0x68(%rsp),%r9
push   %rax
call   1040 <complement@plt>
add    $0x10,%rsp
movslq %r14d,%rbx
mov    0x8(%rsp),%r14
mov    -0x4(%r14,%rbx,4),%edi
mov    0x10(%rsp),%edx
sub    $0x8,%rsp
lea    0x3c(%rsp),%r9
mov    %rbp,%rsi
mov    %r13d,%ecx
mov    0x88(%rsp),%r8
push   $0x1
push   0x30(%rsp)
push   0x50(%rsp)
call   10d0 <one_schreier_orbit@plt>
add    $0x20,%rsp
mov    %rbx,0x18(%rsp)
mov    -0x4(%r14,%rbx,4),%edi
mov    0xb4(%rsp),%edx
sub    $0x8,%rsp
lea    0xb8(%rsp),%r9
mov    0x68(%rsp),%rsi
mov    %r13d,%ecx
mov    0x80(%rsp),%r8
push   $0x1
mov    0x80(%rsp),%rbx
push   %rbx
push   0x70(%rsp)
call   10d0 <one_schreier_orbit@plt>
add    $0x20,%rsp
test   %r13d,%r13d
jle    14ea <schreier_sims_step+0x2ea>
mov    %rbx,%rdx
mov    (%rsp),%r14d
lea    0x0(,%r14,4),%rdi
xor    %r13d,%r13d
mov    0x38(%rsp),%rbx
mov    0x58(%rsp),%rbp
mov    %rdi,0x8(%rsp)
jmp    14af <schreier_sims_step+0x2af>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r13
add    %rdi,%rbp
add    %rdi,%rbx
cmp    %r13,%r14
je     14ea <schreier_sims_step+0x2ea>
mov    (%rdx,%r13,4),%eax
mov    0x20(%rsp),%rcx
cmp    %eax,(%rcx,%r13,4)
je     14a0 <schreier_sims_step+0x2a0>
test   %eax,%eax
je     14a0 <schreier_sims_step+0x2a0>
mov    %rbp,%rdi
mov    %rbx,%rsi
mov    (%rsp),%rdx
call   10e0 <copy_list@plt>
mov    0x8(%rsp),%rdi
mov    0x70(%rsp),%rdx
mov    (%rdx,%r13,4),%eax
mov    0x20(%rsp),%rcx
mov    %eax,(%rcx,%r13,4)
jmp    14a0 <schreier_sims_step+0x2a0>
cmpl   $0x0,0x34(%rsp)
jle    1962 <schreier_sims_step+0x762>
mov    0x160(%rsp),%rbp
mov    0x138(%rsp),%ecx
mov    (%rsp),%rax
imul   %eax,%ecx
mov    %ecx,0xa8(%rsp)
mov    0x140(%rsp),%r13
mov    0x18(%rsp),%rcx
lea    0x0(,%rcx,4),%rcx
add    %r13,%rcx
mov    %rcx,0xf0(%rsp)
movslq %eax,%rcx
mov    %rcx,0x18(%rsp)
mov    %eax,%ebx
neg    %ebx
xor    %eax,%eax
mov    %rcx,0x88(%rsp)
mov    %r15,0xa0(%rsp)
mov    %r12,0x48(%rsp)
mov    %rbx,0xe8(%rsp)
jmp    1580 <schreier_sims_step+0x380>
nop
mov    0xb8(%rsp),%rax
add    $0x1,%rax
mov    %rax,%rcx
movslq 0x34(%rsp),%rax
cmp    %rax,%rcx
mov    %rcx,%rax
jge    1962 <schreier_sims_step+0x762>
mov    %rax,%rcx
mov    0x80(%rsp),%rax
mov    %rcx,0xb8(%rsp)
mov    (%rax,%rcx,4),%edi
mov    0xb0(%rsp),%edx
mov    %edi,0x14(%rsp)
mov    0x78(%rsp),%rsi
call   1050 <position@plt>
test   %rax,%rax
je     15e0 <schreier_sims_step+0x3e0>
mov    0x130(%rsp),%rdi
mov    0x40(%rsp),%rsi
mov    0xa8(%rsp),%edx
call   10e0 <copy_list@plt>
mov    0x138(%rsp),%eax
test   %eax,%eax
jg     1603 <schreier_sims_step+0x403>
jmp    1560 <schreier_sims_step+0x360>
cs nopw 0x0(%rax,%rax,1)
mov    0x10(%rsp),%edx
imul   (%rsp),%edx
mov    0x68(%rsp),%rdi
mov    0x40(%rsp),%rsi
call   10e0 <copy_list@plt>
mov    0x10(%rsp),%eax
test   %eax,%eax
jle    1560 <schreier_sims_step+0x360>
mov    %eax,%eax
mov    %rax,0x90(%rsp)
xor    %eax,%eax
jmp    1644 <schreier_sims_step+0x444>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x48(%rsp),%r12
mov    0x160(%rsp),%rbp
mov    0x8(%rsp),%rax
add    $0x1,%rax
cmp    0x90(%rsp),%rax
je     1560 <schreier_sims_step+0x360>
mov    %rax,0x8(%rsp)
imul   0x18(%rsp),%rax
mov    0x40(%rsp),%rcx
lea    (%rcx,%rax,4),%rdi
mov    0xc0(%rsp),%r12
mov    %r12,%rsi
mov    (%rsp),%r14
mov    %r14d,%edx
call   10e0 <copy_list@plt>
addl   $0x1,0x0(%rbp)
mov    0x14(%rsp),%ebx
mov    %ebx,%edi
mov    0x38(%rsp),%rbp
mov    %rbp,%rsi
mov    0x20(%rsp),%r13
mov    %r13,%rdx
mov    0xe0(%rsp),%r15
mov    %r15,%rcx
mov    %r14d,%r8d
call   1060 <trace_schreier@plt>
mov    %ebx,%edi
mov    %r12,%rsi
mov    %r14d,%edx
call   1120 <onpoints@plt>
mov    %eax,%edi
mov    %rbp,%rsi
mov    %r13,%rdx
mov    0xd0(%rsp),%rbx
mov    %rbx,%rcx
mov    %r14d,%r8d
call   1060 <trace_schreier@plt>
mov    %rbx,%rdi
mov    0xd8(%rsp),%r13
mov    %r13,%rsi
mov    %r14d,%edx
call   1090 <inverse@plt>
mov    %r15,%rdi
mov    0xa0(%rsp),%r15
mov    %r12,%rsi
mov    0xc8(%rsp),%rbx
mov    %rbx,%rdx
mov    %r14d,%ecx
call   1080 <product@plt>
mov    %rbx,%rdi
mov    %r13,%rsi
mov    %r15,%rdx
mov    %r14d,%ecx
call   1080 <product@plt>
mov    0x158(%rsp),%rbp
mov    0x0(%rbp),%esi
imul   0x2c(%rsp),%esi
mov    0x98(%rsp),%rdi
call   10a0 <realloc@plt>
mov    %rax,%rbx
mov    0x150(%rsp),%rax
mov    (%rax),%rdx
mov    0x0(%rbp),%ecx
sub    $0x8,%rsp
mov    0x148(%rsp),%r13
mov    %r13,%rdi
mov    0x58(%rsp),%rbp
mov    %ebp,%esi
mov    %r14d,%r8d
mov    %rbx,%r9
lea    0xb4(%rsp),%rax
push   %rax
call   10c0 <stabilizer@plt>
add    $0x10,%rsp
mov    %r15,%rdi
mov    %r14d,%esi
call   10f0 <isid@plt>
test   %eax,%eax
mov    %rbx,0x98(%rsp)
jne    1620 <schreier_sims_step+0x420>
mov    0xac(%rsp),%r8d
test   %r8d,%r8d
mov    0x148(%rsp),%r14
je     17bc <schreier_sims_step+0x5bc>
mov    (%r14),%edx
sub    %ebp,%edx
mov    %r15,%rdi
mov    0xf0(%rsp),%rsi
mov    %rbx,%rcx
mov    (%rsp),%r9
call   10b0 <perm_member@plt>
test   %eax,%eax
jne    1620 <schreier_sims_step+0x420>
mov    0x150(%rsp),%rbx
mov    (%rbx),%rdi
mov    0x158(%rsp),%rbp
mov    0x0(%rbp),%esi
add    $0x1,%esi
imul   0x2c(%rsp),%esi
call   10a0 <realloc@plt>
mov    %rax,(%rbx)
movslq 0x0(%rbp),%rcx
imul   0x18(%rsp),%rcx
lea    (%rax,%rcx,4),%rsi
mov    %r15,%rdi
mov    (%rsp),%rbx
mov    %ebx,%edx
call   10e0 <copy_list@plt>
addl   $0x1,0x0(%rbp)
mov    %r15,%rdi
mov    %ebx,%esi
mov    0x48(%rsp),%r12
mov    %r12,%rdx
lea    0x30(%rsp),%rcx
call   1100 <stable_points@plt>
mov    (%r14),%eax
test   %eax,%eax
mov    0xe8(%rsp),%rbx
mov    0x88(%rsp),%rbp
jle    186d <schreier_sims_step+0x66d>
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x0(%r13,%rbp,4),%edi
mov    0x30(%rsp),%edx
mov    %r12,%rsi
call   1050 <position@plt>
test   %rax,%rax
je     1867 <schreier_sims_step+0x667>
movslq (%r14),%rax
add    $0x1,%rbp
cmp    %rax,%rbp
jl     1840 <schreier_sims_step+0x640>
lea    0x1(%rax),%ebp
jmp    186d <schreier_sims_step+0x66d>
add    $0x1,%ebp
mov    (%r14),%eax
add    $0x1,%eax
mov    %rbp,0x88(%rsp)
cmp    %eax,%ebp
jne    18e0 <schreier_sims_step+0x6e0>
cmpl   $0x0,(%rsp)
jle    18e0 <schreier_sims_step+0x6e0>
mov    $0x1,%ebp
jmp    18a2 <schreier_sims_step+0x6a2>
nopl   0x0(%rax)
lea    (%rbx,%rbp,1),%eax
add    $0x1,%eax
mov    %ebp,%ecx
add    $0x1,%ecx
mov    %ecx,%ebp
cmp    $0x1,%eax
je     18e0 <schreier_sims_step+0x6e0>
mov    0x30(%rsp),%edx
mov    %ebp,%edi
mov    %r12,%rsi
call   1050 <position@plt>
test   %rax,%rax
jne    1890 <schreier_sims_step+0x690>
mov    (%r14),%edx
mov    %ebp,%edi
mov    %r13,%rsi
call   1050 <position@plt>
test   %rax,%rax
jne    1890 <schreier_sims_step+0x690>
movslq (%r14),%rax
mov    %ebp,0x0(%r13,%rax,4)
addl   $0x1,(%r14)
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x50(%rsp),%rdx
mov    0x88(%rsp),%rcx
cmp    %edx,%ecx
jle    1625 <schreier_sims_step+0x425>
mov    0x158(%rsp),%r15
mov    0x150(%rsp),%r12
mov    %ecx,%ebp
mov    0x160(%rsp),%rbx
nop
mov    (%r14),%esi
mov    (%r12),%rdx
mov    (%r15),%ecx
sub    $0x8,%rsp
mov    %r13,%rdi
mov    0x8(%rsp),%r8
mov    %ebp,%r9d
push   %rbx
push   %r15
push   %r12
push   %r14
push   %r13
push   $0x1
push   0xd8(%rsp)
call   1110 <schreier_sims_step@plt>
add    $0x40,%rsp
add    $0xffffffff,%ebp
cmp    0x50(%rsp),%ebp
jg     1910 <schreier_sims_step+0x710>
mov    0xa0(%rsp),%r15
mov    0x48(%rsp),%r12
mov    %rbx,%rbp
jmp    162d <schreier_sims_step+0x42d>
mov    0xe0(%rsp),%rdi
call   1030 <free@plt>
mov    0xd8(%rsp),%rdi
call   1030 <free@plt>
mov    0xd0(%rsp),%rdi
call   1030 <free@plt>
mov    0xc8(%rsp),%rdi
call   1030 <free@plt>
mov    0x68(%rsp),%rdi
call   1030 <free@plt>
mov    0x60(%rsp),%rdi
call   1030 <free@plt>
mov    0x80(%rsp),%rdi
call   1030 <free@plt>
mov    0x20(%rsp),%rdi
call   1030 <free@plt>
mov    0x38(%rsp),%rdi
call   1030 <free@plt>
mov    0x78(%rsp),%rdi
call   1030 <free@plt>
mov    0x70(%rsp),%rdi
call   1030 <free@plt>
mov    0x58(%rsp),%rdi
call   1030 <free@plt>
mov    0x40(%rsp),%rdi
call   1030 <free@plt>
mov    0xc0(%rsp),%rdi
call   1030 <free@plt>
mov    %r15,%rdi
call   1030 <free@plt>
mov    0x98(%rsp),%rdi
call   1030 <free@plt>
mov    %r12,%rdi
call   1030 <free@plt>
add    $0xf8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @schreier_sims_step(i32* %0, i32 %1, i32* %2, i32 %3, i32 %4, i32 %5, i32* %6, i32 %7, i32* %8, i32* %9, i32** %10, i32* %11, i32* %12) {
%14 = alloca i32*
%15 = alloca i32
%16 = alloca i32*
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
%20 = alloca i32*
%21 = alloca i32
%22 = alloca i32*
%23 = alloca i32*
%24 = alloca i32**
%25 = alloca i32*
%26 = alloca i32*
%27 = alloca i32
%28 = alloca i32
%29 = alloca i32
%30 = alloca i32
%31 = alloca i32*
%32 = alloca i32*
%33 = alloca i32*
%34 = alloca i32*
%35 = alloca i32*
%36 = alloca i32
%37 = alloca i32*
%38 = alloca i32
%39 = alloca i32*
%40 = alloca i32
%41 = alloca i32*
%42 = alloca i32*
%43 = alloca i32*
%44 = alloca i32
%45 = alloca i32*
%46 = alloca i32*
%47 = alloca i32*
%48 = alloca i32
%49 = alloca i32
%50 = alloca i32
%51 = alloca i32
%52 = alloca i32*
%53 = alloca i32*
%54 = alloca i32*
%55 = alloca i32
%56 = alloca i32*
%57 = alloca i32
store i32* %0, i32** %14
store i32 %1, i32* %15
store i32* %2, i32** %16
store i32 %3, i32* %17
store i32 %4, i32* %18
store i32 %5, i32* %19
store i32* %6, i32** %20
store i32 %7, i32* %21
store i32* %8, i32** %22
store i32* %9, i32** %23
store i32** %10, i32*** %24
store i32* %11, i32** %25
store i32* %12, i32** %26
%58 = load i32, i32* %18
%59 = sext i32 %58 to i64
%60 = mul i64 %59, 4
%61 = trunc i64 %60 to i32
%62 = call i64 @malloc(i32 %61)
%63 = inttoptr i64 %62 to i32*
store i32* %63, i32** %31
%64 = load i32, i32* %18
%65 = sext i32 %64 to i64
%66 = mul i64 %65, 4
%67 = trunc i64 %66 to i32
%68 = call i64 @malloc(i32 %67)
%69 = inttoptr i64 %68 to i32*
store i32* %69, i32** %32
%70 = load i32, i32* %18
%71 = sext i32 %70 to i64
%72 = mul i64 %71, 4
%73 = trunc i64 %72 to i32
%74 = call i64 @malloc(i32 %73)
%75 = inttoptr i64 %74 to i32*
store i32* %75, i32** %33
%76 = load i32, i32* %18
%77 = sext i32 %76 to i64
%78 = mul i64 %77, 4
%79 = trunc i64 %78 to i32
%80 = call i64 @malloc(i32 %79)
%81 = inttoptr i64 %80 to i32*
store i32* %81, i32** %34
%82 = load i32, i32* %17
%83 = load i32, i32* %18
%84 = mul nsw i32 %82, %83
%85 = sext i32 %84 to i64
%86 = mul i64 %85, 4
%87 = trunc i64 %86 to i32
%88 = call i64 @malloc(i32 %87)
%89 = inttoptr i64 %88 to i32*
store i32* %89, i32** %35
%90 = load i32, i32* %17
%91 = load i32, i32* %18
%92 = mul nsw i32 %90, %91
%93 = sext i32 %92 to i64
%94 = mul i64 %93, 4
%95 = trunc i64 %94 to i32
%96 = call i64 @malloc(i32 %95)
%97 = inttoptr i64 %96 to i32*
store i32* %97, i32** %37
%98 = load i32, i32* %18
%99 = sext i32 %98 to i64
%100 = mul i64 %99, 4
%101 = trunc i64 %100 to i32
%102 = call i64 @malloc(i32 %101)
%103 = inttoptr i64 %102 to i32*
store i32* %103, i32** %39
%104 = load i32, i32* %18
%105 = sext i32 %104 to i64
%106 = mul i64 %105, 4
%107 = trunc i64 %106 to i32
%108 = call i64 @malloc(i32 %107)
%109 = inttoptr i64 %108 to i32*
store i32* %109, i32** %41
%110 = load i32, i32* %18
%111 = load i32, i32* %18
%112 = mul nsw i32 %110, %111
%113 = sext i32 %112 to i64
%114 = mul i64 %113, 4
%115 = trunc i64 %114 to i32
%116 = call i64 @malloc(i32 %115)
%117 = inttoptr i64 %116 to i32*
store i32* %117, i32** %42
%118 = load i32, i32* %18
%119 = sext i32 %118 to i64
%120 = mul i64 %119, 4
%121 = trunc i64 %120 to i32
%122 = call i64 @malloc(i32 %121)
%123 = inttoptr i64 %122 to i32*
store i32* %123, i32** %43
%124 = load i32, i32* %18
%125 = sext i32 %124 to i64
%126 = mul i64 %125, 4
%127 = trunc i64 %126 to i32
%128 = call i64 @malloc(i32 %127)
%129 = inttoptr i64 %128 to i32*
store i32* %129, i32** %45
%130 = load i32, i32* %18
%131 = load i32, i32* %18
%132 = mul nsw i32 %130, %131
%133 = sext i32 %132 to i64
%134 = mul i64 %133, 4
%135 = trunc i64 %134 to i32
%136 = call i64 @malloc(i32 %135)
%137 = inttoptr i64 %136 to i32*
store i32* %137, i32** %46
%138 = load i32, i32* %17
%139 = load i32, i32* %18
%140 = mul nsw i32 %138, %139
%141 = sext i32 %140 to i64
%142 = mul i64 %141, 4
%143 = trunc i64 %142 to i32
%144 = call i64 @malloc(i32 %143)
%145 = inttoptr i64 %144 to i32*
store i32* %145, i32** %47
%146 = load i32, i32* %18
%147 = sext i32 %146 to i64
%148 = mul i64 %147, 4
%149 = trunc i64 %148 to i32
%150 = call i64 @malloc(i32 %149)
%151 = inttoptr i64 %150 to i32*
store i32* %151, i32** %52
%152 = load i32, i32* %18
%153 = sext i32 %152 to i64
%154 = mul i64 %153, 4
%155 = trunc i64 %154 to i32
%156 = call i64 @malloc(i32 %155)
%157 = inttoptr i64 %156 to i32*
store i32* %157, i32** %53
%158 = load i32, i32* %17
%159 = load i32, i32* %18
%160 = mul nsw i32 %158, %159
%161 = sext i32 %160 to i64
%162 = mul i64 %161, 4
%163 = trunc i64 %162 to i32
%164 = call i64 @malloc(i32 %163)
%165 = inttoptr i64 %164 to i32*
store i32* %165, i32** %54
%166 = load i32, i32* %18
%167 = sext i32 %166 to i64
%168 = mul i64 %167, 4
%169 = trunc i64 %168 to i32
%170 = call i64 @malloc(i32 %169)
%171 = inttoptr i64 %170 to i32*
store i32* %171, i32** %56
%172 = load i32*, i32** %14
%173 = load i32*, i32** %22
%174 = load i32, i32* %15
%175 = call i32 @copy_list(i32* %172, i32* %173, i32 %174)
%176 = load i32, i32* %15
%177 = load i32*, i32** %23
store i32 %176, i32* %177
%178 = load i32*, i32** %16
%179 = load i32**, i32*** %24
%180 = load i32*, i32** %179
%181 = load i32, i32* %17
%182 = load i32, i32* %18
%183 = mul nsw i32 %181, %182
%184 = call i32 @copy_list(i32* %178, i32* %180, i32 %183)
%185 = load i32, i32* %17
%186 = load i32*, i32** %25
store i32 %185, i32* %186
%187 = load i32*, i32** %14
%188 = load i32, i32* %19
%189 = sub nsw i32 %188, 1
%190 = load i32*, i32** %16
%191 = load i32, i32* %17
%192 = load i32, i32* %18
%193 = load i32*, i32** %35
%194 = call i32 @stabilizer(i32* %187, i32 %189, i32* %190, i32 %191, i32 %192, i32* %193, i32* %36)
%195 = load i32*, i32** %35
%196 = load i32, i32* %36
%197 = load i32*, i32** %20
%198 = load i32, i32* %21
%199 = load i32, i32* %18
%200 = load i32*, i32** %37
%201 = call i32 @complement(i32* %195, i32 %196, i32* %197, i32 %198, i32 %199, i32* %200, i32* %38)
%202 = load i32*, i32** %14
%203 = load i32, i32* %19
%204 = sub nsw i32 %203, 1
%205 = sext i32 %204 to i64
%206 = getelementptr inbounds i32, i32* %202, i64 %205
%207 = load i32, i32* %206
%208 = load i32*, i32** %35
%209 = load i32, i32* %36
%210 = load i32, i32* %18
%211 = load i32*, i32** %39
%212 = load i32*, i32** %42
%213 = load i32*, i32** %41
%214 = call i32 @one_schreier_orbit(i32 %207, i32* %208, i32 %209, i32 %210, i32* %211, i32* %40, i32* %212, i32* %213, i32 1)
%215 = load i32*, i32** %14
%216 = load i32, i32* %19
%217 = sub nsw i32 %216, 1
%218 = sext i32 %217 to i64
%219 = getelementptr inbounds i32, i32* %215, i64 %218
%220 = load i32, i32* %219
%221 = load i32*, i32** %37
%222 = load i32, i32* %38
%223 = load i32, i32* %18
%224 = load i32*, i32** %43
%225 = load i32*, i32** %46
%226 = load i32*, i32** %45
%227 = call i32 @one_schreier_orbit(i32 %220, i32* %221, i32 %222, i32 %223, i32* %224, i32* %44, i32* %225, i32* %226, i32 1)
store i32 0, i32* %27
br label %228
228: ; preds = %276, %13
%229 = load i32, i32* %27
%230 = load i32, i32* %18
%231 = icmp slt i32 %229, %230
br i1 %231, label %232, label %279
232: ; preds = %228
%233 = load i32*, i32** %41
%234 = load i32, i32* %27
%235 = sext i32 %234 to i64
%236 = getelementptr inbounds i32, i32* %233, i64 %235
%237 = load i32, i32* %236
%238 = load i32*, i32** %45
%239 = load i32, i32* %27
%240 = sext i32 %239 to i64
%241 = getelementptr inbounds i32, i32* %238, i64 %240
%242 = load i32, i32* %241
%243 = icmp ne i32 %237, %242
br i1 %243, label %244, label %275
244: ; preds = %232
%245 = load i32*, i32** %45
%246 = load i32, i32* %27
%247 = sext i32 %246 to i64
%248 = getelementptr inbounds i32, i32* %245, i64 %247
%249 = load i32, i32* %248
%250 = icmp ne i32 %249, 0
br i1 %250, label %251, label %275
251: ; preds = %244
%252 = load i32*, i32** %46
%253 = load i32, i32* %27
%254 = load i32, i32* %18
%255 = mul nsw i32 %253, %254
%256 = sext i32 %255 to i64
%257 = getelementptr inbounds i32, i32* %252, i64 %256
%258 = load i32*, i32** %42
%259 = load i32, i32* %27
%260 = load i32, i32* %18
%261 = mul nsw i32 %259, %260
%262 = sext i32 %261 to i64
%263 = getelementptr inbounds i32, i32* %258, i64 %262
%264 = load i32, i32* %18
%265 = call i32 @copy_list(i32* %257, i32* %263, i32 %264)
%266 = load i32*, i32** %45
%267 = load i32, i32* %27
%268 = sext i32 %267 to i64
%269 = getelementptr inbounds i32, i32* %266, i64 %268
%270 = load i32, i32* %269
%271 = load i32*, i32** %41
%272 = load i32, i32* %27
%273 = sext i32 %272 to i64
%274 = getelementptr inbounds i32, i32* %271, i64 %273
store i32 %270, i32* %274
br label %275
275: ; preds = %251, %244, %232
br label %276
276: ; preds = %275
%277 = load i32, i32* %27
%278 = add nsw i32 %277, 1
store i32 %278, i32* %27
br label %228
279: ; preds = %228
store i32 0, i32* %50
br label %280
280: ; preds = %527, %279
%281 = load i32, i32* %50
%282 = load i32, i32* %40
%283 = icmp slt i32 %281, %282
br i1 %283, label %284, label %530
284: ; preds = %280
%285 = load i32*, i32** %39
%286 = load i32, i32* %50
%287 = sext i32 %286 to i64
%288 = getelementptr inbounds i32, i32* %285, i64 %287
%289 = load i32, i32* %288
store i32 %289, i32* %49
%290 = load i32, i32* %49
%291 = load i32*, i32** %43
%292 = load i32, i32* %44
%293 = call i64 @position(i32 %290, i32* %291, i32 %292)
%294 = icmp ne i64 %293, 0
br i1 %294, label %295, label %303
295: ; preds = %284
%296 = load i32*, i32** %20
%297 = load i32*, i32** %47
%298 = load i32, i32* %21
%299 = load i32, i32* %18
%300 = mul nsw i32 %298, %299
%301 = call i32 @copy_list(i32* %296, i32* %297, i32 %300)
%302 = load i32, i32* %21
store i32 %302, i32* %48
br label %311
303: ; preds = %284
%304 = load i32*, i32** %35
%305 = load i32*, i32** %47
%306 = load i32, i32* %36
%307 = load i32, i32* %18
%308 = mul nsw i32 %306, %307
%309 = call i32 @copy_list(i32* %304, i32* %305, i32 %308)
%310 = load i32, i32* %36
store i32 %310, i32* %48
br label %311
311: ; preds = %303, %295
store i32 0, i32* %51
br label %312
312: ; preds = %523, %311
%313 = load i32, i32* %51
%314 = load i32, i32* %48
%315 = icmp slt i32 %313, %314
br i1 %315, label %316, label %526
316: ; preds = %312
%317 = load i32*, i32** %47
%318 = load i32, i32* %51
%319 = load i32, i32* %18
%320 = mul nsw i32 %318, %319
%321 = sext i32 %320 to i64
%322 = getelementptr inbounds i32, i32* %317, i64 %321
%323 = load i32*, i32** %52
%324 = load i32, i32* %18
%325 = call i32 @copy_list(i32* %322, i32* %323, i32 %324)
%326 = load i32*, i32** %26
%327 = load i32, i32* %326
%328 = add nsw i32 %327, 1
store i32 %328, i32* %326
%329 = load i32, i32* %49
%330 = load i32*, i32** %42
%331 = load i32*, i32** %41
%332 = load i32*, i32** %31
%333 = load i32, i32* %18
%334 = call i32 @trace_schreier(i32 %329, i32* %330, i32* %331, i32* %332, i32 %333)
%335 = load i32, i32* %49
%336 = load i32*, i32** %52
%337 = load i32, i32* %18
%338 = call i32 @onpoints(i32 %335, i32* %336, i32 %337)
%339 = load i32*, i32** %42
%340 = load i32*, i32** %41
%341 = load i32*, i32** %33
%342 = load i32, i32* %18
%343 = call i32 @trace_schreier(i32 %338, i32* %339, i32* %340, i32* %341, i32 %342)
%344 = load i32*, i32** %33
%345 = load i32*, i32** %32
%346 = load i32, i32* %18
%347 = call i32 @inverse(i32* %344, i32* %345, i32 %346)
%348 = load i32*, i32** %31
%349 = load i32*, i32** %52
%350 = load i32*, i32** %34
%351 = load i32, i32* %18
%352 = call i32 @product(i32* %348, i32* %349, i32* %350, i32 %351)
%353 = load i32*, i32** %34
%354 = load i32*, i32** %32
%355 = load i32*, i32** %53
%356 = load i32, i32* %18
%357 = call i32 @product(i32* %353, i32* %354, i32* %355, i32 %356)
%358 = load i32*, i32** %54
%359 = load i32*, i32** %25
%360 = load i32, i32* %359
%361 = load i32, i32* %18
%362 = mul nsw i32 %360, %361
%363 = sext i32 %362 to i64
%364 = mul i64 %363, 4
%365 = trunc i64 %364 to i32
%366 = call i64 @realloc(i32* %358, i32 %365)
%367 = inttoptr i64 %366 to i32*
store i32* %367, i32** %54
%368 = load i32*, i32** %22
%369 = load i32, i32* %19
%370 = load i32**, i32*** %24
%371 = load i32*, i32** %370
%372 = load i32*, i32** %25
%373 = load i32, i32* %372
%374 = load i32, i32* %18
%375 = load i32*, i32** %54
%376 = call i32 @stabilizer(i32* %368, i32 %369, i32* %371, i32 %373, i32 %374, i32* %375, i32* %55)
%377 = load i32*, i32** %53
%378 = load i32, i32* %18
%379 = call i32 @isid(i32* %377, i32 %378)
%380 = icmp ne i32 %379, 0
br i1 %380, label %522, label %381
381: ; preds = %316
%382 = load i32, i32* %55
%383 = icmp eq i32 %382, 0
br i1 %383, label %399, label %384
384: ; preds = %381
%385 = load i32*, i32** %53
%386 = load i32*, i32** %22
%387 = load i32, i32* %19
%388 = sext i32 %387 to i64
%389 = getelementptr inbounds i32, i32* %386, i64 %388
%390 = load i32*, i32** %23
%391 = load i32, i32* %390
%392 = load i32, i32* %19
%393 = sub nsw i32 %391, %392
%394 = load i32*, i32** %54
%395 = load i32, i32* %55
%396 = load i32, i32* %18
%397 = call i32 @perm_member(i32* %385, i32* %389, i32 %393, i32* %394, i32 %395, i32 %396)
%398 = icmp ne i32 %397, 0
br i1 %398, label %521, label %399
399: ; preds = %384, %381
%400 = load i32**, i32*** %24
%401 = load i32*, i32** %400
%402 = load i32*, i32** %25
%403 = load i32, i32* %402
%404 = add nsw i32 %403, 1
%405 = load i32, i32* %18
%406 = mul nsw i32 %404, %405
%407 = sext i32 %406 to i64
%408 = mul i64 %407, 4
%409 = trunc i64 %408 to i32
%410 = call i64 @realloc(i32* %401, i32 %409)
%411 = inttoptr i64 %410 to i32*
%412 = load i32**, i32*** %24
store i32* %411, i32** %412
%413 = load i32*, i32** %53
%414 = load i32**, i32*** %24
%415 = load i32*, i32** %414
%416 = load i32*, i32** %25
%417 = load i32, i32* %416
%418 = load i32, i32* %18
%419 = mul nsw i32 %417, %418
%420 = sext i32 %419 to i64
%421 = getelementptr inbounds i32, i32* %415, i64 %420
%422 = load i32, i32* %18
%423 = call i32 @copy_list(i32* %413, i32* %421, i32 %422)
%424 = load i32*, i32** %25
%425 = load i32, i32* %424
%426 = add nsw i32 %425, 1
store i32 %426, i32* %424
%427 = load i32*, i32** %53
%428 = load i32, i32* %18
%429 = load i32*, i32** %56
%430 = call i32 @stable_points(i32* %427, i32 %428, i32* %429, i32* %57)
store i32 0, i32* %29
br label %431
431: ; preds = %453, %399
%432 = load i32, i32* %29
%433 = load i32*, i32** %23
%434 = load i32, i32* %433
%435 = icmp slt i32 %432, %434
br i1 %435, label %436, label %456
436: ; preds = %431
%437 = load i32*, i32** %22
%438 = load i32, i32* %29
%439 = sext i32 %438 to i64
%440 = getelementptr inbounds i32, i32* %437, i64 %439
%441 = load i32, i32* %440
%442 = load i32*, i32** %56
%443 = load i32, i32* %57
%444 = call i64 @position(i32 %441, i32* %442, i32 %443)
%445 = icmp ne i64 %444, 0
br i1 %445, label %449, label %446
446: ; preds = %436
%447 = load i32, i32* %29
%448 = add nsw i32 %447, 1
store i32 %448, i32* %28
br label %456
449: ; preds = %436
%450 = load i32*, i32** %23
%451 = load i32, i32* %450
%452 = add nsw i32 %451, 1
store i32 %452, i32* %28
br label %453
453: ; preds = %449
%454 = load i32, i32* %29
%455 = add nsw i32 %454, 1
store i32 %455, i32* %29
br label %431
456: ; preds = %446, %431
%457 = load i32, i32* %28
%458 = load i32*, i32** %23
%459 = load i32, i32* %458
%460 = add nsw i32 %459, 1
%461 = icmp eq i32 %457, %460
br i1 %461, label %462, label %495
462: ; preds = %456
store i32 1, i32* %29
br label %463
463: ; preds = %491, %462
%464 = load i32, i32* %29
%465 = load i32, i32* %18
%466 = icmp sle i32 %464, %465
br i1 %466, label %467, label %494
467: ; preds = %463
%468 = load i32, i32* %29
%469 = load i32*, i32** %56
%470 = load i32, i32* %57
%471 = call i64 @position(i32 %468, i32* %469, i32 %470)
%472 = icmp ne i64 %471, 0
br i1 %472, label %490, label %473
473: ; preds = %467
%474 = load i32, i32* %29
%475 = load i32*, i32** %22
%476 = load i32*, i32** %23
%477 = load i32, i32* %476
%478 = call i64 @position(i32 %474, i32* %475, i32 %477)
%479 = icmp ne i64 %478, 0
br i1 %479, label %490, label %480
480: ; preds = %473
%481 = load i32, i32* %29
%482 = load i32*, i32** %22
%483 = load i32*, i32** %23
%484 = load i32, i32* %483
%485 = sext i32 %484 to i64
%486 = getelementptr inbounds i32, i32* %482, i64 %485
store i32 %481, i32* %486
%487 = load i32*, i32** %23
%488 = load i32, i32* %487
%489 = add nsw i32 %488, 1
store i32 %489, i32* %487
br label %494
490: ; preds = %473, %467
br label %491
491: ; preds = %490
%492 = load i32, i32* %29
%493 = add nsw i32 %492, 1
store i32 %493, i32* %29
br label %463
494: ; preds = %480, %463
br label %495
495: ; preds = %494, %456
%496 = load i32, i32* %28
store i32 %496, i32* %30
br label %497
497: ; preds = %517, %495
%498 = load i32, i32* %30
%499 = load i32, i32* %19
%500 = icmp sgt i32 %498, %499
br i1 %500, label %501, label %520
501: ; preds = %497
%502 = load i32*, i32** %22
%503 = load i32*, i32** %23
%504 = load i32, i32* %503
%505 = load i32**, i32*** %24
%506 = load i32*, i32** %505
%507 = load i32*, i32** %25
%508 = load i32, i32* %507
%509 = load i32, i32* %18
%510 = load i32, i32* %30
%511 = load i32*, i32** %53
%512 = load i32*, i32** %22
%513 = load i32*, i32** %23
%514 = load i32**, i32*** %24
%515 = load i32*, i32** %25
%516 = load i32*, i32** %26
br label %517
517: ; preds = %501
%518 = load i32, i32* %30
%519 = add nsw i32 %518, -1
store i32 %519, i32* %30
br label %497
520: ; preds = %497
br label %521
521: ; preds = %520, %384
br label %522
522: ; preds = %521, %316
br label %523
523: ; preds = %522
%524 = load i32, i32* %51
%525 = add nsw i32 %524, 1
store i32 %525, i32* %51
br label %312
526: ; preds = %312
br label %527
527: ; preds = %526
%528 = load i32, i32* %50
%529 = add nsw i32 %528, 1
store i32 %529, i32* %50
br label %280
530: ; preds = %280
%531 = load i32*, i32** %31
%532 = call i32 @free(i32* %531)
%533 = load i32*, i32** %32
%534 = call i32 @free(i32* %533)
%535 = load i32*, i32** %33
%536 = call i32 @free(i32* %535)
%537 = load i32*, i32** %34
%538 = call i32 @free(i32* %537)
%539 = load i32*, i32** %35
%540 = call i32 @free(i32* %539)
%541 = load i32*, i32** %37
%542 = call i32 @free(i32* %541)
%543 = load i32*, i32** %39
%544 = call i32 @free(i32* %543)
%545 = load i32*, i32** %41
%546 = call i32 @free(i32* %545)
%547 = load i32*, i32** %42
%548 = call i32 @free(i32* %547)
%549 = load i32*, i32** %43
%550 = call i32 @free(i32* %549)
%551 = load i32*, i32** %45
%552 = call i32 @free(i32* %551)
%553 = load i32*, i32** %46
%554 = call i32 @free(i32* %553)
%555 = load i32*, i32** %47
%556 = call i32 @free(i32* %555)
%557 = load i32*, i32** %52
%558 = call i32 @free(i32* %557)
%559 = load i32*, i32** %53
%560 = call i32 @free(i32* %559)
%561 = load i32*, i32** %54
%562 = call i32 @free(i32* %561)
%563 = load i32*, i32** %56
%564 = call i32 @free(i32* %563)
ret void
}

LLVM IR (-O2):
define void @schreier_sims_step(i32* %0, i32 %1, i32* %2, i32 %3, i32 %4, i32 %5, i32* %6, i32 %7, i32* %8, i32* nocapture %9, i32** nocapture %10, i32* nocapture %11, i32* nocapture %12) {
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
%20 = shl i32 %4, 2
%21 = tail call i64 @malloc(i32 %20)
%22 = inttoptr i64 %21 to i32*
%23 = tail call i64 @malloc(i32 %20)
%24 = inttoptr i64 %23 to i32*
%25 = tail call i64 @malloc(i32 %20)
%26 = inttoptr i64 %25 to i32*
%27 = tail call i64 @malloc(i32 %20)
%28 = inttoptr i64 %27 to i32*
%29 = mul nsw i32 %4, %3
%30 = shl i32 %29, 2
%31 = tail call i64 @malloc(i32 %30)
%32 = inttoptr i64 %31 to i32*
%33 = bitcast i32* %14 to i8*
%34 = tail call i64 @malloc(i32 %30)
%35 = inttoptr i64 %34 to i32*
%36 = bitcast i32* %15 to i8*
%37 = tail call i64 @malloc(i32 %20)
%38 = inttoptr i64 %37 to i32*
%39 = bitcast i32* %16 to i8*
%40 = tail call i64 @malloc(i32 %20)
%41 = inttoptr i64 %40 to i32*
%42 = mul i32 %20, %4
%43 = tail call i64 @malloc(i32 %42)
%44 = inttoptr i64 %43 to i32*
%45 = tail call i64 @malloc(i32 %20)
%46 = inttoptr i64 %45 to i32*
%47 = bitcast i32* %17 to i8*
%48 = tail call i64 @malloc(i32 %20)
%49 = inttoptr i64 %48 to i32*
%50 = tail call i64 @malloc(i32 %42)
%51 = inttoptr i64 %50 to i32*
%52 = tail call i64 @malloc(i32 %30)
%53 = inttoptr i64 %52 to i32*
%54 = tail call i64 @malloc(i32 %20)
%55 = inttoptr i64 %54 to i32*
%56 = tail call i64 @malloc(i32 %20)
%57 = inttoptr i64 %56 to i32*
%58 = tail call i64 @malloc(i32 %30)
%59 = inttoptr i64 %58 to i32*
%60 = bitcast i32* %18 to i8*
%61 = tail call i64 @malloc(i32 %20)
%62 = inttoptr i64 %61 to i32*
%63 = bitcast i32* %19 to i8*
%64 = tail call i32 @copy_list(i32* %0, i32* %8, i32 %1)
store i32 %1, i32* %9
%65 = load i32*, i32** %10
%66 = tail call i32 @copy_list(i32* %2, i32* %65, i32 %29)
store i32 %3, i32* %11
%67 = add nsw i32 %5, -1
%68 = call i32 @stabilizer(i32* %0, i32 %67, i32* %2, i32 %3, i32 %4, i32* %32, i32* %14)
%69 = load i32, i32* %14
%70 = call i32 @complement(i32* %32, i32 %69, i32* %6, i32 %7, i32 %4, i32* %35, i32* %15)
%71 = sext i32 %67 to i64
%72 = getelementptr inbounds i32, i32* %0, i64 %71
%73 = load i32, i32* %72
%74 = load i32, i32* %14
%75 = call i32 @one_schreier_orbit(i32 %73, i32* %32, i32 %74, i32 %4, i32* %38, i32* %16, i32* %44, i32* %41, i32 1)
%76 = load i32, i32* %72
%77 = load i32, i32* %15
%78 = call i32 @one_schreier_orbit(i32 %76, i32* %35, i32 %77, i32 %4, i32* %46, i32* %17, i32* %51, i32* %49, i32 1)
%79 = icmp sgt i32 %4, 0
br i1 %79, label %80, label %83
80: ; preds = %13
%81 = zext i32 %4 to i64
%82 = zext i32 %4 to i64
br label %92
83: ; preds = %107, %13
%84 = load i32, i32* %16
%85 = icmp sgt i32 %84, 0
br i1 %85, label %86, label %244
86: ; preds = %83
%87 = mul nsw i32 %7, %4
%88 = sext i32 %5 to i64
%89 = getelementptr inbounds i32, i32* %8, i64 %88
%90 = icmp slt i32 %4, 1
%91 = sext i32 %4 to i64
br label %110
92: ; preds = %80, %107
%93 = phi i64 [ 0, %80 ], [ %108, %107 ]
%94 = getelementptr inbounds i32, i32* %41, i64 %93
%95 = load i32, i32* %94
%96 = getelementptr inbounds i32, i32* %49, i64 %93
%97 = load i32, i32* %96
%98 = icmp eq i32 %95, %97
%99 = icmp eq i32 %97, 0
%100 = or i1 %98, %99
br i1 %100, label %107, label %101
101: ; preds = %92
%102 = mul nsw i64 %93, %81
%103 = getelementptr inbounds i32, i32* %51, i64 %102
%104 = getelementptr inbounds i32, i32* %44, i64 %102
%105 = call i32 @copy_list(i32* %103, i32* %104, i32 %4)
%106 = load i32, i32* %96
store i32 %106, i32* %94
br label %107
107: ; preds = %92, %101
%108 = add nuw nsw i64 %93, 1
%109 = icmp eq i64 %108, %82
br i1 %109, label %83, label %92
110: ; preds = %86, %237
%111 = phi i64 [ 0, %86 ], [ %240, %237 ]
%112 = phi i32* [ %59, %86 ], [ %239, %237 ]
%113 = phi i32 [ undef, %86 ], [ %238, %237 ]
%114 = getelementptr inbounds i32, i32* %38, i64 %111
%115 = load i32, i32* %114
%116 = load i32, i32* %17
%117 = call i64 @position(i32 %115, i32* %46, i32 %116)
%118 = icmp eq i64 %117, 0
br i1 %118, label %121, label %119
119: ; preds = %110
%120 = call i32 @copy_list(i32* %6, i32* %53, i32 %87)
br label %126
121: ; preds = %110
%122 = load i32, i32* %14
%123 = mul nsw i32 %122, %4
%124 = call i32 @copy_list(i32* %32, i32* %53, i32 %123)
%125 = load i32, i32* %14
br label %126
126: ; preds = %121, %119
%127 = phi i32 [ %7, %119 ], [ %125, %121 ]
%128 = icmp sgt i32 %127, 0
br i1 %128, label %129, label %237
129: ; preds = %126
%130 = zext i32 %127 to i64
br label %131
131: ; preds = %129, %231
%132 = phi i64 [ 0, %129 ], [ %233, %231 ]
%133 = phi i32* [ %112, %129 ], [ %149, %231 ]
%134 = phi i32 [ %113, %129 ], [ %232, %231 ]
%135 = mul nsw i64 %132, %91
%136 = getelementptr inbounds i32, i32* %53, i64 %135
%137 = call i32 @copy_list(i32* %136, i32* %55, i32 %4)
%138 = load i32, i32* %12
%139 = add nsw i32 %138, 1
store i32 %139, i32* %12
%140 = call i32 @trace_schreier(i32 %115, i32* %44, i32* %41, i32* %22, i32 %4)
%141 = call i32 @onpoints(i32 %115, i32* %55, i32 %4)
%142 = call i32 @trace_schreier(i32 %141, i32* %44, i32* %41, i32* %26, i32 %4)
%143 = call i32 @inverse(i32* %26, i32* %24, i32 %4)
%144 = call i32 @product(i32* %22, i32* %55, i32* %28, i32 %4)
%145 = call i32 @product(i32* %28, i32* %24, i32* %57, i32 %4)
%146 = load i32, i32* %11
%147 = mul i32 %20, %146
%148 = call i64 @realloc(i32* %133, i32 %147)
%149 = inttoptr i64 %148 to i32*
%150 = load i32*, i32** %10
%151 = load i32, i32* %11
%152 = call i32 @stabilizer(i32* %8, i32 %5, i32* %150, i32 %151, i32 %4, i32* %149, i32* %18)
%153 = call i32 @isid(i32* %57, i32 %4)
%154 = icmp eq i32 %153, 0
br i1 %154, label %155, label %231
155: ; preds = %131
%156 = load i32, i32* %18
%157 = icmp eq i32 %156, 0
br i1 %157, label %163, label %158
158: ; preds = %155
%159 = load i32, i32* %9
%160 = sub nsw i32 %159, %5
%161 = call i32 @perm_member(i32* %57, i32* %89, i32 %160, i32* %149, i32 %156, i32 %4)
%162 = icmp eq i32 %161, 0
br i1 %162, label %163, label %231
163: ; preds = %158, %155
%164 = load i32*, i32** %10
%165 = load i32, i32* %11
%166 = add nsw i32 %165, 1
%167 = mul i32 %20, %166
%168 = call i64 @realloc(i32* %164, i32 %167)
%169 = inttoptr i64 %168 to i32*
store i32* %169, i32** %10
%170 = load i32, i32* %11
%171 = mul nsw i32 %170, %4
%172 = sext i32 %171 to i64
%173 = getelementptr inbounds i32, i32* %169, i64 %172
%174 = call i32 @copy_list(i32* %57, i32* %173, i32 %4)
%175 = load i32, i32* %11
%176 = add nsw i32 %175, 1
store i32 %176, i32* %11
%177 = call i32 @stable_points(i32* %57, i32 %4, i32* %62, i32* %19)
%178 = load i32, i32* %9
%179 = icmp sgt i32 %178, 0
br i1 %179, label %180, label %198
180: ; preds = %163, %191
%181 = phi i64 [ %193, %191 ], [ 0, %163 ]
%182 = getelementptr inbounds i32, i32* %8, i64 %181
%183 = load i32, i32* %182
%184 = load i32, i32* %19
%185 = call i64 @position(i32 %183, i32* %62, i32 %184)
%186 = icmp eq i64 %185, 0
br i1 %186, label %187, label %191
187: ; preds = %180
%188 = trunc i64 %181 to i32
%189 = add nuw nsw i32 %188, 1
%190 = load i32, i32* %9
br label %198
191: ; preds = %180
%192 = load i32, i32* %9
%193 = add nuw nsw i64 %181, 1
%194 = sext i32 %192 to i64
%195 = icmp slt i64 %193, %194
br i1 %195, label %180, label %196
196: ; preds = %191
%197 = add nsw i32 %192, 1
br label %198
198: ; preds = %163, %196, %187
%199 = phi i32 [ %190, %187 ], [ %192, %196 ], [ %178, %163 ]
%200 = phi i32 [ %189, %187 ], [ %197, %196 ], [ %134, %163 ]
%201 = add nsw i32 %199, 1
%202 = icmp ne i32 %200, %201
%203 = or i1 %202, %90
br i1 %203, label %222, label %204
204: ; preds = %198, %219
%205 = phi i32 [ %220, %219 ], [ 1, %198 ]
%206 = load i32, i32* %19
%207 = call i64 @position(i32 %205, i32* %62, i32 %206)
%208 = icmp eq i64 %207, 0
br i1 %208, label %209, label %219
209: ; preds = %204
%210 = load i32, i32* %9
%211 = call i64 @position(i32 %205, i32* %8, i32 %210)
%212 = icmp eq i64 %211, 0
br i1 %212, label %213, label %219
213: ; preds = %209
%214 = load i32, i32* %9
%215 = sext i32 %214 to i64
%216 = getelementptr inbounds i32, i32* %8, i64 %215
store i32 %205, i32* %216
%217 = load i32, i32* %9
%218 = add nsw i32 %217, 1
store i32 %218, i32* %9
br label %222
219: ; preds = %204, %209
%220 = add nuw i32 %205, 1
%221 = icmp eq i32 %205, %4
br i1 %221, label %222, label %204
222: ; preds = %219, %198, %213
%223 = icmp sgt i32 %200, %5
br i1 %223, label %224, label %231
224: ; preds = %222, %224
%225 = phi i32 [ %229, %224 ], [ %200, %222 ]
%226 = load i32, i32* %9
%227 = load i32*, i32** %10
%228 = load i32, i32* %11
%229 = add nsw i32 %225, -1
%230 = icmp sgt i32 %229, %5
br i1 %230, label %224, label %231
231: ; preds = %224, %222, %131, %158
%232 = phi i32 [ %134, %131 ], [ %134, %158 ], [ %200, %222 ], [ %200, %224 ]
%233 = add nuw nsw i64 %132, 1
%234 = icmp eq i64 %233, %130
br i1 %234, label %235, label %131
235: ; preds = %231
%236 = inttoptr i64 %148 to i32*
br label %237
237: ; preds = %235, %126
%238 = phi i32 [ %113, %126 ], [ %232, %235 ]
%239 = phi i32* [ %112, %126 ], [ %236, %235 ]
%240 = add nuw nsw i64 %111, 1
%241 = load i32, i32* %16
%242 = sext i32 %241 to i64
%243 = icmp slt i64 %240, %242
br i1 %243, label %110, label %244
244: ; preds = %237, %83
%245 = phi i32* [ %59, %83 ], [ %239, %237 ]
%246 = call i32 @free(i32* %22)
%247 = call i32 @free(i32* %24)
%248 = call i32 @free(i32* %26)
%249 = call i32 @free(i32* %28)
%250 = call i32 @free(i32* %32)
%251 = call i32 @free(i32* %35)
%252 = call i32 @free(i32* %38)
%253 = call i32 @free(i32* %41)
%254 = call i32 @free(i32* %44)
%255 = call i32 @free(i32* %46)
%256 = call i32 @free(i32* %49)
%257 = call i32 @free(i32* %51)
%258 = call i32 @free(i32* %53)
%259 = call i32 @free(i32* %55)
%260 = call i32 @free(i32* %57)
%261 = call i32 @free(i32* %245)
%262 = call i32 @free(i32* %62)
ret void
}