void snake_init_extrude_bounds(float *bminus, float *bplus, float rad,
                               int pathn) {
  int i;
  for (i = 0; i < pathn; i++) {
    bminus[i] = -rad;
    bplus[i] = rad;
  }
}


x86 assembly (clang, -O0):
<snake_init_extrude_bounds>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movss  %xmm0,-0x14(%rbp)
mov    %edx,-0x18(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1166 <snake_init_extrude_bounds+0x66>
movss  -0x14(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x14(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    111b <snake_init_extrude_bounds+0x1b>
pop    %rbp
ret

x86 assembly (clang, -O2):
<snake_init_extrude_bounds>:
test   %edx,%edx
jle    1286 <snake_init_extrude_bounds+0x186>
movaps 0xef1(%rip),%xmm1
xorps  %xmm0,%xmm1
mov    %edx,%r9d
cmp    $0x8,%edx
jb     112c <snake_init_extrude_bounds+0x2c>
lea    (%rsi,%r9,4),%rax
cmp    %rdi,%rax
jbe    119c <snake_init_extrude_bounds+0x9c>
lea    (%rdi,%r9,4),%rax
cmp    %rsi,%rax
jbe    119c <snake_init_extrude_bounds+0x9c>
xor    %ecx,%ecx
mov    %rcx,%rax
not    %rax
add    %r9,%rax
mov    %r9,%rdx
and    $0x3,%rdx
je     1154 <snake_init_extrude_bounds+0x54>
movss  %xmm1,(%rdi,%rcx,4)
movss  %xmm0,(%rsi,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rdx
jne    1140 <snake_init_extrude_bounds+0x40>
cmp    $0x3,%rax
jb     1286 <snake_init_extrude_bounds+0x186>
xchg   %ax,%ax
movss  %xmm1,(%rdi,%rcx,4)
movss  %xmm0,(%rsi,%rcx,4)
movss  %xmm1,0x4(%rdi,%rcx,4)
movss  %xmm0,0x4(%rsi,%rcx,4)
movss  %xmm1,0x8(%rdi,%rcx,4)
movss  %xmm0,0x8(%rsi,%rcx,4)
movss  %xmm1,0xc(%rdi,%rcx,4)
movss  %xmm0,0xc(%rsi,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%r9
jne    1160 <snake_init_extrude_bounds+0x60>
jmp    1286 <snake_init_extrude_bounds+0x186>
mov    %r9d,%ecx
and    $0xfffffff8,%ecx
movaps %xmm1,%xmm2
shufps $0x0,%xmm1,%xmm2
movaps %xmm0,%xmm3
shufps $0x0,%xmm0,%xmm3
lea    -0x8(%rcx),%rax
mov    %rax,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
mov    %edx,%r8d
and    $0x3,%r8d
cmp    $0x18,%rax
jae    11d0 <snake_init_extrude_bounds+0xd0>
xor    %eax,%eax
jmp    1238 <snake_init_extrude_bounds+0x138>
and    $0xfffffffffffffffc,%rdx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
movups %xmm2,(%rdi,%rax,4)
movups %xmm2,0x10(%rdi,%rax,4)
movups %xmm3,(%rsi,%rax,4)
movups %xmm3,0x10(%rsi,%rax,4)
movups %xmm2,0x20(%rdi,%rax,4)
movups %xmm2,0x30(%rdi,%rax,4)
movups %xmm3,0x20(%rsi,%rax,4)
movups %xmm3,0x30(%rsi,%rax,4)
movups %xmm2,0x40(%rdi,%rax,4)
movups %xmm2,0x50(%rdi,%rax,4)
movups %xmm3,0x40(%rsi,%rax,4)
movups %xmm3,0x50(%rsi,%rax,4)
movups %xmm2,0x60(%rdi,%rax,4)
movups %xmm2,0x70(%rdi,%rax,4)
movups %xmm3,0x60(%rsi,%rax,4)
movups %xmm3,0x70(%rsi,%rax,4)
add    $0x20,%rax
add    $0xfffffffffffffffc,%rdx
jne    11e0 <snake_init_extrude_bounds+0xe0>
test   %r8,%r8
je     127d <snake_init_extrude_bounds+0x17d>
lea    (%rsi,%rax,4),%r10
add    $0x10,%r10
lea    (%rdi,%rax,4),%rax
add    $0x10,%rax
shl    $0x5,%r8
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups %xmm2,-0x10(%rax,%rdx,1)
movups %xmm2,(%rax,%rdx,1)
movups %xmm3,-0x10(%r10,%rdx,1)
movups %xmm3,(%r10,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%r8
jne    1260 <snake_init_extrude_bounds+0x160>
cmp    %r9,%rcx
jne    112e <snake_init_extrude_bounds+0x2e>
ret

LLVM IR (-O0):
define void @snake_init_extrude_bounds(float* %0, float* %1, float %2, i32 %3) {
%5 = alloca float*
%6 = alloca float*
%7 = alloca float
%8 = alloca i32
%9 = alloca i32
store float* %0, float** %5
store float* %1, float** %6
store float %2, float* %7
store i32 %3, i32* %8
store i32 0, i32* %9
br label %10
10: ; preds = %26, %4
%11 = load i32, i32* %9
%12 = load i32, i32* %8
%13 = icmp slt i32 %11, %12
br i1 %13, label %14, label %29
14: ; preds = %10
%15 = load float, float* %7
%16 = fneg float %15
%17 = load float*, float** %5
%18 = load i32, i32* %9
%19 = sext i32 %18 to i64
%20 = getelementptr inbounds float, float* %17, i64 %19
store float %16, float* %20
%21 = load float, float* %7
%22 = load float*, float** %6
%23 = load i32, i32* %9
%24 = sext i32 %23 to i64
%25 = getelementptr inbounds float, float* %22, i64 %24
store float %21, float* %25
br label %26
26: ; preds = %14
%27 = load i32, i32* %9
%28 = add nsw i32 %27, 1
store i32 %28, i32* %9
br label %10
29: ; preds = %10
ret void
}

LLVM IR (-O2):
define void @snake_init_extrude_bounds(float* nocapture writeonly %0, float* nocapture writeonly %1, float %2, i32 %3) {
%5 = icmp sgt i32 %3, 0
br i1 %5, label %6, label %125
6: ; preds = %4
%7 = fneg float %2
%8 = zext i32 %3 to i64
%9 = icmp ult i32 %3, 8
br i1 %9, label %93, label %10
10: ; preds = %6
%11 = getelementptr float, float* %0, i64 %8
%12 = getelementptr float, float* %1, i64 %8
%13 = icmp ugt float* %12, %0
%14 = icmp ugt float* %11, %1
%15 = and i1 %13, %14
br i1 %15, label %93, label %16
16: ; preds = %10
%17 = and i64 %8, 4294967288
%18 = insertelement <4 x float> poison, float %7, i64 0
%19 = shufflevector <4 x float> %18, <4 x float> poison, <4 x i32> zeroinitializer
%20 = insertelement <4 x float> poison, float %7, i64 0
%21 = shufflevector <4 x float> %20, <4 x float> poison, <4 x i32> zeroinitializer
%22 = insertelement <4 x float> poison, float %2, i64 0
%23 = shufflevector <4 x float> %22, <4 x float> poison, <4 x i32> zeroinitializer
%24 = insertelement <4 x float> poison, float %2, i64 0
%25 = shufflevector <4 x float> %24, <4 x float> poison, <4 x i32> zeroinitializer
%26 = add nsw i64 %17, -8
%27 = lshr exact i64 %26, 3
%28 = add nuw nsw i64 %27, 1
%29 = and i64 %28, 3
%30 = icmp ult i64 %26, 24
br i1 %30, label %74, label %31
31: ; preds = %16
%32 = and i64 %28, 4611686018427387900
br label %33
33: ; preds = %33, %31
%34 = phi i64 [ 0, %31 ], [ %71, %33 ]
%35 = phi i64 [ 0, %31 ], [ %72, %33 ]
%36 = getelementptr inbounds float, float* %0, i64 %34
%37 = bitcast float* %36 to <4 x float>*
store <4 x float> %19, <4 x float>* %37
%38 = getelementptr inbounds float, float* %36, i64 4
%39 = bitcast float* %38 to <4 x float>*
store <4 x float> %21, <4 x float>* %39
%40 = getelementptr inbounds float, float* %1, i64 %34
%41 = bitcast float* %40 to <4 x float>*
store <4 x float> %23, <4 x float>* %41
%42 = getelementptr inbounds float, float* %40, i64 4
%43 = bitcast float* %42 to <4 x float>*
store <4 x float> %25, <4 x float>* %43
%44 = or i64 %34, 8
%45 = getelementptr inbounds float, float* %0, i64 %44
%46 = bitcast float* %45 to <4 x float>*
store <4 x float> %19, <4 x float>* %46
%47 = getelementptr inbounds float, float* %45, i64 4
%48 = bitcast float* %47 to <4 x float>*
store <4 x float> %21, <4 x float>* %48
%49 = getelementptr inbounds float, float* %1, i64 %44
%50 = bitcast float* %49 to <4 x float>*
store <4 x float> %23, <4 x float>* %50
%51 = getelementptr inbounds float, float* %49, i64 4
%52 = bitcast float* %51 to <4 x float>*
store <4 x float> %25, <4 x float>* %52
%53 = or i64 %34, 16
%54 = getelementptr inbounds float, float* %0, i64 %53
%55 = bitcast float* %54 to <4 x float>*
store <4 x float> %19, <4 x float>* %55
%56 = getelementptr inbounds float, float* %54, i64 4
%57 = bitcast float* %56 to <4 x float>*
store <4 x float> %21, <4 x float>* %57
%58 = getelementptr inbounds float, float* %1, i64 %53
%59 = bitcast float* %58 to <4 x float>*
store <4 x float> %23, <4 x float>* %59
%60 = getelementptr inbounds float, float* %58, i64 4
%61 = bitcast float* %60 to <4 x float>*
store <4 x float> %25, <4 x float>* %61
%62 = or i64 %34, 24
%63 = getelementptr inbounds float, float* %0, i64 %62
%64 = bitcast float* %63 to <4 x float>*
store <4 x float> %19, <4 x float>* %64
%65 = getelementptr inbounds float, float* %63, i64 4
%66 = bitcast float* %65 to <4 x float>*
store <4 x float> %21, <4 x float>* %66
%67 = getelementptr inbounds float, float* %1, i64 %62
%68 = bitcast float* %67 to <4 x float>*
store <4 x float> %23, <4 x float>* %68
%69 = getelementptr inbounds float, float* %67, i64 4
%70 = bitcast float* %69 to <4 x float>*
store <4 x float> %25, <4 x float>* %70
%71 = add nuw i64 %34, 32
%72 = add i64 %35, 4
%73 = icmp eq i64 %72, %32
br i1 %73, label %74, label %33
74: ; preds = %33, %16
%75 = phi i64 [ 0, %16 ], [ %71, %33 ]
%76 = icmp eq i64 %29, 0
br i1 %76, label %91, label %77
77: ; preds = %74, %77
%78 = phi i64 [ %88, %77 ], [ %75, %74 ]
%79 = phi i64 [ %89, %77 ], [ 0, %74 ]
%80 = getelementptr inbounds float, float* %0, i64 %78
%81 = bitcast float* %80 to <4 x float>*
store <4 x float> %19, <4 x float>* %81
%82 = getelementptr inbounds float, float* %80, i64 4
%83 = bitcast float* %82 to <4 x float>*
store <4 x float> %21, <4 x float>* %83
%84 = getelementptr inbounds float, float* %1, i64 %78
%85 = bitcast float* %84 to <4 x float>*
store <4 x float> %23, <4 x float>* %85
%86 = getelementptr inbounds float, float* %84, i64 4
%87 = bitcast float* %86 to <4 x float>*
store <4 x float> %25, <4 x float>* %87
%88 = add nuw i64 %78, 8
%89 = add i64 %79, 1
%90 = icmp eq i64 %89, %29
br i1 %90, label %91, label %77
91: ; preds = %77, %74
%92 = icmp eq i64 %17, %8
br i1 %92, label %125, label %93
93: ; preds = %10, %6, %91
%94 = phi i64 [ 0, %10 ], [ 0, %6 ], [ %17, %91 ]
%95 = xor i64 %94, -1
%96 = add nsw i64 %95, %8
%97 = and i64 %8, 3
%98 = icmp eq i64 %97, 0
br i1 %98, label %107, label %99
99: ; preds = %93, %99
%100 = phi i64 [ %104, %99 ], [ %94, %93 ]
%101 = phi i64 [ %105, %99 ], [ 0, %93 ]
%102 = getelementptr inbounds float, float* %0, i64 %100
store float %7, float* %102
%103 = getelementptr inbounds float, float* %1, i64 %100
store float %2, float* %103
%104 = add nuw nsw i64 %100, 1
%105 = add i64 %101, 1
%106 = icmp eq i64 %105, %97
br i1 %106, label %107, label %99
107: ; preds = %99, %93
%108 = phi i64 [ %94, %93 ], [ %104, %99 ]
%109 = icmp ult i64 %96, 3
br i1 %109, label %125, label %110
110: ; preds = %107, %110
%111 = phi i64 [ %123, %110 ], [ %108, %107 ]
%112 = getelementptr inbounds float, float* %0, i64 %111
store float %7, float* %112
%113 = getelementptr inbounds float, float* %1, i64 %111
store float %2, float* %113
%114 = add nuw nsw i64 %111, 1
%115 = getelementptr inbounds float, float* %0, i64 %114
store float %7, float* %115
%116 = getelementptr inbounds float, float* %1, i64 %114
store float %2, float* %116
%117 = add nuw nsw i64 %111, 2
%118 = getelementptr inbounds float, float* %0, i64 %117
store float %7, float* %118
%119 = getelementptr inbounds float, float* %1, i64 %117
store float %2, float* %119
%120 = add nuw nsw i64 %111, 3
%121 = getelementptr inbounds float, float* %0, i64 %120
store float %7, float* %121
%122 = getelementptr inbounds float, float* %1, i64 %120
store float %2, float* %122
%123 = add nuw nsw i64 %111, 4
%124 = icmp eq i64 %123, %8
br i1 %124, label %125, label %110
125: ; preds = %107, %110, %91, %4
ret void
}