#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*/ parsit_2(char *, char *, int, int *, int *, int *, double *);
void readgm_2(char *card, char *code, int code_len, int *i1, int *i2,
              double *r1, double *r2, double *r3, double *r4, double *r5,
              double *r6, double *r7) {
  int numInts = 2;
  int numReals = 7;
  int intval[2];
  double reaval[7];
  parsit_2(card, code, code_len, &numInts, &numReals, intval, reaval);
  *i1 = intval[0];
  *i2 = intval[1];
  *r1 = reaval[0];
  *r2 = reaval[1];
  *r3 = reaval[2];
  *r4 = reaval[3];
  *r5 = reaval[4];
  *r6 = reaval[5];
  *r7 = reaval[6];
}


x86 assembly (clang, -O0):
<readgm_2>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
mov    0x38(%rbp),%rax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
movl   $0x2,-0x34(%rbp)
movl   $0x7,-0x38(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x14(%rbp),%edx
lea    -0x40(%rbp),%r9
lea    -0x80(%rbp),%rax
lea    -0x34(%rbp),%rcx
lea    -0x38(%rbp),%r8
mov    %rax,(%rsp)
call   1030 <parsit_2@plt>
mov    -0x40(%rbp),%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x3c(%rbp),%ecx
mov    -0x28(%rbp),%rax
mov    %ecx,(%rax)
movsd  -0x80(%rbp),%xmm0
mov    -0x30(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x78(%rbp),%xmm0
mov    0x10(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x70(%rbp),%xmm0
mov    0x18(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x68(%rbp),%xmm0
mov    0x20(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x60(%rbp),%xmm0
mov    0x28(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x58(%rbp),%xmm0
mov    0x30(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x50(%rbp),%xmm0
mov    0x38(%rbp),%rax
movsd  %xmm0,(%rax)
add    $0x90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<readgm_2>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x58,%rsp
mov    %r9,%r14
mov    %r8,%r15
mov    %rcx,%rbx
mov    0xa0(%rsp),%r12
mov    0x98(%rsp),%r13
mov    0x90(%rsp),%rbp
movl   $0x2,0x14(%rsp)
movl   $0x7,0x10(%rsp)
lea    0x20(%rsp),%rax
mov    %rax,(%rsp)
lea    0x14(%rsp),%rcx
lea    0x10(%rsp),%r8
lea    0x18(%rsp),%r9
call   1030 <parsit_2@plt>
mov    0x18(%rsp),%eax
mov    %eax,(%rbx)
mov    0x1c(%rsp),%eax
mov    %eax,(%r15)
movsd  0x20(%rsp),%xmm0
movsd  %xmm0,(%r14)
movsd  0x28(%rsp),%xmm0
movsd  %xmm0,0x0(%rbp)
movsd  0x30(%rsp),%xmm0
movsd  %xmm0,0x0(%r13)
movsd  0x38(%rsp),%xmm0
movsd  %xmm0,(%r12)
movsd  0x40(%rsp),%xmm0
mov    0xa8(%rsp),%rax
movsd  %xmm0,(%rax)
movsd  0x48(%rsp),%xmm0
mov    0xb0(%rsp),%rax
movsd  %xmm0,(%rax)
movsd  0x50(%rsp),%xmm0
mov    0xb8(%rsp),%rax
movsd  %xmm0,(%rax)
add    $0x58,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @readgm_2(i8* %0, i8* %1, i32 %2, i32* %3, i32* %4, double* %5, double* %6, double* %7, double* %8, double* %9, double* %10, double* %11) {
%13 = alloca i8*
%14 = alloca i8*
%15 = alloca i32
%16 = alloca i32*
%17 = alloca i32*
%18 = alloca double*
%19 = alloca double*
%20 = alloca double*
%21 = alloca double*
%22 = alloca double*
%23 = alloca double*
%24 = alloca double*
%25 = alloca i32
%26 = alloca i32
%27 = alloca [2 x i32]
%28 = alloca [7 x double]
store i8* %0, i8** %13
store i8* %1, i8** %14
store i32 %2, i32* %15
store i32* %3, i32** %16
store i32* %4, i32** %17
store double* %5, double** %18
store double* %6, double** %19
store double* %7, double** %20
store double* %8, double** %21
store double* %9, double** %22
store double* %10, double** %23
store double* %11, double** %24
store i32 2, i32* %25
store i32 7, i32* %26
%29 = load i8*, i8** %13
%30 = load i8*, i8** %14
%31 = load i32, i32* %15
%32 = getelementptr inbounds [2 x i32], [2 x i32]* %27, i64 0, i64 0
%33 = getelementptr inbounds [7 x double], [7 x double]* %28, i64 0, i64 0
%34 = call i32 @parsit_2(i8* %29, i8* %30, i32 %31, i32* %25, i32* %26, i32* %32, double* %33)
%35 = getelementptr inbounds [2 x i32], [2 x i32]* %27, i64 0, i64 0
%36 = load i32, i32* %35
%37 = load i32*, i32** %16
store i32 %36, i32* %37
%38 = getelementptr inbounds [2 x i32], [2 x i32]* %27, i64 0, i64 1
%39 = load i32, i32* %38
%40 = load i32*, i32** %17
store i32 %39, i32* %40
%41 = getelementptr inbounds [7 x double], [7 x double]* %28, i64 0, i64 0
%42 = load double, double* %41
%43 = load double*, double** %18
store double %42, double* %43
%44 = getelementptr inbounds [7 x double], [7 x double]* %28, i64 0, i64 1
%45 = load double, double* %44
%46 = load double*, double** %19
store double %45, double* %46
%47 = getelementptr inbounds [7 x double], [7 x double]* %28, i64 0, i64 2
%48 = load double, double* %47
%49 = load double*, double** %20
store double %48, double* %49
%50 = getelementptr inbounds [7 x double], [7 x double]* %28, i64 0, i64 3
%51 = load double, double* %50
%52 = load double*, double** %21
store double %51, double* %52
%53 = getelementptr inbounds [7 x double], [7 x double]* %28, i64 0, i64 4
%54 = load double, double* %53
%55 = load double*, double** %22
store double %54, double* %55
%56 = getelementptr inbounds [7 x double], [7 x double]* %28, i64 0, i64 5
%57 = load double, double* %56
%58 = load double*, double** %23
store double %57, double* %58
%59 = getelementptr inbounds [7 x double], [7 x double]* %28, i64 0, i64 6
%60 = load double, double* %59
%61 = load double*, double** %24
store double %60, double* %61
ret void
}

LLVM IR (-O2):
define void @readgm_2(i8* %0, i8* %1, i32 %2, i32* nocapture writeonly %3, i32* nocapture writeonly %4, double* nocapture writeonly %5, double* nocapture writeonly %6, double* nocapture writeonly %7, double* nocapture writeonly %8, double* nocapture writeonly %9, double* nocapture writeonly %10, double* nocapture writeonly %11) {
%13 = alloca i32
%14 = alloca i32
%15 = alloca [2 x i32]
%16 = alloca [7 x double]
%17 = bitcast i32* %13 to i8*
store i32 2, i32* %13
%18 = bitcast i32* %14 to i8*
store i32 7, i32* %14
%19 = bitcast [2 x i32]* %15 to i8*
%20 = bitcast [7 x double]* %16 to i8*
%21 = getelementptr inbounds [2 x i32], [2 x i32]* %15, i64 0, i64 0
%22 = getelementptr inbounds [7 x double], [7 x double]* %16, i64 0, i64 0
%23 = call i32 @parsit_2(i8* %0, i8* %1, i32 %2, i32* %13, i32* %14, i32* %21, double* %22)
%24 = load i32, i32* %21
store i32 %24, i32* %3
%25 = getelementptr inbounds [2 x i32], [2 x i32]* %15, i64 0, i64 1
%26 = load i32, i32* %25
store i32 %26, i32* %4
%27 = load double, double* %22
store double %27, double* %5
%28 = getelementptr inbounds [7 x double], [7 x double]* %16, i64 0, i64 1
%29 = load double, double* %28
store double %29, double* %6
%30 = getelementptr inbounds [7 x double], [7 x double]* %16, i64 0, i64 2
%31 = load double, double* %30
store double %31, double* %7
%32 = getelementptr inbounds [7 x double], [7 x double]* %16, i64 0, i64 3
%33 = load double, double* %32
store double %33, double* %8
%34 = getelementptr inbounds [7 x double], [7 x double]* %16, i64 0, i64 4
%35 = load double, double* %34
store double %35, double* %9
%36 = getelementptr inbounds [7 x double], [7 x double]* %16, i64 0, i64 5
%37 = load double, double* %36
store double %37, double* %10
%38 = getelementptr inbounds [7 x double], [7 x double]* %16, i64 0, i64 6
%39 = load double, double* %38
store double %39, double* %11
ret void
}