#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*/ bsort(double *, int);
void clip(double *x, int n, int low, int high) {
  int i;
  if ((low > 0) || (high > 0))
    bsort(x, n);
  if (low > 0) {
    for (i = 0; i < n - low; i++) {
      x[i] = x[i + low];
    }
  }
  return;
}


x86 assembly (clang, -O0):
<clip>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %ecx,-0x14(%rbp)
cmpl   $0x0,-0x10(%rbp)
jg     1139 <clip+0x29>
cmpl   $0x0,-0x14(%rbp)
jle    1145 <clip+0x35>
mov    -0x8(%rbp),%rdi
mov    -0xc(%rbp),%esi
call   1030 <bsort@plt>
cmpl   $0x0,-0x10(%rbp)
jle    1199 <clip+0x89>
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    -0x10(%rbp),%ecx
cmp    %ecx,%eax
jge    1194 <clip+0x84>
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1156 <clip+0x46>
jmp    1199 <clip+0x89>
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<clip>:
push   %rbp
push   %r14
push   %rbx
mov    %edx,%ebp
mov    %esi,%r14d
mov    %rdi,%rbx
test   %edx,%edx
jg     1124 <clip+0x14>
test   %ecx,%ecx
jle    112f <clip+0x1f>
mov    %rbx,%rdi
mov    %r14d,%esi
call   1030 <bsort@plt>
test   %ebp,%ebp
jle    12c4 <clip+0x1b4>
sub    %ebp,%r14d
test   %r14d,%r14d
jle    12c4 <clip+0x1b4>
mov    %ebp,%r8d
mov    %r14d,%eax
cmp    $0x4,%r14d
jb     1171 <clip+0x61>
lea    (%r8,%rax,1),%rcx
lea    (%rbx,%rcx,8),%rcx
cmp    %rbx,%rcx
jbe    11fc <clip+0xec>
lea    (%rbx,%rax,8),%rcx
lea    (%rbx,%r8,8),%rdx
cmp    %rcx,%rdx
jae    11fc <clip+0xec>
xor    %edx,%edx
mov    %rdx,%rcx
not    %rcx
add    %rax,%rcx
mov    %rax,%rsi
and    $0x3,%rsi
je     11a4 <clip+0x94>
lea    (%rbx,%r8,8),%rdi
nopl   0x0(%rax)
movsd  (%rdi,%rdx,8),%xmm0
movsd  %xmm0,(%rbx,%rdx,8)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rsi
jne    1190 <clip+0x80>
cmp    $0x3,%rcx
jb     12c4 <clip+0x1b4>
lea    (%rbx,%r8,8),%rcx
add    $0x18,%rcx
add    $0x18,%rbx
nopw   0x0(%rax,%rax,1)
movsd  -0x18(%rcx,%rdx,8),%xmm0
movsd  %xmm0,-0x18(%rbx,%rdx,8)
movsd  -0x10(%rcx,%rdx,8),%xmm0
movsd  %xmm0,-0x10(%rbx,%rdx,8)
movsd  -0x8(%rcx,%rdx,8),%xmm0
movsd  %xmm0,-0x8(%rbx,%rdx,8)
movsd  (%rcx,%rdx,8),%xmm0
movsd  %xmm0,(%rbx,%rdx,8)
add    $0x4,%rdx
cmp    %rdx,%rax
jne    11c0 <clip+0xb0>
jmp    12c4 <clip+0x1b4>
mov    %eax,%edx
and    $0xfffffffc,%edx
lea    -0x4(%rdx),%rcx
mov    %rcx,%rdi
shr    $0x2,%rdi
add    $0x1,%rdi
mov    %edi,%esi
and    $0x3,%esi
cmp    $0xc,%rcx
jae    121f <clip+0x10f>
xor    %ebp,%ebp
jmp    1288 <clip+0x178>
and    $0xfffffffffffffffc,%rdi
lea    (%rbx,%r8,8),%rcx
add    $0x70,%rcx
xor    %ebp,%ebp
nopl   (%rax)
movups -0x70(%rcx,%rbp,8),%xmm0
movups -0x60(%rcx,%rbp,8),%xmm1
movups %xmm0,(%rbx,%rbp,8)
movups %xmm1,0x10(%rbx,%rbp,8)
movups -0x50(%rcx,%rbp,8),%xmm0
movups -0x40(%rcx,%rbp,8),%xmm1
movups %xmm0,0x20(%rbx,%rbp,8)
movups %xmm1,0x30(%rbx,%rbp,8)
movups -0x30(%rcx,%rbp,8),%xmm0
movups -0x20(%rcx,%rbp,8),%xmm1
movups %xmm0,0x40(%rbx,%rbp,8)
movups %xmm1,0x50(%rbx,%rbp,8)
movups -0x10(%rcx,%rbp,8),%xmm0
movups (%rcx,%rbp,8),%xmm1
movups %xmm0,0x60(%rbx,%rbp,8)
movups %xmm1,0x70(%rbx,%rbp,8)
add    $0x10,%rbp
add    $0xfffffffffffffffc,%rdi
jne    1230 <clip+0x120>
test   %rsi,%rsi
je     12bb <clip+0x1ab>
lea    (%rbx,%rbp,8),%rcx
add    $0x10,%rcx
lea    (%rcx,%r8,8),%rdi
shl    $0x5,%rsi
xor    %ebp,%ebp
nop
movups -0x10(%rdi,%rbp,1),%xmm0
movups (%rdi,%rbp,1),%xmm1
movups %xmm0,-0x10(%rcx,%rbp,1)
movups %xmm1,(%rcx,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%rsi
jne    12a0 <clip+0x190>
cmp    %rax,%rdx
jne    1173 <clip+0x63>
pop    %rbx
pop    %r14
pop    %rbp
ret

LLVM IR (-O0):
define void @clip(double* %0, i32 %1, i32 %2, i32 %3) {
%5 = alloca double*
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
store double* %0, double** %5
store i32 %1, i32* %6
store i32 %2, i32* %7
store i32 %3, i32* %8
%10 = load i32, i32* %7
%11 = icmp sgt i32 %10, 0
br i1 %11, label %15, label %12
12: ; preds = %4
%13 = load i32, i32* %8
%14 = icmp sgt i32 %13, 0
br i1 %14, label %15, label %19
15: ; preds = %12, %4
%16 = load double*, double** %5
%17 = load i32, i32* %6
%18 = call i32 @bsort(double* %16, i32 %17)
br label %19
19: ; preds = %15, %12
%20 = load i32, i32* %7
%21 = icmp sgt i32 %20, 0
br i1 %21, label %22, label %45
22: ; preds = %19
store i32 0, i32* %9
br label %23
23: ; preds = %41, %22
%24 = load i32, i32* %9
%25 = load i32, i32* %6
%26 = load i32, i32* %7
%27 = sub nsw i32 %25, %26
%28 = icmp slt i32 %24, %27
br i1 %28, label %29, label %44
29: ; preds = %23
%30 = load double*, double** %5
%31 = load i32, i32* %9
%32 = load i32, i32* %7
%33 = add nsw i32 %31, %32
%34 = sext i32 %33 to i64
%35 = getelementptr inbounds double, double* %30, i64 %34
%36 = load double, double* %35
%37 = load double*, double** %5
%38 = load i32, i32* %9
%39 = sext i32 %38 to i64
%40 = getelementptr inbounds double, double* %37, i64 %39
store double %36, double* %40
br label %41
41: ; preds = %29
%42 = load i32, i32* %9
%43 = add nsw i32 %42, 1
store i32 %43, i32* %9
br label %23
44: ; preds = %23
br label %45
45: ; preds = %44, %19
ret void
}

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