void removeArgs(int *argc, char **argv, int idx, int nargs) {
  int i;
  if ((idx + nargs) > *argc)
    return;
  for (i = idx + nargs; i < *argc; i++) {
    argv[i - nargs] = argv[i];
  }
  *argc -= nargs;
}


x86 assembly (clang, -O0):
<removeArgs>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
mov    -0x14(%rbp),%eax
add    -0x18(%rbp),%eax
mov    -0x8(%rbp),%rcx
cmp    (%rcx),%eax
jle    1129 <removeArgs+0x29>
jmp    1179 <removeArgs+0x79>
mov    -0x14(%rbp),%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
mov    -0x8(%rbp),%rcx
cmp    (%rcx),%eax
jge    116c <removeArgs+0x6c>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    -0x18(%rbp),%ecx
movslq %ecx,%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1132 <removeArgs+0x32>
mov    -0x18(%rbp),%edx
mov    -0x8(%rbp),%rax
mov    (%rax),%ecx
sub    %edx,%ecx
mov    %ecx,(%rax)
pop    %rbp
ret

x86 assembly (clang, -O2):
<removeArgs>:
push   %r15
push   %r14
push   %r12
push   %rbx
add    %ecx,%edx
movslq (%rdi),%r14
cmp    %r14d,%edx
jg     1227 <removeArgs+0x127>
cmp    %r14d,%edx
jge    1221 <removeArgs+0x121>
movslq %edx,%rdx
movslq %ecx,%r8
mov    %r14,%r9
sub    %rdx,%r9
cmp    $0x4,%r9
jb     11fe <removeArgs+0xfe>
mov    %rdx,%rax
sub    %r8,%rax
lea    (%rsi,%rax,8),%rax
lea    (%rsi,%r14,8),%rbx
cmp    %rbx,%rax
jae    115e <removeArgs+0x5e>
mov    %r14,%rax
sub    %r8,%rax
lea    (%rsi,%rax,8),%rax
lea    (%rsi,%rdx,8),%rbx
cmp    %rax,%rbx
jb     11fe <removeArgs+0xfe>
mov    %r9,%r10
and    $0xfffffffffffffffc,%r10
lea    -0x4(%r10),%rax
mov    %rax,%r11
shr    $0x2,%r11
add    $0x1,%r11
test   %rax,%rax
je     122f <removeArgs+0x12f>
mov    %r11,%rax
and    $0xfffffffffffffffe,%rax
mov    %r8,%rbx
neg    %rbx
add    %rdx,%rbx
add    $0x6,%rbx
lea    (%rsi,%rbx,8),%r15
lea    (%rsi,%rdx,8),%r12
add    $0x30,%r12
xor    %ebx,%ebx
nop
movups -0x30(%r12,%rbx,8),%xmm0
movups -0x20(%r12,%rbx,8),%xmm1
movups %xmm0,-0x30(%r15,%rbx,8)
movups %xmm1,-0x20(%r15,%rbx,8)
movups -0x10(%r12,%rbx,8),%xmm0
movups (%r12,%rbx,8),%xmm1
movups %xmm0,-0x10(%r15,%rbx,8)
movups %xmm1,(%r15,%rbx,8)
add    $0x8,%rbx
add    $0xfffffffffffffffe,%rax
jne    11a0 <removeArgs+0xa0>
test   $0x1,%r11b
je     11f6 <removeArgs+0xf6>
add    %rdx,%rbx
movups (%rsi,%rbx,8),%xmm0
movups 0x10(%rsi,%rbx,8),%xmm1
sub    %r8,%rbx
movups %xmm0,(%rsi,%rbx,8)
movups %xmm1,0x10(%rsi,%rbx,8)
cmp    %r10,%r9
je     1221 <removeArgs+0x121>
add    %r10,%rdx
shl    $0x3,%r8
mov    %rsi,%rax
sub    %r8,%rax
nopl   0x0(%rax,%rax,1)
mov    (%rsi,%rdx,8),%rbx
mov    %rbx,(%rax,%rdx,8)
add    $0x1,%rdx
cmp    %r14,%rdx
jl     1210 <removeArgs+0x110>
sub    %ecx,%r14d
mov    %r14d,(%rdi)
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
ret
xor    %ebx,%ebx
test   $0x1,%r11b
jne    11de <removeArgs+0xde>
jmp    11f6 <removeArgs+0xf6>

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

