#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*/ get_group_catalogue(int, void **);
int /*<<< orphan*/ get_group_coordinates(int, void **);
int /*<<< orphan*/ get_hash_table(int, void **);
int get_hash_table_size(int, void **);
int get_total_number_of_groups(int, void **);
int /*<<< orphan*/ printf(char *, ...);
int /*<<< orphan*/ sprintf(char *, char *);
int /*<<< orphan*/ swap_Nbyte(char *, int, int);
int main() {
  printf("\n\n");
  void *Par[20];
  char OutputDir[200];
  sprintf(OutputDir, "/data/rw9/Millennium/snapdir_063");
  int num = 63;
  int TotNgroups;
  Par[0] = OutputDir;
  Par[1] = &num;
  TotNgroups = get_total_number_of_groups(2, Par);
  swap_Nbyte((char *)&TotNgroups, 1, 4);
  printf("TotNgroups:%d\n", TotNgroups);
  int GroupLen[TotNgroups];
  int GroupFileNr[TotNgroups], GroupNr[TotNgroups];
  Par[2] = &GroupLen[0];
  Par[3] = &GroupFileNr[0];
  Par[4] = &GroupNr[0];
  get_group_catalogue(5, Par);
  int HashTabsize = 0;
  char SnapBase[200];
  sprintf(SnapBase, "snap_millennium");
  int NFiles = 0;
  Par[2] = SnapBase;
  Par[3] = &NFiles;
  HashTabsize = get_hash_table_size(4, Par);
  swap_Nbyte((char *)&HashTabsize, 1, 4);
  swap_Nbyte((char *)&NFiles, 1, 4);
  printf("NFiles:%d\n", NFiles);
  printf("HashTableSize:%d\n", HashTabsize);
  int Hashtable[HashTabsize], Filetable[HashTabsize], LastHashCell[HashTabsize],
      NInFiles[HashTabsize];
  Par[3] = &Hashtable[0];
  Par[4] = &Filetable[0];
  Par[5] = &LastHashCell[0];
  Par[6] = &NInFiles[0];
  get_hash_table(8, Par);
  swap_Nbyte((char *)&Hashtable[0], HashTabsize, 4);
  int N = 1;
  int FiNr, GrNr, Len;
  FiNr = GroupFileNr[N];
  GrNr = GroupNr[N];
  Len = GroupLen[N];
  char PostProcDir[200];
  sprintf(PostProcDir, "/data/rw9/Millennium/postproc_063");
  float vel[Len * 3], pos[Len * 3];
  double Sx, Sy, Sz = 0.0;
  Par[0] = OutputDir;
  Par[1] = PostProcDir;
  Par[2] = &num;
  Par[3] = SnapBase;
  Par[4] = &Hashtable[0];
  Par[5] = &Filetable[0];
  Par[6] = &HashTabsize;
  Par[7] = &LastHashCell[0];
  Par[8] = &NInFiles[0];
  Par[9] = &GrNr;
  Par[10] = &FiNr;
  Par[11] = &Len;
  Par[12] = &pos[0];
  Par[13] = &vel[0];
  Par[14] = &Sx;
  Par[15] = &Sy;
  Par[16] = &Sz;
  get_group_coordinates(16, Par);
  printf("Sx:%lf\n", Sx);
  printf("Sy:%lf\n", Sy);
  printf("Sz:%lf\n", Sz);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x410,%rsp
movl   $0x0,-0x4(%rbp)
lea    0xe67(%rip),%rdi
xor    %eax,%eax
mov    %al,-0x3f1(%rbp)
call   1050 <printf@plt>
lea    0xe56(%rip),%rsi
lea    -0x180(%rbp),%rdi
mov    %rdi,-0x410(%rbp)
call   10a0 <sprintf@plt>
mov    -0x410(%rbp),%rax
movl   $0x3f,-0x184(%rbp)
mov    %rax,-0xb0(%rbp)
lea    -0x184(%rbp),%rax
mov    %rax,-0xa8(%rbp)
mov    $0x2,%edi
lea    -0xb0(%rbp),%rsi
mov    %rsi,-0x3f0(%rbp)
call   1080 <get_total_number_of_groups@plt>
mov    %eax,-0x188(%rbp)
lea    -0x188(%rbp),%rdi
mov    $0x1,%esi
mov    %esi,-0x3f8(%rbp)
mov    $0x4,%edx
mov    %edx,-0x3e4(%rbp)
call   1040 <swap_Nbyte@plt>
mov    -0x3f1(%rbp),%al
mov    -0x188(%rbp),%esi
lea    0xdeb(%rip),%rdi
call   1050 <printf@plt>
mov    -0x3f0(%rbp),%rsi
mov    -0x188(%rbp),%eax
mov    %rsp,%rcx
mov    %rcx,-0x190(%rbp)
lea    0xf(,%rax,4),%rcx
and    $0xfffffffffffffff0,%rcx
mov    %rsp,%rdx
sub    %rcx,%rdx
mov    %rdx,-0x3d0(%rbp)
mov    %rdx,%rsp
mov    %rax,-0x198(%rbp)
mov    -0x188(%rbp),%eax
lea    0xf(,%rax,4),%rdi
and    $0xfffffffffffffff0,%rdi
mov    %rsp,%rcx
sub    %rdi,%rcx
mov    %rcx,-0x3e0(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x1a0(%rbp)
mov    -0x188(%rbp),%eax
mov    %eax,%edi
lea    0xf(,%rdi,4),%r8
and    $0xfffffffffffffff0,%r8
mov    %rsp,%rax
sub    %r8,%rax
mov    %rax,-0x3d8(%rbp)
mov    %rax,%rsp
mov    %rdi,-0x1a8(%rbp)
mov    %rdx,-0xa0(%rbp)
mov    %rcx,-0x98(%rbp)
mov    %rax,-0x90(%rbp)
mov    $0x5,%edi
call   1090 <get_group_catalogue@plt>
movl   $0x0,-0x1ac(%rbp)
lea    0xd37(%rip),%rsi
lea    -0x280(%rbp),%rdi
mov    %rdi,-0x408(%rbp)
call   10a0 <sprintf@plt>
mov    -0x3f0(%rbp),%rsi
mov    -0x3e4(%rbp),%edi
mov    -0x408(%rbp),%rax
movl   $0x0,-0x284(%rbp)
mov    %rax,-0xa0(%rbp)
lea    -0x284(%rbp),%rax
mov    %rax,-0x400(%rbp)
mov    %rax,-0x98(%rbp)
call   1060 <get_hash_table_size@plt>
mov    -0x3f8(%rbp),%esi
mov    -0x3e4(%rbp),%edx
mov    %eax,-0x1ac(%rbp)
lea    -0x1ac(%rbp),%rdi
call   1040 <swap_Nbyte@plt>
mov    -0x400(%rbp),%rdi
mov    -0x3f8(%rbp),%esi
mov    -0x3e4(%rbp),%edx
call   1040 <swap_Nbyte@plt>
mov    -0x3f1(%rbp),%al
mov    -0x284(%rbp),%esi
lea    0xcac(%rip),%rdi
call   1050 <printf@plt>
mov    -0x3f1(%rbp),%al
mov    -0x1ac(%rbp),%esi
lea    0xc9f(%rip),%rdi
call   1050 <printf@plt>
mov    -0x3f0(%rbp),%rsi
mov    -0x1ac(%rbp),%eax
lea    0xf(,%rax,4),%rcx
and    $0xfffffffffffffff0,%rcx
mov    %rsp,%rdi
sub    %rcx,%rdi
mov    %rdi,-0x3c8(%rbp)
mov    %rdi,%rsp
mov    %rax,-0x290(%rbp)
mov    -0x1ac(%rbp),%eax
lea    0xf(,%rax,4),%rcx
and    $0xfffffffffffffff0,%rcx
mov    %rsp,%rdx
sub    %rcx,%rdx
mov    %rdx,-0x3c0(%rbp)
mov    %rdx,%rsp
mov    %rax,-0x298(%rbp)
mov    -0x1ac(%rbp),%eax
lea    0xf(,%rax,4),%r8
and    $0xfffffffffffffff0,%r8
mov    %rsp,%rcx
sub    %r8,%rcx
mov    %rcx,-0x3b8(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x2a0(%rbp)
mov    -0x1ac(%rbp),%eax
mov    %eax,%r8d
lea    0xf(,%r8,4),%r9
and    $0xfffffffffffffff0,%r9
mov    %rsp,%rax
sub    %r9,%rax
mov    %rax,-0x3b0(%rbp)
mov    %rax,%rsp
mov    %r8,-0x2a8(%rbp)
mov    %rdi,-0x98(%rbp)
mov    %rdx,-0x90(%rbp)
mov    %rcx,-0x88(%rbp)
mov    %rax,-0x80(%rbp)
mov    $0x8,%edi
call   1070 <get_hash_table@plt>
mov    -0x3e4(%rbp),%edx
mov    -0x3c8(%rbp),%rdi
mov    -0x1ac(%rbp),%esi
call   1040 <swap_Nbyte@plt>
mov    -0x3e0(%rbp),%rdx
mov    -0x3d8(%rbp),%rcx
mov    -0x3d0(%rbp),%rax
movl   $0x1,-0x2ac(%rbp)
movslq -0x2ac(%rbp),%rsi
mov    (%rdx,%rsi,4),%edx
mov    %edx,-0x2b0(%rbp)
movslq -0x2ac(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
mov    %ecx,-0x2b4(%rbp)
movslq -0x2ac(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x2b8(%rbp)
lea    0xb6d(%rip),%rsi
lea    -0x380(%rbp),%rdi
call   10a0 <sprintf@plt>
mov    -0x3c8(%rbp),%r8
mov    -0x3c0(%rbp),%rdi
mov    -0x3b8(%rbp),%rsi
mov    -0x3b0(%rbp),%rdx
mov    -0x2b8(%rbp),%ecx
mov    %ecx,%eax
lea    (%rax,%rax,2),%eax
mov    %eax,%ecx
lea    0xf(,%rcx,4),%r9
and    $0xfffffffffffffff0,%r9
mov    %rsp,%rax
sub    %r9,%rax
mov    %rax,%rsp
mov    %rcx,-0x388(%rbp)
mov    -0x2b8(%rbp),%r9d
mov    %r9d,%ecx
lea    (%rcx,%rcx,2),%ecx
mov    %ecx,%r9d
lea    0xf(,%r9,4),%r10
and    $0xfffffffffffffff0,%r10
mov    %rsp,%rcx
sub    %r10,%rcx
mov    %rcx,%rsp
mov    %r9,-0x390(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x3a8(%rbp)
ff
lea    -0x180(%rbp),%r9
mov    %r9,-0xb0(%rbp)
lea    -0x380(%rbp),%r9
mov    %r9,-0xa8(%rbp)
lea    -0x184(%rbp),%r9
mov    %r9,-0xa0(%rbp)
lea    -0x280(%rbp),%r9
mov    %r9,-0x98(%rbp)
mov    %r8,-0x90(%rbp)
mov    %rdi,-0x88(%rbp)
lea    -0x1ac(%rbp),%rdi
mov    %rdi,-0x80(%rbp)
mov    %rsi,-0x78(%rbp)
mov    %rdx,-0x70(%rbp)
lea    -0x2b4(%rbp),%rdx
mov    %rdx,-0x68(%rbp)
lea    -0x2b0(%rbp),%rdx
mov    %rdx,-0x60(%rbp)
lea    -0x2b8(%rbp),%rdx
mov    %rdx,-0x58(%rbp)
mov    %rcx,-0x50(%rbp)
mov    %rax,-0x48(%rbp)
lea    -0x398(%rbp),%rax
mov    %rax,-0x40(%rbp)
lea    -0x3a0(%rbp),%rax
mov    %rax,-0x38(%rbp)
lea    -0x3a8(%rbp),%rax
mov    %rax,-0x30(%rbp)
lea    -0xb0(%rbp),%rsi
mov    $0x10,%edi
call   1030 <get_group_coordinates@plt>
movsd  -0x398(%rbp),%xmm0
ff
lea    0xa44(%rip),%rdi
mov    $0x1,%al
call   1050 <printf@plt>
movsd  -0x3a0(%rbp),%xmm0
ff
lea    0xa36(%rip),%rdi
mov    $0x1,%al
call   1050 <printf@plt>
movsd  -0x3a8(%rbp),%xmm0
ff
lea    0xa28(%rip),%rdi
mov    $0x1,%al
call   1050 <printf@plt>
movl   $0x0,-0x4(%rbp)
mov    -0x190(%rbp),%rax
mov    %rax,%rsp
mov    -0x4(%rbp),%eax
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x368,%rsp
lea    0xec0(%rip),%rdi
call   1030 <puts@plt>
movups 0xe69(%rip),%xmm0
movaps %xmm0,-0x1e0(%rbp)
movups 0xe4b(%rip),%xmm0
movaps %xmm0,-0x1f0(%rbp)
movb   $0x0,-0x1d0(%rbp)
movl   $0x3f,-0x38(%rbp)
lea    -0x1f0(%rbp),%rax
mov    %rax,-0x120(%rbp)
lea    -0x38(%rbp),%rax
mov    %rax,-0x118(%rbp)
lea    -0x120(%rbp),%rbx
mov    $0x2,%edi
mov    %rbx,%rsi
call   1090 <get_total_number_of_groups@plt>
mov    %eax,-0x30(%rbp)
lea    -0x30(%rbp),%rdi
mov    $0x1,%esi
mov    $0x4,%edx
call   1050 <swap_Nbyte@plt>
mov    -0x30(%rbp),%esi
lea    0xe0a(%rip),%rdi
xor    %eax,%eax
call   1060 <printf@plt>
mov    %rsp,-0x70(%rbp)
mov    -0x30(%rbp),%eax
mov    %rsp,%rcx
mov    %rcx,-0x68(%rbp)
lea    0xf(,%rax,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rdx,-0x60(%rbp)
mov    %rcx,%rax
sub    %rdx,%rax
mov    %rax,%rsp
mov    -0x30(%rbp),%ecx
mov    %rsp,%rdx
lea    0xf(,%rcx,4),%rcx
and    $0xfffffffffffffff0,%rcx
sub    %rcx,%rdx
mov    %rdx,%rsp
mov    %rdx,-0x58(%rbp)
mov    %rsp,%r15
sub    %rcx,%r15
mov    %r15,%rsp
mov    %rax,-0x110(%rbp)
mov    %rdx,-0x108(%rbp)
mov    %r15,-0x100(%rbp)
mov    $0x5,%edi
mov    %rbx,%rsi
call   10a0 <get_group_catalogue@plt>
movups 0xd9d(%rip),%xmm0
movaps %xmm0,-0x390(%rbp)
movl   $0x0,-0x34(%rbp)
lea    -0x390(%rbp),%rax
mov    %rax,-0x110(%rbp)
lea    -0x34(%rbp),%r14
mov    %r14,-0x108(%rbp)
mov    $0x4,%edi
mov    %rbx,%rsi
call   1070 <get_hash_table_size@plt>
mov    %eax,-0x2c(%rbp)
lea    -0x2c(%rbp),%rdi
mov    $0x1,%esi
mov    $0x4,%edx
call   1050 <swap_Nbyte@plt>
mov    %r14,%rdi
mov    $0x1,%esi
mov    $0x4,%edx
call   1050 <swap_Nbyte@plt>
mov    -0x34(%rbp),%esi
lea    0xd47(%rip),%rdi
xor    %eax,%eax
call   1060 <printf@plt>
mov    -0x2c(%rbp),%esi
lea    0xd41(%rip),%rdi
xor    %eax,%eax
call   1060 <printf@plt>
mov    -0x2c(%rbp),%eax
mov    %rsp,%rbx
lea    0xf(,%rax,4),%rax
and    $0xfffffffffffffff0,%rax
sub    %rax,%rbx
mov    %rbx,%rsp
mov    %rsp,%r13
sub    %rax,%r13
mov    %r13,%rsp
mov    %rsp,%r14
sub    %rax,%r14
mov    %r14,%rsp
mov    %rsp,%r12
sub    %rax,%r12
mov    %r12,%rsp
mov    %rbx,-0x108(%rbp)
mov    %r13,-0x100(%rbp)
mov    %r14,-0xf8(%rbp)
mov    %r12,-0xf0(%rbp)
mov    $0x8,%edi
lea    -0x120(%rbp),%rsi
call   1080 <get_hash_table@plt>
mov    -0x2c(%rbp),%esi
mov    %rbx,%rdi
mov    $0x4,%edx
call   1050 <swap_Nbyte@plt>
mov    -0x58(%rbp),%rax
mov    0x4(%rax),%eax
mov    %eax,-0x44(%rbp)
mov    0x4(%r15),%eax
mov    %eax,-0x40(%rbp)
mov    -0x60(%rbp),%rcx
neg    %rcx
mov    -0x68(%rbp),%rax
mov    0x4(%rax,%rcx,1),%eax
mov    %eax,-0x3c(%rbp)
movups 0xcc2(%rip),%xmm0
movaps %xmm0,-0x2b0(%rbp)
movups 0xca4(%rip),%xmm0
movaps %xmm0,-0x2c0(%rbp)
movw   $0x33,-0x2a0(%rbp)
lea    (%rax,%rax,2),%eax
lea    0xf(,%rax,4),%rax
and    $0xfffffffffffffff0,%rax
mov    %rsp,%rcx
sub    %rax,%rcx
mov    %rcx,%rsp
mov    %rsp,%rdx
sub    %rax,%rdx
mov    %rdx,%rsp
movq   $0x0,-0x50(%rbp)
lea    -0x1f0(%rbp),%rax
mov    %rax,-0x120(%rbp)
lea    -0x2c0(%rbp),%rax
mov    %rax,-0x118(%rbp)
lea    -0x38(%rbp),%rax
mov    %rax,-0x110(%rbp)
lea    -0x390(%rbp),%rax
mov    %rax,-0x108(%rbp)
mov    %rbx,-0x100(%rbp)
mov    %r13,-0xf8(%rbp)
lea    -0x2c(%rbp),%rax
mov    %rax,-0xf0(%rbp)
mov    %r14,-0xe8(%rbp)
mov    %r12,-0xe0(%rbp)
lea    -0x40(%rbp),%rax
mov    %rax,-0xd8(%rbp)
lea    -0x44(%rbp),%rax
mov    %rax,-0xd0(%rbp)
lea    -0x3c(%rbp),%rax
mov    %rax,-0xc8(%rbp)
mov    %rdx,-0xc0(%rbp)
mov    %rcx,-0xb8(%rbp)
lea    -0x80(%rbp),%rax
mov    %rax,-0xb0(%rbp)
lea    -0x78(%rbp),%rax
mov    %rax,-0xa8(%rbp)
lea    -0x50(%rbp),%rax
mov    %rax,-0xa0(%rbp)
mov    $0x10,%edi
lea    -0x120(%rbp),%rsi
call   1040 <get_group_coordinates@plt>
movsd  -0x80(%rbp),%xmm0
lea    0xbc4(%rip),%rdi
mov    $0x1,%al
call   1060 <printf@plt>
movsd  -0x78(%rbp),%xmm0
lea    0xbb9(%rip),%rdi
mov    $0x1,%al
call   1060 <printf@plt>
movsd  -0x50(%rbp),%xmm0
lea    0xbae(%rip),%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    -0x70(%rbp),%rsp
xor    %eax,%eax
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [3 x i8] c"\0A\0A\00"
@.str.1 = [33 x i8] c"/data/rw9/Millennium/snapdir_063\00"
@.str.2 = [15 x i8] c"TotNgroups:%d\0A\00"
@.str.3 = [16 x i8] c"snap_millennium\00"
@.str.4 = [11 x i8] c"NFiles:%d\0A\00"
@.str.5 = [18 x i8] c"HashTableSize:%d\0A\00"
@.str.6 = [34 x i8] c"/data/rw9/Millennium/postproc_063\00"
@.str.7 = [8 x i8] c"Sx:%lf\0A\00"
@.str.8 = [8 x i8] c"Sy:%lf\0A\00"
@.str.9 = [8 x i8] c"Sz:%lf\0A\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca [20 x i8*]
%3 = alloca [200 x i8]
%4 = alloca i32
%5 = alloca i32
%6 = alloca i8*
%7 = alloca i64
%8 = alloca i64
%9 = alloca i64
%10 = alloca i32
%11 = alloca [200 x i8]
%12 = alloca i32
%13 = alloca i64
%14 = alloca i64
%15 = alloca i64
%16 = alloca i64
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
%20 = alloca i32
%21 = alloca [200 x i8]
%22 = alloca i64
%23 = alloca i64
%24 = alloca double
%25 = alloca double
%26 = alloca double
store i32 0, i32* %1
%27 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0))
%28 = getelementptr inbounds [200 x i8], [200 x i8]* %3, i64 0, i64 0
%29 = call i32 @sprintf(i8* %28, i8* getelementptr inbounds ([33 x i8], [33 x i8]* @.str.1, i64 0, i64 0))
store i32 63, i32* %4
%30 = getelementptr inbounds [200 x i8], [200 x i8]* %3, i64 0, i64 0
%31 = getelementptr inbounds [20 x i8*], [20 x i8*]* %2, i64 0, i64 0
store i8* %30, i8** %31
%32 = bitcast i32* %4 to i8*
%33 = getelementptr inbounds [20 x i8*], [20 x i8*]* %2, i64 0, i64 1
store i8* %32, i8** %33
%34 = getelementptr inbounds [20 x i8*], [20 x i8*]* %2, i64 0, i64 0
%35 = call i32 @get_total_number_of_groups(i32 2, i8** %34)
store i32 %35, i32* %5
%36 = bitcast i32* %5 to i8*
%37 = call i32 @swap_Nbyte(i8* %36, i32 1, i32 4)
%38 = load i32, i32* %5
%39 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.2, i64 0, i64 0), i32 %38)
%40 = load i32, i32* %5
%41 = zext i32 %40 to i64
%42 = call i8* @llvm.stacksave()
store i8* %42, i8** %6
%43 = alloca i32, i64 %41
store i64 %41, i64* %7
%44 = load i32, i32* %5
%45 = zext i32 %44 to i64
%46 = alloca i32, i64 %45
store i64 %45, i64* %8
%47 = load i32, i32* %5
%48 = zext i32 %47 to i64
%49 = alloca i32, i64 %48
store i64 %48, i64* %9
%50 = getelementptr inbounds i32, i32* %43, i64 0
%51 = bitcast i32* %50 to i8*
%52 = getelementptr inbounds [20 x i8*], [20 x i8*]* %2, i64 0, i64 2
store i8* %51, i8** %52
%53 = getelementptr inbounds i32, i32* %46, i64 0
%54 = bitcast i32* %53 to i8*
%55 = getelementptr inbounds [20 x i8*], [20 x i8*]* %2, i64 0, i64 3
store i8* %54, i8** %55
%56 = getelementptr inbounds i32, i32* %49, i64 0
%57 = bitcast i32* %56 to i8*
%58 = getelementptr inbounds [20 x i8*], [20 x i8*]* %2, i64 0, i64 4
store i8* %57, i8** %58
%59 = getelementptr inbounds [20 x i8*], [20 x i8*]* %2, i64 0, i64 0
%60 = call i32 @get_group_catalogue(i32 5, i8** %59)
store i32 0, i32* %10
%61 = getelementptr inbounds [200 x i8], [200 x i8]* %11, i64 0, i64 0
%62 = call i32 @sprintf(i8* %61, i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.3, i64 0, i64 0))
store i32 0, i32* %12
%63 = getelementptr inbounds [200 x i8], [200 x i8]* %11, i64 0, i64 0
%64 = getelementptr inbounds [20 x i8*], [20 x i8*]* %2, i64 0, i64 2
store i8* %63, i8** %64
%65 = bitcast i32* %12 to i8*
%66 = getelementptr inbounds [20 x i8*], [20 x i8*]* %2, i64 0, i64 3
store i8* %65, i8** %66
%67 = getelementptr inbounds [20 x i8*], [20 x i8*]* %2, i64 0, i64 0
%68 = call i32 @get_hash_table_size(i32 4, i8** %67)
store i32 %68, i32* %10
%69 = bitcast i32* %10 to i8*
%70 = call i32 @swap_Nbyte(i8* %69, i32 1, i32 4)
%71 = bitcast i32* %12 to i8*
%72 = call i32 @swap_Nbyte(i8* %71, i32 1, i32 4)
%73 = load i32, i32* %12
%74 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.4, i64 0, i64 0), i32 %73)
%75 = load i32, i32* %10
%76 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.5, i64 0, i64 0), i32 %75)
%77 = load i32, i32* %10
%78 = zext i32 %77 to i64
%79 = alloca i32, i64 %78
store i64 %78, i64* %13
%80 = load i32, i32* %10
%81 = zext i32 %80 to i64
%82 = alloca i32, i64 %81
store i64 %81, i64* %14
%83 = load i32, i32* %10
%84 = zext i32 %83 to i64
%85 = alloca i32, i64 %84
store i64 %84, i64* %15
%86 = load i32, i32* %10
%87 = zext i32 %86 to i64
%88 = alloca i32, i64 %87
store i64 %87, i64* %16
%89 = getelementptr inbounds i32, i32* %79, i64 0
%90 = bitcast i32* %89 to i8*
%91 = getelementptr inbounds [20 x i8*], [20 x i8*]* %2, i64 0, i64 3
store i8* %90, i8** %91
%92 = getelementptr inbounds i32, i32* %82, i64 0
%93 = bitcast i32* %92 to i8*
%94 = getelementptr inbounds [20 x i8*], [20 x i8*]* %2, i64 0, i64 4
store i8* %93, i8** %94
%95 = getelementptr inbounds i32, i32* %85, i64 0
%96 = bitcast i32* %95 to i8*
%97 = getelementptr inbounds [20 x i8*], [20 x i8*]* %2, i64 0, i64 5
store i8* %96, i8** %97
%98 = getelementptr inbounds i32, i32* %88, i64 0
%99 = bitcast i32* %98 to i8*
%100 = getelementptr inbounds [20 x i8*], [20 x i8*]* %2, i64 0, i64 6
store i8* %99, i8** %100
%101 = getelementptr inbounds [20 x i8*], [20 x i8*]* %2, i64 0, i64 0
%102 = call i32 @get_hash_table(i32 8, i8** %101)
%103 = getelementptr inbounds i32, i32* %79, i64 0
%104 = bitcast i32* %103 to i8*
%105 = load i32, i32* %10
%106 = call i32 @swap_Nbyte(i8* %104, i32 %105, i32 4)
store i32 1, i32* %17
%107 = load i32, i32* %17
%108 = sext i32 %107 to i64
%109 = getelementptr inbounds i32, i32* %46, i64 %108
%110 = load i32, i32* %109
store i32 %110, i32* %18
%111 = load i32, i32* %17
%112 = sext i32 %111 to i64
%113 = getelementptr inbounds i32, i32* %49, i64 %112
%114 = load i32, i32* %113
store i32 %114, i32* %19
%115 = load i32, i32* %17
%116 = sext i32 %115 to i64
%117 = getelementptr inbounds i32, i32* %43, i64 %116
%118 = load i32, i32* %117
store i32 %118, i32* %20
%119 = getelementptr inbounds [200 x i8], [200 x i8]* %21, i64 0, i64 0
%120 = call i32 @sprintf(i8* %119, i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.6, i64 0, i64 0))
%121 = load i32, i32* %20
%122 = mul nsw i32 %121, 3
%123 = zext i32 %122 to i64
%124 = alloca float, i64 %123
store i64 %123, i64* %22
%125 = load i32, i32* %20
%126 = mul nsw i32 %125, 3
%127 = zext i32 %126 to i64
%128 = alloca float, i64 %127
store i64 %127, i64* %23
store double 0.000000e+00, double* %26
%129 = getelementptr inbounds [200 x i8], [200 x i8]* %3, i64 0, i64 0
%130 = getelementptr inbounds [20 x i8*], [20 x i8*]* %2, i64 0, i64 0
store i8* %129, i8** %130
%131 = getelementptr inbounds [200 x i8], [200 x i8]* %21, i64 0, i64 0
%132 = getelementptr inbounds [20 x i8*], [20 x i8*]* %2, i64 0, i64 1
store i8* %131, i8** %132
%133 = bitcast i32* %4 to i8*
%134 = getelementptr inbounds [20 x i8*], [20 x i8*]* %2, i64 0, i64 2
store i8* %133, i8** %134
%135 = getelementptr inbounds [200 x i8], [200 x i8]* %11, i64 0, i64 0
%136 = getelementptr inbounds [20 x i8*], [20 x i8*]* %2, i64 0, i64 3
store i8* %135, i8** %136
%137 = getelementptr inbounds i32, i32* %79, i64 0
%138 = bitcast i32* %137 to i8*
%139 = getelementptr inbounds [20 x i8*], [20 x i8*]* %2, i64 0, i64 4
store i8* %138, i8** %139
%140 = getelementptr inbounds i32, i32* %82, i64 0
%141 = bitcast i32* %140 to i8*
%142 = getelementptr inbounds [20 x i8*], [20 x i8*]* %2, i64 0, i64 5
store i8* %141, i8** %142
%143 = bitcast i32* %10 to i8*
%144 = getelementptr inbounds [20 x i8*], [20 x i8*]* %2, i64 0, i64 6
store i8* %143, i8** %144
%145 = getelementptr inbounds i32, i32* %85, i64 0
%146 = bitcast i32* %145 to i8*
%147 = getelementptr inbounds [20 x i8*], [20 x i8*]* %2, i64 0, i64 7
store i8* %146, i8** %147
%148 = getelementptr inbounds i32, i32* %88, i64 0
%149 = bitcast i32* %148 to i8*
%150 = getelementptr inbounds [20 x i8*], [20 x i8*]* %2, i64 0, i64 8
store i8* %149, i8** %150
%151 = bitcast i32* %19 to i8*
%152 = getelementptr inbounds [20 x i8*], [20 x i8*]* %2, i64 0, i64 9
store i8* %151, i8** %152
%153 = bitcast i32* %18 to i8*
%154 = getelementptr inbounds [20 x i8*], [20 x i8*]* %2, i64 0, i64 10
store i8* %153, i8** %154
%155 = bitcast i32* %20 to i8*
%156 = getelementptr inbounds [20 x i8*], [20 x i8*]* %2, i64 0, i64 11
store i8* %155, i8** %156
%157 = getelementptr inbounds float, float* %128, i64 0
%158 = bitcast float* %157 to i8*
%159 = getelementptr inbounds [20 x i8*], [20 x i8*]* %2, i64 0, i64 12
store i8* %158, i8** %159
%160 = getelementptr inbounds float, float* %124, i64 0
%161 = bitcast float* %160 to i8*
%162 = getelementptr inbounds [20 x i8*], [20 x i8*]* %2, i64 0, i64 13
store i8* %161, i8** %162
%163 = bitcast double* %24 to i8*
%164 = getelementptr inbounds [20 x i8*], [20 x i8*]* %2, i64 0, i64 14
store i8* %163, i8** %164
%165 = bitcast double* %25 to i8*
%166 = getelementptr inbounds [20 x i8*], [20 x i8*]* %2, i64 0, i64 15
store i8* %165, i8** %166
%167 = bitcast double* %26 to i8*
%168 = getelementptr inbounds [20 x i8*], [20 x i8*]* %2, i64 0, i64 16
store i8* %167, i8** %168
%169 = getelementptr inbounds [20 x i8*], [20 x i8*]* %2, i64 0, i64 0
%170 = call i32 @get_group_coordinates(i32 16, i8** %169)
%171 = load double, double* %24
%172 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.7, i64 0, i64 0), double %171)
%173 = load double, double* %25
%174 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.8, i64 0, i64 0), double %173)
%175 = load double, double* %26
%176 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.9, i64 0, i64 0), double %175)
store i32 0, i32* %1
%177 = load i8*, i8** %6
%178 = load i32, i32* %1
ret i32 %178
}

