#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 */
struct TmpArray {
  int **IntArray;
  long **LngArray;
  float **FltArray;
  double **DblArray;
  char **ChrArray;
};

/* Variables and functions */
int /*<<< orphan*/ free(int **);
int /*<<< orphan*/ memcpy(char *, char *, int);
int sscanf(int /*<<< orphan*/, char *, ...);
scalar_t__ xmalloc(unsigned int);
int GAGetMultiParmeters(int *Parameters[], int *ParamCount, char *CtrlStrCopy,
                        int *argc, char ***argv) {
  int i = 0, ScanRes, NumOfPrm = 0, **Pmain, **Ptemp;
  union TmpArray {
    int *IntArray[100];
    long *LngArray[100];
    float *FltArray[100];
    double *DblArray[100];
    char *ChrArray[100];
  } TmpArray;
  do {
    switch (CtrlStrCopy[2]) {
    case 'd':
      TmpArray.IntArray[NumOfPrm] = (int *)xmalloc(sizeof(int));
      ScanRes =
          sscanf(*((*argv)++), "%d", (int *)TmpArray.IntArray[NumOfPrm++]);
      break;
    case 'u':
      TmpArray.IntArray[NumOfPrm] = (int *)xmalloc(sizeof(int));
      ScanRes = sscanf(*((*argv)++), "%u",
                       (unsigned int *)TmpArray.IntArray[NumOfPrm++]);
      break;
    case 'o':
      TmpArray.IntArray[NumOfPrm] = (int *)xmalloc(sizeof(int));
      ScanRes = sscanf(*((*argv)++), "%o",
                       (unsigned int *)TmpArray.IntArray[NumOfPrm++]);
      break;
    case 'x':
      TmpArray.IntArray[NumOfPrm] = (int *)xmalloc(sizeof(int));
      ScanRes = sscanf(*((*argv)++), "%x",
                       (unsigned int *)TmpArray.IntArray[NumOfPrm++]);
      break;
    case 'D':
      TmpArray.LngArray[NumOfPrm] = (long *)xmalloc(sizeof(long));
      ScanRes =
          sscanf(*((*argv)++), "%ld", (long *)TmpArray.IntArray[NumOfPrm++]);
      break;
    case 'U':
      TmpArray.LngArray[NumOfPrm] = (long *)xmalloc(sizeof(long));
      ScanRes = sscanf(*((*argv)++), "%lu",
                       (unsigned long *)TmpArray.IntArray[NumOfPrm++]);
      break;
    case 'O':
      TmpArray.LngArray[NumOfPrm] = (long *)xmalloc(sizeof(long));
      ScanRes = sscanf(*((*argv)++), "%lo",
                       (unsigned long *)TmpArray.IntArray[NumOfPrm++]);
      break;
    case 'X':
      TmpArray.LngArray[NumOfPrm] = (long *)xmalloc(sizeof(long));
      ScanRes = sscanf(*((*argv)++), "%lx",
                       (unsigned long *)TmpArray.IntArray[NumOfPrm++]);
      break;
    case 'f':
      TmpArray.FltArray[NumOfPrm] = (float *)xmalloc(sizeof(float));
      ScanRes =
          sscanf(*((*argv)++), "%f", (float *)TmpArray.LngArray[NumOfPrm++]);
      break;
    case 'F':
      TmpArray.DblArray[NumOfPrm] = (double *)xmalloc(sizeof(double));
      ScanRes =
          sscanf(*((*argv)++), "%lf", (double *)TmpArray.LngArray[NumOfPrm++]);
      break;
    case 's':
      while ((*argc) && ((**argv)[0] != '-')) {
        TmpArray.ChrArray[NumOfPrm++] = *((*argv)++);
        (*argc)--;
      }
      ScanRes = 0;
      NumOfPrm++;
      (*argv)++;
      break;
    default:
      ScanRes = 0;
    }
    (*argc)--;
  } while (ScanRes == 1);
  (*argv)--;
  NumOfPrm--;
  (*argc)++;
  Ptemp = Pmain = (int **)xmalloc((unsigned)(NumOfPrm + 1) * sizeof(int *));
  for (i = 0; i < NumOfPrm; i++)
    *Ptemp++ = TmpArray.IntArray[i];
  *Ptemp = NULL;
  *Parameters[(*ParamCount)++] = NumOfPrm;
  memcpy((char *)Parameters[(*ParamCount)++], (char *)&Pmain, sizeof(char *));
  free(Pmain);
  return NumOfPrm;
}


