#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*/ cjam(double *, double *, double *, double, double, double,
                        double, int, int, char *, char *, char *, char *, int);
int /*<<< orphan*/ free(double *);
scalar_t__ malloc(int);
int /*<<< orphan*/ printf(char *, ...);
int /*<<< orphan*/ sscanf(char *, char *, ...);
int main(int argc, char *argv[]) {
  char *flmge, *fmmge, *fxy, *fmom;
  double incl, dist, mbh, rbh, *beta, *kappa, *ml, temp;
  int nlg, nmg, i, count, narg, verbose;
  if (argc == 1) {
    printf("\nRequired arguments:\n"
           "  flmge   : path to luminous MGE\n"
           "  nlg     : number of luminous MGE components\n"
           "  fmmge   : path to mass MGE\n"
           "  nmg     : number of mass MGE components\n"
           "  fxy     : path to star positions file\n"
           "  fmom    : path to ouput moments file\n"
           "  incl    : inclination angle [radians]\n"
           "  dist    : distance [kpc]\n"
           "  mbh     : black-hole mass [Msun]\n"
           "  rbh     : black-hole scale length [arcsec]\n"
           "  *beta   : velocity anisotropy (nlg values)\n"
           "  *kappa  : rotation parameter (nlg values)\n"
           "  *ml     : mass-to-light ratio (nmg values)\n"
           "  verbose : print progress, if set\n"
           "\nNote that beta and kappa are required for each\ncomponent of "
           "the luminous MGE, and ml is required for\neach component of the "
           "potential MGE.  In total there\nshould be (10 + 2*nlg + nmg) "
           "arguments provided.\n\n");
    return 0;
  }
  sscanf(argv[argc - 1], "%i", &verbose);
  if (verbose)
    printf("\nReading parameters from command line...\n");
  if (argc - 1 < 4) {
    printf("\nERROR: You have not provided enough arguments to read in "
           "the MGE files.\n\n");
    return 0;
  }
  flmge = argv[1];
  sscanf(argv[2], "%i", &nlg);
  if (verbose)
    printf("  luminous MGE:    %s (%i components)\n", flmge, nlg);
  fmmge = argv[3];
  sscanf(argv[4], "%i", &nmg);
  if (verbose)
    printf("  potential MGE:   %s (%i components)\n", fmmge, nmg);
  narg = 11 + nlg * 2 + nmg;
  if (argc - 1 < narg) {
    printf("\nERROR: Not enough arguments.  Expected %i, got %i.\n\n", narg,
           argc - 1);
    return 0;
  }
  if (argc - 1 > narg) {
    printf("\nERROR: Too many arguments.  Expected %i, got %i.\n\n", narg,
           argc - 1);
    return 0;
  }
  fxy = argv[5];
  if (verbose)
    printf("  input positions: %s\n", fxy);
  fmom = argv[6];
  if (verbose)
    printf("  output moments:  %s\n", fmom);
  sscanf(argv[7], "%lf", &incl);
  if (verbose)
    printf("  inclination:     %lf radians\n", incl);
  sscanf(argv[8], "%lf", &dist);
  if (verbose)
    printf("  distance:        %lf kpc\n", dist);
  sscanf(argv[9], "%lf", &mbh);
  if (verbose)
    printf("  BH mass:         %lf Msun\n", mbh);
  sscanf(argv[10], "%lf", &rbh);
  if (verbose)
    printf("  BH scale length: %lf arcsec\n", rbh);
  count = 11;
  beta = (double *)malloc(nlg * sizeof(double));
  if (verbose)
    printf("  anisotropy:    ");
  for (i = 0; i < nlg; i++) {
    sscanf(argv[count], "%lf", &temp);
    beta[i] = temp;
    if (verbose)
      printf("  %lf", beta[i]);
    count++;
  }
  kappa = (double *)malloc(nlg * sizeof(double));
  if (verbose)
    printf("\n  rotation:      ");
  for (i = 0; i < nlg; i++) {
    sscanf(argv[count], "%lf", &temp);
    kappa[i] = temp;
    if (verbose)
      printf("  %lf", kappa[i]);
    count++;
  }
  ml = (double *)malloc(nmg * sizeof(double));
  if (verbose)
    printf("\n  mass-to-light: ");
  for (i = 0; i < nmg; i++) {
    sscanf(argv[count], "%lf", &temp);
    ml[i] = temp;
    if (verbose)
      printf("  %lf", ml[i]);
    count++;
  }
  if (verbose)
    printf("\n\n");
  cjam(beta, kappa, ml, incl, dist, mbh, rbh, nlg, nmg, flmge, fmmge, fxy, fmom,
       verbose);
  free(beta);
  free(kappa);
  free(ml);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
push   %rbx
sub    $0xa8,%rsp
movl   $0x0,-0xc(%rbp)
mov    %edi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
cmpl   $0x1,-0x10(%rbp)
jne    118e <main+0x3e>
lea    0xe85(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0xc(%rbp)
jmp    1744 <main+0x5f4>
mov    -0x18(%rbp),%rax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x115e(%rip),%rsi
lea    -0x90(%rbp),%rdx
mov    $0x0,%al
call   1060 <sscanf@plt>
cmpl   $0x0,-0x90(%rbp)
je     11cf <main+0x7f>
lea    0x113f(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x10(%rbp),%eax
sub    $0x1,%eax
cmp    $0x4,%eax
jge    11f8 <main+0xa8>
lea    0x114c(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0xc(%rbp)
jmp    1744 <main+0x5f4>
mov    -0x18(%rbp),%rax
mov    0x8(%rax),%rax
mov    %rax,-0x20(%rbp)
mov    -0x18(%rbp),%rax
mov    0x10(%rax),%rdi
lea    0x10f1(%rip),%rsi
lea    -0x7c(%rbp),%rdx
mov    $0x0,%al
call   1060 <sscanf@plt>
cmpl   $0x0,-0x90(%rbp)
je     1240 <main+0xf0>
mov    -0x20(%rbp),%rsi
mov    -0x7c(%rbp),%edx
lea    0x1143(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x18(%rbp),%rax
mov    0x18(%rax),%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
mov    0x20(%rax),%rdi
lea    0x10a9(%rip),%rsi
lea    -0x80(%rbp),%rdx
mov    $0x0,%al
call   1060 <sscanf@plt>
cmpl   $0x0,-0x90(%rbp)
je     1288 <main+0x138>
mov    -0x28(%rbp),%rsi
mov    -0x80(%rbp),%edx
lea    0x1122(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x7c(%rbp),%eax
shl    $0x1,%eax
add    $0xb,%eax
add    -0x80(%rbp),%eax
mov    %eax,-0x8c(%rbp)
mov    -0x10(%rbp),%eax
sub    $0x1,%eax
cmp    -0x8c(%rbp),%eax
jge    12d2 <main+0x182>
mov    -0x8c(%rbp),%esi
mov    -0x10(%rbp),%edx
sub    $0x1,%edx
lea    0x110b(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0xc(%rbp)
jmp    1744 <main+0x5f4>
mov    -0x10(%rbp),%eax
sub    $0x1,%eax
cmp    -0x8c(%rbp),%eax
jle    130a <main+0x1ba>
mov    -0x8c(%rbp),%esi
mov    -0x10(%rbp),%edx
sub    $0x1,%edx
lea    0x1109(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0xc(%rbp)
jmp    1744 <main+0x5f4>
mov    -0x18(%rbp),%rax
mov    0x28(%rax),%rax
mov    %rax,-0x30(%rbp)
cmpl   $0x0,-0x90(%rbp)
je     1335 <main+0x1e5>
mov    -0x30(%rbp),%rsi
lea    0x1106(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x18(%rbp),%rax
mov    0x30(%rax),%rax
mov    %rax,-0x38(%rbp)
cmpl   $0x0,-0x90(%rbp)
je     1360 <main+0x210>
mov    -0x38(%rbp),%rsi
lea    0x10f2(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x18(%rbp),%rax
mov    0x38(%rax),%rdi
lea    0x117f(%rip),%rsi
lea    -0x40(%rbp),%rdx
mov    $0x0,%al
call   1060 <sscanf@plt>
cmpl   $0x0,-0x90(%rbp)
je     139a <main+0x24a>
movsd  -0x40(%rbp),%xmm0
lea    0x10cf(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
mov    -0x18(%rbp),%rax
mov    0x40(%rax),%rdi
lea    0x1145(%rip),%rsi
lea    -0x48(%rbp),%rdx
mov    $0x0,%al
call   1060 <sscanf@plt>
cmpl   $0x0,-0x90(%rbp)
je     13d4 <main+0x284>
movsd  -0x48(%rbp),%xmm0
lea    0x10b5(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
mov    -0x18(%rbp),%rax
mov    0x48(%rax),%rdi
lea    0x110b(%rip),%rsi
lea    -0x50(%rbp),%rdx
mov    $0x0,%al
call   1060 <sscanf@plt>
cmpl   $0x0,-0x90(%rbp)
je     140e <main+0x2be>
movsd  -0x50(%rbp),%xmm0
lea    0x1097(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
mov    -0x18(%rbp),%rax
mov    0x50(%rax),%rdi
lea    0x10d1(%rip),%rsi
lea    -0x58(%rbp),%rdx
mov    $0x0,%al
call   1060 <sscanf@plt>
cmpl   $0x0,-0x90(%rbp)
je     1448 <main+0x2f8>
movsd  -0x58(%rbp),%xmm0
lea    0x107a(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
movl   $0xb,-0x88(%rbp)
movslq -0x7c(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x60(%rbp)
cmpl   $0x0,-0x90(%rbp)
je     1480 <main+0x330>
lea    0x1061(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0x84(%rbp)
mov    -0x84(%rbp),%eax
cmp    -0x7c(%rbp),%eax
jge    151d <main+0x3cd>
mov    -0x18(%rbp),%rax
movslq -0x88(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x103f(%rip),%rsi
lea    -0x78(%rbp),%rdx
mov    $0x0,%al
call   1060 <sscanf@plt>
movsd  -0x78(%rbp),%xmm0
mov    -0x60(%rbp),%rax
movslq -0x84(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
cmpl   $0x0,-0x90(%rbp)
je     14fa <main+0x3aa>
mov    -0x60(%rbp),%rax
movslq -0x84(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
lea    0xff9(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
mov    -0x88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x88(%rbp)
mov    -0x84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
jmp    148a <main+0x33a>
movslq -0x7c(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x68(%rbp)
cmpl   $0x0,-0x90(%rbp)
je     154b <main+0x3fb>
lea    0xfae(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0x84(%rbp)
mov    -0x84(%rbp),%eax
cmp    -0x7c(%rbp),%eax
jge    15e8 <main+0x498>
mov    -0x18(%rbp),%rax
movslq -0x88(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0xf74(%rip),%rsi
lea    -0x78(%rbp),%rdx
mov    $0x0,%al
call   1060 <sscanf@plt>
movsd  -0x78(%rbp),%xmm0
mov    -0x68(%rbp),%rax
movslq -0x84(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
cmpl   $0x0,-0x90(%rbp)
je     15c5 <main+0x475>
mov    -0x68(%rbp),%rax
movslq -0x84(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
lea    0xf2e(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
mov    -0x88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x88(%rbp)
mov    -0x84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
jmp    1555 <main+0x405>
movslq -0x80(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x70(%rbp)
cmpl   $0x0,-0x90(%rbp)
je     1616 <main+0x4c6>
lea    0xef6(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0x84(%rbp)
mov    -0x84(%rbp),%eax
cmp    -0x80(%rbp),%eax
jge    16b3 <main+0x563>
mov    -0x18(%rbp),%rax
movslq -0x88(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0xea9(%rip),%rsi
lea    -0x78(%rbp),%rdx
mov    $0x0,%al
call   1060 <sscanf@plt>
movsd  -0x78(%rbp),%xmm0
mov    -0x70(%rbp),%rax
movslq -0x84(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
cmpl   $0x0,-0x90(%rbp)
je     1690 <main+0x540>
mov    -0x70(%rbp),%rax
movslq -0x84(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
lea    0xe63(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
mov    -0x88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x88(%rbp)
mov    -0x84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
jmp    1620 <main+0x4d0>
cmpl   $0x0,-0x90(%rbp)
je     16ce <main+0x57e>
lea    0xc3a(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x60(%rbp),%rdi
mov    -0x68(%rbp),%rsi
mov    -0x70(%rbp),%rdx
movsd  -0x40(%rbp),%xmm0
movsd  -0x48(%rbp),%xmm1
movsd  -0x50(%rbp),%xmm2
movsd  -0x58(%rbp),%xmm3
mov    -0x7c(%rbp),%ecx
mov    -0x80(%rbp),%r8d
mov    -0x20(%rbp),%r9
mov    -0x28(%rbp),%rbx
mov    -0x30(%rbp),%r11
mov    -0x38(%rbp),%r10
mov    -0x90(%rbp),%eax
mov    %rbx,(%rsp)
mov    %r11,0x8(%rsp)
mov    %r10,0x10(%rsp)
mov    %eax,0x18(%rsp)
call   1070 <cjam@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>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
add    $0xa8,%rsp
pop    %rbx
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x68,%rsp
cmp    $0x1,%edi
jne    1184 <main+0x24>
lea    0x1098(%rip),%rdi
call   1040 <puts@plt>
jmp    15da <main+0x47a>
mov    %rsi,%r15
mov    %edi,%ebp
movslq %edi,%rax
mov    -0x8(%rsi,%rax,8),%rdi
lea    0xe68(%rip),%rsi
lea    0x4(%rsp),%rdx
xor    %eax,%eax
call   1070 <sscanf@plt>
cmpl   $0x0,0x4(%rsp)
je     11b7 <main+0x57>
lea    0x1037(%rip),%rdi
call   1040 <puts@plt>
cmp    $0x4,%ebp
jg     11cd <main+0x6d>
lea    0xfdc(%rip),%rdi
call   1040 <puts@plt>
jmp    15da <main+0x47a>
mov    0x8(%r15),%r14
mov    0x10(%r15),%rdi
lea    0xe24(%rip),%rsi
lea    0x8(%rsp),%rdx
xor    %eax,%eax
call   1070 <sscanf@plt>
cmpl   $0x0,0x4(%rsp)
je     1204 <main+0xa4>
mov    0x8(%rsp),%edx
lea    0xe09(%rip),%rdi
mov    %r14,%rsi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x18(%r15),%rbx
mov    0x20(%r15),%rdi
lea    0xded(%rip),%rsi
lea    0xc(%rsp),%rdx
xor    %eax,%eax
call   1070 <sscanf@plt>
cmpl   $0x0,0x4(%rsp)
je     123b <main+0xdb>
mov    0xc(%rsp),%edx
lea    0xdf9(%rip),%rdi
mov    %rbx,%rsi
xor    %eax,%eax
call   1050 <printf@plt>
lea    -0x1(%rbp),%edx
mov    0x8(%rsp),%eax
mov    0xc(%rsp),%ecx
lea    (%rcx,%rax,2),%esi
add    $0xb,%esi
cmp    %ebp,%esi
jge    125d <main+0xfd>
cmp    %esi,%edx
jle    1270 <main+0x110>
lea    0xe2c(%rip),%rdi
jmp    1264 <main+0x104>
lea    0xded(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
jmp    15da <main+0x47a>
mov    0x28(%r15),%rsi
cmpl   $0x0,0x4(%rsp)
mov    %rsi,0x20(%rsp)
je     12ae <main+0x14e>
lea    0xe34(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x30(%r15),%rsi
cmpl   $0x0,0x4(%rsp)
mov    %rsi,0x18(%rsp)
je     12b7 <main+0x157>
lea    0xe2d(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
jmp    12b7 <main+0x157>
mov    0x30(%r15),%rax
mov    %rax,0x18(%rsp)
mov    0x38(%r15),%rdi
lea    0xeb3(%rip),%rsi
lea    0x60(%rsp),%rdx
xor    %eax,%eax
call   1070 <sscanf@plt>
cmpl   $0x0,0x4(%rsp)
je     12e9 <main+0x189>
movsd  0x60(%rsp),%xmm0
lea    0xe07(%rip),%rdi
mov    $0x1,%al
call   1050 <printf@plt>
mov    0x40(%r15),%rdi
lea    0xe81(%rip),%rsi
lea    0x58(%rsp),%rdx
xor    %eax,%eax
call   1070 <sscanf@plt>
cmpl   $0x0,0x4(%rsp)
je     131b <main+0x1bb>
movsd  0x58(%rsp),%xmm0
lea    0xdf5(%rip),%rdi
mov    $0x1,%al
call   1050 <printf@plt>
mov    0x48(%r15),%rdi
lea    0xe4f(%rip),%rsi
lea    0x50(%rsp),%rdx
xor    %eax,%eax
call   1070 <sscanf@plt>
cmpl   $0x0,0x4(%rsp)
je     134d <main+0x1ed>
movsd  0x50(%rsp),%xmm0
lea    0xddf(%rip),%rdi
mov    $0x1,%al
call   1050 <printf@plt>
mov    0x50(%r15),%rdi
lea    0xe1d(%rip),%rsi
lea    0x48(%rsp),%rdx
xor    %eax,%eax
call   1070 <sscanf@plt>
cmpl   $0x0,0x4(%rsp)
je     137f <main+0x21f>
movsd  0x48(%rsp),%xmm0
lea    0xdca(%rip),%rdi
mov    $0x1,%al
call   1050 <printf@plt>
mov    0x8(%rsp),%edi
shl    $0x3,%edi
call   1060 <malloc@plt>
mov    %rax,%r13
cmpl   $0x0,0x4(%rsp)
je     13a3 <main+0x243>
lea    0xdc5(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x8(%rsp),%edi
test   %edi,%edi
mov    %r14,0x30(%rsp)
mov    %rbx,0x28(%rsp)
jle    1416 <main+0x2b6>
lea    0xdb9(%rip),%rbp
lea    0x10(%rsp),%rbx
lea    0xdab(%rip),%r12
xor    %r14d,%r14d
jmp    13de <main+0x27e>
nopl   (%rax)
add    $0x1,%r14
movslq 0x8(%rsp),%rdi
cmp    %rdi,%r14
jge    1410 <main+0x2b0>
mov    0x58(%r15,%r14,8),%rdi
mov    %rbp,%rsi
mov    %rbx,%rdx
xor    %eax,%eax
call   1070 <sscanf@plt>
movsd  0x10(%rsp),%xmm0
movsd  %xmm0,0x0(%r13,%r14,8)
cmpl   $0x0,0x4(%rsp)
je     13d0 <main+0x270>
mov    %r12,%rdi
mov    $0x1,%al
call   1050 <printf@plt>
jmp    13d0 <main+0x270>
add    $0xb,%r14d
jmp    141c <main+0x2bc>
mov    $0xb,%r14d
shl    $0x3,%edi
call   1060 <malloc@plt>
mov    %rax,0x40(%rsp)
cmpl   $0x0,0x4(%rsp)
je     143e <main+0x2de>
lea    0xd42(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
cmpl   $0x0,0x8(%rsp)
mov    %r13,0x38(%rsp)
jle    14c0 <main+0x360>
mov    %r14d,%r14d
lea    (%r15,%r14,8),%r13
lea    0xd1d(%rip),%rbp
lea    0x10(%rsp),%rbx
xor    %r12d,%r12d
jmp    147e <main+0x31e>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%r12
movslq 0x8(%rsp),%rax
cmp    %rax,%r12
jge    14b8 <main+0x358>
mov    0x0(%r13,%r12,8),%rdi
mov    %rbp,%rsi
mov    %rbx,%rdx
xor    %eax,%eax
call   1070 <sscanf@plt>
movsd  0x10(%rsp),%xmm0
mov    0x40(%rsp),%rax
movsd  %xmm0,(%rax,%r12,8)
cmpl   $0x0,0x4(%rsp)
je     1470 <main+0x310>
lea    0xcc4(%rip),%rdi
mov    $0x1,%al
call   1050 <printf@plt>
jmp    1470 <main+0x310>
add    %r12d,%r14d
mov    0x38(%rsp),%r13
mov    0xc(%rsp),%edi
shl    $0x3,%edi
call   1060 <malloc@plt>
mov    %rax,%r12
cmpl   $0x0,0x4(%rsp)
je     14e4 <main+0x384>
lea    0xcaf(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0xc(%rsp),%r8d
test   %r8d,%r8d
jle    1553 <main+0x3f3>
mov    %r14d,%eax
lea    (%r15,%rax,8),%rbx
lea    0xc79(%rip),%r14
lea    0x10(%rsp),%r13
lea    0xc6b(%rip),%r15
xor    %ebp,%ebp
jmp    151e <main+0x3be>
nopl   0x0(%rax)
add    $0x1,%rbp
movslq 0xc(%rsp),%r8
cmp    %r8,%rbp
jge    154e <main+0x3ee>
mov    (%rbx,%rbp,8),%rdi
mov    %r14,%rsi
mov    %r13,%rdx
xor    %eax,%eax
call   1070 <sscanf@plt>
movsd  0x10(%rsp),%xmm0
movsd  %xmm0,(%r12,%rbp,8)
cmpl   $0x0,0x4(%rsp)
je     1510 <main+0x3b0>
mov    %r15,%rdi
mov    $0x1,%al
call   1050 <printf@plt>
jmp    1510 <main+0x3b0>
mov    0x38(%rsp),%r13
cmpl   $0x0,0x4(%rsp)
je     1572 <main+0x412>
lea    0xb24(%rip),%rdi
call   1040 <puts@plt>
mov    0xc(%rsp),%r8d
mov    0x4(%rsp),%r10d
jmp    1575 <main+0x415>
xor    %r10d,%r10d
mov    0x30(%rsp),%r9
mov    0x28(%rsp),%r11
mov    0x20(%rsp),%rbx
mov    0x18(%rsp),%rax
movsd  0x60(%rsp),%xmm0
movsd  0x58(%rsp),%xmm1
movsd  0x50(%rsp),%xmm2
movsd  0x48(%rsp),%xmm3
mov    0x8(%rsp),%ecx
mov    %r13,%rdi
mov    0x40(%rsp),%rbp
mov    %rbp,%rsi
mov    %r12,%rdx
push   %r10
push   %rax
push   %rbx
push   %r11
call   1080 <cjam@plt>
add    $0x20,%rsp
mov    %r13,%rdi
call   1030 <free@plt>
mov    %rbp,%rdi
call   1030 <free@plt>
mov    %r12,%rdi
call   1030 <free@plt>
xor    %eax,%eax
add    $0x68,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [772 x i8] c"\0ARequired arguments:\0A flmge : path to luminous MGE\0A nlg : number of luminous MGE components\0A fmmge : path to mass MGE\0A nmg : number of mass MGE components\0A fxy : path to star positions file\0A fmom : path to ouput moments file\0A incl : inclination angle [radians]\0A dist : distance [kpc]\0A mbh : black-hole mass [Msun]\0A rbh : black-hole scale length [arcsec]\0A *beta : velocity anisotropy (nlg values)\0A *kappa : rotation parameter (nlg values)\0A *ml : mass-to-light ratio (nmg values)\0A verbose : print progress, if set\0A\0ANote that beta and kappa are required for each\0Acomponent of the luminous MGE, and ml is required for\0Aeach component of the potential MGE. In total there\0Ashould be (10 + 2*nlg + nmg) arguments provided.\0A\0A\00"
@.str.1 = [3 x i8] c"%i\00"
@.str.2 = [42 x i8] c"\0AReading parameters from command line...\0A\00"
@.str.3 = [75 x i8] c"\0AERROR: You have not provided enough arguments to read in the MGE files.\0A\0A\00"
@.str.4 = [39 x i8] c" luminous MGE: %s (%i components)\0A\00"
@.str.5 = [39 x i8] c" potential MGE: %s (%i components)\0A\00"
@.str.6 = [54 x i8] c"\0AERROR: Not enough arguments. Expected %i, got %i.\0A\0A\00"
@.str.7 = [52 x i8] c"\0AERROR: Too many arguments. Expected %i, got %i.\0A\0A\00"
@.str.8 = [23 x i8] c" input positions: %s\0A\00"
@.str.9 = [23 x i8] c" output moments: %s\0A\00"
@.str.10 = [4 x i8] c"%lf\00"
@.str.11 = [32 x i8] c" inclination: %lf radians\0A\00"
@.str.12 = [28 x i8] c" distance: %lf kpc\0A\00"
@.str.13 = [29 x i8] c" BH mass: %lf Msun\0A\00"
@.str.14 = [31 x i8] c" BH scale length: %lf arcsec\0A\00"
@.str.15 = [18 x i8] c" anisotropy: \00"
@.str.16 = [6 x i8] c" %lf\00"
@.str.17 = [19 x i8] c"\0A rotation: \00"
@.str.18 = [19 x i8] c"\0A mass-to-light: \00"
@.str.19 = [3 x i8] c"\0A\0A\00"
define i32 @main(i32 %0, i8** %1) {
%3 = alloca i32
%4 = alloca i32
%5 = alloca i8**
%6 = alloca i8*
%7 = alloca i8*
%8 = alloca i8*
%9 = alloca i8*
%10 = alloca double
%11 = alloca double
%12 = alloca double
%13 = alloca double
%14 = alloca double*
%15 = alloca double*
%16 = alloca double*
%17 = alloca double
%18 = alloca i32
%19 = alloca i32
%20 = alloca i32
%21 = alloca i32
%22 = alloca i32
%23 = alloca i32
store i32 0, i32* %3
store i32 %0, i32* %4
store i8** %1, i8*** %5
%24 = load i32, i32* %4
%25 = icmp eq i32 %24, 1
br i1 %25, label %26, label %28
26: ; preds = %2
%27 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([772 x i8], [772 x i8]* @.str, i64 0, i64 0))
store i32 0, i32* %3
br label %313
28: ; preds = %2
%29 = load i8**, i8*** %5
%30 = load i32, i32* %4
%31 = sub nsw i32 %30, 1
%32 = sext i32 %31 to i64
%33 = getelementptr inbounds i8*, i8** %29, i64 %32
%34 = load i8*, i8** %33
%35 = call i32 (i8*, i8*, ...) @sscanf(i8* %34, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32* %23)
%36 = load i32, i32* %23
%37 = icmp ne i32 %36, 0
br i1 %37, label %38, label %40
38: ; preds = %28
%39 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([42 x i8], [42 x i8]* @.str.2, i64 0, i64 0))
br label %40
40: ; preds = %38, %28
%41 = load i32, i32* %4
%42 = sub nsw i32 %41, 1
%43 = icmp slt i32 %42, 4
br i1 %43, label %44, label %46
44: ; preds = %40
%45 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([75 x i8], [75 x i8]* @.str.3, i64 0, i64 0))
store i32 0, i32* %3
br label %313
46: ; preds = %40
%47 = load i8**, i8*** %5
%48 = getelementptr inbounds i8*, i8** %47, i64 1
%49 = load i8*, i8** %48
store i8* %49, i8** %6
%50 = load i8**, i8*** %5
%51 = getelementptr inbounds i8*, i8** %50, i64 2
%52 = load i8*, i8** %51
%53 = call i32 (i8*, i8*, ...) @sscanf(i8* %52, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32* %18)
%54 = load i32, i32* %23
%55 = icmp ne i32 %54, 0
br i1 %55, label %56, label %60
56: ; preds = %46
%57 = load i8*, i8** %6
%58 = load i32, i32* %18
%59 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str.4, i64 0, i64 0), i8* %57, i32 %58)
br label %60
60: ; preds = %56, %46
%61 = load i8**, i8*** %5
%62 = getelementptr inbounds i8*, i8** %61, i64 3
%63 = load i8*, i8** %62
store i8* %63, i8** %7
%64 = load i8**, i8*** %5
%65 = getelementptr inbounds i8*, i8** %64, i64 4
%66 = load i8*, i8** %65
%67 = call i32 (i8*, i8*, ...) @sscanf(i8* %66, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32* %19)
%68 = load i32, i32* %23
%69 = icmp ne i32 %68, 0
br i1 %69, label %70, label %74
70: ; preds = %60
%71 = load i8*, i8** %7
%72 = load i32, i32* %19
%73 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str.5, i64 0, i64 0), i8* %71, i32 %72)
br label %74
74: ; preds = %70, %60
%75 = load i32, i32* %18
%76 = mul nsw i32 %75, 2
%77 = add nsw i32 11, %76
%78 = load i32, i32* %19
%79 = add nsw i32 %77, %78
store i32 %79, i32* %22
%80 = load i32, i32* %4
%81 = sub nsw i32 %80, 1
%82 = load i32, i32* %22
%83 = icmp slt i32 %81, %82
br i1 %83, label %84, label %89
84: ; preds = %74
%85 = load i32, i32* %22
%86 = load i32, i32* %4
%87 = sub nsw i32 %86, 1
%88 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([54 x i8], [54 x i8]* @.str.6, i64 0, i64 0), i32 %85, i32 %87)
store i32 0, i32* %3
br label %313
89: ; preds = %74
%90 = load i32, i32* %4
%91 = sub nsw i32 %90, 1
%92 = load i32, i32* %22
%93 = icmp sgt i32 %91, %92
br i1 %93, label %94, label %99
94: ; preds = %89
%95 = load i32, i32* %22
%96 = load i32, i32* %4
%97 = sub nsw i32 %96, 1
%98 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([52 x i8], [52 x i8]* @.str.7, i64 0, i64 0), i32 %95, i32 %97)
store i32 0, i32* %3
br label %313
99: ; preds = %89
%100 = load i8**, i8*** %5
%101 = getelementptr inbounds i8*, i8** %100, i64 5
%102 = load i8*, i8** %101
store i8* %102, i8** %8
%103 = load i32, i32* %23
%104 = icmp ne i32 %103, 0
br i1 %104, label %105, label %108
105: ; preds = %99
%106 = load i8*, i8** %8
%107 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str.8, i64 0, i64 0), i8* %106)
br label %108
108: ; preds = %105, %99
%109 = load i8**, i8*** %5
%110 = getelementptr inbounds i8*, i8** %109, i64 6
%111 = load i8*, i8** %110
store i8* %111, i8** %9
%112 = load i32, i32* %23
%113 = icmp ne i32 %112, 0
br i1 %113, label %114, label %117
114: ; preds = %108
%115 = load i8*, i8** %9
%116 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str.9, i64 0, i64 0), i8* %115)
br label %117
117: ; preds = %114, %108
%118 = load i8**, i8*** %5
%119 = getelementptr inbounds i8*, i8** %118, i64 7
%120 = load i8*, i8** %119
%121 = call i32 (i8*, i8*, ...) @sscanf(i8* %120, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.10, i64 0, i64 0), double* %10)
%122 = load i32, i32* %23
%123 = icmp ne i32 %122, 0
br i1 %123, label %124, label %127
124: ; preds = %117
%125 = load double, double* %10
%126 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.11, i64 0, i64 0), double %125)
br label %127
127: ; preds = %124, %117
%128 = load i8**, i8*** %5
%129 = getelementptr inbounds i8*, i8** %128, i64 8
%130 = load i8*, i8** %129
%131 = call i32 (i8*, i8*, ...) @sscanf(i8* %130, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.10, i64 0, i64 0), double* %11)
%132 = load i32, i32* %23
%133 = icmp ne i32 %132, 0
br i1 %133, label %134, label %137
134: ; preds = %127
%135 = load double, double* %11
%136 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str.12, i64 0, i64 0), double %135)
br label %137
137: ; preds = %134, %127
%138 = load i8**, i8*** %5
%139 = getelementptr inbounds i8*, i8** %138, i64 9
%140 = load i8*, i8** %139
%141 = call i32 (i8*, i8*, ...) @sscanf(i8* %140, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.10, i64 0, i64 0), double* %12)
%142 = load i32, i32* %23
%143 = icmp ne i32 %142, 0
br i1 %143, label %144, label %147
144: ; preds = %137
%145 = load double, double* %12
%146 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.13, i64 0, i64 0), double %145)
br label %147
147: ; preds = %144, %137
%148 = load i8**, i8*** %5
%149 = getelementptr inbounds i8*, i8** %148, i64 10
%150 = load i8*, i8** %149
%151 = call i32 (i8*, i8*, ...) @sscanf(i8* %150, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.10, i64 0, i64 0), double* %13)
%152 = load i32, i32* %23
%153 = icmp ne i32 %152, 0
br i1 %153, label %154, label %157
154: ; preds = %147
%155 = load double, double* %13
%156 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str.14, i64 0, i64 0), double %155)
br label %157
157: ; preds = %154, %147
store i32 11, i32* %21
%158 = load i32, i32* %18
%159 = sext i32 %158 to i64
%160 = mul i64 %159, 8
%161 = trunc i64 %160 to i32
%162 = call i64 @malloc(i32 %161)
%163 = inttoptr i64 %162 to double*
store double* %163, double** %14
%164 = load i32, i32* %23
%165 = icmp ne i32 %164, 0
br i1 %165, label %166, label %168
166: ; preds = %157
%167 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.15, i64 0, i64 0))
br label %168
168: ; preds = %166, %157
store i32 0, i32* %20
br label %169
169: ; preds = %197, %168
%170 = load i32, i32* %20
%171 = load i32, i32* %18
%172 = icmp slt i32 %170, %171
br i1 %172, label %173, label %200
173: ; preds = %169
%174 = load i8**, i8*** %5
%175 = load i32, i32* %21
%176 = sext i32 %175 to i64
%177 = getelementptr inbounds i8*, i8** %174, i64 %176
%178 = load i8*, i8** %177
%179 = call i32 (i8*, i8*, ...) @sscanf(i8* %178, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.10, i64 0, i64 0), double* %17)
%180 = load double, double* %17
%181 = load double*, double** %14
%182 = load i32, i32* %20
%183 = sext i32 %182 to i64
%184 = getelementptr inbounds double, double* %181, i64 %183
store double %180, double* %184
%185 = load i32, i32* %23
%186 = icmp ne i32 %185, 0
br i1 %186, label %187, label %194
187: ; preds = %173
%188 = load double*, double** %14
%189 = load i32, i32* %20
%190 = sext i32 %189 to i64
%191 = getelementptr inbounds double, double* %188, i64 %190
%192 = load double, double* %191
%193 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.16, i64 0, i64 0), double %192)
br label %194
194: ; preds = %187, %173
%195 = load i32, i32* %21
%196 = add nsw i32 %195, 1
store i32 %196, i32* %21
br label %197
197: ; preds = %194
%198 = load i32, i32* %20
%199 = add nsw i32 %198, 1
store i32 %199, i32* %20
br label %169
200: ; preds = %169
%201 = load i32, i32* %18
%202 = sext i32 %201 to i64
%203 = mul i64 %202, 8
%204 = trunc i64 %203 to i32
%205 = call i64 @malloc(i32 %204)
%206 = inttoptr i64 %205 to double*
store double* %206, double** %15
%207 = load i32, i32* %23
%208 = icmp ne i32 %207, 0
br i1 %208, label %209, label %211
209: ; preds = %200
%210 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.17, i64 0, i64 0))
br label %211
211: ; preds = %209, %200
store i32 0, i32* %20
br label %212
212: ; preds = %240, %211
%213 = load i32, i32* %20
%214 = load i32, i32* %18
%215 = icmp slt i32 %213, %214
br i1 %215, label %216, label %243
216: ; preds = %212
%217 = load i8**, i8*** %5
%218 = load i32, i32* %21
%219 = sext i32 %218 to i64
%220 = getelementptr inbounds i8*, i8** %217, i64 %219
%221 = load i8*, i8** %220
%222 = call i32 (i8*, i8*, ...) @sscanf(i8* %221, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.10, i64 0, i64 0), double* %17)
%223 = load double, double* %17
%224 = load double*, double** %15
%225 = load i32, i32* %20
%226 = sext i32 %225 to i64
%227 = getelementptr inbounds double, double* %224, i64 %226
store double %223, double* %227
%228 = load i32, i32* %23
%229 = icmp ne i32 %228, 0
br i1 %229, label %230, label %237
230: ; preds = %216
%231 = load double*, double** %15
%232 = load i32, i32* %20
%233 = sext i32 %232 to i64
%234 = getelementptr inbounds double, double* %231, i64 %233
%235 = load double, double* %234
%236 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.16, i64 0, i64 0), double %235)
br label %237
237: ; preds = %230, %216
%238 = load i32, i32* %21
%239 = add nsw i32 %238, 1
store i32 %239, i32* %21
br label %240
240: ; preds = %237
%241 = load i32, i32* %20
%242 = add nsw i32 %241, 1
store i32 %242, i32* %20
br label %212
243: ; preds = %212
%244 = load i32, i32* %19
%245 = sext i32 %244 to i64
%246 = mul i64 %245, 8
%247 = trunc i64 %246 to i32
%248 = call i64 @malloc(i32 %247)
%249 = inttoptr i64 %248 to double*
store double* %249, double** %16
%250 = load i32, i32* %23
%251 = icmp ne i32 %250, 0
br i1 %251, label %252, label %254
252: ; preds = %243
%253 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.18, i64 0, i64 0))
br label %254
254: ; preds = %252, %243
store i32 0, i32* %20
br label %255
255: ; preds = %283, %254
%256 = load i32, i32* %20
%257 = load i32, i32* %19
%258 = icmp slt i32 %256, %257
br i1 %258, label %259, label %286
259: ; preds = %255
%260 = load i8**, i8*** %5
%261 = load i32, i32* %21
%262 = sext i32 %261 to i64
%263 = getelementptr inbounds i8*, i8** %260, i64 %262
%264 = load i8*, i8** %263
%265 = call i32 (i8*, i8*, ...) @sscanf(i8* %264, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.10, i64 0, i64 0), double* %17)
%266 = load double, double* %17
%267 = load double*, double** %16
%268 = load i32, i32* %20
%269 = sext i32 %268 to i64
%270 = getelementptr inbounds double, double* %267, i64 %269
store double %266, double* %270
%271 = load i32, i32* %23
%272 = icmp ne i32 %271, 0
br i1 %272, label %273, label %280
273: ; preds = %259
%274 = load double*, double** %16
%275 = load i32, i32* %20
%276 = sext i32 %275 to i64
%277 = getelementptr inbounds double, double* %274, i64 %276
%278 = load double, double* %277
%279 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.16, i64 0, i64 0), double %278)
br label %280
280: ; preds = %273, %259
%281 = load i32, i32* %21
%282 = add nsw i32 %281, 1
store i32 %282, i32* %21
br label %283
283: ; preds = %280
%284 = load i32, i32* %20
%285 = add nsw i32 %284, 1
store i32 %285, i32* %20
br label %255
286: ; preds = %255
%287 = load i32, i32* %23
%288 = icmp ne i32 %287, 0
br i1 %288, label %289, label %291
289: ; preds = %286
%290 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.19, i64 0, i64 0))
br label %291
291: ; preds = %289, %286
%292 = load double*, double** %14
%293 = load double*, double** %15
%294 = load double*, double** %16
%295 = load double, double* %10
%296 = load double, double* %11
%297 = load double, double* %12
%298 = load double, double* %13
%299 = load i32, i32* %18
%300 = load i32, i32* %19
%301 = load i8*, i8** %6
%302 = load i8*, i8** %7
%303 = load i8*, i8** %8
%304 = load i8*, i8** %9
%305 = load i32, i32* %23
%306 = call i32 @cjam(double* %292, double* %293, double* %294, double %295, double %296, double %297, double %298, i32 %299, i32 %300, i8* %301, i8* %302, i8* %303, i8* %304, i32 %305)
%307 = load double*, double** %14
%308 = call i32 @free(double* %307)
%309 = load double*, double** %15
%310 = call i32 @free(double* %309)
%311 = load double*, double** %16
%312 = call i32 @free(double* %311)
store i32 0, i32* %3
br label %313
313: ; preds = %291, %94, %84, %44, %26
%314 = load i32, i32* %3
ret i32 %314
}

