#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 */
scalar_t__ RAND_MAX;
int do_rand(int);
scalar_t__ rand();
void init_table(char **t, int *p, int n, int k, int p2) {
  int m, i, j, add_o;
  add_o = 6;
  double d;
  d = (double)rand() / ((double)RAND_MAX + 1);
  d = d * 4;
  m = (int)d;
  if (m == 0) {
    t[0][0] = 'M';
    *p = 0;
    *(p + 1) = 0;
  } else if (m == 1) {
    t[0][k - 1] = 'M';
    *p = 0;
    *(p + 1) = k - 1;
  } else if (m == 2) {
    t[n - 1][0] = 'M';
    *p = n - 1;
    *(p + 1) = 0;
  } else {
    t[n - 1][k - 1] = 'M';
    *p = n - 1;
    *(p + 1) = k - 1;
  }
  do {
    (*(p + 2)) = do_rand(n);
    *(p + 3) = do_rand(k);
  } while (t[*(p + 2)][*(p + 3)] == 'M');
  t[*(p + 2)][*(p + 3)] = 'S';
  do {
    (*(p + 4)) = do_rand(n);
    *(p + 5) = do_rand(k);
  } while (t[*(p + 4)][*(p + 5)] == 'M' || t[*(p + 4)][*(p + 5)] == 'S');
  t[*(p + 4)][*(p + 5)] = 'G';
  while (add_o <= p2 + 6) {
    do {
      *(p + add_o) = do_rand(n);
      *(p + add_o + 1) = do_rand(k);
    } while ((t[*(p + add_o)][*(p + add_o + 1)] == 'M' ||
              t[*(p + add_o)][*(p + add_o + 1)] == 'S' ||
              t[*(p + add_o)][*(p + add_o + 1)] == 'G'));
    t[*(p + add_o)][*(p + add_o + 1)] = 'O';
    add_o += 2;
  }
  for (i = 0; i < n; i++) {
    for (j = 0; j < k; j++) {
      if (t[i][j] != 'M' && t[i][j] != 'S' && t[i][j] != 'G' && t[i][j] != 'O')
        t[i][j] = '#';
    }
  }
}