x86 assembly (clang, -O0):
<GAGetMultiParmeters>:
push   %rbp
mov    %rsp,%rbp
sub    $0x380,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
movl   $0x0,-0x2c(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x18(%rbp),%rax
movsbl 0x2(%rax),%eax
add    $0xffffffbc,%eax
mov    %eax,%ecx
mov    %rcx,-0x370(%rbp)
sub    $0x34,%eax
ja     15c7 <GAGetMultiParmeters+0x487>
mov    -0x370(%rbp),%rax
lea    0xe68(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    $0x4,%edi
call   1040 <xmalloc@plt>
mov    %rax,%rcx
movslq -0x34(%rbp),%rax
mov    %rcx,-0x368(%rbp,%rax,8)
ff
mov    -0x28(%rbp),%rcx
mov    (%rcx),%rax
mov    %rax,%rdx
add    $0x8,%rdx
mov    %rdx,(%rcx)
mov    (%rax),%rax
mov    %eax,%edi
mov    -0x34(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x34(%rbp)
cltq
mov    -0x368(%rbp,%rax,8),%rdx
ff
lea    0xee8(%rip),%rsi
mov    $0x0,%al
call   1060 <sscanf@plt>
mov    %eax,-0x30(%rbp)
jmp    15ce <GAGetMultiParmeters+0x48e>
mov    $0x4,%edi
call   1040 <xmalloc@plt>
mov    %rax,%rcx
movslq -0x34(%rbp),%rax
mov    %rcx,-0x368(%rbp,%rax,8)
ff
mov    -0x28(%rbp),%rcx
mov    (%rcx),%rax
mov    %rax,%rdx
add    $0x8,%rdx
mov    %rdx,(%rcx)
mov    (%rax),%rax
mov    %eax,%edi
mov    -0x34(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x34(%rbp)
cltq
mov    -0x368(%rbp,%rax,8),%rdx
ff
lea    0xe91(%rip),%rsi
mov    $0x0,%al
call   1060 <sscanf@plt>
mov    %eax,-0x30(%rbp)
jmp    15ce <GAGetMultiParmeters+0x48e>
mov    $0x4,%edi
call   1040 <xmalloc@plt>
mov    %rax,%rcx
movslq -0x34(%rbp),%rax
mov    %rcx,-0x368(%rbp,%rax,8)
ff
mov    -0x28(%rbp),%rcx
mov    (%rcx),%rax
mov    %rax,%rdx
add    $0x8,%rdx
mov    %rdx,(%rcx)
mov    (%rax),%rax
mov    %eax,%edi
mov    -0x34(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x34(%rbp)
cltq
mov    -0x368(%rbp,%rax,8),%rdx
ff
lea    0xe3a(%rip),%rsi
mov    $0x0,%al
call   1060 <sscanf@plt>
mov    %eax,-0x30(%rbp)
jmp    15ce <GAGetMultiParmeters+0x48e>
mov    $0x4,%edi
call   1040 <xmalloc@plt>
mov    %rax,%rcx
movslq -0x34(%rbp),%rax
mov    %rcx,-0x368(%rbp,%rax,8)
ff
mov    -0x28(%rbp),%rcx
mov    (%rcx),%rax
mov    %rax,%rdx
add    $0x8,%rdx
mov    %rdx,(%rcx)
mov    (%rax),%rax
mov    %eax,%edi
mov    -0x34(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x34(%rbp)
cltq
mov    -0x368(%rbp,%rax,8),%rdx
ff
lea    0xde3(%rip),%rsi
mov    $0x0,%al
call   1060 <sscanf@plt>
mov    %eax,-0x30(%rbp)
jmp    15ce <GAGetMultiParmeters+0x48e>
mov    $0x8,%edi
call   1040 <xmalloc@plt>
mov    %rax,%rcx
movslq -0x34(%rbp),%rax
mov    %rcx,-0x368(%rbp,%rax,8)
ff
mov    -0x28(%rbp),%rcx
mov    (%rcx),%rax
mov    %rax,%rdx
add    $0x8,%rdx
mov    %rdx,(%rcx)
mov    (%rax),%rax
mov    %eax,%edi
mov    -0x34(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x34(%rbp)
cltq
mov    -0x368(%rbp,%rax,8),%rdx
ff
lea    0xd8c(%rip),%rsi
mov    $0x0,%al
call   1060 <sscanf@plt>
mov    %eax,-0x30(%rbp)
jmp    15ce <GAGetMultiParmeters+0x48e>
mov    $0x8,%edi
call   1040 <xmalloc@plt>
mov    %rax,%rcx
movslq -0x34(%rbp),%rax
mov    %rcx,-0x368(%rbp,%rax,8)
ff
mov    -0x28(%rbp),%rcx
mov    (%rcx),%rax
mov    %rax,%rdx
add    $0x8,%rdx
mov    %rdx,(%rcx)
mov    (%rax),%rax
mov    %eax,%edi
mov    -0x34(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x34(%rbp)
cltq
mov    -0x368(%rbp,%rax,8),%rdx
ff
lea    0xd36(%rip),%rsi
mov    $0x0,%al
call   1060 <sscanf@plt>
mov    %eax,-0x30(%rbp)
jmp    15ce <GAGetMultiParmeters+0x48e>
mov    $0x8,%edi
call   1040 <xmalloc@plt>
mov    %rax,%rcx
movslq -0x34(%rbp),%rax
mov    %rcx,-0x368(%rbp,%rax,8)
ff
mov    -0x28(%rbp),%rcx
mov    (%rcx),%rax
mov    %rax,%rdx
add    $0x8,%rdx
mov    %rdx,(%rcx)
mov    (%rax),%rax
mov    %eax,%edi
mov    -0x34(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x34(%rbp)
cltq
mov    -0x368(%rbp,%rax,8),%rdx
lea    0xce0(%rip),%rsi
mov    $0x0,%al
call   1060 <sscanf@plt>
mov    %eax,-0x30(%rbp)
jmp    15ce <GAGetMultiParmeters+0x48e>
mov    $0x8,%edi
call   1040 <xmalloc@plt>
mov    %rax,%rcx
movslq -0x34(%rbp),%rax
mov    %rcx,-0x368(%rbp,%rax,8)
ff
mov    -0x28(%rbp),%rcx
mov    (%rcx),%rax
mov    %rax,%rdx
add    $0x8,%rdx
mov    %rdx,(%rcx)
mov    (%rax),%rax
mov    %eax,%edi
mov    -0x34(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x34(%rbp)
cltq
mov    -0x368(%rbp,%rax,8),%rdx
ff
lea    0xc8a(%rip),%rsi
mov    $0x0,%al
call   1060 <sscanf@plt>
mov    %eax,-0x30(%rbp)
jmp    15ce <GAGetMultiParmeters+0x48e>
mov    $0x4,%edi
call   1040 <xmalloc@plt>
mov    %rax,%rcx
movslq -0x34(%rbp),%rax
mov    %rcx,-0x368(%rbp,%rax,8)
ff
mov    -0x28(%rbp),%rcx
mov    (%rcx),%rax
mov    %rax,%rdx
add    $0x8,%rdx
mov    %rdx,(%rcx)
mov    (%rax),%rax
mov    %eax,%edi
mov    -0x34(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x34(%rbp)
cltq
mov    -0x368(%rbp,%rax,8),%rdx
ff
lea    0xc34(%rip),%rsi
mov    $0x0,%al
call   1060 <sscanf@plt>
mov    %eax,-0x30(%rbp)
jmp    15ce <GAGetMultiParmeters+0x48e>
mov    $0x8,%edi
call   1040 <xmalloc@plt>
mov    %rax,%rcx
movslq -0x34(%rbp),%rax
mov    %rcx,-0x368(%rbp,%rax,8)
ff
mov    -0x28(%rbp),%rcx
mov    (%rcx),%rax
mov    %rax,%rdx
add    $0x8,%rdx
mov    %rdx,(%rcx)
mov    (%rax),%rax
mov    %eax,%edi
mov    -0x34(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x34(%rbp)
cltq
mov    -0x368(%rbp,%rax,8),%rdx
ff
lea    0xbdd(%rip),%rsi
mov    $0x0,%al
call   1060 <sscanf@plt>
mov    %eax,-0x30(%rbp)
jmp    15ce <GAGetMultiParmeters+0x48e>
jmp    152a <GAGetMultiParmeters+0x3ea>
mov    -0x20(%rbp),%rcx
xor    %eax,%eax
cmpl   $0x0,(%rcx)
mov    %al,-0x371(%rbp)
je     1558 <GAGetMultiParmeters+0x418>
mov    -0x28(%rbp),%rax
mov    (%rax),%rax
mov    (%rax),%rax
movsbl (%rax),%eax
cmp    $0x2d,%eax
setne  %al
mov    %al,-0x371(%rbp)
mov    -0x371(%rbp),%al
test   $0x1,%al
jne    156b <GAGetMultiParmeters+0x42b>
jmp    15a4 <GAGetMultiParmeters+0x464>
mov    -0x28(%rbp),%rcx
mov    (%rcx),%rax
mov    %rax,%rdx
add    $0x8,%rdx
mov    %rdx,(%rcx)
mov    (%rax),%rcx
mov    -0x34(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0x34(%rbp)
cltq
mov    %rcx,-0x368(%rbp,%rax,8)
ff
mov    -0x20(%rbp),%rax
mov    (%rax),%ecx
add    $0xffffffff,%ecx
mov    %ecx,(%rax)
jmp    152a <GAGetMultiParmeters+0x3ea>
movl   $0x0,-0x30(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x28(%rbp),%rax
mov    (%rax),%rcx
add    $0x8,%rcx
mov    %rcx,(%rax)
jmp    15ce <GAGetMultiParmeters+0x48e>
movl   $0x0,-0x30(%rbp)
mov    -0x20(%rbp),%rax
mov    (%rax),%ecx
add    $0xffffffff,%ecx
mov    %ecx,(%rax)
cmpl   $0x1,-0x30(%rbp)
je     116d <GAGetMultiParmeters+0x2d>
mov    -0x28(%rbp),%rax
mov    (%rax),%rcx
add    $0xfffffffffffffff8,%rcx
mov    %rcx,(%rax)
mov    -0x34(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x34(%rbp)
mov    -0x20(%rbp),%rax
mov    (%rax),%ecx
add    $0x1,%ecx
mov    %ecx,(%rax)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,%eax
shl    $0x3,%rax
mov    %eax,%edi
call   1040 <xmalloc@plt>
mov    %rax,-0x40(%rbp)
mov    %rax,-0x48(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    165f <GAGetMultiParmeters+0x51f>
movslq -0x2c(%rbp),%rax
mov    -0x368(%rbp,%rax,8),%rcx
ff
mov    -0x48(%rbp),%rax
mov    %rax,%rdx
add    $0x8,%rdx
mov    %rdx,-0x48(%rbp)
mov    %rcx,(%rax)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1627 <GAGetMultiParmeters+0x4e7>
mov    -0x48(%rbp),%rax
movq   $0x0,(%rax)
mov    -0x34(%rbp),%ecx
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%rsi
mov    (%rsi),%edx
mov    %edx,%edi
add    $0x1,%edi
mov    %edi,(%rsi)
movslq %edx,%rdx
mov    (%rax,%rdx,8),%rax
mov    %ecx,(%rax)
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%rdx
mov    (%rdx),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,(%rdx)
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rdi
lea    -0x40(%rbp),%rsi
mov    $0x8,%edx
call   1050 <memcpy@plt>
mov    -0x40(%rbp),%rdi
call   1030 <free@plt>
mov    -0x34(%rbp),%eax
add    $0x380,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<GAGetMultiParmeters>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x338,%rsp
mov    %r8,%rbx
mov    %rcx,%r12
mov    %rdx,%r13
mov    %rsi,%r15
mov    %rdi,0x8(%rsp)
lea    0xe97(%rip),%rbp
xor    %r14d,%r14d
jmp    11b2 <GAGetMultiParmeters+0x72>
mov    $0x4,%edi
call   1040 <xmalloc@plt>
mov    %rax,0x18(%rsp,%r14,8)
mov    (%rbx),%rcx
lea    0x8(%rcx),%rdx
mov    %rdx,(%rbx)
mov    (%rcx),%edi
lea    0xf44(%rip),%rsi
mov    %rax,%rdx
xor    %eax,%eax
call   1060 <sscanf@plt>
add    $0x1,%r14
mov    (%r12),%ecx
lea    -0x1(%rcx),%edx
mov    %edx,(%r12)
cmp    $0x1,%eax
jne    132d <GAGetMultiParmeters+0x1ed>
movsbl 0x2(%r13),%eax
add    $0xffffffbc,%eax
cmp    $0x34,%eax
ja     1329 <GAGetMultiParmeters+0x1e9>
movslq 0x0(%rbp,%rax,4),%rax
add    %rbp,%rax
jmp    *%rax
mov    $0x8,%edi
call   1040 <xmalloc@plt>
mov    %rax,0x18(%rsp,%r14,8)
mov    (%rbx),%rcx
lea    0x8(%rcx),%rdx
mov    %rdx,(%rbx)
mov    (%rcx),%edi
lea    0xef1(%rip),%rsi
jmp    1190 <GAGetMultiParmeters+0x50>
mov    $0x8,%edi
call   1040 <xmalloc@plt>
mov    %rax,0x18(%rsp,%r14,8)
mov    (%rbx),%rcx
lea    0x8(%rcx),%rdx
mov    %rdx,(%rbx)
mov    (%rcx),%edi
lea    0xee0(%rip),%rsi
jmp    1190 <GAGetMultiParmeters+0x50>
mov    $0x8,%edi
call   1040 <xmalloc@plt>
mov    %rax,0x18(%rsp,%r14,8)
mov    (%rbx),%rcx
lea    0x8(%rcx),%rdx
mov    %rdx,(%rbx)
mov    (%rcx),%edi
lea    0xeae(%rip),%rsi
jmp    1190 <GAGetMultiParmeters+0x50>
mov    $0x8,%edi
call   1040 <xmalloc@plt>
mov    %rax,0x18(%rsp,%r14,8)
mov    (%rbx),%rcx
lea    0x8(%rcx),%rdx
mov    %rdx,(%rbx)
mov    (%rcx),%edi
lea    0xe83(%rip),%rsi
jmp    1190 <GAGetMultiParmeters+0x50>
mov    $0x8,%edi
call   1040 <xmalloc@plt>
mov    %rax,0x18(%rsp,%r14,8)
mov    (%rbx),%rcx
lea    0x8(%rcx),%rdx
mov    %rdx,(%rbx)
mov    (%rcx),%edi
lea    0xe64(%rip),%rsi
jmp    1190 <GAGetMultiParmeters+0x50>
mov    $0x4,%edi
call   1040 <xmalloc@plt>
mov    %rax,0x18(%rsp,%r14,8)
mov    (%rbx),%rcx
lea    0x8(%rcx),%rdx
mov    %rdx,(%rbx)
mov    (%rcx),%edi
lea    0xe41(%rip),%rsi
jmp    1190 <GAGetMultiParmeters+0x50>
mov    $0x4,%edi
call   1040 <xmalloc@plt>
mov    %rax,0x18(%rsp,%r14,8)
mov    (%rbx),%rcx
lea    0x8(%rcx),%rdx
mov    %rdx,(%rbx)
mov    (%rcx),%edi
lea    0xe04(%rip),%rsi
jmp    1190 <GAGetMultiParmeters+0x50>
mov    $0x4,%edi
call   1040 <xmalloc@plt>
mov    %rax,0x18(%rsp,%r14,8)
mov    (%rbx),%rcx
lea    0x8(%rcx),%rdx
mov    %rdx,(%rbx)
mov    (%rcx),%edi
lea    0xdda(%rip),%rsi
jmp    1190 <GAGetMultiParmeters+0x50>
mov    $0x4,%edi
call   1040 <xmalloc@plt>
mov    %rax,0x18(%rsp,%r14,8)
mov    (%rbx),%rcx
lea    0x8(%rcx),%rdx
mov    %rdx,(%rbx)
mov    (%rcx),%edi
lea    0xdb9(%rip),%rsi
jmp    1190 <GAGetMultiParmeters+0x50>
mov    (%r12),%ecx
mov    0x8(%rsp),%r13
addq   $0xfffffffffffffff8,(%rbx)
lea    -0x1(%r14),%ebx
mov    %ecx,(%r12)
lea    0x0(,%r14,8),%edi
call   1040 <xmalloc@plt>
mov    %rax,%rbp
mov    %rax,0x10(%rsp)
cmp    $0x2,%r14d
jl     1375 <GAGetMultiParmeters+0x235>
mov    %ebx,%edx
shl    $0x3,%rdx
lea    0x18(%rsp),%rsi
mov    %rbp,%rdi
call   1050 <memcpy@plt>
add    $0xfffffffe,%r14d
lea    0x8(%rbp,%r14,8),%rbp
movq   $0x0,0x0(%rbp)
movslq (%r15),%rax
lea    0x1(%rax),%ecx
mov    %ecx,(%r15)
mov    0x0(%r13,%rax,8),%rax
mov    %ebx,(%rax)
movslq (%r15),%rax
lea    0x1(%rax),%ecx
mov    %ecx,(%r15)
mov    0x0(%r13,%rax,8),%rdi
lea    0x10(%rsp),%rsi
mov    $0x8,%edx
call   1050 <memcpy@plt>
mov    0x10(%rsp),%rdi
call   1030 <free@plt>
mov    %ebx,%eax
add    $0x338,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    (%r12),%ecx
test   %rcx,%rcx
je     1433 <GAGetMultiParmeters+0x2f3>
lea    (%rcx,%r14,1),%r8
mov    (%rbx),%rdi
mov    %r14d,%eax
lea    (%rsp,%rax,8),%r9
add    $0x18,%r9
mov    $0xffffffff,%edx
xor    %esi,%esi
mov    %rdi,%rax
mov    0x8(%rsp),%r13
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    (%rdi,%rsi,8),%rbp
cmpb   $0x2d,0x0(%rbp)
je     143f <GAGetMultiParmeters+0x2ff>
add    $0x8,%rax
mov    %rax,(%rbx)
mov    (%rdi,%rsi,8),%rbp
mov    %rbp,(%r9,%rsi,8)
lea    (%rcx,%rdx,1),%ebp
mov    %ebp,(%r12)
add    $0x1,%rsi
add    $0xffffffffffffffff,%rdx
cmp    %esi,%ecx
jne    1400 <GAGetMultiParmeters+0x2c0>
xor    %ecx,%ecx
mov    %r8d,%r14d
jmp    1444 <GAGetMultiParmeters+0x304>
mov    (%rbx),%rax
xor    %ecx,%ecx
mov    0x8(%rsp),%r13
jmp    1444 <GAGetMultiParmeters+0x304>
add    %esi,%r14d
sub    %esi,%ecx
add    $0x1,%r14d
add    $0x8,%rax
mov    %rax,(%rbx)
jmp    1332 <GAGetMultiParmeters+0x1f2>

LLVM IR (-O0):
%union.TmpArray = type { [100 x i32*] }
@.str = [3 x i8] c"%d\00"
@.str.1 = [3 x i8] c"%u\00"
@.str.2 = [3 x i8] c"%o\00"
@.str.3 = [3 x i8] c"%x\00"
@.str.4 = [4 x i8] c"%ld\00"
@.str.5 = [4 x i8] c"%lu\00"
@.str.6 = [4 x i8] c"%lo\00"
@.str.7 = [4 x i8] c"%lx\00"
@.str.8 = [3 x i8] c"%f\00"
@.str.9 = [4 x i8] c"%lf\00"
define i32 @GAGetMultiParmeters(i32** %0, i32* %1, i8* %2, i32* %3, i8*** %4) {
%6 = alloca i32**
%7 = alloca i32*
%8 = alloca i8*
%9 = alloca i32*
%10 = alloca i8***
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32**
%15 = alloca i32**
%16 = alloca %union.TmpArray
store i32** %0, i32*** %6
store i32* %1, i32** %7
store i8* %2, i8** %8
store i32* %3, i32** %9
store i8*** %4, i8**** %10
store i32 0, i32* %11
store i32 0, i32* %13
br label %17
17: ; preds = %257, %5
%18 = load i8*, i8** %8
%19 = getelementptr inbounds i8, i8* %18, i64 2
%20 = load i8, i8* %19
%21 = sext i8 %20 to i32
switch i32 %21, label %252 [
i32 100, label %22
i32 117, label %41
i32 111, label %60
i32 120, label %79
i32 68, label %98
i32 85, label %118
i32 79, label %138
i32 88, label %158
i32 102, label %178
i32 70, label %198
i32 115, label %218
]
22: ; preds = %17
%23 = call i64 @xmalloc(i32 4)
%24 = inttoptr i64 %23 to i32*
%25 = bitcast %union.TmpArray* %16 to [100 x i32*]*
%26 = load i32, i32* %13
%27 = sext i32 %26 to i64
%28 = getelementptr inbounds [100 x i32*], [100 x i32*]* %25, i64 0, i64 %27
store i32* %24, i32** %28
%29 = load i8***, i8**** %10
%30 = load i8**, i8*** %29
%31 = getelementptr inbounds i8*, i8** %30, i32 1
store i8** %31, i8*** %29
%32 = load i8*, i8** %30
%33 = ptrtoint i8* %32 to i32
%34 = bitcast %union.TmpArray* %16 to [100 x i32*]*
%35 = load i32, i32* %13
%36 = add nsw i32 %35, 1
store i32 %36, i32* %13
%37 = sext i32 %35 to i64
%38 = getelementptr inbounds [100 x i32*], [100 x i32*]* %34, i64 0, i64 %37
%39 = load i32*, i32** %38
%40 = call i32 (i32, i8*, ...) @sscanf(i32 %33, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i32* %39)
store i32 %40, i32* %12
br label %253
41: ; preds = %17
%42 = call i64 @xmalloc(i32 4)
%43 = inttoptr i64 %42 to i32*
%44 = bitcast %union.TmpArray* %16 to [100 x i32*]*
%45 = load i32, i32* %13
%46 = sext i32 %45 to i64
%47 = getelementptr inbounds [100 x i32*], [100 x i32*]* %44, i64 0, i64 %46
store i32* %43, i32** %47
%48 = load i8***, i8**** %10
%49 = load i8**, i8*** %48
%50 = getelementptr inbounds i8*, i8** %49, i32 1
store i8** %50, i8*** %48
%51 = load i8*, i8** %49
%52 = ptrtoint i8* %51 to i32
%53 = bitcast %union.TmpArray* %16 to [100 x i32*]*
%54 = load i32, i32* %13
%55 = add nsw i32 %54, 1
store i32 %55, i32* %13
%56 = sext i32 %54 to i64
%57 = getelementptr inbounds [100 x i32*], [100 x i32*]* %53, i64 0, i64 %56
%58 = load i32*, i32** %57
%59 = call i32 (i32, i8*, ...) @sscanf(i32 %52, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32* %58)
store i32 %59, i32* %12
br label %253
60: ; preds = %17
%61 = call i64 @xmalloc(i32 4)
%62 = inttoptr i64 %61 to i32*
%63 = bitcast %union.TmpArray* %16 to [100 x i32*]*
%64 = load i32, i32* %13
%65 = sext i32 %64 to i64
%66 = getelementptr inbounds [100 x i32*], [100 x i32*]* %63, i64 0, i64 %65
store i32* %62, i32** %66
%67 = load i8***, i8**** %10
%68 = load i8**, i8*** %67
%69 = getelementptr inbounds i8*, i8** %68, i32 1
store i8** %69, i8*** %67
%70 = load i8*, i8** %68
%71 = ptrtoint i8* %70 to i32
%72 = bitcast %union.TmpArray* %16 to [100 x i32*]*
%73 = load i32, i32* %13
%74 = add nsw i32 %73, 1
store i32 %74, i32* %13
%75 = sext i32 %73 to i64
%76 = getelementptr inbounds [100 x i32*], [100 x i32*]* %72, i64 0, i64 %75
%77 = load i32*, i32** %76
%78 = call i32 (i32, i8*, ...) @sscanf(i32 %71, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.2, i64 0, i64 0), i32* %77)
store i32 %78, i32* %12
br label %253
79: ; preds = %17
%80 = call i64 @xmalloc(i32 4)
%81 = inttoptr i64 %80 to i32*
%82 = bitcast %union.TmpArray* %16 to [100 x i32*]*
%83 = load i32, i32* %13
%84 = sext i32 %83 to i64
%85 = getelementptr inbounds [100 x i32*], [100 x i32*]* %82, i64 0, i64 %84
store i32* %81, i32** %85
%86 = load i8***, i8**** %10
%87 = load i8**, i8*** %86
%88 = getelementptr inbounds i8*, i8** %87, i32 1
store i8** %88, i8*** %86
%89 = load i8*, i8** %87
%90 = ptrtoint i8* %89 to i32
%91 = bitcast %union.TmpArray* %16 to [100 x i32*]*
%92 = load i32, i32* %13
%93 = add nsw i32 %92, 1
store i32 %93, i32* %13
%94 = sext i32 %92 to i64
%95 = getelementptr inbounds [100 x i32*], [100 x i32*]* %91, i64 0, i64 %94
%96 = load i32*, i32** %95
%97 = call i32 (i32, i8*, ...) @sscanf(i32 %90, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), i32* %96)
store i32 %97, i32* %12
br label %253
98: ; preds = %17
%99 = call i64 @xmalloc(i32 8)
%100 = inttoptr i64 %99 to i64*
%101 = bitcast %union.TmpArray* %16 to [100 x i64*]*
%102 = load i32, i32* %13
%103 = sext i32 %102 to i64
%104 = getelementptr inbounds [100 x i64*], [100 x i64*]* %101, i64 0, i64 %103
store i64* %100, i64** %104
%105 = load i8***, i8**** %10
%106 = load i8**, i8*** %105
%107 = getelementptr inbounds i8*, i8** %106, i32 1
store i8** %107, i8*** %105
%108 = load i8*, i8** %106
%109 = ptrtoint i8* %108 to i32
%110 = bitcast %union.TmpArray* %16 to [100 x i32*]*
%111 = load i32, i32* %13
%112 = add nsw i32 %111, 1
store i32 %112, i32* %13
%113 = sext i32 %111 to i64
%114 = getelementptr inbounds [100 x i32*], [100 x i32*]* %110, i64 0, i64 %113
%115 = load i32*, i32** %114
%116 = bitcast i32* %115 to i64*
%117 = call i32 (i32, i8*, ...) @sscanf(i32 %109, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.4, i64 0, i64 0), i64* %116)
store i32 %117, i32* %12
br label %253
118: ; preds = %17
%119 = call i64 @xmalloc(i32 8)
%120 = inttoptr i64 %119 to i64*
%121 = bitcast %union.TmpArray* %16 to [100 x i64*]*
%122 = load i32, i32* %13
%123 = sext i32 %122 to i64
%124 = getelementptr inbounds [100 x i64*], [100 x i64*]* %121, i64 0, i64 %123
store i64* %120, i64** %124
%125 = load i8***, i8**** %10
%126 = load i8**, i8*** %125
%127 = getelementptr inbounds i8*, i8** %126, i32 1
store i8** %127, i8*** %125
%128 = load i8*, i8** %126
%129 = ptrtoint i8* %128 to i32
%130 = bitcast %union.TmpArray* %16 to [100 x i32*]*
%131 = load i32, i32* %13
%132 = add nsw i32 %131, 1
store i32 %132, i32* %13
%133 = sext i32 %131 to i64
%134 = getelementptr inbounds [100 x i32*], [100 x i32*]* %130, i64 0, i64 %133
%135 = load i32*, i32** %134
%136 = bitcast i32* %135 to i64*
%137 = call i32 (i32, i8*, ...) @sscanf(i32 %129, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.5, i64 0, i64 0), i64* %136)
store i32 %137, i32* %12
br label %253
138: ; preds = %17
%139 = call i64 @xmalloc(i32 8)
%140 = inttoptr i64 %139 to i64*
%141 = bitcast %union.TmpArray* %16 to [100 x i64*]*
%142 = load i32, i32* %13
%143 = sext i32 %142 to i64
%144 = getelementptr inbounds [100 x i64*], [100 x i64*]* %141, i64 0, i64 %143
store i64* %140, i64** %144
%145 = load i8***, i8**** %10
%146 = load i8**, i8*** %145
%147 = getelementptr inbounds i8*, i8** %146, i32 1
store i8** %147, i8*** %145
%148 = load i8*, i8** %146
%149 = ptrtoint i8* %148 to i32
%150 = bitcast %union.TmpArray* %16 to [100 x i32*]*
%151 = load i32, i32* %13
%152 = add nsw i32 %151, 1
store i32 %152, i32* %13
%153 = sext i32 %151 to i64
%154 = getelementptr inbounds [100 x i32*], [100 x i32*]* %150, i64 0, i64 %153
%155 = load i32*, i32** %154
%156 = bitcast i32* %155 to i64*
%157 = call i32 (i32, i8*, ...) @sscanf(i32 %149, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.6, i64 0, i64 0), i64* %156)
store i32 %157, i32* %12
br label %253
158: ; preds = %17
%159 = call i64 @xmalloc(i32 8)
%160 = inttoptr i64 %159 to i64*
%161 = bitcast %union.TmpArray* %16 to [100 x i64*]*
%162 = load i32, i32* %13
%163 = sext i32 %162 to i64
%164 = getelementptr inbounds [100 x i64*], [100 x i64*]* %161, i64 0, i64 %163
store i64* %160, i64** %164
%165 = load i8***, i8**** %10
%166 = load i8**, i8*** %165
%167 = getelementptr inbounds i8*, i8** %166, i32 1
store i8** %167, i8*** %165
%168 = load i8*, i8** %166
%169 = ptrtoint i8* %168 to i32
%170 = bitcast %union.TmpArray* %16 to [100 x i32*]*
%171 = load i32, i32* %13
%172 = add nsw i32 %171, 1
store i32 %172, i32* %13
%173 = sext i32 %171 to i64
%174 = getelementptr inbounds [100 x i32*], [100 x i32*]* %170, i64 0, i64 %173
%175 = load i32*, i32** %174
%176 = bitcast i32* %175 to i64*
%177 = call i32 (i32, i8*, ...) @sscanf(i32 %169, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.7, i64 0, i64 0), i64* %176)
store i32 %177, i32* %12
br label %253
178: ; preds = %17
%179 = call i64 @xmalloc(i32 4)
%180 = inttoptr i64 %179 to float*
%181 = bitcast %union.TmpArray* %16 to [100 x float*]*
%182 = load i32, i32* %13
%183 = sext i32 %182 to i64
%184 = getelementptr inbounds [100 x float*], [100 x float*]* %181, i64 0, i64 %183
store float* %180, float** %184
%185 = load i8***, i8**** %10
%186 = load i8**, i8*** %185
%187 = getelementptr inbounds i8*, i8** %186, i32 1
store i8** %187, i8*** %185
%188 = load i8*, i8** %186
%189 = ptrtoint i8* %188 to i32
%190 = bitcast %union.TmpArray* %16 to [100 x i64*]*
%191 = load i32, i32* %13
%192 = add nsw i32 %191, 1
store i32 %192, i32* %13
%193 = sext i32 %191 to i64
%194 = getelementptr inbounds [100 x i64*], [100 x i64*]* %190, i64 0, i64 %193
%195 = load i64*, i64** %194
%196 = bitcast i64* %195 to float*
%197 = call i32 (i32, i8*, ...) @sscanf(i32 %189, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.8, i64 0, i64 0), float* %196)
store i32 %197, i32* %12
br label %253
198: ; preds = %17
%199 = call i64 @xmalloc(i32 8)
%200 = inttoptr i64 %199 to double*
%201 = bitcast %union.TmpArray* %16 to [100 x double*]*
%202 = load i32, i32* %13
%203 = sext i32 %202 to i64
%204 = getelementptr inbounds [100 x double*], [100 x double*]* %201, i64 0, i64 %203
store double* %200, double** %204
%205 = load i8***, i8**** %10
%206 = load i8**, i8*** %205
%207 = getelementptr inbounds i8*, i8** %206, i32 1
store i8** %207, i8*** %205
%208 = load i8*, i8** %206
%209 = ptrtoint i8* %208 to i32
%210 = bitcast %union.TmpArray* %16 to [100 x i64*]*
%211 = load i32, i32* %13
%212 = add nsw i32 %211, 1
store i32 %212, i32* %13
%213 = sext i32 %211 to i64
%214 = getelementptr inbounds [100 x i64*], [100 x i64*]* %210, i64 0, i64 %213
%215 = load i64*, i64** %214
%216 = bitcast i64* %215 to double*
%217 = call i32 (i32, i8*, ...) @sscanf(i32 %209, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.9, i64 0, i64 0), double* %216)
store i32 %217, i32* %12
br label %253
218: ; preds = %17
br label %219
219: ; preds = %233, %218
%220 = load i32*, i32** %9
%221 = load i32, i32* %220
%222 = icmp ne i32 %221, 0
br i1 %222, label %223, label %231
223: ; preds = %219
%224 = load i8***, i8**** %10
%225 = load i8**, i8*** %224
%226 = load i8*, i8** %225
%227 = getelementptr inbounds i8, i8* %226, i64 0
%228 = load i8, i8* %227
%229 = sext i8 %228 to i32
%230 = icmp ne i32 %229, 45
br label %231
231: ; preds = %223, %219
%232 = phi i1 [ false, %219 ], [ %230, %223 ]
br i1 %232, label %233, label %246
233: ; preds = %231
%234 = load i8***, i8**** %10
%235 = load i8**, i8*** %234
%236 = getelementptr inbounds i8*, i8** %235, i32 1
store i8** %236, i8*** %234
%237 = load i8*, i8** %235
%238 = bitcast %union.TmpArray* %16 to [100 x i8*]*
%239 = load i32, i32* %13
%240 = add nsw i32 %239, 1
store i32 %240, i32* %13
%241 = sext i32 %239 to i64
%242 = getelementptr inbounds [100 x i8*], [100 x i8*]* %238, i64 0, i64 %241
store i8* %237, i8** %242
%243 = load i32*, i32** %9
%244 = load i32, i32* %243
%245 = add nsw i32 %244, -1
store i32 %245, i32* %243
br label %219
246: ; preds = %231
store i32 0, i32* %12
%247 = load i32, i32* %13
%248 = add nsw i32 %247, 1
store i32 %248, i32* %13
%249 = load i8***, i8**** %10
%250 = load i8**, i8*** %249
%251 = getelementptr inbounds i8*, i8** %250, i32 1
store i8** %251, i8*** %249
br label %253
252: ; preds = %17
store i32 0, i32* %12
br label %253
253: ; preds = %252, %246, %198, %178, %158, %138, %118, %98, %79, %60, %41, %22
%254 = load i32*, i32** %9
%255 = load i32, i32* %254
%256 = add nsw i32 %255, -1
store i32 %256, i32* %254
br label %257
257: ; preds = %253
%258 = load i32, i32* %12
%259 = icmp eq i32 %258, 1
br i1 %259, label %17, label %260
260: ; preds = %257
%261 = load i8***, i8**** %10
%262 = load i8**, i8*** %261
%263 = getelementptr inbounds i8*, i8** %262, i32 -1
store i8** %263, i8*** %261
%264 = load i32, i32* %13
%265 = add nsw i32 %264, -1
store i32 %265, i32* %13
%266 = load i32*, i32** %9
%267 = load i32, i32* %266
%268 = add nsw i32 %267, 1
store i32 %268, i32* %266
%269 = load i32, i32* %13
%270 = add nsw i32 %269, 1
%271 = zext i32 %270 to i64
%272 = mul i64 %271, 8
%273 = trunc i64 %272 to i32
%274 = call i64 @xmalloc(i32 %273)
%275 = inttoptr i64 %274 to i32**
store i32** %275, i32*** %14
store i32** %275, i32*** %15
store i32 0, i32* %11
br label %276
276: ; preds = %288, %260
%277 = load i32, i32* %11
%278 = load i32, i32* %13
%279 = icmp slt i32 %277, %278
br i1 %279, label %280, label %291
280: ; preds = %276
%281 = bitcast %union.TmpArray* %16 to [100 x i32*]*
%282 = load i32, i32* %11
%283 = sext i32 %282 to i64
%284 = getelementptr inbounds [100 x i32*], [100 x i32*]* %281, i64 0, i64 %283
%285 = load i32*, i32** %284
%286 = load i32**, i32*** %15
%287 = getelementptr inbounds i32*, i32** %286, i32 1
store i32** %287, i32*** %15
store i32* %285, i32** %286
br label %288
288: ; preds = %280
%289 = load i32, i32* %11
%290 = add nsw i32 %289, 1
store i32 %290, i32* %11
br label %276
291: ; preds = %276
%292 = load i32**, i32*** %15
store i32* null, i32** %292
%293 = load i32, i32* %13
%294 = load i32**, i32*** %6
%295 = load i32*, i32** %7
%296 = load i32, i32* %295
%297 = add nsw i32 %296, 1
store i32 %297, i32* %295
%298 = sext i32 %296 to i64
%299 = getelementptr inbounds i32*, i32** %294, i64 %298
%300 = load i32*, i32** %299
store i32 %293, i32* %300
%301 = load i32**, i32*** %6
%302 = load i32*, i32** %7
%303 = load i32, i32* %302
%304 = add nsw i32 %303, 1
store i32 %304, i32* %302
%305 = sext i32 %303 to i64
%306 = getelementptr inbounds i32*, i32** %301, i64 %305
%307 = load i32*, i32** %306
%308 = bitcast i32* %307 to i8*
%309 = bitcast i32*** %14 to i8*
%310 = call i32 @memcpy(i8* %308, i8* %309, i32 8)
%311 = load i32**, i32*** %14
%312 = call i32 @free(i32** %311)
%313 = load i32, i32* %13
ret i32 %313
}

LLVM IR (-O2):
%union.TmpArray = type { [100 x i32*] }
@.str = [3 x i8] c"%d\00"
@.str.1 = [3 x i8] c"%u\00"
@.str.2 = [3 x i8] c"%o\00"
@.str.3 = [3 x i8] c"%x\00"
@.str.4 = [4 x i8] c"%ld\00"
@.str.5 = [4 x i8] c"%lu\00"
@.str.6 = [4 x i8] c"%lo\00"
@.str.7 = [4 x i8] c"%lx\00"
@.str.8 = [3 x i8] c"%f\00"
@.str.9 = [4 x i8] c"%lf\00"
define i32 @GAGetMultiParmeters(i32** nocapture %0, i32* nocapture %1, i8* nocapture %2, i32* nocapture %3, i8*** %4) {
%6 = alloca i32**
%7 = alloca %union.TmpArray
%8 = bitcast %union.TmpArray* %7 to i8*
%9 = bitcast i32*** %6 to i8*
%10 = getelementptr inbounds i8, i8* %2, i64 2
%11 = bitcast %union.TmpArray* %7 to [100 x double*]*
%12 = bitcast %union.TmpArray* %7 to [100 x i64*]*
%13 = bitcast %union.TmpArray* %7 to [100 x float*]*
br label %14
14: ; preds = %154, %5
%15 = phi i64 [ %156, %154 ], [ 0, %5 ]
%16 = load i8, i8* %10
%17 = sext i8 %16 to i32
switch i32 %17, label %151 [
i32 100, label %18
i32 117, label %28
i32 111, label %38
i32 120, label %48
i32 68, label %58
i32 85, label %68
i32 79, label %78
i32 88, label %88
i32 102, label %98
i32 70, label %108
i32 115, label %118
]
18: ; preds = %14
%19 = tail call i64 @xmalloc(i32 4)
%20 = inttoptr i64 %19 to i32*
%21 = getelementptr inbounds %union.TmpArray, %union.TmpArray* %7, i64 0, i32 0, i64 %15
store i32* %20, i32** %21
%22 = load i8**, i8*** %4
%23 = getelementptr inbounds i8*, i8** %22, i64 1
store i8** %23, i8*** %4
%24 = load i8*, i8** %22
%25 = ptrtoint i8* %24 to i64
%26 = trunc i64 %25 to i32
%27 = tail call i32 (i32, i8*, ...) @sscanf(i32 %26, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i32* %20)
br label %154
28: ; preds = %14
%29 = tail call i64 @xmalloc(i32 4)
%30 = inttoptr i64 %29 to i32*
%31 = getelementptr inbounds %union.TmpArray, %union.TmpArray* %7, i64 0, i32 0, i64 %15
store i32* %30, i32** %31
%32 = load i8**, i8*** %4
%33 = getelementptr inbounds i8*, i8** %32, i64 1
store i8** %33, i8*** %4
%34 = load i8*, i8** %32
%35 = ptrtoint i8* %34 to i64
%36 = trunc i64 %35 to i32
%37 = tail call i32 (i32, i8*, ...) @sscanf(i32 %36, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32* %30)
br label %154
38: ; preds = %14
%39 = tail call i64 @xmalloc(i32 4)
%40 = inttoptr i64 %39 to i32*
%41 = getelementptr inbounds %union.TmpArray, %union.TmpArray* %7, i64 0, i32 0, i64 %15
store i32* %40, i32** %41
%42 = load i8**, i8*** %4
%43 = getelementptr inbounds i8*, i8** %42, i64 1
store i8** %43, i8*** %4
%44 = load i8*, i8** %42
%45 = ptrtoint i8* %44 to i64
%46 = trunc i64 %45 to i32
%47 = tail call i32 (i32, i8*, ...) @sscanf(i32 %46, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.2, i64 0, i64 0), i32* %40)
br label %154
48: ; preds = %14
%49 = tail call i64 @xmalloc(i32 4)
%50 = inttoptr i64 %49 to i32*
%51 = getelementptr inbounds %union.TmpArray, %union.TmpArray* %7, i64 0, i32 0, i64 %15
store i32* %50, i32** %51
%52 = load i8**, i8*** %4
%53 = getelementptr inbounds i8*, i8** %52, i64 1
store i8** %53, i8*** %4
%54 = load i8*, i8** %52
%55 = ptrtoint i8* %54 to i64
%56 = trunc i64 %55 to i32
%57 = tail call i32 (i32, i8*, ...) @sscanf(i32 %56, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), i32* %50)
br label %154
58: ; preds = %14
%59 = tail call i64 @xmalloc(i32 8)
%60 = inttoptr i64 %59 to i64*
%61 = getelementptr inbounds [100 x i64*], [100 x i64*]* %12, i64 0, i64 %15
store i64* %60, i64** %61
%62 = load i8**, i8*** %4
%63 = getelementptr inbounds i8*, i8** %62, i64 1
store i8** %63, i8*** %4
%64 = load i8*, i8** %62
%65 = ptrtoint i8* %64 to i64
%66 = trunc i64 %65 to i32
%67 = tail call i32 (i32, i8*, ...) @sscanf(i32 %66, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.4, i64 0, i64 0), i64* %60)
br label %154
68: ; preds = %14
%69 = tail call i64 @xmalloc(i32 8)
%70 = inttoptr i64 %69 to i64*
%71 = getelementptr inbounds [100 x i64*], [100 x i64*]* %12, i64 0, i64 %15
store i64* %70, i64** %71
%72 = load i8**, i8*** %4
%73 = getelementptr inbounds i8*, i8** %72, i64 1
store i8** %73, i8*** %4
%74 = load i8*, i8** %72
%75 = ptrtoint i8* %74 to i64
%76 = trunc i64 %75 to i32
%77 = tail call i32 (i32, i8*, ...) @sscanf(i32 %76, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.5, i64 0, i64 0), i64* %70)
br label %154
78: ; preds = %14
%79 = tail call i64 @xmalloc(i32 8)
%80 = inttoptr i64 %79 to i64*
%81 = getelementptr inbounds [100 x i64*], [100 x i64*]* %12, i64 0, i64 %15
store i64* %80, i64** %81
%82 = load i8**, i8*** %4
%83 = getelementptr inbounds i8*, i8** %82, i64 1
store i8** %83, i8*** %4
%84 = load i8*, i8** %82
%85 = ptrtoint i8* %84 to i64
%86 = trunc i64 %85 to i32
%87 = tail call i32 (i32, i8*, ...) @sscanf(i32 %86, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.6, i64 0, i64 0), i64* %80)
br label %154
88: ; preds = %14
%89 = tail call i64 @xmalloc(i32 8)
%90 = inttoptr i64 %89 to i64*
%91 = getelementptr inbounds [100 x i64*], [100 x i64*]* %12, i64 0, i64 %15
store i64* %90, i64** %91
%92 = load i8**, i8*** %4
%93 = getelementptr inbounds i8*, i8** %92, i64 1
store i8** %93, i8*** %4
%94 = load i8*, i8** %92
%95 = ptrtoint i8* %94 to i64
%96 = trunc i64 %95 to i32
%97 = tail call i32 (i32, i8*, ...) @sscanf(i32 %96, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.7, i64 0, i64 0), i64* %90)
br label %154
98: ; preds = %14
%99 = tail call i64 @xmalloc(i32 4)
%100 = inttoptr i64 %99 to float*
%101 = getelementptr inbounds [100 x float*], [100 x float*]* %13, i64 0, i64 %15
store float* %100, float** %101
%102 = load i8**, i8*** %4
%103 = getelementptr inbounds i8*, i8** %102, i64 1
store i8** %103, i8*** %4
%104 = load i8*, i8** %102
%105 = ptrtoint i8* %104 to i64
%106 = trunc i64 %105 to i32
%107 = tail call i32 (i32, i8*, ...) @sscanf(i32 %106, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.8, i64 0, i64 0), float* %100)
br label %154
108: ; preds = %14
%109 = tail call i64 @xmalloc(i32 8)
%110 = inttoptr i64 %109 to double*
%111 = getelementptr inbounds [100 x double*], [100 x double*]* %11, i64 0, i64 %15
store double* %110, double** %111
%112 = load i8**, i8*** %4
%113 = getelementptr inbounds i8*, i8** %112, i64 1
store i8** %113, i8*** %4
%114 = load i8*, i8** %112
%115 = ptrtoint i8* %114 to i64
%116 = trunc i64 %115 to i32
%117 = tail call i32 (i32, i8*, ...) @sscanf(i32 %116, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.9, i64 0, i64 0), double* %110)
br label %154
118: ; preds = %14
%119 = trunc i64 %15 to i32
%120 = load i32, i32* %3
%121 = icmp eq i32 %120, 0
br i1 %121, label %122, label %124
122: ; preds = %118
%123 = load i8**, i8*** %4
br label %145
124: ; preds = %118
%125 = bitcast %union.TmpArray* %7 to [100 x i8*]*
%126 = and i64 %15, 4294967295
%127 = add i32 %120, %119
%128 = load i8**, i8*** %4
br label %129
129: ; preds = %124, %136
%130 = phi i8** [ %128, %124 ], [ %137, %136 ]
%131 = phi i64 [ %126, %124 ], [ %139, %136 ]
%132 = phi i32 [ %120, %124 ], [ %141, %136 ]
%133 = load i8*, i8** %130
%134 = load i8, i8* %133
%135 = icmp eq i8 %134, 45
br i1 %135, label %143, label %136
136: ; preds = %129
%137 = getelementptr inbounds i8*, i8** %130, i64 1
store i8** %137, i8*** %4
%138 = load i8*, i8** %130
%139 = add nuw nsw i64 %131, 1
%140 = getelementptr inbounds [100 x i8*], [100 x i8*]* %125, i64 0, i64 %131
store i8* %138, i8** %140
%141 = add nsw i32 %132, -1
store i32 %141, i32* %3
%142 = icmp eq i32 %141, 0
br i1 %142, label %145, label %129
143: ; preds = %129
%144 = trunc i64 %131 to i32
br label %145
145: ; preds = %136, %143, %122
%146 = phi i32 [ 0, %122 ], [ %132, %143 ], [ 0, %136 ]
%147 = phi i8** [ %123, %122 ], [ %130, %143 ], [ %137, %136 ]
%148 = phi i32 [ %119, %122 ], [ %144, %143 ], [ %127, %136 ]
%149 = add nuw nsw i32 %148, 1
%150 = getelementptr inbounds i8*, i8** %147, i64 1
store i8** %150, i8*** %4
br label %162
151: ; preds = %14
%152 = trunc i64 %15 to i32
%153 = load i32, i32* %3
br label %162
154: ; preds = %108, %98, %88, %78, %68, %58, %48, %38, %28, %18
%155 = phi i32 [ %117, %108 ], [ %107, %98 ], [ %97, %88 ], [ %87, %78 ], [ %77, %68 ], [ %67, %58 ], [ %57, %48 ], [ %47, %38 ], [ %37, %28 ], [ %27, %18 ]
%156 = add nuw i64 %15, 1
%157 = load i32, i32* %3
%158 = add nsw i32 %157, -1
store i32 %158, i32* %3
%159 = icmp eq i32 %155, 1
br i1 %159, label %14, label %160
160: ; preds = %154
%161 = trunc i64 %156 to i32
br label %162
162: ; preds = %145, %151, %160
%163 = phi i32 [ %157, %160 ], [ %146, %145 ], [ %153, %151 ]
%164 = phi i32 [ %161, %160 ], [ %149, %145 ], [ %152, %151 ]
%165 = load i8**, i8*** %4
%166 = getelementptr inbounds i8*, i8** %165, i64 -1
store i8** %166, i8*** %4
%167 = add i32 %164, -1
store i32 %163, i32* %3
%168 = shl i32 %164, 3
%169 = tail call i64 @xmalloc(i32 %168)
%170 = inttoptr i64 %169 to i32**
store i32** %170, i32*** %6
%171 = icmp sgt i32 %164, 1
br i1 %171, label %172, label %180
172: ; preds = %162
%173 = inttoptr i64 %169 to i8*
%174 = zext i32 %167 to i64
%175 = shl nuw nsw i64 %174, 3
%176 = add nsw i32 %164, -2
%177 = zext i32 %176 to i64
%178 = add nuw nsw i64 %177, 1
%179 = getelementptr i32*, i32** %170, i64 %178
br label %180
180: ; preds = %172, %162
%181 = phi i32** [ %170, %162 ], [ %179, %172 ]
store i32* null, i32** %181
%182 = load i32, i32* %1
%183 = add nsw i32 %182, 1
store i32 %183, i32* %1
%184 = sext i32 %182 to i64
%185 = getelementptr inbounds i32*, i32** %0, i64 %184
%186 = load i32*, i32** %185
store i32 %167, i32* %186
%187 = load i32, i32* %1
%188 = add nsw i32 %187, 1
store i32 %188, i32* %1
%189 = sext i32 %187 to i64
%190 = getelementptr inbounds i32*, i32** %0, i64 %189
%191 = bitcast i32** %190 to i8**
%192 = load i8*, i8** %191
%193 = call i32 @memcpy(i8* %192, i8* %9, i32 8)
%194 = load i32**, i32*** %6
%195 = call i32 @free(i32** %194)
ret i32 %167
}