#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*/ CreateDenseMatrixGeneral(char *, unsigned long,
                                            unsigned long, unsigned int, double,
                                            double);
int /*<<< orphan*/
CreateDenseMatrixGeneralDiagonallyDominant(char *, unsigned long, unsigned long,
                                           unsigned int, double, double);
int /*<<< orphan*/ CreateDenseMatrixGeneralDiagonallyDominantRowLine(
    char *, unsigned long, unsigned long, unsigned int, double, double);
int /*<<< orphan*/ CreateDenseMatrixGeneralRowLine(char *, unsigned long,
                                                   unsigned long, unsigned int,
                                                   double, double);
int /*<<< orphan*/ CreateDenseMatrixSymmetric(char *, unsigned long,
                                              unsigned long, unsigned int,
                                              double, double);
int /*<<< orphan*/ CreateDenseMatrixSymmetricDiagonallyDominant(
    char *, unsigned long, unsigned long, unsigned int, double, double);
int /*<<< orphan*/ CreateDenseMatrixSymmetricDiagonallyDominantRowLine(
    char *, unsigned long, unsigned long, unsigned int, double, double);
int /*<<< orphan*/ CreateDenseMatrixSymmetricRowLine(char *, unsigned long,
                                                     unsigned long,
                                                     unsigned int, double,
                                                     double);
scalar_t__ atof(int /*<<< orphan*/);
unsigned int atoi(char *);
unsigned long atol(char *);
int getopt(int, char **, char *);
scalar_t__ malloc(int);
int /*<<< orphan*/ optarg;
int optind;
int /*<<< orphan*/ sprintf(char *, char *);
int /*<<< orphan*/ strcpy(char *, int /*<<< orphan*/);
int strlen(int /*<<< orphan*/);
int /*<<< orphan*/ usageCreateDenseMatrix();
int CreateDenseMatrix(int argc, char *argv[]) {
  int inputFormatRow = 0;
  int symmetric = 0;
  int diagonallyDominant = 0;
  char *outputFileName = NULL;
  double min = 0.0;
  double max = 1.0;
  int option;
  while ((option = getopt(argc, argv, "rso:dl:m:")) >= 0) {
    switch (option) {
    case 'o':
      outputFileName = (char *)malloc(sizeof(char) * strlen(optarg) + 1);
      strcpy(outputFileName, optarg);
      break;
    case 's':
      symmetric = 1;
      break;
    case 'r':
      inputFormatRow = 1;
      break;
    case 'd':
      diagonallyDominant = 1;
      break;
    case 'l':
      min = (double)atof(optarg);
      break;
    case 'm':
      max = (double)atof(optarg);
      break;
    default:
      break;
    }
  }
  if ((optind + 3 > argc) || (optind + 4 <= argc)) {
    usageCreateDenseMatrix();
    return 0;
  }
  if (outputFileName == NULL) {
    outputFileName = (char *)malloc(sizeof(char) * 7);
    sprintf(outputFileName, "stdout");
  }
  unsigned long int numRows = atol(argv[optind]);
  unsigned long int numCols = atol(argv[optind + 1]);
  unsigned int seed = atoi(argv[optind + 2]);
  if (symmetric && inputFormatRow && !diagonallyDominant) {
    CreateDenseMatrixSymmetricRowLine(outputFileName, numRows, numCols, seed,
                                      min, max);
  } else if (!symmetric && inputFormatRow && !diagonallyDominant) {
    CreateDenseMatrixGeneralRowLine(outputFileName, numRows, numCols, seed, min,
                                    max);
  } else if (symmetric && !inputFormatRow && !diagonallyDominant) {
    CreateDenseMatrixSymmetric(outputFileName, numRows, numCols, seed, min,
                               max);
  } else if (!symmetric && !inputFormatRow && !diagonallyDominant) {
    CreateDenseMatrixGeneral(outputFileName, numRows, numCols, seed, min, max);
  } else if (symmetric && inputFormatRow && diagonallyDominant) {
    CreateDenseMatrixSymmetricDiagonallyDominantRowLine(
        outputFileName, numRows, numCols, seed, min, max);
  } else if (!symmetric && inputFormatRow && diagonallyDominant) {
    CreateDenseMatrixGeneralDiagonallyDominantRowLine(outputFileName, numRows,
                                                      numCols, seed, min, max);
  } else if (symmetric && !inputFormatRow && diagonallyDominant) {
    CreateDenseMatrixSymmetricDiagonallyDominant(outputFileName, numRows,
                                                 numCols, seed, min, max);
  } else if (!symmetric && !inputFormatRow && diagonallyDominant) {
    CreateDenseMatrixGeneralDiagonallyDominant(outputFileName, numRows, numCols,
                                               seed, min, max);
  }
  return 1;
}


