void copyImage16To32(short *fromImageData, int *toImageData, int width,
                     int height, int affectedL, int affectedT, int affectedR,
                     int affectedB) {
  long scanLine16, firstWord16, lastWord16;
  long scanLine32, firstWord32;
  int line;
  register unsigned int col;
  scanLine16 = ((((width) * (16) + 31) >> 5) << 2);
  firstWord16 = scanLine16 * affectedT + ((((affectedL) * (16)) >> 5) << 2);
  lastWord16 = scanLine16 * affectedT + ((((affectedR) * (16) + 31) >> 5) << 2);
  scanLine32 = ((((width) * (32) + 31) >> 5) << 2);
  firstWord32 = 0;
  for (line = affectedT; line < affectedB; line++) {
    register unsigned short *from =
        (unsigned short *)((long)fromImageData + firstWord16);
    register unsigned short *limit =
        (unsigned short *)((long)fromImageData + lastWord16);
    register unsigned int *to =
        (unsigned int *)((long)toImageData + firstWord32);
    while (from < limit) {
      to[0] = (col = (from[1]), (((col >> 10) & 0x1f) << 3) |
                                    (((col >> 5) & 0x1f) << 11) |
                                    ((col & 0x1f) << 19));
      to[1] = (col = (from[0]), (((col >> 10) & 0x1f) << 3) |
                                    (((col >> 5) & 0x1f) << 11) |
                                    ((col & 0x1f) << 19));
      from += 2;
      to += 2;
    }
    firstWord16 += scanLine16;
    lastWord16 += scanLine16;
    firstWord32 += scanLine32;
  }
}


