void swap2(char **argv, int st, int pl) {
  char *t1;
  char *t2;
  int i;
  t1 = argv[st];
  t2 = argv[st + 1];
  for (i = st - 1; i >= pl; --i) {
    argv[i + 2] = argv[i];
  }
  argv[pl] = t1;
  argv[pl + 1] = t2;
}


x86 assembly (clang, -O0):
<swap2>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x18(%rbp)
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x20(%rbp)
mov    -0xc(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x10(%rbp),%eax
jl     1173 <swap2+0x73>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x24(%rbp)
jmp    113c <swap2+0x3c>
mov    -0x18(%rbp),%rdx
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x20(%rbp),%rdx
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %rdx,(%rax,%rcx,8)
pop    %rbp
ret

x86 assembly (clang, -O2):
<swap2>:
push   %r14
push   %rbx
movslq %esi,%rsi
mov    (%rdi,%rsi,8),%r8
mov    0x8(%rdi,%rsi,8),%r10
movslq %edx,%rax
cmp    %edx,%esi
jle    11e6 <swap2+0xe6>
mov    %rsi,%r11
sub    %rax,%r11
cmp    $0x2,%r11
jb     11d0 <swap2+0xd0>
mov    %r11,%r9
and    $0xfffffffffffffffe,%r9
lea    -0x2(%r9),%rcx
mov    %rcx,%rbx
shr    %rbx
add    $0x1,%rbx
mov    %ebx,%r14d
and    $0x3,%r14d
cmp    $0x6,%rcx
jae    1155 <swap2+0x55>
xor    %edx,%edx
test   %r14,%r14
jne    1199 <swap2+0x99>
jmp    11c5 <swap2+0xc5>
and    $0xfffffffffffffffc,%rbx
lea    (%rdi,%rsi,8),%rcx
xor    %edx,%edx
nop
movups -0x40(%rcx,%rdx,8),%xmm0
movups -0x30(%rcx,%rdx,8),%xmm1
movups -0x20(%rcx,%rdx,8),%xmm2
movups -0x10(%rcx,%rdx,8),%xmm3
movups %xmm3,(%rcx,%rdx,8)
movups %xmm2,-0x10(%rcx,%rdx,8)
movups %xmm1,-0x20(%rcx,%rdx,8)
movups %xmm0,-0x30(%rcx,%rdx,8)
add    $0xfffffffffffffff8,%rdx
add    $0xfffffffffffffffc,%rbx
jne    1160 <swap2+0x60>
neg    %rdx
test   %r14,%r14
je     11c5 <swap2+0xc5>
mov    %rsi,%rcx
sub    %rdx,%rcx
lea    (%rdi,%rcx,8),%rcx
shl    $0x4,%r14
xor    %edx,%edx
nopl   0x0(%rax)
movups -0x10(%rcx,%rdx,1),%xmm0
movups %xmm0,(%rcx,%rdx,1)
add    $0xfffffffffffffff0,%rdx
mov    %r14,%rbx
add    %rdx,%rbx
jne    11b0 <swap2+0xb0>
cmp    %r9,%r11
je     11e6 <swap2+0xe6>
sub    %r9,%rsi
nopl   (%rax)
mov    -0x8(%rdi,%rsi,8),%rcx
mov    %rcx,0x8(%rdi,%rsi,8)
lea    -0x1(%rsi),%rcx
mov    %rcx,%rsi
cmp    %rax,%rcx
jg     11d0 <swap2+0xd0>
mov    %r8,(%rdi,%rax,8)
mov    %r10,0x8(%rdi,%rax,8)
pop    %rbx
pop    %r14
ret

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

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