x86 assembly (clang, -O0):
<CreateDenseMatrix>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movl   $0x0,-0x14(%rbp)
movl   $0x0,-0x18(%rbp)
movl   $0x0,-0x1c(%rbp)
movq   $0x0,-0x28(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x30(%rbp)
movsd  0xdb4(%rip),%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x8(%rbp),%edi
mov    -0x10(%rbp),%rsi
lea    0xde9(%rip),%rdx
call   1100 <getopt@plt>
mov    %eax,-0x3c(%rbp)
cmp    $0x0,%eax
jl     133b <CreateDenseMatrix+0x12b>
mov    -0x3c(%rbp),%eax
add    $0xffffff9c,%eax
mov    %eax,%ecx
mov    %rcx,-0x60(%rbp)
sub    $0xf,%eax
ja     1331 <CreateDenseMatrix+0x121>
mov    -0x60(%rbp),%rax
lea    0xd78(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    0x2d58(%rip),%rax
mov    (%rax),%edi
call   1060 <strlen@plt>
cltq
shl    $0x0,%rax
add    $0x1,%rax
mov    %eax,%edi
call   10d0 <malloc@plt>
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rdi
mov    0x2d31(%rip),%rax
mov    (%rax),%esi
call   1030 <strcpy@plt>
jmp    1336 <CreateDenseMatrix+0x126>
movl   $0x1,-0x18(%rbp)
jmp    1336 <CreateDenseMatrix+0x126>
movl   $0x1,-0x14(%rbp)
jmp    1336 <CreateDenseMatrix+0x126>
movl   $0x1,-0x1c(%rbp)
jmp    1336 <CreateDenseMatrix+0x126>
mov    0x2cfa(%rip),%rax
mov    (%rax),%edi
call   1040 <atof@plt>
cvtsi2sd %rax,%xmm0
movsd  %xmm0,-0x30(%rbp)
jmp    1336 <CreateDenseMatrix+0x126>
mov    0x2cdd(%rip),%rax
mov    (%rax),%edi
call   1040 <atof@plt>
cvtsi2sd %rax,%xmm0
movsd  %xmm0,-0x38(%rbp)
jmp    1336 <CreateDenseMatrix+0x126>
jmp    1336 <CreateDenseMatrix+0x126>
jmp    1251 <CreateDenseMatrix+0x41>
mov    0x2c9e(%rip),%rax
mov    (%rax),%eax
add    $0x3,%eax
cmp    -0x8(%rbp),%eax
jg     1365 <CreateDenseMatrix+0x155>
mov    0x2c89(%rip),%rax
mov    (%rax),%eax
add    $0x4,%eax
cmp    -0x8(%rbp),%eax
jg     1378 <CreateDenseMatrix+0x168>
mov    $0x0,%al
call   10e0 <usageCreateDenseMatrix@plt>
movl   $0x0,-0x4(%rbp)
jmp    1628 <CreateDenseMatrix+0x418>
cmpq   $0x0,-0x28(%rbp)
jne    13a1 <CreateDenseMatrix+0x191>
mov    $0x7,%edi
call   10d0 <malloc@plt>
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rdi
lea    0xcb6(%rip),%rsi
call   1130 <sprintf@plt>
mov    -0x10(%rbp),%rax
mov    0x2c34(%rip),%rcx
movslq (%rcx),%rcx
mov    (%rax,%rcx,8),%rdi
call   10f0 <atol@plt>
mov    %rax,-0x48(%rbp)
mov    -0x10(%rbp),%rax
mov    0x2c19(%rip),%rcx
mov    (%rcx),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rdi
call   10f0 <atol@plt>
mov    %rax,-0x50(%rbp)
mov    -0x10(%rbp),%rax
mov    0x2bf9(%rip),%rcx
mov    (%rcx),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rdi
call   1120 <atoi@plt>
mov    %eax,-0x54(%rbp)
cmpl   $0x0,-0x18(%rbp)
je     143c <CreateDenseMatrix+0x22c>
cmpl   $0x0,-0x14(%rbp)
je     143c <CreateDenseMatrix+0x22c>
cmpl   $0x0,-0x1c(%rbp)
jne    143c <CreateDenseMatrix+0x22c>
mov    -0x28(%rbp),%rdi
mov    -0x48(%rbp),%rsi
mov    -0x50(%rbp),%rdx
mov    -0x54(%rbp),%ecx
movsd  -0x30(%rbp),%xmm0
movsd  -0x38(%rbp),%xmm1
call   1050 <CreateDenseMatrixSymmetricRowLine@plt>
jmp    1621 <CreateDenseMatrix+0x411>
cmpl   $0x0,-0x18(%rbp)
jne    147d <CreateDenseMatrix+0x26d>
cmpl   $0x0,-0x14(%rbp)
je     147d <CreateDenseMatrix+0x26d>
cmpl   $0x0,-0x1c(%rbp)
jne    147d <CreateDenseMatrix+0x26d>
mov    -0x28(%rbp),%rdi
mov    -0x48(%rbp),%rsi
mov    -0x50(%rbp),%rdx
mov    -0x54(%rbp),%ecx
movsd  -0x30(%rbp),%xmm0
movsd  -0x38(%rbp),%xmm1
call   1070 <CreateDenseMatrixGeneralRowLine@plt>
jmp    161c <CreateDenseMatrix+0x40c>
cmpl   $0x0,-0x18(%rbp)
je     14be <CreateDenseMatrix+0x2ae>
cmpl   $0x0,-0x14(%rbp)
jne    14be <CreateDenseMatrix+0x2ae>
cmpl   $0x0,-0x1c(%rbp)
jne    14be <CreateDenseMatrix+0x2ae>
mov    -0x28(%rbp),%rdi
mov    -0x48(%rbp),%rsi
mov    -0x50(%rbp),%rdx
mov    -0x54(%rbp),%ecx
movsd  -0x30(%rbp),%xmm0
movsd  -0x38(%rbp),%xmm1
call   1080 <CreateDenseMatrixSymmetric@plt>
jmp    1617 <CreateDenseMatrix+0x407>
cmpl   $0x0,-0x18(%rbp)
jne    14ff <CreateDenseMatrix+0x2ef>
cmpl   $0x0,-0x14(%rbp)
jne    14ff <CreateDenseMatrix+0x2ef>
cmpl   $0x0,-0x1c(%rbp)
jne    14ff <CreateDenseMatrix+0x2ef>
mov    -0x28(%rbp),%rdi
mov    -0x48(%rbp),%rsi
mov    -0x50(%rbp),%rdx
mov    -0x54(%rbp),%ecx
movsd  -0x30(%rbp),%xmm0
movsd  -0x38(%rbp),%xmm1
call   10c0 <CreateDenseMatrixGeneral@plt>
jmp    1612 <CreateDenseMatrix+0x402>
cmpl   $0x0,-0x18(%rbp)
je     1540 <CreateDenseMatrix+0x330>
cmpl   $0x0,-0x14(%rbp)
je     1540 <CreateDenseMatrix+0x330>
cmpl   $0x0,-0x1c(%rbp)
je     1540 <CreateDenseMatrix+0x330>
mov    -0x28(%rbp),%rdi
mov    -0x48(%rbp),%rsi
mov    -0x50(%rbp),%rdx
mov    -0x54(%rbp),%ecx
movsd  -0x30(%rbp),%xmm0
movsd  -0x38(%rbp),%xmm1
call   1090 <CreateDenseMatrixSymmetricDiagonallyDominantRowLine@plt>
jmp    160d <CreateDenseMatrix+0x3fd>
cmpl   $0x0,-0x18(%rbp)
jne    1581 <CreateDenseMatrix+0x371>
cmpl   $0x0,-0x14(%rbp)
je     1581 <CreateDenseMatrix+0x371>
cmpl   $0x0,-0x1c(%rbp)
je     1581 <CreateDenseMatrix+0x371>
mov    -0x28(%rbp),%rdi
mov    -0x48(%rbp),%rsi
mov    -0x50(%rbp),%rdx
mov    -0x54(%rbp),%ecx
movsd  -0x30(%rbp),%xmm0
movsd  -0x38(%rbp),%xmm1
call   1110 <CreateDenseMatrixGeneralDiagonallyDominantRowLine@plt>
jmp    1608 <CreateDenseMatrix+0x3f8>
cmpl   $0x0,-0x18(%rbp)
je     15c2 <CreateDenseMatrix+0x3b2>
cmpl   $0x0,-0x14(%rbp)
jne    15c2 <CreateDenseMatrix+0x3b2>
cmpl   $0x0,-0x1c(%rbp)
je     15c2 <CreateDenseMatrix+0x3b2>
mov    -0x28(%rbp),%rdi
mov    -0x48(%rbp),%rsi
mov    -0x50(%rbp),%rdx
mov    -0x54(%rbp),%ecx
movsd  -0x30(%rbp),%xmm0
movsd  -0x38(%rbp),%xmm1
call   10a0 <CreateDenseMatrixSymmetricDiagonallyDominant@plt>
jmp    1603 <CreateDenseMatrix+0x3f3>
cmpl   $0x0,-0x18(%rbp)
jne    15fe <CreateDenseMatrix+0x3ee>
cmpl   $0x0,-0x14(%rbp)
jne    15fe <CreateDenseMatrix+0x3ee>
cmpl   $0x0,-0x1c(%rbp)
je     15fe <CreateDenseMatrix+0x3ee>
mov    -0x28(%rbp),%rdi
mov    -0x48(%rbp),%rsi
mov    -0x50(%rbp),%rdx
mov    -0x54(%rbp),%ecx
movsd  -0x30(%rbp),%xmm0
movsd  -0x38(%rbp),%xmm1
call   10b0 <CreateDenseMatrixGeneralDiagonallyDominant@plt>
jmp    1603 <CreateDenseMatrix+0x3f3>
jmp    1608 <CreateDenseMatrix+0x3f8>
jmp    160d <CreateDenseMatrix+0x3fd>
jmp    1612 <CreateDenseMatrix+0x402>
jmp    1617 <CreateDenseMatrix+0x407>
jmp    161c <CreateDenseMatrix+0x40c>
jmp    1621 <CreateDenseMatrix+0x411>
movl   $0x1,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<CreateDenseMatrix>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    %rsi,%rbx
mov    %edi,%ebp
lea    0xe2e(%rip),%rdx
call   1100 <getopt@plt>
test   %eax,%eax
js     1315 <CreateDenseMatrix+0x115>
xorps  %xmm0,%xmm0
movsd  %xmm0,0x8(%rsp)
movsd  0xdc8(%rip),%xmm0
movsd  %xmm0,0x10(%rsp)
xor    %ecx,%ecx
mov    %rcx,0x20(%rsp)
lea    0xdfc(%rip),%r15
lea    0xdb5(%rip),%r13
mov    0x2d9e(%rip),%r12
movl   $0x0,0x18(%rsp)
movl   $0x0,0x1c(%rsp)
xor    %r14d,%r14d
jmp    12a5 <CreateDenseMatrix+0xa5>
mov    (%r12),%edi
call   1040 <atof@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %rax,%xmm0
movsd  %xmm0,0x10(%rsp)
cs nopw 0x0(%rax,%rax,1)
mov    %ebp,%edi
mov    %rbx,%rsi
mov    %r15,%rdx
call   1100 <getopt@plt>
test   %eax,%eax
js     1347 <CreateDenseMatrix+0x147>
add    $0xffffff9c,%eax
cmp    $0xf,%eax
ja     1290 <CreateDenseMatrix+0x90>
movslq 0x0(%r13,%rax,4),%rax
add    %r13,%rax
jmp    *%rax
movl   $0x1,0x1c(%rsp)
jmp    1290 <CreateDenseMatrix+0x90>
mov    (%r12),%edi
call   1040 <atof@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %rax,%xmm0
movsd  %xmm0,0x8(%rsp)
jmp    1290 <CreateDenseMatrix+0x90>
mov    (%r12),%edi
call   1060 <strlen@plt>
lea    0x1(%rax),%edi
call   10d0 <malloc@plt>
mov    %rax,%r14
mov    (%r12),%esi
mov    %rax,%rdi
call   1030 <strcpy@plt>
jmp    1290 <CreateDenseMatrix+0x90>
mov    $0x1,%eax
mov    %rax,0x20(%rsp)
jmp    1290 <CreateDenseMatrix+0x90>
movl   $0x1,0x18(%rsp)
jmp    1290 <CreateDenseMatrix+0x90>
xor    %r14d,%r14d
movsd  0xce0(%rip),%xmm0
movsd  %xmm0,0x10(%rsp)
xorpd  %xmm0,%xmm0
movsd  %xmm0,0x8(%rsp)
movl   $0x0,0x1c(%rsp)
movl   $0x0,0x18(%rsp)
xor    %eax,%eax
mov    %rax,0x20(%rsp)
mov    0x2c92(%rip),%r15
mov    (%r15),%eax
lea    0x3(%rax),%ecx
cmp    %ebp,%ecx
jg     13f4 <CreateDenseMatrix+0x1f4>
lea    0x4(%rax),%ecx
cmp    %ebp,%ecx
jle    13f4 <CreateDenseMatrix+0x1f4>
test   %r14,%r14
jne    1389 <CreateDenseMatrix+0x189>
mov    $0x7,%edi
call   10d0 <malloc@plt>
mov    %rax,%r14
movl   $0x6f647473,(%rax)
movl   $0x74756f,0x3(%rax)
mov    (%r15),%eax
movslq %eax,%rbp
mov    (%rbx,%rbp,8),%rdi
call   10f0 <atol@plt>
mov    %rax,%r12
mov    0x8(%rbx,%rbp,8),%rdi
call   10f0 <atol@plt>
mov    %rax,%r15
mov    0x10(%rbx,%rbp,8),%rdi
call   1120 <atoi@plt>
mov    0x18(%rsp),%edi
test   %edi,%edi
setne  %dl
mov    0x20(%rsp),%rsi
test   %esi,%esi
setne  %cl
and    %dl,%cl
cmp    $0x1,%cl
mov    0x1c(%rsp),%ebp
jne    140e <CreateDenseMatrix+0x20e>
test   %ebp,%ebp
jne    140e <CreateDenseMatrix+0x20e>
mov    %r14,%rdi
mov    %r12,%rsi
mov    %r15,%rdx
mov    %eax,%ecx
movsd  0x8(%rsp),%xmm0
movsd  0x10(%rsp),%xmm1
call   1050 <CreateDenseMatrixSymmetricRowLine@plt>
mov    $0x1,%ebx
jmp    13fd <CreateDenseMatrix+0x1fd>
xor    %ebx,%ebx
xor    %eax,%eax
call   10e0 <usageCreateDenseMatrix@plt>
mov    %ebx,%eax
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
test   %esi,%esi
setne  %bl
test   %edi,%edi
sete   %dl
and    %bl,%dl
cmp    $0x1,%dl
jne    1446 <CreateDenseMatrix+0x246>
test   %ebp,%ebp
jne    1446 <CreateDenseMatrix+0x246>
mov    %r14,%rdi
mov    %r12,%rsi
mov    %r15,%rdx
mov    %eax,%ecx
movsd  0x8(%rsp),%xmm0
movsd  0x10(%rsp),%xmm1
call   1070 <CreateDenseMatrixGeneralRowLine@plt>
mov    $0x1,%ebx
jmp    13fd <CreateDenseMatrix+0x1fd>
test   %edi,%edi
sete   %bl
test   %esi,%esi
setne  %r8b
or     %bl,%r8b
jne    147d <CreateDenseMatrix+0x27d>
test   %ebp,%ebp
jne    147d <CreateDenseMatrix+0x27d>
mov    %r14,%rdi
mov    %r12,%rsi
mov    %r15,%rdx
mov    %eax,%ecx
movsd  0x8(%rsp),%xmm0
movsd  0x10(%rsp),%xmm1
call   1080 <CreateDenseMatrixSymmetric@plt>
mov    $0x1,%ebx
jmp    13fd <CreateDenseMatrix+0x1fd>
or     %esi,%edi
setne  %sil
jne    14af <CreateDenseMatrix+0x2af>
test   %ebp,%ebp
jne    14af <CreateDenseMatrix+0x2af>
mov    %r14,%rdi
mov    %r12,%rsi
mov    %r15,%rdx
mov    %eax,%ecx
movsd  0x8(%rsp),%xmm0
movsd  0x10(%rsp),%xmm1
call   10c0 <CreateDenseMatrixGeneral@plt>
mov    $0x1,%ebx
jmp    13fd <CreateDenseMatrix+0x1fd>
test   %ebp,%ebp
setne  %bl
and    %bl,%cl
cmp    $0x1,%cl
jne    14e1 <CreateDenseMatrix+0x2e1>
mov    %r14,%rdi
mov    %r12,%rsi
mov    %r15,%rdx
mov    %eax,%ecx
movsd  0x8(%rsp),%xmm0
movsd  0x10(%rsp),%xmm1
call   1090 <CreateDenseMatrixSymmetricDiagonallyDominantRowLine@plt>
mov    $0x1,%ebx
jmp    13fd <CreateDenseMatrix+0x1fd>
test   %ebp,%ebp
setne  %cl
and    %cl,%dl
cmp    $0x1,%dl
jne    1513 <CreateDenseMatrix+0x313>
mov    %r14,%rdi
mov    %r12,%rsi
mov    %r15,%rdx
mov    %eax,%ecx
movsd  0x8(%rsp),%xmm0
movsd  0x10(%rsp),%xmm1
call   1110 <CreateDenseMatrixGeneralDiagonallyDominantRowLine@plt>
mov    $0x1,%ebx
jmp    13fd <CreateDenseMatrix+0x1fd>
test   %r8b,%r8b
jne    1542 <CreateDenseMatrix+0x342>
test   %ebp,%ebp
je     1542 <CreateDenseMatrix+0x342>
mov    %r14,%rdi
mov    %r12,%rsi
mov    %r15,%rdx
mov    %eax,%ecx
movsd  0x8(%rsp),%xmm0
movsd  0x10(%rsp),%xmm1
call   10a0 <CreateDenseMatrixSymmetricDiagonallyDominant@plt>
mov    $0x1,%ebx
jmp    13fd <CreateDenseMatrix+0x1fd>
mov    $0x1,%ebx
test   %sil,%sil
jne    13fd <CreateDenseMatrix+0x1fd>
test   %ebp,%ebp
je     13fd <CreateDenseMatrix+0x1fd>
mov    %r14,%rdi
mov    %r12,%rsi
mov    %r15,%rdx
mov    %eax,%ecx
movsd  0x8(%rsp),%xmm0
movsd  0x10(%rsp),%xmm1
call   10b0 <CreateDenseMatrixGeneralDiagonallyDominant@plt>
jmp    13fd <CreateDenseMatrix+0x1fd>

LLVM IR (-O0):
@.str = [10 x i8] c"rso:dl:m:\00"
@optarg = global i32 0
@optind = global i32 0
@.str.1 = [7 x i8] c"stdout\00"
define i32 @CreateDenseMatrix(i32 %0, i8** %1) {
%3 = alloca i32
%4 = alloca i32
%5 = alloca i8**
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca i8*
%10 = alloca double
%11 = alloca double
%12 = alloca i32
%13 = alloca i64
%14 = alloca i64
%15 = alloca i32
store i32 %0, i32* %4
store i8** %1, i8*** %5
store i32 0, i32* %6
store i32 0, i32* %7
store i32 0, i32* %8
store i8* null, i8** %9
store double 0.000000e+00, double* %10
store double 1.000000e+00, double* %11
br label %16
16: ; preds = %47, %2
%17 = load i32, i32* %4
%18 = load i8**, i8*** %5
%19 = call i32 @getopt(i32 %17, i8** %18, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i64 0, i64 0))
store i32 %19, i32* %12
%20 = icmp sge i32 %19, 0
br i1 %20, label %21, label %48
21: ; preds = %16
%22 = load i32, i32* %12
switch i32 %22, label %46 [
i32 111, label %23
i32 115, label %35
i32 114, label %36
i32 100, label %37
i32 108, label %38
i32 109, label %42
]
23: ; preds = %21
%24 = load i32, i32* @optarg
%25 = call i32 @strlen(i32 %24)
%26 = sext i32 %25 to i64
%27 = mul i64 1, %26
%28 = add i64 %27, 1
%29 = trunc i64 %28 to i32
%30 = call i64 @malloc(i32 %29)
%31 = inttoptr i64 %30 to i8*
store i8* %31, i8** %9
%32 = load i8*, i8** %9
%33 = load i32, i32* @optarg
%34 = call i32 @strcpy(i8* %32, i32 %33)
br label %47
35: ; preds = %21
store i32 1, i32* %7
br label %47
36: ; preds = %21
store i32 1, i32* %6
br label %47
37: ; preds = %21
store i32 1, i32* %8
br label %47
38: ; preds = %21
%39 = load i32, i32* @optarg
%40 = call i64 @atof(i32 %39)
%41 = sitofp i64 %40 to double
store double %41, double* %10
br label %47
42: ; preds = %21
%43 = load i32, i32* @optarg
%44 = call i64 @atof(i32 %43)
%45 = sitofp i64 %44 to double
store double %45, double* %11
br label %47
46: ; preds = %21
br label %47
47: ; preds = %46, %42, %38, %37, %36, %35, %23
br label %16
48: ; preds = %16
%49 = load i32, i32* @optind
%50 = add nsw i32 %49, 3
%51 = load i32, i32* %4
%52 = icmp sgt i32 %50, %51
br i1 %52, label %58, label %53
53: ; preds = %48
%54 = load i32, i32* @optind
%55 = add nsw i32 %54, 4
%56 = load i32, i32* %4
%57 = icmp sle i32 %55, %56
br i1 %57, label %58, label %60
58: ; preds = %53, %48
%59 = call i32 (...) @usageCreateDenseMatrix()
store i32 0, i32* %3
br label %232
60: ; preds = %53
%61 = load i8*, i8** %9
%62 = icmp eq i8* %61, null
br i1 %62, label %63, label %68
63: ; preds = %60
%64 = call i64 @malloc(i32 7)
%65 = inttoptr i64 %64 to i8*
store i8* %65, i8** %9
%66 = load i8*, i8** %9
%67 = call i32 @sprintf(i8* %66, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0))
br label %68
68: ; preds = %63, %60
%69 = load i8**, i8*** %5
%70 = load i32, i32* @optind
%71 = sext i32 %70 to i64
%72 = getelementptr inbounds i8*, i8** %69, i64 %71
%73 = load i8*, i8** %72
%74 = call i64 @atol(i8* %73)
store i64 %74, i64* %13
%75 = load i8**, i8*** %5
%76 = load i32, i32* @optind
%77 = add nsw i32 %76, 1
%78 = sext i32 %77 to i64
%79 = getelementptr inbounds i8*, i8** %75, i64 %78
%80 = load i8*, i8** %79
%81 = call i64 @atol(i8* %80)
store i64 %81, i64* %14
%82 = load i8**, i8*** %5
%83 = load i32, i32* @optind
%84 = add nsw i32 %83, 2
%85 = sext i32 %84 to i64
%86 = getelementptr inbounds i8*, i8** %82, i64 %85
%87 = load i8*, i8** %86
%88 = call i32 @atoi(i8* %87)
store i32 %88, i32* %15
%89 = load i32, i32* %7
%90 = icmp ne i32 %89, 0
br i1 %90, label %91, label %105
91: ; preds = %68
%92 = load i32, i32* %6
%93 = icmp ne i32 %92, 0
br i1 %93, label %94, label %105
94: ; preds = %91
%95 = load i32, i32* %8
%96 = icmp ne i32 %95, 0
br i1 %96, label %105, label %97
97: ; preds = %94
%98 = load i8*, i8** %9
%99 = load i64, i64* %13
%100 = load i64, i64* %14
%101 = load i32, i32* %15
%102 = load double, double* %10
%103 = load double, double* %11
%104 = call i32 @CreateDenseMatrixSymmetricRowLine(i8* %98, i64 %99, i64 %100, i32 %101, double %102, double %103)
br label %231
105: ; preds = %94, %91, %68
%106 = load i32, i32* %7
%107 = icmp ne i32 %106, 0
br i1 %107, label %122, label %108
108: ; preds = %105
%109 = load i32, i32* %6
%110 = icmp ne i32 %109, 0
br i1 %110, label %111, label %122
111: ; preds = %108
%112 = load i32, i32* %8
%113 = icmp ne i32 %112, 0
br i1 %113, label %122, label %114
114: ; preds = %111
%115 = load i8*, i8** %9
%116 = load i64, i64* %13
%117 = load i64, i64* %14
%118 = load i32, i32* %15
%119 = load double, double* %10
%120 = load double, double* %11
%121 = call i32 @CreateDenseMatrixGeneralRowLine(i8* %115, i64 %116, i64 %117, i32 %118, double %119, double %120)
br label %230
122: ; preds = %111, %108, %105
%123 = load i32, i32* %7
%124 = icmp ne i32 %123, 0
br i1 %124, label %125, label %139
125: ; preds = %122
%126 = load i32, i32* %6
%127 = icmp ne i32 %126, 0
br i1 %127, label %139, label %128
128: ; preds = %125
%129 = load i32, i32* %8
%130 = icmp ne i32 %129, 0
br i1 %130, label %139, label %131
131: ; preds = %128
%132 = load i8*, i8** %9
%133 = load i64, i64* %13
%134 = load i64, i64* %14
%135 = load i32, i32* %15
%136 = load double, double* %10
%137 = load double, double* %11
%138 = call i32 @CreateDenseMatrixSymmetric(i8* %132, i64 %133, i64 %134, i32 %135, double %136, double %137)
br label %229
139: ; preds = %128, %125, %122
%140 = load i32, i32* %7
%141 = icmp ne i32 %140, 0
br i1 %141, label %156, label %142
142: ; preds = %139
%143 = load i32, i32* %6
%144 = icmp ne i32 %143, 0
br i1 %144, label %156, label %145
145: ; preds = %142
%146 = load i32, i32* %8
%147 = icmp ne i32 %146, 0
br i1 %147, label %156, label %148
148: ; preds = %145
%149 = load i8*, i8** %9
%150 = load i64, i64* %13
%151 = load i64, i64* %14
%152 = load i32, i32* %15
%153 = load double, double* %10
%154 = load double, double* %11
%155 = call i32 @CreateDenseMatrixGeneral(i8* %149, i64 %150, i64 %151, i32 %152, double %153, double %154)
br label %228
156: ; preds = %145, %142, %139
%157 = load i32, i32* %7
%158 = icmp ne i32 %157, 0
br i1 %158, label %159, label %173
159: ; preds = %156
%160 = load i32, i32* %6
%161 = icmp ne i32 %160, 0
br i1 %161, label %162, label %173
162: ; preds = %159
%163 = load i32, i32* %8
%164 = icmp ne i32 %163, 0
br i1 %164, label %165, label %173
165: ; preds = %162
%166 = load i8*, i8** %9
%167 = load i64, i64* %13
%168 = load i64, i64* %14
%169 = load i32, i32* %15
%170 = load double, double* %10
%171 = load double, double* %11
%172 = call i32 @CreateDenseMatrixSymmetricDiagonallyDominantRowLine(i8* %166, i64 %167, i64 %168, i32 %169, double %170, double %171)
br label %227
173: ; preds = %162, %159, %156
%174 = load i32, i32* %7
%175 = icmp ne i32 %174, 0
br i1 %175, label %190, label %176
176: ; preds = %173
%177 = load i32, i32* %6
%178 = icmp ne i32 %177, 0
br i1 %178, label %179, label %190
179: ; preds = %176
%180 = load i32, i32* %8
%181 = icmp ne i32 %180, 0
br i1 %181, label %182, label %190
182: ; preds = %179
%183 = load i8*, i8** %9
%184 = load i64, i64* %13
%185 = load i64, i64* %14
%186 = load i32, i32* %15
%187 = load double, double* %10
%188 = load double, double* %11
%189 = call i32 @CreateDenseMatrixGeneralDiagonallyDominantRowLine(i8* %183, i64 %184, i64 %185, i32 %186, double %187, double %188)
br label %226
190: ; preds = %179, %176, %173
%191 = load i32, i32* %7
%192 = icmp ne i32 %191, 0
br i1 %192, label %193, label %207
193: ; preds = %190
%194 = load i32, i32* %6
%195 = icmp ne i32 %194, 0
br i1 %195, label %207, label %196
196: ; preds = %193
%197 = load i32, i32* %8
%198 = icmp ne i32 %197, 0
br i1 %198, label %199, label %207
199: ; preds = %196
%200 = load i8*, i8** %9
%201 = load i64, i64* %13
%202 = load i64, i64* %14
%203 = load i32, i32* %15
%204 = load double, double* %10
%205 = load double, double* %11
%206 = call i32 @CreateDenseMatrixSymmetricDiagonallyDominant(i8* %200, i64 %201, i64 %202, i32 %203, double %204, double %205)
br label %225
207: ; preds = %196, %193, %190
%208 = load i32, i32* %7
%209 = icmp ne i32 %208, 0
br i1 %209, label %224, label %210
210: ; preds = %207
%211 = load i32, i32* %6
%212 = icmp ne i32 %211, 0
br i1 %212, label %224, label %213
213: ; preds = %210
%214 = load i32, i32* %8
%215 = icmp ne i32 %214, 0
br i1 %215, label %216, label %224
216: ; preds = %213
%217 = load i8*, i8** %9
%218 = load i64, i64* %13
%219 = load i64, i64* %14
%220 = load i32, i32* %15
%221 = load double, double* %10
%222 = load double, double* %11
%223 = call i32 @CreateDenseMatrixGeneralDiagonallyDominant(i8* %217, i64 %218, i64 %219, i32 %220, double %221, double %222)
br label %224
224: ; preds = %216, %213, %210, %207
br label %225
225: ; preds = %224, %199
br label %226
226: ; preds = %225, %182
br label %227
227: ; preds = %226, %165
br label %228
228: ; preds = %227, %148
br label %229
229: ; preds = %228, %131
br label %230
230: ; preds = %229, %114
br label %231
231: ; preds = %230, %97
store i32 1, i32* %3
br label %232
232: ; preds = %231, %58
%233 = load i32, i32* %3
ret i32 %233
}

