#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 */
double exp(double);
int /*<<< orphan*/ zufall(int, double *);
int fische(int n, double *mu, int *p) {
  int left, indx[1024], i, k, nsegs, p0, ii, jj, nl0;
  double q[1024], u[1024], q0, pmu;
  --p;
  if (n <= 0)
    return 0;
  pmu = exp(-(*mu));
  p0 = 0;
  nsegs = (n - 1) / 1024;
  left = n - (nsegs << 10);
  ++nsegs;
  nl0 = left;
  for (k = 1; k <= nsegs; ++k) {
    for (i = 1; i <= left; ++i) {
      indx[i - 1] = i;
      p[p0 + i] = 0;
      q[i - 1] = 1.0;
    }
    do {
      zufall(left, u);
      jj = 0;
      for (i = 1; i <= left; ++i) {
        ii = indx[i - 1];
        q0 = q[ii - 1] * u[i - 1];
        q[ii - 1] = q0;
        if (q0 > pmu) {
          indx[jj++] = ii;
          ++p[p0 + ii];
        }
      }
      left = jj;
    } while (left > 0);
    p0 += nl0;
    nl0 = left = 1024;
  }
  return 0;
}


x86 assembly (clang, -O0):
<fische>:
push   %rbp
mov    %rsp,%rbp
sub    $0x5050,%rsp
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    -0x18(%rbp),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,-0x18(%rbp)
cmpl   $0x0,-0x8(%rbp)
jg     1158 <fische+0x38>
movl   $0x0,-0x4(%rbp)
jmp    13b9 <fische+0x299>
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
call   1040 <exp@plt>
movsd  %xmm0,-0x5050(%rbp)
ff
movl   $0x0,-0x1030(%rbp)
mov    -0x8(%rbp),%eax
sub    $0x1,%eax
mov    $0x400,%ecx
cltd
idiv   %ecx
mov    %eax,-0x102c(%rbp)
mov    -0x8(%rbp),%eax
mov    -0x102c(%rbp),%ecx
shl    $0xa,%ecx
sub    %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x102c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x102c(%rbp)
mov    -0x1c(%rbp),%eax
mov    %eax,-0x103c(%rbp)
movl   $0x1,-0x1028(%rbp)
mov    -0x1028(%rbp),%eax
cmp    -0x102c(%rbp),%eax
jg     13b2 <fische+0x292>
movl   $0x1,-0x1024(%rbp)
mov    -0x1024(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     1262 <fische+0x142>
mov    -0x1024(%rbp),%ecx
mov    -0x1024(%rbp),%eax
sub    $0x1,%eax
cltq
mov    %ecx,-0x1020(%rbp,%rax,4)
mov    -0x18(%rbp),%rax
mov    -0x1030(%rbp),%ecx
add    -0x1024(%rbp),%ecx
movslq %ecx,%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x1024(%rbp),%eax
sub    $0x1,%eax
cltq
movsd  0xdbb(%rip),%xmm0
movsd  %xmm0,-0x3040(%rbp,%rax,8)
ff ff
mov    -0x1024(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1024(%rbp)
jmp    11f1 <fische+0xd1>
jmp    1267 <fische+0x147>
mov    -0x1c(%rbp),%edi
lea    -0x5040(%rbp),%rsi
call   1030 <zufall@plt>
movl   $0x0,-0x1038(%rbp)
movl   $0x1,-0x1024(%rbp)
mov    -0x1024(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     1368 <fische+0x248>
mov    -0x1024(%rbp),%eax
sub    $0x1,%eax
cltq
mov    -0x1020(%rbp,%rax,4),%eax
mov    %eax,-0x1034(%rbp)
mov    -0x1034(%rbp),%eax
sub    $0x1,%eax
cltq
movsd  -0x3040(%rbp,%rax,8),%xmm0
ff ff
mov    -0x1024(%rbp),%eax
sub    $0x1,%eax
cltq
mulsd  -0x5040(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x5048(%rbp)
ff
movsd  -0x5048(%rbp),%xmm0
ff
mov    -0x1034(%rbp),%eax
sub    $0x1,%eax
cltq
movsd  %xmm0,-0x3040(%rbp,%rax,8)
ff ff
movsd  -0x5048(%rbp),%xmm0
ff
ucomisd -0x5050(%rbp),%xmm0
ff
jbe    134f <fische+0x22f>
mov    -0x1034(%rbp),%ecx
mov    -0x1038(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0x1038(%rbp)
cltq
mov    %ecx,-0x1020(%rbp,%rax,4)
mov    -0x18(%rbp),%rax
mov    -0x1030(%rbp),%ecx
add    -0x1034(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    %edx,(%rax,%rcx,4)
jmp    1354 <fische+0x234>
mov    -0x1024(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1024(%rbp)
jmp    128a <fische+0x16a>
mov    -0x1038(%rbp),%eax
mov    %eax,-0x1c(%rbp)
cmpl   $0x0,-0x1c(%rbp)
jg     1267 <fische+0x147>
mov    -0x103c(%rbp),%eax
add    -0x1030(%rbp),%eax
mov    %eax,-0x1030(%rbp)
movl   $0x400,-0x1c(%rbp)
movl   $0x400,-0x103c(%rbp)
mov    -0x1028(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1028(%rbp)
jmp    11d5 <fische+0xb5>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x5050,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<fische>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x5028,%rsp
test   %edi,%edi
jle    139e <fische+0x26e>
mov    %rdx,%r13
mov    %edi,%r14d
add    $0xfffffffffffffffc,%r13
movq   (%rsi),%xmm0
pxor   0xea1(%rip),%xmm0
call   1050 <exp@plt>
movq   %xmm0,0x18(%rsp)
lea    -0x1(%r14),%ecx
shr    $0xa,%ecx
mov    %ecx,%eax
shl    $0xa,%eax
sub    %eax,%r14d
add    $0x1,%ecx
mov    %ecx,0xc(%rsp)
mov    $0x1,%eax
xor    %ebx,%ebx
lea    0x3020(%rsp),%r15
movabs $0x3ff0000000000000,%r12
jmp    11bb <fische+0x8b>
nopl   0x0(%rax,%rax,1)
add    %r14d,%ebx
mov    0x10(%rsp),%rcx
lea    0x1(%rcx),%eax
mov    $0x400,%r14d
cmp    0xc(%rsp),%ecx
je     139e <fische+0x26e>
mov    %rax,0x10(%rsp)
test   %r14d,%r14d
jle    1305 <fische+0x1d5>
lea    0x1(%rbx),%eax
cltq
lea    0x0(,%rax,4),%rdi
add    %r13,%rdi
mov    %r14d,%ebp
lea    0x0(,%rbp,4),%rdx
xor    %esi,%esi
call   1040 <memset@plt>
movdqa 0xe6d(%rip),%xmm7
movdqa 0xe55(%rip),%xmm6
movdqa 0xe3d(%rip),%xmm5
movaps 0xe26(%rip),%xmm4
movdqa 0xe0e(%rip),%xmm3
mov    $0x1,%eax
cmp    $0x4,%r14d
jb     12de <fische+0x1ae>
mov    %ebp,%eax
and    $0xfffffffc,%eax
lea    -0x4(%rax),%rdx
mov    %rdx,%rcx
shr    $0x2,%rcx
add    $0x1,%rcx
test   %rdx,%rdx
je     1386 <fische+0x256>
mov    %rcx,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %edx,%edx
movdqa 0xdc1(%rip),%xmm0
nop
movdqa %xmm0,%xmm1
paddd  %xmm3,%xmm1
movdqa %xmm0,%xmm2
punpcklqdq %xmm1,%xmm2
movdqa %xmm2,0x20(%rsp,%rdx,4)
movaps %xmm4,0x1020(%rsp,%rdx,8)
movaps %xmm4,0x1030(%rsp,%rdx,8)
movdqa %xmm0,%xmm1
paddd  %xmm5,%xmm1
movdqa %xmm0,%xmm2
paddd  %xmm6,%xmm2
punpcklqdq %xmm2,%xmm1
movdqa %xmm1,0x30(%rsp,%rdx,4)
movaps %xmm4,0x1040(%rsp,%rdx,8)
movaps %xmm4,0x1050(%rsp,%rdx,8)
add    $0x8,%rdx
paddd  %xmm7,%xmm0
add    $0xfffffffffffffffe,%rsi
jne    1250 <fische+0x120>
test   $0x1,%cl
je     12d5 <fische+0x1a5>
movdqa %xmm0,%xmm1
paddd  %xmm3,%xmm1
punpcklqdq %xmm1,%xmm0
movdqa %xmm0,0x20(%rsp,%rdx,4)
movaps %xmm4,0x1020(%rsp,%rdx,8)
movaps %xmm4,0x1030(%rsp,%rdx,8)
cmp    %rax,%rbp
je     1305 <fische+0x1d5>
or     $0x1,%rax
add    $0x1,%rbp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %eax,0x1c(%rsp,%rax,4)
mov    %r12,0x1018(%rsp,%rax,8)
add    $0x1,%rax
cmp    %rax,%rbp
jne    12f0 <fische+0x1c0>
mov    %r14d,%ebp
jmp    1318 <fische+0x1e8>
nopw   0x0(%rax,%rax,1)
test   %ebp,%ebp
jle    11a0 <fische+0x70>
mov    %ebp,%edi
mov    %r15,%rsi
call   1030 <zufall@plt>
movsd  0x18(%rsp),%xmm1
test   %ebp,%ebp
jle    11a0 <fische+0x70>
mov    %ebp,%eax
xor    %ecx,%ecx
xor    %ebp,%ebp
jmp    1349 <fische+0x219>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rcx
cmp    %rcx,%rax
je     1310 <fische+0x1e0>
movslq 0x20(%rsp,%rcx,4),%rdx
movsd  0x1018(%rsp,%rdx,8),%xmm0
mulsd  0x3020(%rsp,%rcx,8),%xmm0
movsd  %xmm0,0x1018(%rsp,%rdx,8)
ucomisd %xmm1,%xmm0
jbe    1340 <fische+0x210>
movslq %ebp,%rsi
add    $0x1,%ebp
mov    %edx,0x20(%rsp,%rsi,4)
add    %ebx,%edx
movslq %edx,%rdx
addl   $0x1,0x0(%r13,%rdx,4)
jmp    1340 <fische+0x210>
xor    %edx,%edx
movdqa 0xc80(%rip),%xmm0
test   $0x1,%cl
jne    12b3 <fische+0x183>
jmp    12d5 <fische+0x1a5>
xor    %eax,%eax
add    $0x5028,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define i32 @fische(i32 %0, double* %1, i32* %2) {
%4 = alloca i32
%5 = alloca i32
%6 = alloca double*
%7 = alloca i32*
%8 = alloca i32
%9 = alloca [1024 x i32]
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca [1024 x double]
%18 = alloca [1024 x double]
%19 = alloca double
%20 = alloca double
store i32 %0, i32* %5
store double* %1, double** %6
store i32* %2, i32** %7
%21 = load i32*, i32** %7
%22 = getelementptr inbounds i32, i32* %21, i32 -1
store i32* %22, i32** %7
%23 = load i32, i32* %5
%24 = icmp sle i32 %23, 0
br i1 %24, label %25, label %26
25: ; preds = %3
store i32 0, i32* %4
br label %134
26: ; preds = %3
%27 = load double*, double** %6
%28 = load double, double* %27
%29 = fneg double %28
%30 = call double @exp(double %29)
store double %30, double* %20
store i32 0, i32* %13
%31 = load i32, i32* %5
%32 = sub nsw i32 %31, 1
%33 = sdiv i32 %32, 1024
store i32 %33, i32* %12
%34 = load i32, i32* %5
%35 = load i32, i32* %12
%36 = shl i32 %35, 10
%37 = sub nsw i32 %34, %36
store i32 %37, i32* %8
%38 = load i32, i32* %12
%39 = add nsw i32 %38, 1
store i32 %39, i32* %12
%40 = load i32, i32* %8
store i32 %40, i32* %16
store i32 1, i32* %11
br label %41
41: ; preds = %130, %26
%42 = load i32, i32* %11
%43 = load i32, i32* %12
%44 = icmp sle i32 %42, %43
br i1 %44, label %45, label %133
45: ; preds = %41
store i32 1, i32* %10
br label %46
46: ; preds = %66, %45
%47 = load i32, i32* %10
%48 = load i32, i32* %8
%49 = icmp sle i32 %47, %48
br i1 %49, label %50, label %69
50: ; preds = %46
%51 = load i32, i32* %10
%52 = load i32, i32* %10
%53 = sub nsw i32 %52, 1
%54 = sext i32 %53 to i64
%55 = getelementptr inbounds [1024 x i32], [1024 x i32]* %9, i64 0, i64 %54
store i32 %51, i32* %55
%56 = load i32*, i32** %7
%57 = load i32, i32* %13
%58 = load i32, i32* %10
%59 = add nsw i32 %57, %58
%60 = sext i32 %59 to i64
%61 = getelementptr inbounds i32, i32* %56, i64 %60
store i32 0, i32* %61
%62 = load i32, i32* %10
%63 = sub nsw i32 %62, 1
%64 = sext i32 %63 to i64
%65 = getelementptr inbounds [1024 x double], [1024 x double]* %17, i64 0, i64 %64
store double 1.000000e+00, double* %65
br label %66
66: ; preds = %50
%67 = load i32, i32* %10
%68 = add nsw i32 %67, 1
store i32 %68, i32* %10
br label %46
69: ; preds = %46
br label %70
70: ; preds = %123, %69
%71 = load i32, i32* %8
%72 = getelementptr inbounds [1024 x double], [1024 x double]* %18, i64 0, i64 0
%73 = call i32 @zufall(i32 %71, double* %72)
store i32 0, i32* %15
store i32 1, i32* %10
br label %74
74: ; preds = %118, %70
%75 = load i32, i32* %10
%76 = load i32, i32* %8
%77 = icmp sle i32 %75, %76
br i1 %77, label %78, label %121
78: ; preds = %74
%79 = load i32, i32* %10
%80 = sub nsw i32 %79, 1
%81 = sext i32 %80 to i64
%82 = getelementptr inbounds [1024 x i32], [1024 x i32]* %9, i64 0, i64 %81
%83 = load i32, i32* %82
store i32 %83, i32* %14
%84 = load i32, i32* %14
%85 = sub nsw i32 %84, 1
%86 = sext i32 %85 to i64
%87 = getelementptr inbounds [1024 x double], [1024 x double]* %17, i64 0, i64 %86
%88 = load double, double* %87
%89 = load i32, i32* %10
%90 = sub nsw i32 %89, 1
%91 = sext i32 %90 to i64
%92 = getelementptr inbounds [1024 x double], [1024 x double]* %18, i64 0, i64 %91
%93 = load double, double* %92
%94 = fmul double %88, %93
store double %94, double* %19
%95 = load double, double* %19
%96 = load i32, i32* %14
%97 = sub nsw i32 %96, 1
%98 = sext i32 %97 to i64
%99 = getelementptr inbounds [1024 x double], [1024 x double]* %17, i64 0, i64 %98
store double %95, double* %99
%100 = load double, double* %19
%101 = load double, double* %20
%102 = fcmp ogt double %100, %101
br i1 %102, label %103, label %117
103: ; preds = %78
%104 = load i32, i32* %14
%105 = load i32, i32* %15
%106 = add nsw i32 %105, 1
store i32 %106, i32* %15
%107 = sext i32 %105 to i64
%108 = getelementptr inbounds [1024 x i32], [1024 x i32]* %9, i64 0, i64 %107
store i32 %104, i32* %108
%109 = load i32*, i32** %7
%110 = load i32, i32* %13
%111 = load i32, i32* %14
%112 = add nsw i32 %110, %111
%113 = sext i32 %112 to i64
%114 = getelementptr inbounds i32, i32* %109, i64 %113
%115 = load i32, i32* %114
%116 = add nsw i32 %115, 1
store i32 %116, i32* %114
br label %117
117: ; preds = %103, %78
br label %118
118: ; preds = %117
%119 = load i32, i32* %10
%120 = add nsw i32 %119, 1
store i32 %120, i32* %10
br label %74
121: ; preds = %74
%122 = load i32, i32* %15
store i32 %122, i32* %8
br label %123
123: ; preds = %121
%124 = load i32, i32* %8
%125 = icmp sgt i32 %124, 0
br i1 %125, label %70, label %126
126: ; preds = %123
%127 = load i32, i32* %16
%128 = load i32, i32* %13
%129 = add nsw i32 %128, %127
store i32 %129, i32* %13
store i32 1024, i32* %8
store i32 1024, i32* %16
br label %130
130: ; preds = %126
%131 = load i32, i32* %11
%132 = add nsw i32 %131, 1
store i32 %132, i32* %11
br label %41
133: ; preds = %41
store i32 0, i32* %4
br label %134
134: ; preds = %133, %25
%135 = load i32, i32* %4
ret i32 %135
}

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