x86 assembly (clang, -O0):
<init_table>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
mov    %r8d,-0x1c(%rbp)
movl   $0x6,-0x2c(%rbp)
mov    $0x0,%al
call   1040 <rand@plt>
cvtsi2sd %rax,%xmm0
mov    0x2e94(%rip),%rax
cvtsi2sdq (%rax),%xmm1
movsd  0xea7(%rip),%xmm2
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  0xe8a(%rip),%xmm0
mulsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x38(%rbp)
cvttsd2si -0x38(%rbp),%eax
mov    %eax,-0x20(%rbp)
cmpl   $0x0,-0x20(%rbp)
jne    11b6 <init_table+0x96>
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
movb   $0x4d,(%rax)
mov    -0x10(%rbp),%rax
movl   $0x0,(%rax)
mov    -0x10(%rbp),%rax
movl   $0x0,0x4(%rax)
jmp    126b <init_table+0x14b>
cmpl   $0x1,-0x20(%rbp)
jne    11f0 <init_table+0xd0>
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movb   $0x4d,(%rax,%rcx,1)
mov    -0x10(%rbp),%rax
movl   $0x0,(%rax)
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x10(%rbp),%rax
mov    %ecx,0x4(%rax)
jmp    1266 <init_table+0x146>
cmpl   $0x2,-0x20(%rbp)
jne    122a <init_table+0x10a>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movb   $0x4d,(%rax)
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x10(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x10(%rbp),%rax
movl   $0x0,0x4(%rax)
jmp    1261 <init_table+0x141>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movb   $0x4d,(%rax,%rcx,1)
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x10(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x10(%rbp),%rax
mov    %ecx,0x4(%rax)
jmp    1266 <init_table+0x146>
jmp    126b <init_table+0x14b>
jmp    1270 <init_table+0x150>
mov    -0x14(%rbp),%edi
call   1030 <do_rand@plt>
mov    %eax,%ecx
mov    -0x10(%rbp),%rax
mov    %ecx,0x8(%rax)
mov    -0x18(%rbp),%edi
call   1030 <do_rand@plt>
mov    %eax,%ecx
mov    -0x10(%rbp),%rax
mov    %ecx,0xc(%rax)
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%rcx
movslq 0x8(%rcx),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x10(%rbp),%rcx
movslq 0xc(%rcx),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x4d,%eax
je     1270 <init_table+0x150>
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%rcx
movslq 0x8(%rcx),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x10(%rbp),%rcx
movslq 0xc(%rcx),%rcx
movb   $0x53,(%rax,%rcx,1)
mov    -0x14(%rbp),%edi
call   1030 <do_rand@plt>
mov    %eax,%ecx
mov    -0x10(%rbp),%rax
mov    %ecx,0x10(%rax)
mov    -0x18(%rbp),%edi
call   1030 <do_rand@plt>
mov    %eax,%ecx
mov    -0x10(%rbp),%rax
mov    %ecx,0x14(%rax)
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%rcx
movslq 0x10(%rcx),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x10(%rbp),%rcx
movslq 0x14(%rcx),%rcx
movsbl (%rax,%rcx,1),%ecx
mov    $0x1,%al
cmp    $0x4d,%ecx
mov    %al,-0x39(%rbp)
je     1344 <init_table+0x224>
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%rcx
movslq 0x10(%rcx),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x10(%rbp),%rcx
movslq 0x14(%rcx),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x53,%eax
sete   %al
mov    %al,-0x39(%rbp)
mov    -0x39(%rbp),%al
test   $0x1,%al
jne    12d3 <init_table+0x1b3>
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%rcx
movslq 0x10(%rcx),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x10(%rbp),%rcx
movslq 0x14(%rcx),%rcx
movb   $0x47,(%rax,%rcx,1)
mov    -0x2c(%rbp),%eax
mov    -0x1c(%rbp),%ecx
add    $0x6,%ecx
cmp    %ecx,%eax
jg     147e <init_table+0x35e>
jmp    1381 <init_table+0x261>
mov    -0x14(%rbp),%edi
call   1030 <do_rand@plt>
mov    %eax,%edx
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x18(%rbp),%edi
call   1030 <do_rand@plt>
mov    %eax,%edx
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %edx,0x4(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x10(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
movslq 0x4(%rcx,%rdx,4),%rcx
movsbl (%rax,%rcx,1),%ecx
mov    $0x1,%al
cmp    $0x4d,%ecx
mov    %al,-0x3a(%rbp)
je     1440 <init_table+0x320>
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x10(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
movslq 0x4(%rcx,%rdx,4),%rcx
movsbl (%rax,%rcx,1),%ecx
mov    $0x1,%al
cmp    $0x53,%ecx
mov    %al,-0x3a(%rbp)
je     1440 <init_table+0x320>
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x10(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
movslq 0x4(%rcx,%rdx,4),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x47,%eax
sete   %al
mov    %al,-0x3a(%rbp)
mov    -0x3a(%rbp),%al
test   $0x1,%al
jne    1381 <init_table+0x261>
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x10(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
movslq 0x4(%rcx,%rdx,4),%rcx
movb   $0x4f,(%rax,%rcx,1)
mov    -0x2c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x2c(%rbp)
jmp    136b <init_table+0x24b>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1552 <init_table+0x432>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    153f <init_table+0x41f>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x4d,%eax
je     152c <init_table+0x40c>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x53,%eax
je     152c <init_table+0x40c>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x47,%eax
je     152c <init_table+0x40c>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x4f,%eax
je     152c <init_table+0x40c>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movb   $0x23,(%rax,%rcx,1)
jmp    1531 <init_table+0x411>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1498 <init_table+0x378>
jmp    1544 <init_table+0x424>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1485 <init_table+0x365>
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<init_table>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %r8d,%r13d
mov    %ecx,%r14d
mov    %edx,%r12d
mov    %rsi,%rbx
mov    %rdi,%r15
xor    %ebp,%ebp
xor    %eax,%eax
call   1040 <rand@plt>
cvtsi2sd %rax,%xmm0
mov    0x2e99(%rip),%rax
cvtsi2sdq (%rax),%xmm1
addsd  0xea4(%rip),%xmm1
divsd  %xmm1,%xmm0
mulsd  0xea0(%rip),%xmm0
cvttsd2si %xmm0,%eax
cmp    $0x2,%eax
je     1183 <init_table+0x63>
cmp    $0x1,%eax
je     1192 <init_table+0x72>
test   %eax,%eax
jne    11a7 <init_table+0x87>
mov    (%r15),%rcx
xor    %eax,%eax
xor    %ebp,%ebp
jmp    11c2 <init_table+0xa2>
lea    -0x1(%r12),%eax
movslq %r12d,%rcx
mov    -0x8(%r15,%rcx,8),%rcx
jmp    11c2 <init_table+0xa2>
mov    (%r15),%rax
lea    -0x1(%r14),%ebp
movslq %r14d,%rcx
add    %rax,%rcx
add    $0xffffffffffffffff,%rcx
xor    %eax,%eax
jmp    11c2 <init_table+0xa2>
lea    -0x1(%r12),%eax
movslq %r12d,%rcx
mov    -0x8(%r15,%rcx,8),%rcx
lea    -0x1(%r14),%ebp
movslq %r14d,%rdx
add    %rdx,%rcx
add    $0xffffffffffffffff,%rcx
movb   $0x4d,(%rcx)
mov    %eax,(%rbx)
mov    %ebp,0x4(%rbx)
nopw   0x0(%rax,%rax,1)
mov    %r12d,%edi
call   1030 <do_rand@plt>
mov    %eax,0x8(%rbx)
mov    %r14d,%edi
call   1030 <do_rand@plt>
mov    %eax,0xc(%rbx)
movslq 0x8(%rbx),%rcx
mov    (%r15,%rcx,8),%rcx
cltq
cmpb   $0x4d,(%rcx,%rax,1)
je     11d0 <init_table+0xb0>
movb   $0x53,(%rcx,%rax,1)
nopw   0x0(%rax,%rax,1)
mov    %r12d,%edi
call   1030 <do_rand@plt>
mov    %eax,0x10(%rbx)
mov    %r14d,%edi
call   1030 <do_rand@plt>
mov    %eax,0x14(%rbx)
movslq 0x10(%rbx),%rcx
mov    (%r15,%rcx,8),%rcx
cltq
movzbl (%rcx,%rax,1),%edx
cmp    $0x4d,%dl
je     1200 <init_table+0xe0>
cmp    $0x53,%dl
je     1200 <init_table+0xe0>
movb   $0x47,(%rcx,%rax,1)
test   %r13d,%r13d
js     129a <init_table+0x17a>
add    $0x4,%r13d
movslq %r13d,%rax
mov    %rax,(%rsp)
mov    $0x6,%r13d
mov    $0x1041,%ebp
jmp    1260 <init_table+0x140>
movb   $0x4f,(%rcx,%rax,1)
lea    0x2(%r13),%rax
cmp    (%rsp),%r13
mov    %rax,%r13
jg     129a <init_table+0x17a>
mov    %r12d,%edi
call   1030 <do_rand@plt>
mov    %eax,(%rbx,%r13,4)
mov    %r14d,%edi
call   1030 <do_rand@plt>
mov    %eax,0x4(%rbx,%r13,4)
movslq (%rbx,%r13,4),%rcx
mov    (%r15,%rcx,8),%rcx
cltq
movzbl (%rcx,%rax,1),%edx
add    $0xb9,%dl
cmp    $0xc,%dl
ja     124f <init_table+0x12f>
movzbl %dl,%edx
bt     %rdx,%rbp
jb     1260 <init_table+0x140>
jmp    124f <init_table+0x12f>
test   %r12d,%r12d
jle    1346 <init_table+0x226>
mov    %r12d,%eax
mov    %r14d,%r8d
mov    %r8d,%edx
and    $0xfffffffe,%edx
xor    %esi,%esi
mov    $0x59,%edi
jmp    12c9 <init_table+0x1a9>
movb   $0x23,(%rbx,%rbp,1)
nopl   0x0(%rax)
add    $0x1,%rsi
cmp    %rax,%rsi
je     1346 <init_table+0x226>
test   %r14d,%r14d
jle    12c0 <init_table+0x1a0>
xor    %ebp,%ebp
cmp    $0x1,%r14d
jne    1309 <init_table+0x1e9>
test   $0x1,%r8b
je     12c0 <init_table+0x1a0>
mov    (%r15,%rsi,8),%rbx
mov    (%rbx,%rbp,1),%cl
add    $0xb9,%cl
ror    %cl
cmp    $0x6,%cl
ja     12b8 <init_table+0x198>
movzbl %cl,%ecx
bt     %ecx,%edi
jb     12c0 <init_table+0x1a0>
jmp    12b8 <init_table+0x198>
movb   $0x23,0x1(%rbx,%rbp,1)
nopl   0x0(%rax)
add    $0x2,%rbp
cmp    %rbp,%rdx
je     12d6 <init_table+0x1b6>
mov    (%r15,%rsi,8),%rbx
movzbl (%rbx,%rbp,1),%ecx
add    $0xb9,%cl
ror    %cl
cmp    $0x6,%cl
ja     1340 <init_table+0x220>
movzbl %cl,%ecx
bt     %ecx,%edi
jae    1340 <init_table+0x220>
mov    (%r15,%rsi,8),%rbx
movzbl 0x1(%rbx,%rbp,1),%ecx
add    $0xb9,%cl
ror    %cl
cmp    $0x6,%cl
ja     12f7 <init_table+0x1d7>
movzbl %cl,%ecx
bt     %ecx,%edi
jb     1300 <init_table+0x1e0>
jmp    12f7 <init_table+0x1d7>
movb   $0x23,(%rbx,%rbp,1)
jmp    1323 <init_table+0x203>
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@RAND_MAX = global i64 0
define void @init_table(i8** %0, i32* %1, i32 %2, i32 %3, i32 %4) {
%6 = alloca i8**
%7 = alloca i32*
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca double
store i8** %0, i8*** %6
store i32* %1, i32** %7
store i32 %2, i32* %8
store i32 %3, i32* %9
store i32 %4, i32* %10
store i32 6, i32* %14
%16 = call i64 (...) @rand()
%17 = sitofp i64 %16 to double
%18 = load i64, i64* @RAND_MAX
%19 = sitofp i64 %18 to double
%20 = fadd double %19, 1.000000e+00
%21 = fdiv double %17, %20
store double %21, double* %15
%22 = load double, double* %15
%23 = fmul double %22, 4.000000e+00
store double %23, double* %15
%24 = load double, double* %15
%25 = fptosi double %24 to i32
store i32 %25, i32* %11
%26 = load i32, i32* %11
%27 = icmp eq i32 %26, 0
br i1 %27, label %28, label %36
28: ; preds = %5
%29 = load i8**, i8*** %6
%30 = getelementptr inbounds i8*, i8** %29, i64 0
%31 = load i8*, i8** %30
%32 = getelementptr inbounds i8, i8* %31, i64 0
store i8 77, i8* %32
%33 = load i32*, i32** %7
store i32 0, i32* %33
%34 = load i32*, i32** %7
%35 = getelementptr inbounds i32, i32* %34, i64 1
store i32 0, i32* %35
br label %88
36: ; preds = %5
%37 = load i32, i32* %11
%38 = icmp eq i32 %37, 1
br i1 %38, label %39, label %52
39: ; preds = %36
%40 = load i8**, i8*** %6
%41 = getelementptr inbounds i8*, i8** %40, i64 0
%42 = load i8*, i8** %41
%43 = load i32, i32* %9
%44 = sub nsw i32 %43, 1
%45 = sext i32 %44 to i64
%46 = getelementptr inbounds i8, i8* %42, i64 %45
store i8 77, i8* %46
%47 = load i32*, i32** %7
store i32 0, i32* %47
%48 = load i32, i32* %9
%49 = sub nsw i32 %48, 1
%50 = load i32*, i32** %7
%51 = getelementptr inbounds i32, i32* %50, i64 1
store i32 %49, i32* %51
br label %87
52: ; preds = %36
%53 = load i32, i32* %11
%54 = icmp eq i32 %53, 2
br i1 %54, label %55, label %68
55: ; preds = %52
%56 = load i8**, i8*** %6
%57 = load i32, i32* %8
%58 = sub nsw i32 %57, 1
%59 = sext i32 %58 to i64
%60 = getelementptr inbounds i8*, i8** %56, i64 %59
%61 = load i8*, i8** %60
%62 = getelementptr inbounds i8, i8* %61, i64 0
store i8 77, i8* %62
%63 = load i32, i32* %8
%64 = sub nsw i32 %63, 1
%65 = load i32*, i32** %7
store i32 %64, i32* %65
%66 = load i32*, i32** %7
%67 = getelementptr inbounds i32, i32* %66, i64 1
store i32 0, i32* %67
br label %86
68: ; preds = %52
%69 = load i8**, i8*** %6
%70 = load i32, i32* %8
%71 = sub nsw i32 %70, 1
%72 = sext i32 %71 to i64
%73 = getelementptr inbounds i8*, i8** %69, i64 %72
%74 = load i8*, i8** %73
%75 = load i32, i32* %9
%76 = sub nsw i32 %75, 1
%77 = sext i32 %76 to i64
%78 = getelementptr inbounds i8, i8* %74, i64 %77
store i8 77, i8* %78
%79 = load i32, i32* %8
%80 = sub nsw i32 %79, 1
%81 = load i32*, i32** %7
store i32 %80, i32* %81
%82 = load i32, i32* %9
%83 = sub nsw i32 %82, 1
%84 = load i32*, i32** %7
%85 = getelementptr inbounds i32, i32* %84, i64 1
store i32 %83, i32* %85
br label %86
86: ; preds = %68, %55
br label %87
87: ; preds = %86, %39
br label %88
88: ; preds = %87, %28
br label %89
89: ; preds = %98, %88
%90 = load i32, i32* %8
%91 = call i32 @do_rand(i32 %90)
%92 = load i32*, i32** %7
%93 = getelementptr inbounds i32, i32* %92, i64 2
store i32 %91, i32* %93
%94 = load i32, i32* %9
%95 = call i32 @do_rand(i32 %94)
%96 = load i32*, i32** %7
%97 = getelementptr inbounds i32, i32* %96, i64 3
store i32 %95, i32* %97
br label %98
98: ; preds = %89
%99 = load i8**, i8*** %6
%100 = load i32*, i32** %7
%101 = getelementptr inbounds i32, i32* %100, i64 2
%102 = load i32, i32* %101
%103 = sext i32 %102 to i64
%104 = getelementptr inbounds i8*, i8** %99, i64 %103
%105 = load i8*, i8** %104
%106 = load i32*, i32** %7
%107 = getelementptr inbounds i32, i32* %106, i64 3
%108 = load i32, i32* %107
%109 = sext i32 %108 to i64
%110 = getelementptr inbounds i8, i8* %105, i64 %109
%111 = load i8, i8* %110
%112 = sext i8 %111 to i32
%113 = icmp eq i32 %112, 77
br i1 %113, label %89, label %114
114: ; preds = %98
%115 = load i8**, i8*** %6
%116 = load i32*, i32** %7
%117 = getelementptr inbounds i32, i32* %116, i64 2
%118 = load i32, i32* %117
%119 = sext i32 %118 to i64
%120 = getelementptr inbounds i8*, i8** %115, i64 %119
%121 = load i8*, i8** %120
%122 = load i32*, i32** %7
%123 = getelementptr inbounds i32, i32* %122, i64 3
%124 = load i32, i32* %123
%125 = sext i32 %124 to i64
%126 = getelementptr inbounds i8, i8* %121, i64 %125
store i8 83, i8* %126
br label %127
127: ; preds = %168, %114
%128 = load i32, i32* %8
%129 = call i32 @do_rand(i32 %128)
%130 = load i32*, i32** %7
%131 = getelementptr inbounds i32, i32* %130, i64 4
store i32 %129, i32* %131
%132 = load i32, i32* %9
%133 = call i32 @do_rand(i32 %132)
%134 = load i32*, i32** %7
%135 = getelementptr inbounds i32, i32* %134, i64 5
store i32 %133, i32* %135
br label %136
136: ; preds = %127
%137 = load i8**, i8*** %6
%138 = load i32*, i32** %7
%139 = getelementptr inbounds i32, i32* %138, i64 4
%140 = load i32, i32* %139
%141 = sext i32 %140 to i64
%142 = getelementptr inbounds i8*, i8** %137, i64 %141
%143 = load i8*, i8** %142
%144 = load i32*, i32** %7
%145 = getelementptr inbounds i32, i32* %144, i64 5
%146 = load i32, i32* %145
%147 = sext i32 %146 to i64
%148 = getelementptr inbounds i8, i8* %143, i64 %147
%149 = load i8, i8* %148
%150 = sext i8 %149 to i32
%151 = icmp eq i32 %150, 77
br i1 %151, label %168, label %152
152: ; preds = %136
%153 = load i8**, i8*** %6
%154 = load i32*, i32** %7
%155 = getelementptr inbounds i32, i32* %154, i64 4
%156 = load i32, i32* %155
%157 = sext i32 %156 to i64
%158 = getelementptr inbounds i8*, i8** %153, i64 %157
%159 = load i8*, i8** %158
%160 = load i32*, i32** %7
%161 = getelementptr inbounds i32, i32* %160, i64 5
%162 = load i32, i32* %161
%163 = sext i32 %162 to i64
%164 = getelementptr inbounds i8, i8* %159, i64 %163
%165 = load i8, i8* %164
%166 = sext i8 %165 to i32
%167 = icmp eq i32 %166, 83
br label %168
168: ; preds = %152, %136
%169 = phi i1 [ true, %136 ], [ %167, %152 ]
br i1 %169, label %127, label %170
170: ; preds = %168
%171 = load i8**, i8*** %6
%172 = load i32*, i32** %7
%173 = getelementptr inbounds i32, i32* %172, i64 4
%174 = load i32, i32* %173
%175 = sext i32 %174 to i64
%176 = getelementptr inbounds i8*, i8** %171, i64 %175
%177 = load i8*, i8** %176
%178 = load i32*, i32** %7
%179 = getelementptr inbounds i32, i32* %178, i64 5
%180 = load i32, i32* %179
%181 = sext i32 %180 to i64
%182 = getelementptr inbounds i8, i8* %177, i64 %181
store i8 71, i8* %182
br label %183
183: ; preds = %268, %170
%184 = load i32, i32* %14
%185 = load i32, i32* %10
%186 = add nsw i32 %185, 6
%187 = icmp sle i32 %184, %186
br i1 %187, label %188, label %288
188: ; preds = %183
br label %189
189: ; preds = %266, %188
%190 = load i32, i32* %8
%191 = call i32 @do_rand(i32 %190)
%192 = load i32*, i32** %7
%193 = load i32, i32* %14
%194 = sext i32 %193 to i64
%195 = getelementptr inbounds i32, i32* %192, i64 %194
store i32 %191, i32* %195
%196 = load i32, i32* %9
%197 = call i32 @do_rand(i32 %196)
%198 = load i32*, i32** %7
%199 = load i32, i32* %14
%200 = sext i32 %199 to i64
%201 = getelementptr inbounds i32, i32* %198, i64 %200
%202 = getelementptr inbounds i32, i32* %201, i64 1
store i32 %197, i32* %202
br label %203
203: ; preds = %189
%204 = load i8**, i8*** %6
%205 = load i32*, i32** %7
%206 = load i32, i32* %14
%207 = sext i32 %206 to i64
%208 = getelementptr inbounds i32, i32* %205, i64 %207
%209 = load i32, i32* %208
%210 = sext i32 %209 to i64
%211 = getelementptr inbounds i8*, i8** %204, i64 %210
%212 = load i8*, i8** %211
%213 = load i32*, i32** %7
%214 = load i32, i32* %14
%215 = sext i32 %214 to i64
%216 = getelementptr inbounds i32, i32* %213, i64 %215
%217 = getelementptr inbounds i32, i32* %216, i64 1
%218 = load i32, i32* %217
%219 = sext i32 %218 to i64
%220 = getelementptr inbounds i8, i8* %212, i64 %219
%221 = load i8, i8* %220
%222 = sext i8 %221 to i32
%223 = icmp eq i32 %222, 77
br i1 %223, label %266, label %224
224: ; preds = %203
%225 = load i8**, i8*** %6
%226 = load i32*, i32** %7
%227 = load i32, i32* %14
%228 = sext i32 %227 to i64
%229 = getelementptr inbounds i32, i32* %226, i64 %228
%230 = load i32, i32* %229
%231 = sext i32 %230 to i64
%232 = getelementptr inbounds i8*, i8** %225, i64 %231
%233 = load i8*, i8** %232
%234 = load i32*, i32** %7
%235 = load i32, i32* %14
%236 = sext i32 %235 to i64
%237 = getelementptr inbounds i32, i32* %234, i64 %236
%238 = getelementptr inbounds i32, i32* %237, i64 1
%239 = load i32, i32* %238
%240 = sext i32 %239 to i64
%241 = getelementptr inbounds i8, i8* %233, i64 %240
%242 = load i8, i8* %241
%243 = sext i8 %242 to i32
%244 = icmp eq i32 %243, 83
br i1 %244, label %266, label %245
245: ; preds = %224
%246 = load i8**, i8*** %6
%247 = load i32*, i32** %7
%248 = load i32, i32* %14
%249 = sext i32 %248 to i64
%250 = getelementptr inbounds i32, i32* %247, i64 %249
%251 = load i32, i32* %250
%252 = sext i32 %251 to i64
%253 = getelementptr inbounds i8*, i8** %246, i64 %252
%254 = load i8*, i8** %253
%255 = load i32*, i32** %7
%256 = load i32, i32* %14
%257 = sext i32 %256 to i64
%258 = getelementptr inbounds i32, i32* %255, i64 %257
%259 = getelementptr inbounds i32, i32* %258, i64 1
%260 = load i32, i32* %259
%261 = sext i32 %260 to i64
%262 = getelementptr inbounds i8, i8* %254, i64 %261
%263 = load i8, i8* %262
%264 = sext i8 %263 to i32
%265 = icmp eq i32 %264, 71
br label %266
266: ; preds = %245, %224, %203
%267 = phi i1 [ true, %224 ], [ true, %203 ], [ %265, %245 ]
br i1 %267, label %189, label %268
268: ; preds = %266
%269 = load i8**, i8*** %6
%270 = load i32*, i32** %7
%271 = load i32, i32* %14
%272 = sext i32 %271 to i64
%273 = getelementptr inbounds i32, i32* %270, i64 %272
%274 = load i32, i32* %273
%275 = sext i32 %274 to i64
%276 = getelementptr inbounds i8*, i8** %269, i64 %275
%277 = load i8*, i8** %276
%278 = load i32*, i32** %7
%279 = load i32, i32* %14
%280 = sext i32 %279 to i64
%281 = getelementptr inbounds i32, i32* %278, i64 %280
%282 = getelementptr inbounds i32, i32* %281, i64 1
%283 = load i32, i32* %282
%284 = sext i32 %283 to i64
%285 = getelementptr inbounds i8, i8* %277, i64 %284
store i8 79, i8* %285
%286 = load i32, i32* %14
%287 = add nsw i32 %286, 2
store i32 %287, i32* %14
br label %183
288: ; preds = %183
store i32 0, i32* %12
br label %289
289: ; preds = %360, %288
%290 = load i32, i32* %12
%291 = load i32, i32* %8
%292 = icmp slt i32 %290, %291
br i1 %292, label %293, label %363
293: ; preds = %289
store i32 0, i32* %13
br label %294
294: ; preds = %356, %293
%295 = load i32, i32* %13
%296 = load i32, i32* %9
%297 = icmp slt i32 %295, %296
br i1 %297, label %298, label %359
298: ; preds = %294
%299 = load i8**, i8*** %6
%300 = load i32, i32* %12
%301 = sext i32 %300 to i64
%302 = getelementptr inbounds i8*, i8** %299, i64 %301
%303 = load i8*, i8** %302
%304 = load i32, i32* %13
%305 = sext i32 %304 to i64
%306 = getelementptr inbounds i8, i8* %303, i64 %305
%307 = load i8, i8* %306
%308 = sext i8 %307 to i32
%309 = icmp ne i32 %308, 77
br i1 %309, label %310, label %355
310: ; preds = %298
%311 = load i8**, i8*** %6
%312 = load i32, i32* %12
%313 = sext i32 %312 to i64
%314 = getelementptr inbounds i8*, i8** %311, i64 %313
%315 = load i8*, i8** %314
%316 = load i32, i32* %13
%317 = sext i32 %316 to i64
%318 = getelementptr inbounds i8, i8* %315, i64 %317
%319 = load i8, i8* %318
%320 = sext i8 %319 to i32
%321 = icmp ne i32 %320, 83
br i1 %321, label %322, label %355
322: ; preds = %310
%323 = load i8**, i8*** %6
%324 = load i32, i32* %12
%325 = sext i32 %324 to i64
%326 = getelementptr inbounds i8*, i8** %323, i64 %325
%327 = load i8*, i8** %326
%328 = load i32, i32* %13
%329 = sext i32 %328 to i64
%330 = getelementptr inbounds i8, i8* %327, i64 %329
%331 = load i8, i8* %330
%332 = sext i8 %331 to i32
%333 = icmp ne i32 %332, 71
br i1 %333, label %334, label %355
334: ; preds = %322
%335 = load i8**, i8*** %6
%336 = load i32, i32* %12
%337 = sext i32 %336 to i64
%338 = getelementptr inbounds i8*, i8** %335, i64 %337
%339 = load i8*, i8** %338
%340 = load i32, i32* %13
%341 = sext i32 %340 to i64
%342 = getelementptr inbounds i8, i8* %339, i64 %341
%343 = load i8, i8* %342
%344 = sext i8 %343 to i32
%345 = icmp ne i32 %344, 79
br i1 %345, label %346, label %355
346: ; preds = %334
%347 = load i8**, i8*** %6
%348 = load i32, i32* %12
%349 = sext i32 %348 to i64
%350 = getelementptr inbounds i8*, i8** %347, i64 %349
%351 = load i8*, i8** %350
%352 = load i32, i32* %13
%353 = sext i32 %352 to i64
%354 = getelementptr inbounds i8, i8* %351, i64 %353
store i8 35, i8* %354
br label %355
355: ; preds = %346, %334, %322, %310, %298
br label %356
356: ; preds = %355
%357 = load i32, i32* %13
%358 = add nsw i32 %357, 1
store i32 %358, i32* %13
br label %294
359: ; preds = %294
br label %360
360: ; preds = %359
%361 = load i32, i32* %12
%362 = add nsw i32 %361, 1
store i32 %362, i32* %12
br label %289
363: ; preds = %289
ret void
}

LLVM IR (-O2):
@RAND_MAX = global i64 0
define void @init_table(i8** nocapture %0, i32* nocapture %1, i32 %2, i32 %3, i32 %4) {
%6 = tail call i64 (...) @rand()
%7 = sitofp i64 %6 to double
%8 = load i64, i64* @RAND_MAX
%9 = sitofp i64 %8 to double
%10 = fadd double %9, 1.000000e+00
%11 = fdiv double %7, %10
%12 = fmul double %11, 4.000000e+00
%13 = fptosi double %12 to i32
switch i32 %13, label %26 [
i32 0, label %14
i32 1, label %16
i32 2, label %21
]
14: ; preds = %5
%15 = load i8*, i8** %0
br label %34
16: ; preds = %5
%17 = load i8*, i8** %0
%18 = add nsw i32 %3, -1
%19 = sext i32 %18 to i64
%20 = getelementptr inbounds i8, i8* %17, i64 %19
br label %34
21: ; preds = %5
%22 = add nsw i32 %2, -1
%23 = sext i32 %22 to i64
%24 = getelementptr inbounds i8*, i8** %0, i64 %23
%25 = load i8*, i8** %24
br label %34
26: ; preds = %5
%27 = add nsw i32 %2, -1
%28 = sext i32 %27 to i64
%29 = getelementptr inbounds i8*, i8** %0, i64 %28
%30 = load i8*, i8** %29
%31 = add nsw i32 %3, -1
%32 = sext i32 %31 to i64
%33 = getelementptr inbounds i8, i8* %30, i64 %32
br label %34
34: ; preds = %16, %26, %21, %14
%35 = phi i8* [ %20, %16 ], [ %33, %26 ], [ %25, %21 ], [ %15, %14 ]
%36 = phi i32 [ 0, %16 ], [ %27, %26 ], [ %22, %21 ], [ 0, %14 ]
%37 = phi i32 [ %18, %16 ], [ %31, %26 ], [ 0, %21 ], [ 0, %14 ]
store i8 77, i8* %35
store i32 %36, i32* %1
%38 = getelementptr inbounds i32, i32* %1, i64 1
store i32 %37, i32* %38
%39 = getelementptr inbounds i32, i32* %1, i64 2
%40 = getelementptr inbounds i32, i32* %1, i64 3
br label %41
41: ; preds = %41, %34
%42 = tail call i32 @do_rand(i32 %2)
store i32 %42, i32* %39
%43 = tail call i32 @do_rand(i32 %3)
store i32 %43, i32* %40
%44 = load i32, i32* %39
%45 = sext i32 %44 to i64
%46 = getelementptr inbounds i8*, i8** %0, i64 %45
%47 = load i8*, i8** %46
%48 = sext i32 %43 to i64
%49 = getelementptr inbounds i8, i8* %47, i64 %48
%50 = load i8, i8* %49
%51 = icmp eq i8 %50, 77
br i1 %51, label %41, label %52
52: ; preds = %41
%53 = getelementptr inbounds i8, i8* %47, i64 %48
store i8 83, i8* %53
%54 = getelementptr inbounds i32, i32* %1, i64 4
%55 = getelementptr inbounds i32, i32* %1, i64 5
br label %56
56: ; preds = %66, %52
%57 = tail call i32 @do_rand(i32 %2)
store i32 %57, i32* %54
%58 = tail call i32 @do_rand(i32 %3)
store i32 %58, i32* %55
%59 = load i32, i32* %54
%60 = sext i32 %59 to i64
%61 = getelementptr inbounds i8*, i8** %0, i64 %60
%62 = load i8*, i8** %61
%63 = sext i32 %58 to i64
%64 = getelementptr inbounds i8, i8* %62, i64 %63
%65 = load i8, i8* %64
switch i8 %65, label %67 [
i8 77, label %66
i8 83, label %66
]
66: ; preds = %56, %56
br label %56
67: ; preds = %56
%68 = getelementptr inbounds i8, i8* %62, i64 %63
store i8 71, i8* %68
%69 = icmp slt i32 %4, 0
br i1 %69, label %77, label %70
70: ; preds = %67
%71 = add nsw i32 %4, 4
%72 = sext i32 %71 to i64
br label %73
73: ; preds = %70, %98
%74 = phi i64 [ 6, %70 ], [ %100, %98 ]
%75 = getelementptr inbounds i32, i32* %1, i64 %74
%76 = getelementptr inbounds i32, i32* %75, i64 1
br label %87
77: ; preds = %98, %67
%78 = icmp sgt i32 %2, 0
br i1 %78, label %79, label %139
79: ; preds = %77
%80 = icmp sgt i32 %3, 0
%81 = zext i32 %2 to i64
%82 = zext i32 %3 to i64
%83 = and i64 %82, 1
%84 = icmp eq i32 %3, 1
%85 = and i64 %82, 4294967294
%86 = icmp eq i64 %83, 0
br label %102
87: ; preds = %97, %73
%88 = tail call i32 @do_rand(i32 %2)
store i32 %88, i32* %75
%89 = tail call i32 @do_rand(i32 %3)
store i32 %89, i32* %76
%90 = load i32, i32* %75
%91 = sext i32 %90 to i64
%92 = getelementptr inbounds i8*, i8** %0, i64 %91
%93 = load i8*, i8** %92
%94 = sext i32 %89 to i64
%95 = getelementptr inbounds i8, i8* %93, i64 %94
%96 = load i8, i8* %95
switch i8 %96, label %98 [
i8 77, label %97
i8 83, label %97
i8 71, label %97
]
97: ; preds = %87, %87, %87
br label %87
98: ; preds = %87
%99 = getelementptr inbounds i8, i8* %93, i64 %94
store i8 79, i8* %99
%100 = add nuw nsw i64 %74, 2
%101 = icmp sgt i64 %74, %72
br i1 %101, label %77, label %73
102: ; preds = %79, %136
%103 = phi i64 [ 0, %79 ], [ %137, %136 ]
br i1 %80, label %104, label %136
104: ; preds = %102
%105 = getelementptr inbounds i8*, i8** %0, i64 %103
br i1 %84, label %127, label %106
106: ; preds = %104, %123
%107 = phi i64 [ %124, %123 ], [ 0, %104 ]
%108 = phi i64 [ %125, %123 ], [ 0, %104 ]
%109 = load i8*, i8** %105
%110 = getelementptr inbounds i8, i8* %109, i64 %107
%111 = load i8, i8* %110
%112 = add i8 %111, -71
%113 = tail call i8 @llvm.fshl.i8(i8 %112, i8 %112, i8 7)
switch i8 %113, label %114 [
i8 3, label %115
i8 6, label %115
i8 0, label %115
i8 4, label %115
]
114: ; preds = %106
store i8 35, i8* %110
br label %115
115: ; preds = %106, %106, %106, %106, %114
%116 = or i64 %107, 1
%117 = load i8*, i8** %105
%118 = getelementptr inbounds i8, i8* %117, i64 %116
%119 = load i8, i8* %118
%120 = add i8 %119, -71
%121 = tail call i8 @llvm.fshl.i8(i8 %120, i8 %120, i8 7)
switch i8 %121, label %122 [
i8 3, label %123
i8 6, label %123
i8 0, label %123
i8 4, label %123
]
122: ; preds = %115
store i8 35, i8* %118
br label %123
123: ; preds = %122, %115, %115, %115, %115
%124 = add nuw nsw i64 %107, 2
%125 = add i64 %108, 2
%126 = icmp eq i64 %125, %85
br i1 %126, label %127, label %106
127: ; preds = %123, %104
%128 = phi i64 [ 0, %104 ], [ %124, %123 ]
br i1 %86, label %136, label %129
129: ; preds = %127
%130 = load i8*, i8** %105
%131 = getelementptr inbounds i8, i8* %130, i64 %128
%132 = load i8, i8* %131
%133 = add i8 %132, -71
%134 = tail call i8 @llvm.fshl.i8(i8 %133, i8 %133, i8 7)
switch i8 %134, label %135 [
i8 3, label %136
i8 6, label %136
i8 0, label %136
i8 4, label %136
]
135: ; preds = %129
store i8 35, i8* %131
br label %136
136: ; preds = %127, %135, %129, %129, %129, %129, %102
%137 = add nuw nsw i64 %103, 1
%138 = icmp eq i64 %137, %81
br i1 %138, label %139, label %102
139: ; preds = %136, %77
ret void
}