LLVM IR (-O2):
@.str = [10 x i8] c"rso:dl:m:\00"
@optarg = global i32 0
@optind = global i32 0
@.str.1 = [7 x i8] c"stdout\00"
define i32 @CreateDenseMatrix(i32 %0, i8** %1) {
%3 = tail call i32 @getopt(i32 %0, i8** %1, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i64 0, i64 0))
%4 = icmp sgt i32 %3, -1
br i1 %4, label %5, label %41
5: ; preds = %2, %32
%6 = phi i32 [ %39, %32 ], [ %3, %2 ]
%7 = phi i32 [ %38, %32 ], [ 0, %2 ]
%8 = phi i32 [ %37, %32 ], [ 0, %2 ]
%9 = phi i32 [ %36, %32 ], [ 0, %2 ]
%10 = phi double [ %35, %32 ], [ 1.000000e+00, %2 ]
%11 = phi double [ %34, %32 ], [ 0.000000e+00, %2 ]
%12 = phi i8* [ %33, %32 ], [ null, %2 ]
switch i32 %6, label %32 [
i32 111, label %13
i32 115, label %21
i32 114, label %22
i32 100, label %23
i32 108, label %24
i32 109, label %28
]
13: ; preds = %5
%14 = load i32, i32* @optarg
%15 = tail call i32 @strlen(i32 %14)
%16 = add i32 %15, 1
%17 = tail call i64 @malloc(i32 %16)
%18 = inttoptr i64 %17 to i8*
%19 = load i32, i32* @optarg
%20 = tail call i32 @strcpy(i8* %18, i32 %19)
br label %32
21: ; preds = %5
br label %32
22: ; preds = %5
br label %32
23: ; preds = %5
br label %32
24: ; preds = %5
%25 = load i32, i32* @optarg
%26 = tail call i64 @atof(i32 %25)
%27 = sitofp i64 %26 to double
br label %32
28: ; preds = %5
%29 = load i32, i32* @optarg
%30 = tail call i64 @atof(i32 %29)
%31 = sitofp i64 %30 to double
br label %32
32: ; preds = %5, %28, %24, %23, %22, %21, %13
%33 = phi i8* [ %12, %5 ], [ %12, %28 ], [ %12, %24 ], [ %12, %23 ], [ %12, %22 ], [ %12, %21 ], [ %18, %13 ]
%34 = phi double [ %11, %5 ], [ %11, %28 ], [ %27, %24 ], [ %11, %23 ], [ %11, %22 ], [ %11, %21 ], [ %11, %13 ]
%35 = phi double [ %10, %5 ], [ %31, %28 ], [ %10, %24 ], [ %10, %23 ], [ %10, %22 ], [ %10, %21 ], [ %10, %13 ]
%36 = phi i32 [ %9, %5 ], [ %9, %28 ], [ %9, %24 ], [ 1, %23 ], [ %9, %22 ], [ %9, %21 ], [ %9, %13 ]
%37 = phi i32 [ %8, %5 ], [ %8, %28 ], [ %8, %24 ], [ %8, %23 ], [ %8, %22 ], [ 1, %21 ], [ %8, %13 ]
%38 = phi i32 [ %7, %5 ], [ %7, %28 ], [ %7, %24 ], [ %7, %23 ], [ 1, %22 ], [ %7, %21 ], [ %7, %13 ]
%39 = tail call i32 @getopt(i32 %0, i8** %1, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i64 0, i64 0))
%40 = icmp sgt i32 %39, -1
br i1 %40, label %5, label %41
41: ; preds = %32, %2
%42 = phi i8* [ null, %2 ], [ %33, %32 ]
%43 = phi double [ 0.000000e+00, %2 ], [ %34, %32 ]
%44 = phi double [ 1.000000e+00, %2 ], [ %35, %32 ]
%45 = phi i32 [ 0, %2 ], [ %36, %32 ]
%46 = phi i32 [ 0, %2 ], [ %37, %32 ]
%47 = phi i32 [ 0, %2 ], [ %38, %32 ]
%48 = load i32, i32* @optind
%49 = add nsw i32 %48, 3
%50 = icmp sle i32 %49, %0
%51 = add nsw i32 %48, 4
%52 = icmp sgt i32 %51, %0
%53 = select i1 %50, i1 %52, i1 false
br i1 %53, label %56, label %54
54: ; preds = %41
%55 = tail call i32 (...) @usageCreateDenseMatrix()
br label %122
56: ; preds = %41
%57 = icmp eq i8* %42, null
br i1 %57, label %58, label %62
58: ; preds = %56
%59 = tail call i64 @malloc(i32 7)
%60 = inttoptr i64 %59 to i8*
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(7) %60, i8* align 1 dereferenceable(7) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), i64 7, i1 false)
%61 = load i32, i32* @optind
br label %62
62: ; preds = %58, %56
%63 = phi i32 [ %61, %58 ], [ %48, %56 ]
%64 = phi i8* [ %60, %58 ], [ %42, %56 ]
%65 = sext i32 %63 to i64
%66 = getelementptr inbounds i8*, i8** %1, i64 %65
%67 = load i8*, i8** %66
%68 = tail call i64 @atol(i8* %67)
%69 = add nsw i32 %63, 1
%70 = sext i32 %69 to i64
%71 = getelementptr inbounds i8*, i8** %1, i64 %70
%72 = load i8*, i8** %71
%73 = tail call i64 @atol(i8* %72)
%74 = add nsw i32 %63, 2
%75 = sext i32 %74 to i64
%76 = getelementptr inbounds i8*, i8** %1, i64 %75
%77 = load i8*, i8** %76
%78 = tail call i32 @atoi(i8* %77)
%79 = icmp ne i32 %46, 0
%80 = icmp ne i32 %47, 0
%81 = select i1 %79, i1 %80, i1 false
%82 = xor i1 %81, true
%83 = icmp ne i32 %45, 0
%84 = select i1 %82, i1 true, i1 %83
br i1 %84, label %87, label %85
85: ; preds = %62
%86 = tail call i32 @CreateDenseMatrixSymmetricRowLine(i8* %64, i64 %68, i64 %73, i32 %78, double %43, double %44)
br label %122
87: ; preds = %62
%88 = icmp eq i32 %46, 0
%89 = select i1 %88, i1 %80, i1 false
%90 = xor i1 %89, true
%91 = select i1 %90, i1 true, i1 %83
br i1 %91, label %94, label %92
92: ; preds = %87
%93 = tail call i32 @CreateDenseMatrixGeneralRowLine(i8* %64, i64 %68, i64 %73, i32 %78, double %43, double %44)
br label %122
94: ; preds = %87
%95 = select i1 %88, i1 true, i1 %80
%96 = select i1 %95, i1 true, i1 %83
br i1 %96, label %99, label %97
97: ; preds = %94
%98 = tail call i32 @CreateDenseMatrixSymmetric(i8* %64, i64 %68, i64 %73, i32 %78, double %43, double %44)
br label %122
99: ; preds = %94
%100 = select i1 %79, i1 true, i1 %80
%101 = select i1 %100, i1 true, i1 %83
br i1 %101, label %104, label %102
102: ; preds = %99
%103 = tail call i32 @CreateDenseMatrixGeneral(i8* %64, i64 %68, i64 %73, i32 %78, double %43, double %44)
br label %122
104: ; preds = %99
%105 = select i1 %81, i1 %83, i1 false
br i1 %105, label %106, label %108
106: ; preds = %104
%107 = tail call i32 @CreateDenseMatrixSymmetricDiagonallyDominantRowLine(i8* %64, i64 %68, i64 %73, i32 %78, double %43, double %44)
br label %122
108: ; preds = %104
%109 = select i1 %89, i1 %83, i1 false
br i1 %109, label %110, label %112
110: ; preds = %108
%111 = tail call i32 @CreateDenseMatrixGeneralDiagonallyDominantRowLine(i8* %64, i64 %68, i64 %73, i32 %78, double %43, double %44)
br label %122
112: ; preds = %108
%113 = xor i1 %95, true
%114 = select i1 %113, i1 %83, i1 false
br i1 %114, label %115, label %117
115: ; preds = %112
%116 = tail call i32 @CreateDenseMatrixSymmetricDiagonallyDominant(i8* %64, i64 %68, i64 %73, i32 %78, double %43, double %44)
br label %122
117: ; preds = %112
%118 = xor i1 %100, true
%119 = select i1 %118, i1 %83, i1 false
br i1 %119, label %120, label %122
120: ; preds = %117
%121 = tail call i32 @CreateDenseMatrixGeneralDiagonallyDominant(i8* %64, i64 %68, i64 %73, i32 %78, double %43, double %44)
br label %122
122: ; preds = %85, %97, %106, %115, %120, %117, %110, %102, %92, %54
%123 = phi i32 [ 0, %54 ], [ 1, %92 ], [ 1, %102 ], [ 1, %110 ], [ 1, %117 ], [ 1, %120 ], [ 1, %115 ], [ 1, %106 ], [ 1, %97 ], [ 1, %85 ]
ret i32 %123
}