#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*/ mapstd_stride(float *, int, int, float, float, float *);
float mean_stride(float *, int, int);
float std_stride(float *, int, int);
void prestd(int size, float *p, int leninp, float *t, int lenoup, float *pn,
            float *tn, float ymean, float ystd, float omean, float ostd,
            float *dmean, float *dstd, float *tmean, float *tstd) {
  int i;
  float temp;
  for (i = 0; i < leninp; ++i) {
    mapstd_stride(p + i, size, leninp, ymean, ystd, pn + i);
    temp = mean_stride(p + i, size, leninp);
    dmean[i] = temp;
    temp = std_stride(p + i, size, leninp);
    dstd[i] = temp;
  }
  for (i = 0; i < lenoup; ++i) {
    mapstd_stride(t + i, size, lenoup, omean, ostd, tn + i);
    temp = mean_stride(t + i, size, lenoup);
    tmean[i] = temp;
    temp = std_stride(t + i, size, lenoup);
    tstd[i] = temp;
  }
}


x86 assembly (clang, -O0):
<prestd>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8d,-0x24(%rbp)
mov    %r9,-0x30(%rbp)
movss  %xmm0,-0x34(%rbp)
movss  %xmm1,-0x38(%rbp)
movss  %xmm2,-0x3c(%rbp)
movss  %xmm3,-0x40(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    122c <prestd+0xfc>
mov    -0x10(%rbp),%rdi
movslq -0x44(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rdi
mov    -0x4(%rbp),%esi
mov    -0x14(%rbp),%edx
movss  -0x34(%rbp),%xmm0
movss  -0x38(%rbp),%xmm1
mov    -0x30(%rbp),%rcx
movslq -0x44(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rcx
call   1050 <mapstd_stride@plt>
mov    -0x10(%rbp),%rdi
movslq -0x44(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rdi
mov    -0x4(%rbp),%esi
mov    -0x14(%rbp),%edx
call   1030 <mean_stride@plt>
movss  %xmm0,-0x48(%rbp)
movss  -0x48(%rbp),%xmm0
mov    0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rdi
movslq -0x44(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rdi
mov    -0x4(%rbp),%esi
mov    -0x14(%rbp),%edx
call   1040 <std_stride@plt>
movss  %xmm0,-0x48(%rbp)
movss  -0x48(%rbp),%xmm0
mov    0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    117d <prestd+0x4d>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    12e2 <prestd+0x1b2>
mov    -0x20(%rbp),%rdi
movslq -0x44(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rdi
mov    -0x4(%rbp),%esi
mov    -0x24(%rbp),%edx
movss  -0x3c(%rbp),%xmm0
movss  -0x40(%rbp),%xmm1
mov    0x10(%rbp),%rcx
movslq -0x44(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rcx
call   1050 <mapstd_stride@plt>
mov    -0x20(%rbp),%rdi
movslq -0x44(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rdi
mov    -0x4(%rbp),%esi
mov    -0x24(%rbp),%edx
call   1030 <mean_stride@plt>
movss  %xmm0,-0x48(%rbp)
movss  -0x48(%rbp),%xmm0
mov    0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%rdi
movslq -0x44(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rdi
mov    -0x4(%rbp),%esi
mov    -0x24(%rbp),%edx
call   1040 <std_stride@plt>
movss  %xmm0,-0x48(%rbp)
movss  -0x48(%rbp),%xmm0
mov    0x30(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1233 <prestd+0x103>
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<prestd>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
movss  %xmm3,0x14(%rsp)
movss  %xmm2,0x10(%rsp)
mov    %r8d,0x4(%rsp)
mov    %rcx,0x18(%rsp)
mov    %edi,%ebp
test   %edx,%edx
jle    11d9 <prestd+0xa9>
mov    %r9,%r15
mov    %edx,%ebx
mov    %rsi,%r12
mov    %edx,%eax
shl    $0x2,%rax
mov    %rax,0x20(%rsp)
xor    %r13d,%r13d
movss  %xmm1,0xc(%rsp)
movss  %xmm0,0x8(%rsp)
nopl   0x0(%rax)
lea    (%r12,%r13,1),%r14
lea    (%r15,%r13,1),%rcx
mov    %r14,%rdi
mov    %ebp,%esi
mov    %ebx,%edx
movss  0x8(%rsp),%xmm0
movss  0xc(%rsp),%xmm1
call   1050 <mapstd_stride@plt>
mov    %r14,%rdi
mov    %ebp,%esi
mov    %ebx,%edx
call   1030 <mean_stride@plt>
mov    0x68(%rsp),%rax
movss  %xmm0,(%rax,%r13,1)
mov    %r14,%rdi
mov    %ebp,%esi
mov    %ebx,%edx
call   1040 <std_stride@plt>
mov    0x70(%rsp),%rax
movss  %xmm0,(%rax,%r13,1)
add    $0x4,%r13
cmp    %r13,0x20(%rsp)
jne    1180 <prestd+0x50>
mov    0x4(%rsp),%r12d
test   %r12d,%r12d
mov    0x18(%rsp),%r13
jle    1262 <prestd+0x132>
mov    %r12d,%r14d
shl    $0x2,%r14
xor    %r15d,%r15d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    (%r15,%r13,1),%rbx
mov    0x60(%rsp),%rax
lea    (%rax,%r15,1),%rcx
mov    %rbx,%rdi
mov    %ebp,%esi
mov    %r12d,%edx
movss  0x10(%rsp),%xmm0
movss  0x14(%rsp),%xmm1
call   1050 <mapstd_stride@plt>
mov    %rbx,%rdi
mov    %ebp,%esi
mov    %r12d,%edx
call   1030 <mean_stride@plt>
mov    0x78(%rsp),%rax
movss  %xmm0,(%rax,%r15,1)
mov    %rbx,%rdi
mov    %ebp,%esi
mov    %r12d,%edx
call   1040 <std_stride@plt>
mov    0x80(%rsp),%rax
movss  %xmm0,(%rax,%r15,1)
add    $0x4,%r15
cmp    %r15,%r14
jne    1200 <prestd+0xd0>
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define void @prestd(i32 %0, float* %1, i32 %2, float* %3, i32 %4, float* %5, float* %6, float %7, float %8, float %9, float %10, float* nocapture writeonly %11, float* nocapture writeonly %12, float* nocapture writeonly %13, float* nocapture writeonly %14) {
%16 = icmp sgt i32 %2, 0
br i1 %16, label %17, label %19
17: ; preds = %15
%18 = zext i32 %2 to i64
br label %23
19: ; preds = %23, %15
%20 = icmp sgt i32 %4, 0
br i1 %20, label %21, label %45
21: ; preds = %19
%22 = zext i32 %4 to i64
br label %34
23: ; preds = %17, %23
%24 = phi i64 [ 0, %17 ], [ %32, %23 ]
%25 = getelementptr inbounds float, float* %1, i64 %24
%26 = getelementptr inbounds float, float* %5, i64 %24
%27 = tail call i32 @mapstd_stride(float* %25, i32 %0, i32 %2, float %7, float %8, float* %26)
%28 = tail call float @mean_stride(float* %25, i32 %0, i32 %2)
%29 = getelementptr inbounds float, float* %11, i64 %24
store float %28, float* %29
%30 = tail call float @std_stride(float* %25, i32 %0, i32 %2)
%31 = getelementptr inbounds float, float* %12, i64 %24
store float %30, float* %31
%32 = add nuw nsw i64 %24, 1
%33 = icmp eq i64 %32, %18
br i1 %33, label %19, label %23
34: ; preds = %21, %34
%35 = phi i64 [ 0, %21 ], [ %43, %34 ]
%36 = getelementptr inbounds float, float* %3, i64 %35
%37 = getelementptr inbounds float, float* %6, i64 %35
%38 = tail call i32 @mapstd_stride(float* %36, i32 %0, i32 %4, float %9, float %10, float* %37)
%39 = tail call float @mean_stride(float* %36, i32 %0, i32 %4)
%40 = getelementptr inbounds float, float* %13, i64 %35
store float %39, float* %40
%41 = tail call float @std_stride(float* %36, i32 %0, i32 %4)
%42 = getelementptr inbounds float, float* %14, i64 %35
store float %41, float* %42
%43 = add nuw nsw i64 %35, 1
%44 = icmp eq i64 %43, %22
br i1 %44, label %45, label %34
45: ; preds = %34, %19
ret void
}