x86 assembly (clang, -O0):
<copyImage16To32>:
push   %rbp
mov    %rsp,%rbp
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%eax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
mov    %r8d,-0x1c(%rbp)
mov    %r9d,-0x20(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x4,%eax
add    $0x1f,%eax
sar    $0x5,%eax
shl    $0x2,%eax
cltq
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x20(%rbp),%rcx
imul   %rcx,%rax
mov    -0x1c(%rbp),%ecx
shl    $0x4,%ecx
sar    $0x5,%ecx
shl    $0x2,%ecx
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x20(%rbp),%rcx
imul   %rcx,%rax
mov    0x10(%rbp),%ecx
shl    $0x4,%ecx
add    $0x1f,%ecx
sar    $0x5,%ecx
shl    $0x2,%ecx
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x5,%eax
add    $0x1f,%eax
sar    $0x5,%eax
shl    $0x2,%eax
cltq
mov    %rax,-0x40(%rbp)
movq   $0x0,-0x48(%rbp)
mov    -0x20(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    1298 <copyImage16To32+0x198>
mov    -0x8(%rbp),%rax
add    -0x30(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x8(%rbp),%rax
add    -0x38(%rbp),%rax
mov    %rax,-0x60(%rbp)
mov    -0x10(%rbp),%rax
add    -0x48(%rbp),%rax
mov    %rax,-0x68(%rbp)
mov    -0x58(%rbp),%rax
cmp    -0x60(%rbp),%rax
jae    1266 <copyImage16To32+0x166>
mov    -0x58(%rbp),%rax
movzwl 0x2(%rax),%eax
mov    %eax,-0x50(%rbp)
mov    -0x50(%rbp),%ecx
shr    $0xa,%ecx
and    $0x1f,%ecx
shl    $0x3,%ecx
mov    -0x50(%rbp),%eax
shr    $0x5,%eax
and    $0x1f,%eax
shl    $0xb,%eax
or     %eax,%ecx
mov    -0x50(%rbp),%eax
and    $0x1f,%eax
shl    $0x13,%eax
or     %eax,%ecx
mov    -0x68(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x58(%rbp),%rax
movzwl (%rax),%eax
mov    %eax,-0x50(%rbp)
mov    -0x50(%rbp),%ecx
shr    $0xa,%ecx
and    $0x1f,%ecx
shl    $0x3,%ecx
mov    -0x50(%rbp),%eax
shr    $0x5,%eax
and    $0x1f,%eax
shl    $0xb,%eax
or     %eax,%ecx
mov    -0x50(%rbp),%eax
and    $0x1f,%eax
shl    $0x13,%eax
or     %eax,%ecx
mov    -0x68(%rbp),%rax
mov    %ecx,0x4(%rax)
mov    -0x58(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x58(%rbp)
mov    -0x68(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x68(%rbp)
jmp    11cf <copyImage16To32+0xcf>
mov    -0x28(%rbp),%rax
add    -0x30(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x28(%rbp),%rax
add    -0x38(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x40(%rbp),%rax
add    -0x48(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    119f <copyImage16To32+0x9f>
pop    %rbp
ret

x86 assembly (clang, -O2):
<copyImage16To32>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %rsi,-0x18(%rsp)
mov    0x40(%rsp),%r11d
cmp    %r11d,%r9d
jge    135f <copyImage16To32+0x25f>
mov    0x38(%rsp),%eax
mov    %edx,%ecx
shl    $0x4,%ecx
add    $0x1f,%ecx
sar    $0x3,%ecx
and    $0xfffffffc,%ecx
movslq %ecx,%r14
movslq %r9d,%rsi
imul   %r14,%rsi
shl    $0x2,%edx
movslq %edx,%rcx
mov    %rcx,-0x10(%rsp)
shl    $0x4,%eax
add    $0x1f,%eax
sar    $0x3,%eax
and    $0xfffffffc,%eax
cltq
lea    (%rsi,%rax,1),%r13
add    %r8d,%r8d
and    $0xfffffffc,%r8d
movslq %r8d,%rcx
lea    (%rdi,%rsi,1),%r15
add    %rcx,%rsi
lea    (%r15,%rcx,1),%rdx
lea    (%rcx,%r15,1),%r8
add    $0x4,%r8
add    %rax,%r15
not    %rdx
mov    %rdx,-0x28(%rsp)
xor    %r12d,%r12d
movdqa 0xe77(%rip),%xmm0
movdqa 0xe7f(%rip),%xmm1
movdqa 0xe87(%rip),%xmm2
movdqa 0xe8f(%rip),%xmm3
mov    %r14,-0x30(%rsp)
jmp    11d8 <copyImage16To32+0xd8>
nopl   0x0(%rax,%rax,1)
mov    -0x8(%rsp),%rsi
add    %r14,%rsi
add    %r14,%r13
add    -0x10(%rsp),%r12
add    $0x1,%r9d
add    %r14,%r8
add    %r14,%r15
sub    %r14,-0x28(%rsp)
cmp    %r11d,%r9d
je     135f <copyImage16To32+0x25f>
cmp    %r15,%r8
mov    %r15,%rcx
cmova  %r8,%rcx
mov    %rsi,-0x8(%rsp)
lea    (%rsi,%rdi,1),%r10
lea    (%rdi,%r13,1),%rax
cmp    %rax,%r10
jae    11b0 <copyImage16To32+0xb0>
mov    %r11d,%ebx
mov    %rdi,%rsi
lea    0x4(%r10),%rdx
cmp    %rdx,%rax
cmova  %rax,%rdx
mov    -0x18(%rsp),%rdi
lea    (%r12,%rdi,1),%r11
mov    %r10,%r14
not    %r14
add    %rdx,%r14
cmp    $0x4,%r14
jae    1240 <copyImage16To32+0x140>
mov    %r11,%rdx
mov    %r10,%rbp
mov    %rsi,%rdi
mov    %ebx,%r11d
mov    -0x30(%rsp),%r14
jmp    1300 <copyImage16To32+0x200>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    -0x28(%rsp),%rcx
shr    $0x2,%rcx
add    $0x1,%rcx
and    $0xfffffffffffffffe,%rcx
shr    $0x2,%r14
add    $0x1,%r14
mov    %r14,%rdi
and    $0xfffffffffffffffe,%rdi
lea    (%r11,%rdi,8),%rdx
mov    %rdi,-0x20(%rsp)
lea    (%r10,%rdi,4),%rbp
xor    %edi,%edi
nop
movq   (%r10,%rdi,4),%xmm4
movdqa %xmm4,%xmm5
psrld  $0x17,%xmm5
pand   %xmm0,%xmm5
movdqa %xmm4,%xmm6
psrld  $0xa,%xmm6
pand   %xmm1,%xmm6
por    %xmm5,%xmm6
movdqa %xmm4,%xmm5
pslld  $0x3,%xmm5
pand   %xmm2,%xmm5
por    %xmm6,%xmm5
pand   %xmm3,%xmm4
movdqa %xmm4,%xmm6
psrld  $0x7,%xmm6
pand   %xmm0,%xmm6
movdqa %xmm4,%xmm7
pslld  $0x6,%xmm7
pand   %xmm1,%xmm7
por    %xmm6,%xmm7
pslld  $0x13,%xmm4
pand   %xmm2,%xmm4
por    %xmm7,%xmm4
punpckldq %xmm4,%xmm5
movdqu %xmm5,(%r11,%rdi,8)
add    $0x2,%rdi
cmp    %rdi,%rcx
jne    1270 <copyImage16To32+0x170>
cmp    -0x20(%rsp),%r14
mov    %rsi,%rdi
mov    %ebx,%r11d
mov    -0x30(%rsp),%r14
je     11b0 <copyImage16To32+0xb0>
nopl   (%rax)
movzwl 0x2(%rbp),%ecx
mov    %ecx,%esi
shr    $0x7,%esi
and    $0xf8,%esi
mov    %ecx,%ebx
shl    $0x6,%ebx
and    $0xf800,%ebx
or     %esi,%ebx
and    $0x1f,%ecx
shl    $0x13,%ecx
or     %ebx,%ecx
mov    %ecx,(%rdx)
movzwl 0x0(%rbp),%ecx
mov    %ecx,%esi
shr    $0x7,%esi
and    $0xf8,%esi
mov    %ecx,%ebx
shl    $0x6,%ebx
and    $0xf800,%ebx
or     %esi,%ebx
and    $0x1f,%ecx
shl    $0x13,%ecx
or     %ebx,%ecx
mov    %ecx,0x4(%rdx)
add    $0x4,%rbp
add    $0x8,%rdx
cmp    %rax,%rbp
jb     1300 <copyImage16To32+0x200>
jmp    11b0 <copyImage16To32+0xb0>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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