LLVM IR (-O2):
define void @removeArgs(i32* nocapture %0, i8** nocapture %1, i32 %2, i32 %3) {
%5 = add i32 %3, %2
%6 = load i32, i32* %0
%7 = icmp sgt i32 %5, %6
br i1 %7, label %97, label %8
8: ; preds = %4
%9 = icmp slt i32 %5, %6
br i1 %9, label %10, label %95
10: ; preds = %8
%11 = sext i32 %5 to i64
%12 = sext i32 %3 to i64
%13 = sext i32 %6 to i64
%14 = sub nsw i64 %13, %11
%15 = icmp ult i64 %14, 4
br i1 %15, label %85, label %16
16: ; preds = %10
%17 = sub nsw i64 %11, %12
%18 = getelementptr i8*, i8** %1, i64 %17
%19 = sub nsw i64 %13, %12
%20 = getelementptr i8*, i8** %1, i64 %19
%21 = getelementptr i8*, i8** %1, i64 %11
%22 = getelementptr i8*, i8** %1, i64 %13
%23 = icmp ult i8** %18, %22
%24 = icmp ult i8** %21, %20
%25 = and i1 %23, %24
br i1 %25, label %85, label %26
26: ; preds = %16
%27 = and i64 %14, -4
%28 = add nsw i64 %27, %11
%29 = add nsw i64 %27, -4
%30 = lshr exact i64 %29, 2
%31 = add nuw nsw i64 %30, 1
%32 = and i64 %31, 1
%33 = icmp eq i64 %29, 0
br i1 %33, label %67, label %34
34: ; preds = %26
%35 = and i64 %31, 9223372036854775806
br label %36
36: ; preds = %36, %34
%37 = phi i64 [ 0, %34 ], [ %64, %36 ]
%38 = phi i64 [ 0, %34 ], [ %65, %36 ]
%39 = add i64 %37, %11
%40 = getelementptr inbounds i8*, i8** %1, i64 %39
%41 = bitcast i8** %40 to <2 x i8*>*
%42 = load <2 x i8*>, <2 x i8*>* %41
%43 = getelementptr inbounds i8*, i8** %40, i64 2
%44 = bitcast i8** %43 to <2 x i8*>*
%45 = load <2 x i8*>, <2 x i8*>* %44
%46 = sub nsw i64 %39, %12
%47 = getelementptr inbounds i8*, i8** %1, i64 %46
%48 = bitcast i8** %47 to <2 x i8*>*
store <2 x i8*> %42, <2 x i8*>* %48
%49 = getelementptr inbounds i8*, i8** %47, i64 2
%50 = bitcast i8** %49 to <2 x i8*>*
store <2 x i8*> %45, <2 x i8*>* %50
%51 = or i64 %37, 4
%52 = add i64 %51, %11
%53 = getelementptr inbounds i8*, i8** %1, i64 %52
%54 = bitcast i8** %53 to <2 x i8*>*
%55 = load <2 x i8*>, <2 x i8*>* %54
%56 = getelementptr inbounds i8*, i8** %53, i64 2
%57 = bitcast i8** %56 to <2 x i8*>*
%58 = load <2 x i8*>, <2 x i8*>* %57
%59 = sub nsw i64 %52, %12
%60 = getelementptr inbounds i8*, i8** %1, i64 %59
%61 = bitcast i8** %60 to <2 x i8*>*
store <2 x i8*> %55, <2 x i8*>* %61
%62 = getelementptr inbounds i8*, i8** %60, i64 2
%63 = bitcast i8** %62 to <2 x i8*>*
store <2 x i8*> %58, <2 x i8*>* %63
%64 = add nuw i64 %37, 8
%65 = add i64 %38, 2
%66 = icmp eq i64 %65, %35
br i1 %66, label %67, label %36
67: ; preds = %36, %26
%68 = phi i64 [ 0, %26 ], [ %64, %36 ]
%69 = icmp eq i64 %32, 0
br i1 %69, label %83, label %70
70: ; preds = %67
%71 = add i64 %68, %11
%72 = getelementptr inbounds i8*, i8** %1, i64 %71
%73 = bitcast i8** %72 to <2 x i8*>*
%74 = load <2 x i8*>, <2 x i8*>* %73
%75 = getelementptr inbounds i8*, i8** %72, i64 2
%76 = bitcast i8** %75 to <2 x i8*>*
%77 = load <2 x i8*>, <2 x i8*>* %76
%78 = sub nsw i64 %71, %12
%79 = getelementptr inbounds i8*, i8** %1, i64 %78
%80 = bitcast i8** %79 to <2 x i8*>*
store <2 x i8*> %74, <2 x i8*>* %80
%81 = getelementptr inbounds i8*, i8** %79, i64 2
%82 = bitcast i8** %81 to <2 x i8*>*
store <2 x i8*> %77, <2 x i8*>* %82
br label %83
83: ; preds = %67, %70
%84 = icmp eq i64 %14, %27
br i1 %84, label %95, label %85
85: ; preds = %16, %10, %83
%86 = phi i64 [ %11, %16 ], [ %11, %10 ], [ %28, %83 ]
br label %87
87: ; preds = %85, %87
%88 = phi i64 [ %93, %87 ], [ %86, %85 ]
%89 = getelementptr inbounds i8*, i8** %1, i64 %88
%90 = load i8*, i8** %89
%91 = sub nsw i64 %88, %12
%92 = getelementptr inbounds i8*, i8** %1, i64 %91
store i8* %90, i8** %92
%93 = add nsw i64 %88, 1
%94 = icmp slt i64 %93, %13
br i1 %94, label %87, label %95
95: ; preds = %87, %83, %8
%96 = sub nsw i32 %6, %3
store i32 %96, i32* %0
br label %97
97: ; preds = %4, %95
ret void
}