LLVM IR (-O2):
@.str.1 = [3 x i8] c"%i\00"
@.str.4 = [39 x i8] c" luminous MGE: %s (%i components)\0A\00"
@.str.5 = [39 x i8] c" potential MGE: %s (%i components)\0A\00"
@.str.6 = [54 x i8] c"\0AERROR: Not enough arguments. Expected %i, got %i.\0A\0A\00"
@.str.7 = [52 x i8] c"\0AERROR: Too many arguments. Expected %i, got %i.\0A\0A\00"
@.str.8 = [23 x i8] c" input positions: %s\0A\00"
@.str.9 = [23 x i8] c" output moments: %s\0A\00"
@.str.10 = [4 x i8] c"%lf\00"
@.str.11 = [32 x i8] c" inclination: %lf radians\0A\00"
@.str.12 = [28 x i8] c" distance: %lf kpc\0A\00"
@.str.13 = [29 x i8] c" BH mass: %lf Msun\0A\00"
@.str.14 = [31 x i8] c" BH scale length: %lf arcsec\0A\00"
@.str.15 = [18 x i8] c" anisotropy: \00"
@.str.16 = [6 x i8] c" %lf\00"
@.str.17 = [19 x i8] c"\0A rotation: \00"
@.str.18 = [19 x i8] c"\0A mass-to-light: \00"
@str = [2 x i8] c"\0A\00"
@str.20 = [74 x i8] c"\0AERROR: You have not provided enough arguments to read in the MGE files.\0A\00"
@str.21 = [41 x i8] c"\0AReading parameters from command line...\00"
@str.22 = [771 x i8] c"\0ARequired arguments:\0A flmge : path to luminous MGE\0A nlg : number of luminous MGE components\0A fmmge : path to mass MGE\0A nmg : number of mass MGE components\0A fxy : path to star positions file\0A fmom : path to ouput moments file\0A incl : inclination angle [radians]\0A dist : distance [kpc]\0A mbh : black-hole mass [Msun]\0A rbh : black-hole scale length [arcsec]\0A *beta : velocity anisotropy (nlg values)\0A *kappa : rotation parameter (nlg values)\0A *ml : mass-to-light ratio (nmg values)\0A verbose : print progress, if set\0A\0ANote that beta and kappa are required for each\0Acomponent of the luminous MGE, and ml is required for\0Aeach component of the potential MGE. In total there\0Ashould be (10 + 2*nlg + nmg) arguments provided.\0A\00"
define i32 @main(i32 %0, i8** nocapture %1) {
%3 = alloca double
%4 = alloca double
%5 = alloca double
%6 = alloca double
%7 = alloca double
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = bitcast double* %3 to i8*
%12 = bitcast double* %4 to i8*
%13 = bitcast double* %5 to i8*
%14 = bitcast double* %6 to i8*
%15 = bitcast double* %7 to i8*
%16 = bitcast i32* %8 to i8*
%17 = bitcast i32* %9 to i8*
%18 = bitcast i32* %10 to i8*
%19 = icmp eq i32 %0, 1
br i1 %19, label %20, label %22
20: ; preds = %2
%21 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([771 x i8], [771 x i8]* @str.22, i64 0, i64 0))
br label %244
22: ; preds = %2
%23 = add nsw i32 %0, -1
%24 = sext i32 %23 to i64
%25 = getelementptr inbounds i8*, i8** %1, i64 %24
%26 = load i8*, i8** %25
%27 = call i32 (i8*, i8*, ...) @sscanf(i8* %26, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32* %10)
%28 = load i32, i32* %10
%29 = icmp eq i32 %28, 0
br i1 %29, label %32, label %30
30: ; preds = %22
%31 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([41 x i8], [41 x i8]* @str.21, i64 0, i64 0))
br label %32
32: ; preds = %30, %22
%33 = icmp slt i32 %0, 5
br i1 %33, label %34, label %36
34: ; preds = %32
%35 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([74 x i8], [74 x i8]* @str.20, i64 0, i64 0))
br label %244
36: ; preds = %32
%37 = getelementptr inbounds i8*, i8** %1, i64 1
%38 = load i8*, i8** %37
%39 = getelementptr inbounds i8*, i8** %1, i64 2
%40 = load i8*, i8** %39
%41 = call i32 (i8*, i8*, ...) @sscanf(i8* %40, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32* %8)
%42 = load i32, i32* %10
%43 = icmp eq i32 %42, 0
br i1 %43, label %47, label %44
44: ; preds = %36
%45 = load i32, i32* %8
%46 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([39 x i8], [39 x i8]* @.str.4, i64 0, i64 0), i8* %38, i32 %45)
br label %47
47: ; preds = %44, %36
%48 = getelementptr inbounds i8*, i8** %1, i64 3
%49 = load i8*, i8** %48
%50 = getelementptr inbounds i8*, i8** %1, i64 4
%51 = load i8*, i8** %50
%52 = call i32 (i8*, i8*, ...) @sscanf(i8* %51, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32* %9)
%53 = load i32, i32* %10
%54 = icmp eq i32 %53, 0
br i1 %54, label %58, label %55
55: ; preds = %47
%56 = load i32, i32* %9
%57 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([39 x i8], [39 x i8]* @.str.5, i64 0, i64 0), i8* %49, i32 %56)
br label %58
58: ; preds = %55, %47
%59 = load i32, i32* %8
%60 = shl nsw i32 %59, 1
%61 = add nsw i32 %60, 11
%62 = load i32, i32* %9
%63 = add nsw i32 %61, %62
%64 = icmp slt i32 %63, %0
br i1 %64, label %67, label %65
65: ; preds = %58
%66 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([54 x i8], [54 x i8]* @.str.6, i64 0, i64 0), i32 %63, i32 %23)
br label %244
67: ; preds = %58
%68 = icmp sgt i32 %23, %63
br i1 %68, label %69, label %71
69: ; preds = %67
%70 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([52 x i8], [52 x i8]* @.str.7, i64 0, i64 0), i32 %63, i32 %23)
br label %244
71: ; preds = %67
%72 = getelementptr inbounds i8*, i8** %1, i64 5
%73 = load i8*, i8** %72
%74 = load i32, i32* %10
%75 = icmp eq i32 %74, 0
br i1 %75, label %76, label %79
76: ; preds = %71
%77 = getelementptr inbounds i8*, i8** %1, i64 6
%78 = load i8*, i8** %77
br label %87
79: ; preds = %71
%80 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([23 x i8], [23 x i8]* @.str.8, i64 0, i64 0), i8* %73)
%81 = load i32, i32* %10
%82 = getelementptr inbounds i8*, i8** %1, i64 6
%83 = load i8*, i8** %82
%84 = icmp eq i32 %81, 0
br i1 %84, label %87, label %85
85: ; preds = %79
%86 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([23 x i8], [23 x i8]* @.str.9, i64 0, i64 0), i8* %83)
br label %87
87: ; preds = %76, %85, %79
%88 = phi i8* [ %78, %76 ], [ %83, %85 ], [ %83, %79 ]
%89 = getelementptr inbounds i8*, i8** %1, i64 7
%90 = load i8*, i8** %89
%91 = call i32 (i8*, i8*, ...) @sscanf(i8* %90, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.10, i64 0, i64 0), double* %3)
%92 = load i32, i32* %10
%93 = icmp eq i32 %92, 0
br i1 %93, label %97, label %94
94: ; preds = %87
%95 = load double, double* %3
%96 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([32 x i8], [32 x i8]* @.str.11, i64 0, i64 0), double %95)
br label %97
97: ; preds = %94, %87
%98 = getelementptr inbounds i8*, i8** %1, i64 8
%99 = load i8*, i8** %98
%100 = call i32 (i8*, i8*, ...) @sscanf(i8* %99, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.10, i64 0, i64 0), double* %4)
%101 = load i32, i32* %10
%102 = icmp eq i32 %101, 0
br i1 %102, label %106, label %103
103: ; preds = %97
%104 = load double, double* %4
%105 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([28 x i8], [28 x i8]* @.str.12, i64 0, i64 0), double %104)
br label %106
106: ; preds = %103, %97
%107 = getelementptr inbounds i8*, i8** %1, i64 9
%108 = load i8*, i8** %107
%109 = call i32 (i8*, i8*, ...) @sscanf(i8* %108, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.10, i64 0, i64 0), double* %5)
%110 = load i32, i32* %10
%111 = icmp eq i32 %110, 0
br i1 %111, label %115, label %112
112: ; preds = %106
%113 = load double, double* %5
%114 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([29 x i8], [29 x i8]* @.str.13, i64 0, i64 0), double %113)
br label %115
115: ; preds = %112, %106
%116 = getelementptr inbounds i8*, i8** %1, i64 10
%117 = load i8*, i8** %116
%118 = call i32 (i8*, i8*, ...) @sscanf(i8* %117, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.10, i64 0, i64 0), double* %6)
%119 = load i32, i32* %10
%120 = icmp eq i32 %119, 0
br i1 %120, label %124, label %121
121: ; preds = %115
%122 = load double, double* %6
%123 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([31 x i8], [31 x i8]* @.str.14, i64 0, i64 0), double %122)
br label %124
124: ; preds = %121, %115
%125 = load i32, i32* %8
%126 = shl i32 %125, 3
%127 = call i64 @malloc(i32 %126)
%128 = inttoptr i64 %127 to double*
%129 = load i32, i32* %10
%130 = icmp eq i32 %129, 0
br i1 %130, label %133, label %131
131: ; preds = %124
%132 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([18 x i8], [18 x i8]* @.str.15, i64 0, i64 0))
br label %133
133: ; preds = %131, %124
%134 = load i32, i32* %8
%135 = icmp sgt i32 %134, 0
br i1 %135, label %136, label %156
136: ; preds = %133, %148
%137 = phi i64 [ %150, %148 ], [ 0, %133 ]
%138 = phi i64 [ %149, %148 ], [ 11, %133 ]
%139 = getelementptr inbounds i8*, i8** %1, i64 %138
%140 = load i8*, i8** %139
%141 = call i32 (i8*, i8*, ...) @sscanf(i8* %140, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.10, i64 0, i64 0), double* %7)
%142 = load double, double* %7
%143 = getelementptr inbounds double, double* %128, i64 %137
store double %142, double* %143
%144 = load i32, i32* %10
%145 = icmp eq i32 %144, 0
br i1 %145, label %148, label %146
146: ; preds = %136
%147 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.16, i64 0, i64 0), double %142)
br label %148
148: ; preds = %146, %136
%149 = add nuw nsw i64 %138, 1
%150 = add nuw nsw i64 %137, 1
%151 = load i32, i32* %8
%152 = sext i32 %151 to i64
%153 = icmp slt i64 %150, %152
br i1 %153, label %136, label %154
154: ; preds = %148
%155 = trunc i64 %149 to i32
br label %156
156: ; preds = %154, %133
%157 = phi i32 [ 11, %133 ], [ %155, %154 ]
%158 = phi i32 [ %134, %133 ], [ %151, %154 ]
%159 = shl i32 %158, 3
%160 = call i64 @malloc(i32 %159)
%161 = inttoptr i64 %160 to double*
%162 = load i32, i32* %10
%163 = icmp eq i32 %162, 0
br i1 %163, label %166, label %164
164: ; preds = %156
%165 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([19 x i8], [19 x i8]* @.str.17, i64 0, i64 0))
br label %166
166: ; preds = %164, %156
%167 = load i32, i32* %8
%168 = icmp sgt i32 %167, 0
br i1 %168, label %169, label %191
169: ; preds = %166
%170 = zext i32 %157 to i64
br label %171
171: ; preds = %169, %183
%172 = phi i64 [ 0, %169 ], [ %185, %183 ]
%173 = phi i64 [ %170, %169 ], [ %184, %183 ]
%174 = getelementptr inbounds i8*, i8** %1, i64 %173
%175 = load i8*, i8** %174
%176 = call i32 (i8*, i8*, ...) @sscanf(i8* %175, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.10, i64 0, i64 0), double* %7)
%177 = load double, double* %7
%178 = getelementptr inbounds double, double* %161, i64 %172
store double %177, double* %178
%179 = load i32, i32* %10
%180 = icmp eq i32 %179, 0
br i1 %180, label %183, label %181
181: ; preds = %171
%182 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.16, i64 0, i64 0), double %177)
br label %183
183: ; preds = %181, %171
%184 = add nuw nsw i64 %173, 1
%185 = add nuw nsw i64 %172, 1
%186 = load i32, i32* %8
%187 = sext i32 %186 to i64
%188 = icmp slt i64 %185, %187
br i1 %188, label %171, label %189
189: ; preds = %183
%190 = trunc i64 %184 to i32
br label %191
191: ; preds = %189, %166
%192 = phi i32 [ %157, %166 ], [ %190, %189 ]
%193 = load i32, i32* %9
%194 = shl i32 %193, 3
%195 = call i64 @malloc(i32 %194)
%196 = inttoptr i64 %195 to double*
%197 = load i32, i32* %10
%198 = icmp eq i32 %197, 0
br i1 %198, label %201, label %199
199: ; preds = %191
%200 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([19 x i8], [19 x i8]* @.str.18, i64 0, i64 0))
br label %201
201: ; preds = %199, %191
%202 = load i32, i32* %9
%203 = icmp sgt i32 %202, 0
br i1 %203, label %204, label %224
204: ; preds = %201
%205 = zext i32 %192 to i64
br label %206
206: ; preds = %204, %218
%207 = phi i64 [ 0, %204 ], [ %220, %218 ]
%208 = phi i64 [ %205, %204 ], [ %219, %218 ]
%209 = getelementptr inbounds i8*, i8** %1, i64 %208
%210 = load i8*, i8** %209
%211 = call i32 (i8*, i8*, ...) @sscanf(i8* %210, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.10, i64 0, i64 0), double* %7)
%212 = load double, double* %7
%213 = getelementptr inbounds double, double* %196, i64 %207
store double %212, double* %213
%214 = load i32, i32* %10
%215 = icmp eq i32 %214, 0
br i1 %215, label %218, label %216
216: ; preds = %206
%217 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.16, i64 0, i64 0), double %212)
br label %218
218: ; preds = %216, %206
%219 = add nuw nsw i64 %208, 1
%220 = add nuw nsw i64 %207, 1
%221 = load i32, i32* %9
%222 = sext i32 %221 to i64
%223 = icmp slt i64 %220, %222
br i1 %223, label %206, label %224
224: ; preds = %218, %201
%225 = phi i32 [ %202, %201 ], [ %221, %218 ]
%226 = load i32, i32* %10
%227 = icmp eq i32 %226, 0
br i1 %227, label %232, label %228
228: ; preds = %224
%229 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([2 x i8], [2 x i8]* @str, i64 0, i64 0))
%230 = load i32, i32* %9
%231 = load i32, i32* %10
br label %232
232: ; preds = %228, %224
%233 = phi i32 [ %231, %228 ], [ 0, %224 ]
%234 = phi i32 [ %230, %228 ], [ %225, %224 ]
%235 = load double, double* %3
%236 = load double, double* %4
%237 = load double, double* %5
%238 = load double, double* %6
%239 = load i32, i32* %8
%240 = call i32 @cjam(double* %128, double* %161, double* %196, double %235, double %236, double %237, double %238, i32 %239, i32 %234, i8* %38, i8* %49, i8* %73, i8* %88, i32 %233)
%241 = call i32 @free(double* %128)
%242 = call i32 @free(double* %161)
%243 = call i32 @free(double* %196)
br label %244
244: ; preds = %232, %69, %65, %34, %20
ret i32 0
}