#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*/ printf(char *, ...);
int spg_get_symmetry_with_collinear_spin(int ***, double **, int *, int,
                                         double **, double **, int *, double *,
                                         int, int);
void test_spg_get_symmetry_with_collinear_spin(void) {
  double lattice[3][3] = {{4, 0, 0}, {0, 4, 0}, {0, 0, 4}};
  double position[][3] = {{0, 0, 0}, {0.5, 0.5, 0.5}};
  int types[] = {1, 1};
  int equivalent_atoms[2];
  double spins[2];
  int num_atom = 2;
  int max_size = 300;
  int i, j, size;
  int rotation[max_size][3][3];
  double translation[max_size][3];
  printf("*** Example of spg_get_symmetry_with_spin (BCC ferro) ***:\n");
  spins[0] = 1;
  spins[1] = 1;
  size = spg_get_symmetry_with_collinear_spin(
      rotation, translation, equivalent_atoms, max_size, lattice, position,
      types, spins, num_atom, 1e-5);
  for (i = 0; i < size; i++) {
    printf("--- %d ---\n", i + 1);
    for (j = 0; j < 3; j++) {
      printf("%2d %2d %2d\n", rotation[i][j][0], rotation[i][j][1],
             rotation[i][j][2]);
    }
    printf("%f %f %f\n", translation[i][0], translation[i][1],
           translation[i][2]);
  }
  printf("*** Example of spg_get_symmetry_with_spin (BCC antiferro) ***:\n");
  spins[0] = 1;
  spins[1] = -1;
  size = spg_get_symmetry_with_collinear_spin(
      rotation, translation, equivalent_atoms, max_size, lattice, position,
      types, spins, num_atom, 1e-5);
  for (i = 0; i < size; i++) {
    printf("--- %d ---\n", i + 1);
    for (j = 0; j < 3; j++) {
      printf("%2d %2d %2d\n", rotation[i][j][0], rotation[i][j][1],
             rotation[i][j][2]);
    }
    printf("%f %f %f\n", translation[i][0], translation[i][1],
           translation[i][2]);
  }
  printf("*** Example of spg_get_symmetry_with_spin (BCC broken spin) ***:\n");
  spins[0] = 1;
  spins[1] = 2;
  size = spg_get_symmetry_with_collinear_spin(
      rotation, translation, equivalent_atoms, max_size, lattice, position,
      types, spins, num_atom, 1e-5);
  for (i = 0; i < size; i++) {
    printf("--- %d ---\n", i + 1);
    for (j = 0; j < 3; j++) {
      printf("%2d %2d %2d\n", rotation[i][j][0], rotation[i][j][1],
             rotation[i][j][2]);
    }
    printf("%f %f %f\n", translation[i][0], translation[i][1],
           translation[i][2]);
  }
}