LLVM IR (-O2):
@.str.1 = [33 x i8] c"/data/rw9/Millennium/snapdir_063\00"
@.str.2 = [15 x i8] c"TotNgroups:%d\0A\00"
@.str.3 = [16 x i8] c"snap_millennium\00"
@.str.4 = [11 x i8] c"NFiles:%d\0A\00"
@.str.5 = [18 x i8] c"HashTableSize:%d\0A\00"
@.str.6 = [34 x i8] c"/data/rw9/Millennium/postproc_063\00"
@.str.7 = [8 x i8] c"Sx:%lf\0A\00"
@.str.8 = [8 x i8] c"Sy:%lf\0A\00"
@.str.9 = [8 x i8] c"Sz:%lf\0A\00"
@str = [2 x i8] c"\0A\00"
define i32 @main() {
%1 = alloca [20 x i8*]
%2 = alloca [200 x i8]
%3 = alloca i32
%4 = alloca i32
%5 = alloca i32
%6 = alloca [200 x i8]
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca [200 x i8]
%12 = alloca double
%13 = alloca double
%14 = alloca double
%15 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([2 x i8], [2 x i8]* @str, i64 0, i64 0))
%16 = bitcast [20 x i8*]* %1 to i8*
%17 = getelementptr inbounds [200 x i8], [200 x i8]* %2, i64 0, i64 0
%18 = bitcast i32* %3 to i8*
store i32 63, i32* %3
%19 = bitcast i32* %4 to i8*
%20 = getelementptr inbounds [20 x i8*], [20 x i8*]* %1, i64 0, i64 0
store i8* %17, i8** %20
%21 = getelementptr inbounds [20 x i8*], [20 x i8*]* %1, i64 0, i64 1
%22 = bitcast i8** %21 to i32**
store i32* %3, i32** %22
%23 = call i32 @get_total_number_of_groups(i32 2, i8** %20)
store i32 %23, i32* %4
%24 = call i32 @swap_Nbyte(i8* %19, i32 1, i32 4)
%25 = load i32, i32* %4
%26 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([15 x i8], [15 x i8]* @.str.2, i64 0, i64 0), i32 %25)
%27 = load i32, i32* %4
%28 = zext i32 %27 to i64
%29 = call i8* @llvm.stacksave()
%30 = alloca i32, i64 %28
%31 = load i32, i32* %4
%32 = zext i32 %31 to i64
%33 = alloca i32, i64 %32
%34 = alloca i32, i64 %32
%35 = getelementptr inbounds [20 x i8*], [20 x i8*]* %1, i64 0, i64 2
%36 = bitcast i8** %35 to i32**
store i32* %30, i32** %36
%37 = getelementptr inbounds [20 x i8*], [20 x i8*]* %1, i64 0, i64 3
%38 = bitcast i8** %37 to i32**
store i32* %33, i32** %38
%39 = getelementptr inbounds [20 x i8*], [20 x i8*]* %1, i64 0, i64 4
%40 = bitcast i8** %39 to i32**
store i32* %34, i32** %40
%41 = call i32 @get_group_catalogue(i32 5, i8** %20)
%42 = bitcast i32* %5 to i8*
%43 = getelementptr inbounds [200 x i8], [200 x i8]* %6, i64 0, i64 0
%44 = bitcast i32* %7 to i8*
store i32 0, i32* %7
store i8* %43, i8** %35
store i32* %7, i32** %38
%45 = call i32 @get_hash_table_size(i32 4, i8** %20)
store i32 %45, i32* %5
%46 = call i32 @swap_Nbyte(i8* %42, i32 1, i32 4)
%47 = call i32 @swap_Nbyte(i8* %44, i32 1, i32 4)
%48 = load i32, i32* %7
%49 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([11 x i8], [11 x i8]* @.str.4, i64 0, i64 0), i32 %48)
%50 = load i32, i32* %5
%51 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([18 x i8], [18 x i8]* @.str.5, i64 0, i64 0), i32 %50)
%52 = load i32, i32* %5
%53 = zext i32 %52 to i64
%54 = alloca i32, i64 %53
%55 = alloca i32, i64 %53
%56 = alloca i32, i64 %53
%57 = alloca i32, i64 %53
%58 = bitcast i32* %54 to i8*
store i32* %54, i32** %38
store i32* %55, i32** %40
%59 = getelementptr inbounds [20 x i8*], [20 x i8*]* %1, i64 0, i64 5
%60 = bitcast i8** %59 to i32**
store i32* %56, i32** %60
%61 = getelementptr inbounds [20 x i8*], [20 x i8*]* %1, i64 0, i64 6
%62 = bitcast i8** %61 to i32**
store i32* %57, i32** %62
%63 = call i32 @get_hash_table(i32 8, i8** %20)
%64 = load i32, i32* %5
%65 = call i32 @swap_Nbyte(i8* %58, i32 %64, i32 4)
%66 = bitcast i32* %8 to i8*
%67 = bitcast i32* %9 to i8*
%68 = bitcast i32* %10 to i8*
%69 = getelementptr inbounds i32, i32* %33, i64 1
%70 = load i32, i32* %69
store i32 %70, i32* %8
%71 = getelementptr inbounds i32, i32* %34, i64 1
%72 = load i32, i32* %71
store i32 %72, i32* %9
%73 = getelementptr inbounds i32, i32* %30, i64 1
%74 = load i32, i32* %73
store i32 %74, i32* %10
%75 = getelementptr inbounds [200 x i8], [200 x i8]* %11, i64 0, i64 0
%76 = mul nsw i32 %74, 3
%77 = zext i32 %76 to i64
%78 = alloca float, i64 %77
%79 = alloca float, i64 %77
%80 = bitcast double* %12 to i8*
%81 = bitcast double* %13 to i8*
%82 = bitcast double* %14 to i8*
store double 0.000000e+00, double* %14
store i8* %17, i8** %20
store i8* %75, i8** %21
store i32* %3, i32** %36
store i8* %43, i8** %37
store i32* %54, i32** %40
store i32* %55, i32** %60
store i32* %5, i32** %62
%83 = getelementptr inbounds [20 x i8*], [20 x i8*]* %1, i64 0, i64 7
%84 = bitcast i8** %83 to i32**
store i32* %56, i32** %84
%85 = getelementptr inbounds [20 x i8*], [20 x i8*]* %1, i64 0, i64 8
%86 = bitcast i8** %85 to i32**
store i32* %57, i32** %86
%87 = getelementptr inbounds [20 x i8*], [20 x i8*]* %1, i64 0, i64 9
%88 = bitcast i8** %87 to i32**
store i32* %9, i32** %88
%89 = getelementptr inbounds [20 x i8*], [20 x i8*]* %1, i64 0, i64 10
%90 = bitcast i8** %89 to i32**
store i32* %8, i32** %90
%91 = getelementptr inbounds [20 x i8*], [20 x i8*]* %1, i64 0, i64 11
%92 = bitcast i8** %91 to i32**
store i32* %10, i32** %92
%93 = getelementptr inbounds [20 x i8*], [20 x i8*]* %1, i64 0, i64 12
%94 = bitcast i8** %93 to float**
store float* %79, float** %94
%95 = getelementptr inbounds [20 x i8*], [20 x i8*]* %1, i64 0, i64 13
%96 = bitcast i8** %95 to float**
store float* %78, float** %96
%97 = getelementptr inbounds [20 x i8*], [20 x i8*]* %1, i64 0, i64 14
%98 = bitcast i8** %97 to double**
store double* %12, double** %98
%99 = getelementptr inbounds [20 x i8*], [20 x i8*]* %1, i64 0, i64 15
%100 = bitcast i8** %99 to double**
store double* %13, double** %100
%101 = getelementptr inbounds [20 x i8*], [20 x i8*]* %1, i64 0, i64 16
%102 = bitcast i8** %101 to double**
store double* %14, double** %102
%103 = call i32 @get_group_coordinates(i32 16, i8** %20)
%104 = load double, double* %12
%105 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.7, i64 0, i64 0), double %104)
%106 = load double, double* %13
%107 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.8, i64 0, i64 0), double %106)
%108 = load double, double* %14
%109 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.9, i64 0, i64 0), double %108)
ret i32 0
}