void cbguard2l(float bxy[], int nx, int ny, int nxe, int nye) {
  int j, k;
  for (k = 0; k < ny; k++) {
    bxy[3 * nx + 3 * nxe * k] = bxy[3 * nxe * k];
    bxy[1 + 3 * nx + 3 * nxe * k] = bxy[1 + 3 * nxe * k];
    bxy[2 + 3 * nx + 3 * nxe * k] = bxy[2 + 3 * nxe * k];
  }
  for (j = 0; j < nx; j++) {
    bxy[3 * j + 3 * nxe * ny] = bxy[3 * j];
    bxy[1 + 3 * j + 3 * nxe * ny] = bxy[1 + 3 * j];
    bxy[2 + 3 * j + 3 * nxe * ny] = bxy[2 + 3 * j];
  }
  bxy[3 * nx + 3 * nxe * ny] = bxy[0];
  bxy[1 + 3 * nx + 3 * nxe * ny] = bxy[1];
  bxy[2 + 3 * nx + 3 * nxe * ny] = bxy[2];
  return;
}


x86 assembly (clang, -O0):
<cbguard2l>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %ecx,-0x14(%rbp)
mov    %r8d,-0x18(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    11cc <cbguard2l+0xcc>
mov    -0x8(%rbp),%rax
imul   $0x3,-0x14(%rbp),%ecx
imul   -0x20(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
imul   $0x3,-0xc(%rbp),%ecx
imul   $0x3,-0x14(%rbp),%edx
imul   -0x20(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
imul   $0x3,-0x14(%rbp),%ecx
imul   -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
imul   $0x3,-0xc(%rbp),%ecx
add    $0x1,%ecx
imul   $0x3,-0x14(%rbp),%edx
imul   -0x20(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
imul   $0x3,-0x14(%rbp),%ecx
imul   -0x20(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
imul   $0x3,-0xc(%rbp),%ecx
add    $0x2,%ecx
imul   $0x3,-0x14(%rbp),%edx
imul   -0x20(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    111c <cbguard2l+0x1c>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1277 <cbguard2l+0x177>
mov    -0x8(%rbp),%rax
imul   $0x3,-0x1c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
imul   $0x3,-0x1c(%rbp),%ecx
imul   $0x3,-0x14(%rbp),%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
imul   $0x3,-0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
imul   $0x3,-0x1c(%rbp),%ecx
add    $0x1,%ecx
imul   $0x3,-0x14(%rbp),%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
imul   $0x3,-0x1c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
imul   $0x3,-0x1c(%rbp),%ecx
add    $0x2,%ecx
imul   $0x3,-0x14(%rbp),%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    11d3 <cbguard2l+0xd3>
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x8(%rbp),%rax
imul   $0x3,-0xc(%rbp),%ecx
imul   $0x3,-0x14(%rbp),%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x8(%rbp),%rax
imul   $0x3,-0xc(%rbp),%ecx
add    $0x1,%ecx
imul   $0x3,-0x14(%rbp),%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x8(%rbp),%rax
imul   $0x3,-0xc(%rbp),%ecx
add    $0x2,%ecx
imul   $0x3,-0x14(%rbp),%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
pop    %rbp
ret

x86 assembly (clang, -O2):
<cbguard2l>:
push   %rbp
push   %rbx
test   %edx,%edx
jle    1162 <cbguard2l+0x62>
lea    (%rcx,%rcx,2),%r8d
lea    (%rsi,%rsi,2),%eax
movslq %r8d,%r10
movslq %eax,%r9
mov    %edx,%r11d
lea    (%rsi,%rsi,2),%eax
add    $0x2,%eax
shl    $0x2,%r10
mov    %rdi,%rbx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  (%rbx),%xmm0
movss  %xmm0,(%rbx,%r9,4)
movss  0x4(%rbx),%xmm0
lea    -0x1(%rax),%ebp
movslq %ebp,%rbp
movss  %xmm0,(%rdi,%rbp,4)
movss  0x8(%rbx),%xmm0
cltq
movss  %xmm0,(%rdi,%rax,4)
add    %r8d,%eax
add    %r10,%rbx
add    $0xffffffffffffffff,%r11
jne    1130 <cbguard2l+0x30>
imul   %edx,%ecx
lea    (%rcx,%rcx,2),%eax
test   %esi,%esi
jle    11a9 <cbguard2l+0xa9>
movslq %eax,%rcx
mov    %esi,%edx
lea    0x8(%rdi),%rbx
cs nopw 0x0(%rax,%rax,1)
nop
movss  -0x8(%rbx),%xmm0
movss  %xmm0,-0x8(%rbx,%rcx,4)
movss  -0x4(%rbx),%xmm0
movss  %xmm0,-0x4(%rbx,%rcx,4)
movss  (%rbx),%xmm0
movss  %xmm0,(%rbx,%rcx,4)
add    $0xc,%rbx
add    $0xffffffffffffffff,%rdx
jne    1180 <cbguard2l+0x80>
movss  (%rdi),%xmm0
lea    (%rsi,%rsi,2),%ecx
lea    (%rax,%rcx,1),%edx
movslq %edx,%rdx
movss  %xmm0,(%rdi,%rdx,4)
movss  0x4(%rdi),%xmm0
lea    0x1(%rax,%rcx,1),%edx
movslq %edx,%rdx
movss  %xmm0,(%rdi,%rdx,4)
movss  0x8(%rdi),%xmm0
lea    0x2(%rax,%rcx,1),%eax
cltq
movss  %xmm0,(%rdi,%rax,4)
pop    %rbx
pop    %rbp
ret

LLVM IR (-O0):
define void @cbguard2l(float* %0, i32 %1, i32 %2, i32 %3, i32 %4) {
%6 = alloca float*
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
store float* %0, float** %6
store i32 %1, i32* %7
store i32 %2, i32* %8
store i32 %3, i32* %9
store i32 %4, i32* %10
store i32 0, i32* %12
br label %13
13: ; preds = %76, %5
%14 = load i32, i32* %12
%15 = load i32, i32* %8
%16 = icmp slt i32 %14, %15
br i1 %16, label %17, label %79
17: ; preds = %13
%18 = load float*, float** %6
%19 = load i32, i32* %9
%20 = mul nsw i32 3, %19
%21 = load i32, i32* %12
%22 = mul nsw i32 %20, %21
%23 = sext i32 %22 to i64
%24 = getelementptr inbounds float, float* %18, i64 %23
%25 = load float, float* %24
%26 = load float*, float** %6
%27 = load i32, i32* %7
%28 = mul nsw i32 3, %27
%29 = load i32, i32* %9
%30 = mul nsw i32 3, %29
%31 = load i32, i32* %12
%32 = mul nsw i32 %30, %31
%33 = add nsw i32 %28, %32
%34 = sext i32 %33 to i64
%35 = getelementptr inbounds float, float* %26, i64 %34
store float %25, float* %35
%36 = load float*, float** %6
%37 = load i32, i32* %9
%38 = mul nsw i32 3, %37
%39 = load i32, i32* %12
%40 = mul nsw i32 %38, %39
%41 = add nsw i32 1, %40
%42 = sext i32 %41 to i64
%43 = getelementptr inbounds float, float* %36, i64 %42
%44 = load float, float* %43
%45 = load float*, float** %6
%46 = load i32, i32* %7
%47 = mul nsw i32 3, %46
%48 = add nsw i32 1, %47
%49 = load i32, i32* %9
%50 = mul nsw i32 3, %49
%51 = load i32, i32* %12
%52 = mul nsw i32 %50, %51
%53 = add nsw i32 %48, %52
%54 = sext i32 %53 to i64
%55 = getelementptr inbounds float, float* %45, i64 %54
store float %44, float* %55
%56 = load float*, float** %6
%57 = load i32, i32* %9
%58 = mul nsw i32 3, %57
%59 = load i32, i32* %12
%60 = mul nsw i32 %58, %59
%61 = add nsw i32 2, %60
%62 = sext i32 %61 to i64
%63 = getelementptr inbounds float, float* %56, i64 %62
%64 = load float, float* %63
%65 = load float*, float** %6
%66 = load i32, i32* %7
%67 = mul nsw i32 3, %66
%68 = add nsw i32 2, %67
%69 = load i32, i32* %9
%70 = mul nsw i32 3, %69
%71 = load i32, i32* %12
%72 = mul nsw i32 %70, %71
%73 = add nsw i32 %68, %72
%74 = sext i32 %73 to i64
%75 = getelementptr inbounds float, float* %65, i64 %74
store float %64, float* %75
br label %76
76: ; preds = %17
%77 = load i32, i32* %12
%78 = add nsw i32 %77, 1
store i32 %78, i32* %12
br label %13
79: ; preds = %13
store i32 0, i32* %11
br label %80
80: ; preds = %137, %79
%81 = load i32, i32* %11
%82 = load i32, i32* %7
%83 = icmp slt i32 %81, %82
br i1 %83, label %84, label %140
84: ; preds = %80
%85 = load float*, float** %6
%86 = load i32, i32* %11
%87 = mul nsw i32 3, %86
%88 = sext i32 %87 to i64
%89 = getelementptr inbounds float, float* %85, i64 %88
%90 = load float, float* %89
%91 = load float*, float** %6
%92 = load i32, i32* %11
%93 = mul nsw i32 3, %92
%94 = load i32, i32* %9
%95 = mul nsw i32 3, %94
%96 = load i32, i32* %8
%97 = mul nsw i32 %95, %96
%98 = add nsw i32 %93, %97
%99 = sext i32 %98 to i64
%100 = getelementptr inbounds float, float* %91, i64 %99
store float %90, float* %100
%101 = load float*, float** %6
%102 = load i32, i32* %11
%103 = mul nsw i32 3, %102
%104 = add nsw i32 1, %103
%105 = sext i32 %104 to i64
%106 = getelementptr inbounds float, float* %101, i64 %105
%107 = load float, float* %106
%108 = load float*, float** %6
%109 = load i32, i32* %11
%110 = mul nsw i32 3, %109
%111 = add nsw i32 1, %110
%112 = load i32, i32* %9
%113 = mul nsw i32 3, %112
%114 = load i32, i32* %8
%115 = mul nsw i32 %113, %114
%116 = add nsw i32 %111, %115
%117 = sext i32 %116 to i64
%118 = getelementptr inbounds float, float* %108, i64 %117
store float %107, float* %118
%119 = load float*, float** %6
%120 = load i32, i32* %11
%121 = mul nsw i32 3, %120
%122 = add nsw i32 2, %121
%123 = sext i32 %122 to i64
%124 = getelementptr inbounds float, float* %119, i64 %123
%125 = load float, float* %124
%126 = load float*, float** %6
%127 = load i32, i32* %11
%128 = mul nsw i32 3, %127
%129 = add nsw i32 2, %128
%130 = load i32, i32* %9
%131 = mul nsw i32 3, %130
%132 = load i32, i32* %8
%133 = mul nsw i32 %131, %132
%134 = add nsw i32 %129, %133
%135 = sext i32 %134 to i64
%136 = getelementptr inbounds float, float* %126, i64 %135
store float %125, float* %136
br label %137
137: ; preds = %84
%138 = load i32, i32* %11
%139 = add nsw i32 %138, 1
store i32 %139, i32* %11
br label %80
140: ; preds = %80
%141 = load float*, float** %6
%142 = getelementptr inbounds float, float* %141, i64 0
%143 = load float, float* %142
%144 = load float*, float** %6
%145 = load i32, i32* %7
%146 = mul nsw i32 3, %145
%147 = load i32, i32* %9
%148 = mul nsw i32 3, %147
%149 = load i32, i32* %8
%150 = mul nsw i32 %148, %149
%151 = add nsw i32 %146, %150
%152 = sext i32 %151 to i64
%153 = getelementptr inbounds float, float* %144, i64 %152
store float %143, float* %153
%154 = load float*, float** %6
%155 = getelementptr inbounds float, float* %154, i64 1
%156 = load float, float* %155
%157 = load float*, float** %6
%158 = load i32, i32* %7
%159 = mul nsw i32 3, %158
%160 = add nsw i32 1, %159
%161 = load i32, i32* %9
%162 = mul nsw i32 3, %161
%163 = load i32, i32* %8
%164 = mul nsw i32 %162, %163
%165 = add nsw i32 %160, %164
%166 = sext i32 %165 to i64
%167 = getelementptr inbounds float, float* %157, i64 %166
store float %156, float* %167
%168 = load float*, float** %6
%169 = getelementptr inbounds float, float* %168, i64 2
%170 = load float, float* %169
%171 = load float*, float** %6
%172 = load i32, i32* %7
%173 = mul nsw i32 3, %172
%174 = add nsw i32 2, %173
%175 = load i32, i32* %9
%176 = mul nsw i32 3, %175
%177 = load i32, i32* %8
%178 = mul nsw i32 %176, %177
%179 = add nsw i32 %174, %178
%180 = sext i32 %179 to i64
%181 = getelementptr inbounds float, float* %171, i64 %180
store float %170, float* %181
ret void
}

LLVM IR (-O2):
define void @cbguard2l(float* nocapture %0, i32 %1, i32 %2, i32 %3, i32 %4) {
%6 = icmp sgt i32 %2, 0
br i1 %6, label %7, label %13
7: ; preds = %5
%8 = mul nsw i32 %3, 3
%9 = mul nsw i32 %1, 3
%10 = sext i32 %8 to i64
%11 = sext i32 %9 to i64
%12 = zext i32 %2 to i64
br label %20
13: ; preds = %20, %5
%14 = icmp sgt i32 %1, 0
%15 = mul nsw i32 %3, 3
%16 = mul nsw i32 %15, %2
br i1 %14, label %17, label %62
17: ; preds = %13
%18 = sext i32 %16 to i64
%19 = zext i32 %1 to i64
br label %43
20: ; preds = %7, %20
%21 = phi i64 [ 0, %7 ], [ %41, %20 ]
%22 = mul nsw i64 %21, %10
%23 = getelementptr inbounds float, float* %0, i64 %22
%24 = load float, float* %23
%25 = add nsw i64 %22, %11
%26 = getelementptr inbounds float, float* %0, i64 %25
store float %24, float* %26
%27 = add nsw i64 %22, 1
%28 = getelementptr inbounds float, float* %0, i64 %27
%29 = load float, float* %28
%30 = trunc i64 %22 to i32
%31 = add i32 %9, %30
%32 = add i32 %31, 1
%33 = sext i32 %32 to i64
%34 = getelementptr inbounds float, float* %0, i64 %33
store float %29, float* %34
%35 = add nsw i64 %22, 2
%36 = getelementptr inbounds float, float* %0, i64 %35
%37 = load float, float* %36
%38 = add i32 %31, 2
%39 = sext i32 %38 to i64
%40 = getelementptr inbounds float, float* %0, i64 %39
store float %37, float* %40
%41 = add nuw nsw i64 %21, 1
%42 = icmp eq i64 %41, %12
br i1 %42, label %13, label %20
43: ; preds = %17, %43
%44 = phi i64 [ 0, %17 ], [ %60, %43 ]
%45 = mul nuw nsw i64 %44, 3
%46 = getelementptr inbounds float, float* %0, i64 %45
%47 = load float, float* %46
%48 = add nsw i64 %45, %18
%49 = getelementptr inbounds float, float* %0, i64 %48
store float %47, float* %49
%50 = add nuw nsw i64 %45, 1
%51 = getelementptr inbounds float, float* %0, i64 %50
%52 = load float, float* %51
%53 = add nsw i64 %50, %18
%54 = getelementptr inbounds float, float* %0, i64 %53
store float %52, float* %54
%55 = add nuw nsw i64 %45, 2
%56 = getelementptr inbounds float, float* %0, i64 %55
%57 = load float, float* %56
%58 = add nsw i64 %55, %18
%59 = getelementptr inbounds float, float* %0, i64 %58
store float %57, float* %59
%60 = add nuw nsw i64 %44, 1
%61 = icmp eq i64 %60, %19
br i1 %61, label %62, label %43
62: ; preds = %43, %13
%63 = load float, float* %0
%64 = mul nsw i32 %1, 3
%65 = add i32 %16, %64
%66 = sext i32 %65 to i64
%67 = getelementptr inbounds float, float* %0, i64 %66
store float %63, float* %67
%68 = getelementptr inbounds float, float* %0, i64 1
%69 = load float, float* %68
%70 = add i32 %65, 1
%71 = sext i32 %70 to i64
%72 = getelementptr inbounds float, float* %0, i64 %71
store float %69, float* %72
%73 = getelementptr inbounds float, float* %0, i64 2
%74 = load float, float* %73
%75 = add i32 %65, 2
%76 = sext i32 %75 to i64
%77 = getelementptr inbounds float, float* %0, i64 %76
store float %74, float* %77
ret void
}