x86 assembly (clang, -O0):
<test_spg_get_symmetry_with_collinear_spin>:
push   %rbp
mov    %rsp,%rbp
push   %rbx
sub    $0xd8,%rsp
xorps  %xmm0,%xmm0
movaps %xmm0,-0x20(%rbp)
movaps %xmm0,-0x30(%rbp)
movaps %xmm0,-0x40(%rbp)
movaps %xmm0,-0x50(%rbp)
movq   $0x0,-0x10(%rbp)
movabs $0x4010000000000000,%rax
mov    %rax,-0x50(%rbp)
mov    %rax,-0x30(%rbp)
mov    %rax,-0x10(%rbp)
movaps %xmm0,-0x60(%rbp)
movaps %xmm0,-0x70(%rbp)
movaps %xmm0,-0x80(%rbp)
movabs $0x3fe0000000000000,%rax
mov    %rax,-0x68(%rbp)
mov    %rax,-0x60(%rbp)
mov    %rax,-0x58(%rbp)
mov    0xe92(%rip),%rax
mov    %rax,-0x88(%rbp)
movl   $0x2,-0xa4(%rbp)
movl   $0x12c,-0xa8(%rbp)
mov    -0xa8(%rbp),%eax
mov    %rsp,%rcx
mov    %rcx,-0xc0(%rbp)
lea    (%rax,%rax,8),%rcx
lea    0xf(,%rcx,4),%rdx
movabs $0x7ffffffff0,%rcx
and    %rcx,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0xe0(%rbp)
mov    %rcx,%rsp
mov    %rax,-0xc8(%rbp)
mov    -0xa8(%rbp),%eax
lea    (%rax,%rax,2),%rcx
lea    0xf(,%rcx,8),%rdx
movabs $0x3ffffffff0,%rcx
and    %rcx,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0xd8(%rbp)
mov    %rcx,%rsp
mov    %rax,-0xd0(%rbp)
lea    0xe02(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0xe0(%rbp),%rdi
mov    -0xd8(%rbp),%rsi
movsd  0xdc5(%rip),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  0xdb5(%rip),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
lea    -0x90(%rbp),%rdx
mov    -0xa8(%rbp),%ecx
lea    -0x50(%rbp),%r8
lea    -0x80(%rbp),%r9
lea    -0x88(%rbp),%r11
lea    -0xa0(%rbp),%r10
mov    -0xa4(%rbp),%eax
xor    %ebx,%ebx
sub    $0x20,%rsp
mov    %r11,(%rsp)
mov    %r10,0x8(%rsp)
mov    %eax,0x10(%rsp)
movl   $0x0,0x18(%rsp)
call   1030 <spg_get_symmetry_with_collinear_spin@plt>
add    $0x20,%rsp
mov    %eax,-0xb4(%rbp)
movl   $0x0,-0xac(%rbp)
mov    -0xac(%rbp),%eax
cmp    -0xb4(%rbp),%eax
jge    13e2 <test_spg_get_symmetry_with_collinear_spin+0x2c2>
mov    -0xac(%rbp),%esi
add    $0x1,%esi
lea    0xd8a(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0xb0(%rbp)
cmpl   $0x3,-0xb0(%rbp)
jge    137b <test_spg_get_symmetry_with_collinear_spin+0x25b>
mov    -0xe0(%rbp),%rax
movslq -0xac(%rbp),%rcx
imul   $0x24,%rcx,%rdx
mov    %rax,%rcx
add    %rdx,%rcx
movslq -0xb0(%rbp),%rdx
imul   $0xc,%rdx,%rdx
add    %rdx,%rcx
mov    (%rcx),%esi
movslq -0xac(%rbp),%rcx
imul   $0x24,%rcx,%rdx
mov    %rax,%rcx
add    %rdx,%rcx
movslq -0xb0(%rbp),%rdx
imul   $0xc,%rdx,%rdx
add    %rdx,%rcx
mov    0x4(%rcx),%edx
movslq -0xac(%rbp),%rcx
imul   $0x24,%rcx,%rcx
add    %rcx,%rax
movslq -0xb0(%rbp),%rcx
imul   $0xc,%rcx,%rcx
add    %rcx,%rax
mov    0x8(%rax),%ecx
lea    0xd08(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0xb0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb0(%rbp)
jmp    12e3 <test_spg_get_symmetry_with_collinear_spin+0x1c3>
mov    -0xd8(%rbp),%rax
movslq -0xac(%rbp),%rcx
imul   $0x18,%rcx,%rdx
mov    %rax,%rcx
add    %rdx,%rcx
movsd  (%rcx),%xmm0
movslq -0xac(%rbp),%rcx
imul   $0x18,%rcx,%rdx
mov    %rax,%rcx
add    %rdx,%rcx
movsd  0x8(%rcx),%xmm1
movslq -0xac(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movsd  0x10(%rax),%xmm2
lea    0xcae(%rip),%rdi
mov    $0x3,%al
call   1040 <printf@plt>
mov    -0xac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xac(%rbp)
jmp    12b0 <test_spg_get_symmetry_with_collinear_spin+0x190>
lea    0xc96(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0xe0(%rbp),%rdi
mov    -0xd8(%rbp),%rsi
movsd  0xbfa(%rip),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  0xbf2(%rip),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
lea    -0x90(%rbp),%rdx
mov    -0xa8(%rbp),%ecx
lea    -0x50(%rbp),%r8
lea    -0x80(%rbp),%r9
lea    -0x88(%rbp),%r11
lea    -0xa0(%rbp),%r10
mov    -0xa4(%rbp),%eax
xor    %ebx,%ebx
sub    $0x20,%rsp
mov    %r11,(%rsp)
mov    %r10,0x8(%rsp)
mov    %eax,0x10(%rsp)
movl   $0x0,0x18(%rsp)
call   1030 <spg_get_symmetry_with_collinear_spin@plt>
add    $0x20,%rsp
mov    %eax,-0xb4(%rbp)
movl   $0x0,-0xac(%rbp)
mov    -0xac(%rbp),%eax
cmp    -0xb4(%rbp),%eax
jge    15ad <test_spg_get_symmetry_with_collinear_spin+0x48d>
mov    -0xac(%rbp),%esi
add    $0x1,%esi
lea    0xbbf(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0xb0(%rbp)
cmpl   $0x3,-0xb0(%rbp)
jge    1546 <test_spg_get_symmetry_with_collinear_spin+0x426>
mov    -0xe0(%rbp),%rax
movslq -0xac(%rbp),%rcx
imul   $0x24,%rcx,%rdx
mov    %rax,%rcx
add    %rdx,%rcx
movslq -0xb0(%rbp),%rdx
imul   $0xc,%rdx,%rdx
add    %rdx,%rcx
mov    (%rcx),%esi
movslq -0xac(%rbp),%rcx
imul   $0x24,%rcx,%rdx
mov    %rax,%rcx
add    %rdx,%rcx
movslq -0xb0(%rbp),%rdx
imul   $0xc,%rdx,%rdx
add    %rdx,%rcx
mov    0x4(%rcx),%edx
movslq -0xac(%rbp),%rcx
imul   $0x24,%rcx,%rcx
add    %rcx,%rax
movslq -0xb0(%rbp),%rcx
imul   $0xc,%rcx,%rcx
add    %rcx,%rax
mov    0x8(%rax),%ecx
lea    0xb3d(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0xb0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb0(%rbp)
jmp    14ae <test_spg_get_symmetry_with_collinear_spin+0x38e>
mov    -0xd8(%rbp),%rax
movslq -0xac(%rbp),%rcx
imul   $0x18,%rcx,%rdx
mov    %rax,%rcx
add    %rdx,%rcx
movsd  (%rcx),%xmm0
movslq -0xac(%rbp),%rcx
imul   $0x18,%rcx,%rdx
mov    %rax,%rcx
add    %rdx,%rcx
movsd  0x8(%rcx),%xmm1
movslq -0xac(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movsd  0x10(%rax),%xmm2
lea    0xae3(%rip),%rdi
mov    $0x3,%al
call   1040 <printf@plt>
mov    -0xac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xac(%rbp)
jmp    147b <test_spg_get_symmetry_with_collinear_spin+0x35b>
lea    0xb0b(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0xe0(%rbp),%rdi
mov    -0xd8(%rbp),%rsi
movsd  0xa2f(%rip),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  0xa2f(%rip),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
lea    -0x90(%rbp),%rdx
mov    -0xa8(%rbp),%ecx
lea    -0x50(%rbp),%r8
lea    -0x80(%rbp),%r9
lea    -0x88(%rbp),%r11
lea    -0xa0(%rbp),%r10
mov    -0xa4(%rbp),%eax
xor    %ebx,%ebx
sub    $0x20,%rsp
mov    %r11,(%rsp)
mov    %r10,0x8(%rsp)
mov    %eax,0x10(%rsp)
movl   $0x0,0x18(%rsp)
call   1030 <spg_get_symmetry_with_collinear_spin@plt>
add    $0x20,%rsp
mov    %eax,-0xb4(%rbp)
movl   $0x0,-0xac(%rbp)
mov    -0xac(%rbp),%eax
cmp    -0xb4(%rbp),%eax
jge    1778 <test_spg_get_symmetry_with_collinear_spin+0x658>
mov    -0xac(%rbp),%esi
add    $0x1,%esi
lea    0x9f4(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0xb0(%rbp)
cmpl   $0x3,-0xb0(%rbp)
jge    1711 <test_spg_get_symmetry_with_collinear_spin+0x5f1>
mov    -0xe0(%rbp),%rax
movslq -0xac(%rbp),%rcx
imul   $0x24,%rcx,%rdx
mov    %rax,%rcx
add    %rdx,%rcx
movslq -0xb0(%rbp),%rdx
imul   $0xc,%rdx,%rdx
add    %rdx,%rcx
mov    (%rcx),%esi
movslq -0xac(%rbp),%rcx
imul   $0x24,%rcx,%rdx
mov    %rax,%rcx
add    %rdx,%rcx
movslq -0xb0(%rbp),%rdx
imul   $0xc,%rdx,%rdx
add    %rdx,%rcx
mov    0x4(%rcx),%edx
movslq -0xac(%rbp),%rcx
imul   $0x24,%rcx,%rcx
add    %rcx,%rax
movslq -0xb0(%rbp),%rcx
imul   $0xc,%rcx,%rcx
add    %rcx,%rax
mov    0x8(%rax),%ecx
lea    0x972(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0xb0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb0(%rbp)
jmp    1679 <test_spg_get_symmetry_with_collinear_spin+0x559>
mov    -0xd8(%rbp),%rax
movslq -0xac(%rbp),%rcx
imul   $0x18,%rcx,%rdx
mov    %rax,%rcx
add    %rdx,%rcx
movsd  (%rcx),%xmm0
movslq -0xac(%rbp),%rcx
imul   $0x18,%rcx,%rdx
mov    %rax,%rcx
add    %rdx,%rcx
movsd  0x8(%rcx),%xmm1
movslq -0xac(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movsd  0x10(%rax),%xmm2
lea    0x918(%rip),%rdi
mov    $0x3,%al
call   1040 <printf@plt>
mov    -0xac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xac(%rbp)
jmp    1646 <test_spg_get_symmetry_with_collinear_spin+0x526>
mov    -0xc0(%rbp),%rax
mov    %rax,%rsp
lea    -0x8(%rbp),%rsp
pop    %rbx
pop    %rbp
ret

x86 assembly (clang, -O2):
<test_spg_get_symmetry_with_collinear_spin>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x4708,%rsp
mov    %rsp,0x28(%rsp)
xorps  %xmm0,%xmm0
movaps %xmm0,0x60(%rsp)
movaps %xmm0,0x80(%rsp)
movaps %xmm0,0x90(%rsp)
movaps %xmm0,0x70(%rsp)
movabs $0x4010000000000000,%rax
mov    %rax,0x60(%rsp)
mov    %rax,0x80(%rsp)
mov    %rax,0xa0(%rsp)
movaps %xmm0,0x40(%rsp)
movaps %xmm0,0x30(%rsp)
movaps 0xe6d(%rip),%xmm0
movups %xmm0,0x48(%rsp)
movabs $0x3fe0000000000000,%rax
mov    %rax,0x58(%rsp)
movabs $0x100000001,%rax
mov    %rax,0x8(%rsp)
lea    0xea6(%rip),%rdi
call   1030 <puts@plt>
movaps 0xe47(%rip),%xmm0
movaps %xmm0,0x10(%rsp)
lea    0x10(%rsp),%rbp
lea    0x8(%rsp),%rax
lea    0xb0(%rsp),%rdi
lea    0x2ae0(%rsp),%rsi
lea    0x20(%rsp),%rdx
lea    0x60(%rsp),%r8
lea    0x30(%rsp),%r9
mov    $0x12c,%ecx
push   $0x0
push   $0x2
push   %rbp
push   %rax
call   1040 <spg_get_symmetry_with_collinear_spin@plt>
add    $0x20,%rsp
test   %eax,%eax
jle    12e3 <test_spg_get_symmetry_with_collinear_spin+0x1b3>
mov    %eax,%eax
lea    0x2af0(%rsp),%rbp
shl    $0x2,%rax
lea    (%rax,%rax,8),%r13
mov    $0x1,%ebx
lea    0xe1b(%rip),%r15
lea    0xe21(%rip),%r12
xor    %r14d,%r14d
nopl   0x0(%rax,%rax,1)
lea    0xdf9(%rip),%rdi
mov    %ebx,%esi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0xb0(%rsp,%r14,1),%esi
mov    0xb4(%rsp,%r14,1),%edx
mov    0xb8(%rsp,%r14,1),%ecx
mov    %r15,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0xbc(%rsp,%r14,1),%esi
mov    0xc0(%rsp,%r14,1),%edx
mov    0xc4(%rsp,%r14,1),%ecx
mov    %r15,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0xc8(%rsp,%r14,1),%esi
mov    0xcc(%rsp,%r14,1),%edx
mov    0xd0(%rsp,%r14,1),%ecx
mov    %r15,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
movsd  -0x10(%rbp),%xmm0
movsd  -0x8(%rbp),%xmm1
movsd  0x0(%rbp),%xmm2
mov    %r12,%rdi
mov    $0x3,%al
call   1050 <printf@plt>
add    $0x18,%rbp
add    $0x24,%r14
add    $0x1,%ebx
cmp    %r14,%r13
jne    1240 <test_spg_get_symmetry_with_collinear_spin+0x110>
lea    0xdb4(%rip),%rdi
call   1030 <puts@plt>
movaps 0xd2a(%rip),%xmm0
movaps %xmm0,0x10(%rsp)
lea    0xb0(%rsp),%rdi
lea    0x2ae0(%rsp),%rsi
lea    0x20(%rsp),%rdx
lea    0x60(%rsp),%r8
lea    0x30(%rsp),%r9
mov    $0x12c,%ecx
push   $0x0
push   $0x2
lea    0x20(%rsp),%rax
push   %rax
lea    0x20(%rsp),%rax
push   %rax
call   1040 <spg_get_symmetry_with_collinear_spin@plt>
add    $0x20,%rsp
test   %eax,%eax
jle    1413 <test_spg_get_symmetry_with_collinear_spin+0x2e3>
mov    %eax,%eax
lea    0x2af0(%rsp),%rbp
shl    $0x2,%rax
lea    (%rax,%rax,8),%r13
mov    $0x1,%ebx
lea    0xcee(%rip),%r15
lea    0xcf4(%rip),%r12
xor    %r14d,%r14d
nopl   0x0(%rax,%rax,1)
lea    0xcc9(%rip),%rdi
mov    %ebx,%esi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0xb0(%rsp,%r14,1),%esi
mov    0xb4(%rsp,%r14,1),%edx
mov    0xb8(%rsp,%r14,1),%ecx
mov    %r15,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0xbc(%rsp,%r14,1),%esi
mov    0xc0(%rsp,%r14,1),%edx
mov    0xc4(%rsp,%r14,1),%ecx
mov    %r15,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0xc8(%rsp,%r14,1),%esi
mov    0xcc(%rsp,%r14,1),%edx
mov    0xd0(%rsp,%r14,1),%ecx
mov    %r15,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
movsd  -0x10(%rbp),%xmm0
movsd  -0x8(%rbp),%xmm1
movsd  0x0(%rbp),%xmm2
mov    %r12,%rdi
mov    $0x3,%al
call   1050 <printf@plt>
add    $0x18,%rbp
add    $0x24,%r14
add    $0x1,%ebx
cmp    %r14,%r13
jne    1370 <test_spg_get_symmetry_with_collinear_spin+0x240>
lea    0xcc3(%rip),%rdi
call   1030 <puts@plt>
movaps 0xc0a(%rip),%xmm0
movaps %xmm0,0x10(%rsp)
lea    0xb0(%rsp),%rdi
lea    0x2ae0(%rsp),%rsi
lea    0x20(%rsp),%rdx
lea    0x60(%rsp),%r8
lea    0x30(%rsp),%r9
mov    $0x12c,%ecx
push   $0x0
push   $0x2
lea    0x20(%rsp),%rax
push   %rax
lea    0x20(%rsp),%rax
push   %rax
call   1040 <spg_get_symmetry_with_collinear_spin@plt>
add    $0x20,%rsp
test   %eax,%eax
jle    1543 <test_spg_get_symmetry_with_collinear_spin+0x413>
mov    %eax,%eax
lea    0x2af0(%rsp),%rbp
shl    $0x2,%rax
lea    (%rax,%rax,8),%r13
mov    $0x1,%ebx
lea    0xbbe(%rip),%r15
lea    0xbc4(%rip),%r12
xor    %r14d,%r14d
nopl   0x0(%rax,%rax,1)
lea    0xb99(%rip),%rdi
mov    %ebx,%esi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0xb0(%rsp,%r14,1),%esi
mov    0xb4(%rsp,%r14,1),%edx
mov    0xb8(%rsp,%r14,1),%ecx
mov    %r15,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0xbc(%rsp,%r14,1),%esi
mov    0xc0(%rsp,%r14,1),%edx
mov    0xc4(%rsp,%r14,1),%ecx
mov    %r15,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0xc8(%rsp,%r14,1),%esi
mov    0xcc(%rsp,%r14,1),%edx
mov    0xd0(%rsp,%r14,1),%ecx
mov    %r15,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
movsd  -0x10(%rbp),%xmm0
movsd  -0x8(%rbp),%xmm1
movsd  0x0(%rbp),%xmm2
mov    %r12,%rdi
mov    $0x3,%al
call   1050 <printf@plt>
add    $0x18,%rbp
add    $0x24,%r14
add    $0x1,%ebx
cmp    %r14,%r13
jne    14a0 <test_spg_get_symmetry_with_collinear_spin+0x370>
mov    0x28(%rsp),%rsp
add    $0x4708,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
@.str.1 = [12 x i8] c"--- %d ---\0A\00"
@.str.2 = [13 x i8] c"%2d %2d %2d\0A\00"
@.str.3 = [10 x i8] c"%f %f %f\0A\00"
@str = [59 x i8] c"*** Example of spg_get_symmetry_with_spin (BCC ferro) ***:\00"
@str.6 = [63 x i8] c"*** Example of spg_get_symmetry_with_spin (BCC antiferro) ***:\00"
@str.7 = [65 x i8] c"*** Example of spg_get_symmetry_with_spin (BCC broken spin) ***:\00"
define void @test_spg_get_symmetry_with_collinear_spin() {
%1 = alloca [3 x [3 x double]]
%2 = alloca [2 x [3 x double]]
%3 = alloca i64
%4 = alloca [2 x i32]
%5 = alloca <2 x double>
%6 = bitcast [3 x [3 x double]]* %1 to i8*
%7 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %1, i64 0, i64 0, i64 0
store double 4.000000e+00, double* %7
%8 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %1, i64 0, i64 1, i64 1
store double 4.000000e+00, double* %8
%9 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %1, i64 0, i64 2, i64 2
store double 4.000000e+00, double* %9
%10 = bitcast [2 x [3 x double]]* %2 to i8*
%11 = getelementptr inbounds [2 x [3 x double]], [2 x [3 x double]]* %2, i64 0, i64 1, i64 0
%12 = bitcast double* %11 to <2 x double>*
store <2 x double> <double 5.000000e-01, double 5.000000e-01>, <2 x double>* %12
%13 = getelementptr inbounds [2 x [3 x double]], [2 x [3 x double]]* %2, i64 0, i64 1, i64 2
store double 5.000000e-01, double* %13
%14 = bitcast i64* %3 to i8*
store i64 4294967297, i64* %3
%15 = bitcast [2 x i32]* %4 to i8*
%16 = bitcast <2 x double>* %5 to i8*
%17 = tail call i8* @llvm.stacksave()
%18 = alloca [300 x [3 x [3 x i32]]]
%19 = alloca [300 x [3 x double]]
%20 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([59 x i8], [59 x i8]* @str, i64 0, i64 0))
%21 = getelementptr inbounds <2 x double>, <2 x double>* %5, i64 0, i64 0
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %5
%22 = bitcast [300 x [3 x [3 x i32]]]* %18 to i32***
%23 = bitcast [300 x [3 x double]]* %19 to double**
%24 = getelementptr inbounds [2 x i32], [2 x i32]* %4, i64 0, i64 0
%25 = bitcast [3 x [3 x double]]* %1 to double**
%26 = bitcast [2 x [3 x double]]* %2 to double**
%27 = bitcast i64* %3 to i32*
%28 = call i32 @spg_get_symmetry_with_collinear_spin(i32*** %22, double** %23, i32* %24, i32 300, double** %25, double** %26, i32* %27, double* %21, i32 2, i32 0)
%29 = icmp sgt i32 %28, 0
br i1 %29, label %30, label %66
30: ; preds = %0
%31 = zext i32 %28 to i64
br label %32
32: ; preds = %30, %32
%33 = phi i64 [ 0, %30 ], [ %34, %32 ]
%34 = add nuw nsw i64 %33, 1
%35 = trunc i64 %34 to i32
%36 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([12 x i8], [12 x i8]* @.str.1, i64 0, i64 0), i32 %35)
%37 = getelementptr inbounds [300 x [3 x [3 x i32]]], [300 x [3 x [3 x i32]]]* %18, i64 0, i64 %33, i64 0, i64 0
%38 = load i32, i32* %37
%39 = getelementptr inbounds [300 x [3 x [3 x i32]]], [300 x [3 x [3 x i32]]]* %18, i64 0, i64 %33, i64 0, i64 1
%40 = load i32, i32* %39
%41 = getelementptr inbounds [300 x [3 x [3 x i32]]], [300 x [3 x [3 x i32]]]* %18, i64 0, i64 %33, i64 0, i64 2
%42 = load i32, i32* %41
%43 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([13 x i8], [13 x i8]* @.str.2, i64 0, i64 0), i32 %38, i32 %40, i32 %42)
%44 = getelementptr inbounds [300 x [3 x [3 x i32]]], [300 x [3 x [3 x i32]]]* %18, i64 0, i64 %33, i64 1, i64 0
%45 = load i32, i32* %44
%46 = getelementptr inbounds [300 x [3 x [3 x i32]]], [300 x [3 x [3 x i32]]]* %18, i64 0, i64 %33, i64 1, i64 1
%47 = load i32, i32* %46
%48 = getelementptr inbounds [300 x [3 x [3 x i32]]], [300 x [3 x [3 x i32]]]* %18, i64 0, i64 %33, i64 1, i64 2
%49 = load i32, i32* %48
%50 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([13 x i8], [13 x i8]* @.str.2, i64 0, i64 0), i32 %45, i32 %47, i32 %49)
%51 = getelementptr inbounds [300 x [3 x [3 x i32]]], [300 x [3 x [3 x i32]]]* %18, i64 0, i64 %33, i64 2, i64 0
%52 = load i32, i32* %51
%53 = getelementptr inbounds [300 x [3 x [3 x i32]]], [300 x [3 x [3 x i32]]]* %18, i64 0, i64 %33, i64 2, i64 1
%54 = load i32, i32* %53
%55 = getelementptr inbounds [300 x [3 x [3 x i32]]], [300 x [3 x [3 x i32]]]* %18, i64 0, i64 %33, i64 2, i64 2
%56 = load i32, i32* %55
%57 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([13 x i8], [13 x i8]* @.str.2, i64 0, i64 0), i32 %52, i32 %54, i32 %56)
%58 = getelementptr inbounds [300 x [3 x double]], [300 x [3 x double]]* %19, i64 0, i64 %33, i64 0
%59 = load double, double* %58
%60 = getelementptr inbounds [300 x [3 x double]], [300 x [3 x double]]* %19, i64 0, i64 %33, i64 1
%61 = load double, double* %60
%62 = getelementptr inbounds [300 x [3 x double]], [300 x [3 x double]]* %19, i64 0, i64 %33, i64 2
%63 = load double, double* %62
%64 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([10 x i8], [10 x i8]* @.str.3, i64 0, i64 0), double %59, double %61, double %63)
%65 = icmp eq i64 %34, %31
br i1 %65, label %66, label %32
66: ; preds = %32, %0
%67 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([63 x i8], [63 x i8]* @str.6, i64 0, i64 0))
store <2 x double> <double 1.000000e+00, double -1.000000e+00>, <2 x double>* %5
%68 = call i32 @spg_get_symmetry_with_collinear_spin(i32*** %22, double** %23, i32* %24, i32 300, double** %25, double** %26, i32* %27, double* %21, i32 2, i32 0)
%69 = icmp sgt i32 %68, 0
br i1 %69, label %70, label %106
70: ; preds = %66
%71 = zext i32 %68 to i64
br label %72
72: ; preds = %70, %72
%73 = phi i64 [ 0, %70 ], [ %74, %72 ]
%74 = add nuw nsw i64 %73, 1
%75 = trunc i64 %74 to i32
%76 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([12 x i8], [12 x i8]* @.str.1, i64 0, i64 0), i32 %75)
%77 = getelementptr inbounds [300 x [3 x [3 x i32]]], [300 x [3 x [3 x i32]]]* %18, i64 0, i64 %73, i64 0, i64 0
%78 = load i32, i32* %77
%79 = getelementptr inbounds [300 x [3 x [3 x i32]]], [300 x [3 x [3 x i32]]]* %18, i64 0, i64 %73, i64 0, i64 1
%80 = load i32, i32* %79
%81 = getelementptr inbounds [300 x [3 x [3 x i32]]], [300 x [3 x [3 x i32]]]* %18, i64 0, i64 %73, i64 0, i64 2
%82 = load i32, i32* %81
%83 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([13 x i8], [13 x i8]* @.str.2, i64 0, i64 0), i32 %78, i32 %80, i32 %82)
%84 = getelementptr inbounds [300 x [3 x [3 x i32]]], [300 x [3 x [3 x i32]]]* %18, i64 0, i64 %73, i64 1, i64 0
%85 = load i32, i32* %84
%86 = getelementptr inbounds [300 x [3 x [3 x i32]]], [300 x [3 x [3 x i32]]]* %18, i64 0, i64 %73, i64 1, i64 1
%87 = load i32, i32* %86
%88 = getelementptr inbounds [300 x [3 x [3 x i32]]], [300 x [3 x [3 x i32]]]* %18, i64 0, i64 %73, i64 1, i64 2
%89 = load i32, i32* %88
%90 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([13 x i8], [13 x i8]* @.str.2, i64 0, i64 0), i32 %85, i32 %87, i32 %89)
%91 = getelementptr inbounds [300 x [3 x [3 x i32]]], [300 x [3 x [3 x i32]]]* %18, i64 0, i64 %73, i64 2, i64 0
%92 = load i32, i32* %91
%93 = getelementptr inbounds [300 x [3 x [3 x i32]]], [300 x [3 x [3 x i32]]]* %18, i64 0, i64 %73, i64 2, i64 1
%94 = load i32, i32* %93
%95 = getelementptr inbounds [300 x [3 x [3 x i32]]], [300 x [3 x [3 x i32]]]* %18, i64 0, i64 %73, i64 2, i64 2
%96 = load i32, i32* %95
%97 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([13 x i8], [13 x i8]* @.str.2, i64 0, i64 0), i32 %92, i32 %94, i32 %96)
%98 = getelementptr inbounds [300 x [3 x double]], [300 x [3 x double]]* %19, i64 0, i64 %73, i64 0
%99 = load double, double* %98
%100 = getelementptr inbounds [300 x [3 x double]], [300 x [3 x double]]* %19, i64 0, i64 %73, i64 1
%101 = load double, double* %100
%102 = getelementptr inbounds [300 x [3 x double]], [300 x [3 x double]]* %19, i64 0, i64 %73, i64 2
%103 = load double, double* %102
%104 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([10 x i8], [10 x i8]* @.str.3, i64 0, i64 0), double %99, double %101, double %103)
%105 = icmp eq i64 %74, %71
br i1 %105, label %106, label %72
106: ; preds = %72, %66
%107 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([65 x i8], [65 x i8]* @str.7, i64 0, i64 0))
store <2 x double> <double 1.000000e+00, double 2.000000e+00>, <2 x double>* %5
%108 = call i32 @spg_get_symmetry_with_collinear_spin(i32*** %22, double** %23, i32* %24, i32 300, double** %25, double** %26, i32* %27, double* %21, i32 2, i32 0)
%109 = icmp sgt i32 %108, 0
br i1 %109, label %110, label %146
110: ; preds = %106
%111 = zext i32 %108 to i64
br label %112
112: ; preds = %110, %112
%113 = phi i64 [ 0, %110 ], [ %114, %112 ]
%114 = add nuw nsw i64 %113, 1
%115 = trunc i64 %114 to i32
%116 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([12 x i8], [12 x i8]* @.str.1, i64 0, i64 0), i32 %115)
%117 = getelementptr inbounds [300 x [3 x [3 x i32]]], [300 x [3 x [3 x i32]]]* %18, i64 0, i64 %113, i64 0, i64 0
%118 = load i32, i32* %117
%119 = getelementptr inbounds [300 x [3 x [3 x i32]]], [300 x [3 x [3 x i32]]]* %18, i64 0, i64 %113, i64 0, i64 1
%120 = load i32, i32* %119
%121 = getelementptr inbounds [300 x [3 x [3 x i32]]], [300 x [3 x [3 x i32]]]* %18, i64 0, i64 %113, i64 0, i64 2
%122 = load i32, i32* %121
%123 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([13 x i8], [13 x i8]* @.str.2, i64 0, i64 0), i32 %118, i32 %120, i32 %122)
%124 = getelementptr inbounds [300 x [3 x [3 x i32]]], [300 x [3 x [3 x i32]]]* %18, i64 0, i64 %113, i64 1, i64 0
%125 = load i32, i32* %124
%126 = getelementptr inbounds [300 x [3 x [3 x i32]]], [300 x [3 x [3 x i32]]]* %18, i64 0, i64 %113, i64 1, i64 1
%127 = load i32, i32* %126
%128 = getelementptr inbounds [300 x [3 x [3 x i32]]], [300 x [3 x [3 x i32]]]* %18, i64 0, i64 %113, i64 1, i64 2
%129 = load i32, i32* %128
%130 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([13 x i8], [13 x i8]* @.str.2, i64 0, i64 0), i32 %125, i32 %127, i32 %129)
%131 = getelementptr inbounds [300 x [3 x [3 x i32]]], [300 x [3 x [3 x i32]]]* %18, i64 0, i64 %113, i64 2, i64 0
%132 = load i32, i32* %131
%133 = getelementptr inbounds [300 x [3 x [3 x i32]]], [300 x [3 x [3 x i32]]]* %18, i64 0, i64 %113, i64 2, i64 1
%134 = load i32, i32* %133
%135 = getelementptr inbounds [300 x [3 x [3 x i32]]], [300 x [3 x [3 x i32]]]* %18, i64 0, i64 %113, i64 2, i64 2
%136 = load i32, i32* %135
%137 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([13 x i8], [13 x i8]* @.str.2, i64 0, i64 0), i32 %132, i32 %134, i32 %136)
%138 = getelementptr inbounds [300 x [3 x double]], [300 x [3 x double]]* %19, i64 0, i64 %113, i64 0
%139 = load double, double* %138
%140 = getelementptr inbounds [300 x [3 x double]], [300 x [3 x double]]* %19, i64 0, i64 %113, i64 1
%141 = load double, double* %140
%142 = getelementptr inbounds [300 x [3 x double]], [300 x [3 x double]]* %19, i64 0, i64 %113, i64 2
%143 = load double, double* %142
%144 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([10 x i8], [10 x i8]* @.str.3, i64 0, i64 0), double %139, double %141, double %143)
%145 = icmp eq i64 %114, %111
br i1 %145, label %146, label %112
146: ; preds = %112, %106
ret void
}