void __pscpy(dps, dbl, doffset, sps, sbl, start, length) unsigned char *dps;
unsigned long dbl;
unsigned long doffset;
const unsigned char *sps;
unsigned long sbl;
unsigned long start;
unsigned long length;
{
  unsigned long end = start + length - 1;
  unsigned long src, dst;
  for (src = start, dst = doffset; src <= end; src++, dst++) {
    char tmp;
    if (sbl <= sizeof(char))
      tmp = (((*((unsigned char *)sps)) >> (src)) & 1);
    else if (sbl <= (sizeof(char) * sizeof(unsigned char)))
      tmp = (((*((unsigned char *)sps)) >> (src)) & 1);
    else
      tmp = (((sps[src / (sizeof(char) * sizeof(unsigned char))]) >>
              (src % (sizeof(char) * sizeof(unsigned char)))) &
             1);
    if (tmp & 1) {
      if (dbl <= sizeof(char))
        ((*((unsigned char *)dps)) |= 1 << (dst));
      else if (dbl <= (sizeof(char) * sizeof(unsigned char)))
        ((*((unsigned char *)dps)) |= 1 << (dst));
      else
        ((dps[dst / (sizeof(char) * sizeof(unsigned char))]) |=
         1 << (dst % (sizeof(char) * sizeof(unsigned char))));
    } else {
      if (dbl <= sizeof(char))
        ((*((unsigned char *)dps)) &= ~(1 << (dst)));
      else if (dbl <= (sizeof(char) * sizeof(unsigned char)))
        ((*((unsigned char *)dps)) &= ~(1 << (dst)));
      else
        ((dps[dst / (sizeof(char) * sizeof(unsigned char))]) &=
         ~(1 << (dst % (sizeof(char) * sizeof(unsigned char)))));
    }
  }
  if (dbl <= sizeof(char)) {
    {
      if (dbl)
        *((unsigned char *)dps) &= ~((~0) << (dbl));
    };
  } else if (dbl <= (sizeof(char) * sizeof(unsigned char))) {
    {
      if (dbl)
        *((unsigned char *)dps) &= ~((~0) << (dbl));
    };
  } else {
    {
      if (dbl % (sizeof(char) * sizeof(unsigned char)))
        *((unsigned char *)(dps +
                            (dbl / (sizeof(char) * sizeof(unsigned char))))) &=
            ~((~0) << (dbl % (sizeof(char) * sizeof(unsigned char))));
    };
  }
}


x86 assembly (clang, -O0):
<__pscpy>:
push   %rbp
mov    %rsp,%rbp
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
mov    -0x30(%rbp),%rax
add    0x10(%rbp),%rax
sub    $0x1,%rax
mov    %rax,-0x38(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x40(%rbp),%rax
cmp    -0x38(%rbp),%rax
ja     12f4 <__pscpy+0x1f4>
cmpq   $0x1,-0x28(%rbp)
ja     1171 <__pscpy+0x71>
mov    -0x20(%rbp),%rax
movzbl (%rax),%eax
mov    -0x40(%rbp),%rcx
sar    %cl,%eax
and    $0x1,%eax
mov    %al,-0x49(%rbp)
jmp    11b9 <__pscpy+0xb9>
cmpq   $0x1,-0x28(%rbp)
ja     1194 <__pscpy+0x94>
mov    -0x20(%rbp),%rax
movzbl (%rax),%eax
mov    -0x40(%rbp),%rcx
sar    %cl,%eax
and    $0x1,%eax
mov    %al,-0x49(%rbp)
jmp    11b4 <__pscpy+0xb4>
mov    -0x20(%rbp),%rax
mov    -0x40(%rbp),%rcx
shr    $0x0,%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x40(%rbp),%rcx
and    $0x0,%rcx
sar    %cl,%eax
and    $0x1,%eax
mov    %al,-0x49(%rbp)
jmp    11b9 <__pscpy+0xb9>
movsbl -0x49(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     1249 <__pscpy+0x149>
cmpq   $0x1,-0x10(%rbp)
ja     11f1 <__pscpy+0xf1>
mov    -0x48(%rbp),%rax
mov    %eax,%ecx
mov    $0x1,%edx
shl    %cl,%edx
mov    -0x8(%rbp),%rax
movzbl (%rax),%ecx
or     %edx,%ecx
mov    %cl,(%rax)
jmp    1244 <__pscpy+0x144>
cmpq   $0x1,-0x10(%rbp)
ja     1219 <__pscpy+0x119>
mov    -0x48(%rbp),%rax
mov    %eax,%ecx
mov    $0x1,%edx
shl    %cl,%edx
mov    -0x8(%rbp),%rax
movzbl (%rax),%ecx
or     %edx,%ecx
mov    %cl,(%rax)
jmp    123f <__pscpy+0x13f>
mov    -0x48(%rbp),%rax
and    $0x0,%rax
mov    %eax,%ecx
mov    $0x1,%esi
shl    %cl,%esi
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%rcx
shr    $0x0,%rcx
movzbl (%rax,%rcx,1),%edx
or     %esi,%edx
mov    %dl,(%rax,%rcx,1)
jmp    1244 <__pscpy+0x144>
jmp    12d2 <__pscpy+0x1d2>
cmpq   $0x1,-0x10(%rbp)
ja     1274 <__pscpy+0x174>
mov    -0x48(%rbp),%rax
mov    %eax,%ecx
mov    $0x1,%edx
shl    %cl,%edx
xor    $0xffffffff,%edx
mov    -0x8(%rbp),%rax
movzbl (%rax),%ecx
and    %edx,%ecx
mov    %cl,(%rax)
jmp    12cd <__pscpy+0x1cd>
cmpq   $0x1,-0x10(%rbp)
ja     129f <__pscpy+0x19f>
mov    -0x48(%rbp),%rax
mov    %eax,%ecx
mov    $0x1,%edx
shl    %cl,%edx
xor    $0xffffffff,%edx
mov    -0x8(%rbp),%rax
movzbl (%rax),%ecx
and    %edx,%ecx
mov    %cl,(%rax)
jmp    12c8 <__pscpy+0x1c8>
mov    -0x48(%rbp),%rax
and    $0x0,%rax
mov    %eax,%ecx
mov    $0x1,%esi
shl    %cl,%esi
xor    $0xffffffff,%esi
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%rcx
shr    $0x0,%rcx
movzbl (%rax,%rcx,1),%edx
and    %esi,%edx
mov    %dl,(%rax,%rcx,1)
jmp    12cd <__pscpy+0x1cd>
jmp    12d2 <__pscpy+0x1d2>
jmp    12d7 <__pscpy+0x1d7>
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
mov    -0x48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x48(%rbp)
jmp    1140 <__pscpy+0x40>
cmpq   $0x1,-0x10(%rbp)
ja     132a <__pscpy+0x22a>
cmpq   $0x0,-0x10(%rbp)
je     1325 <__pscpy+0x225>
mov    -0x10(%rbp),%rax
mov    %eax,%ecx
mov    $0xffffffff,%edx
shl    %cl,%edx
xor    $0xffffffff,%edx
mov    -0x8(%rbp),%rax
movzbl (%rax),%ecx
and    %edx,%ecx
mov    %cl,(%rax)
jmp    13a5 <__pscpy+0x2a5>
cmpq   $0x1,-0x10(%rbp)
ja     1360 <__pscpy+0x260>
cmpq   $0x0,-0x10(%rbp)
je     135b <__pscpy+0x25b>
mov    -0x10(%rbp),%rax
mov    %eax,%ecx
mov    $0xffffffff,%edx
shl    %cl,%edx
xor    $0xffffffff,%edx
mov    -0x8(%rbp),%rax
movzbl (%rax),%ecx
and    %edx,%ecx
mov    %cl,(%rax)
jmp    13a0 <__pscpy+0x2a0>
mov    -0x10(%rbp),%rax
and    $0x0,%rax
cmp    $0x0,%rax
je     139b <__pscpy+0x29b>
mov    -0x10(%rbp),%rax
and    $0x0,%rax
mov    %eax,%ecx
mov    $0xffffffff,%esi
shl    %cl,%esi
xor    $0xffffffff,%esi
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%rcx
shr    $0x0,%rcx
movzbl (%rax,%rcx,1),%edx
and    %esi,%edx
mov    %dl,(%rax,%rcx,1)
jmp    13a0 <__pscpy+0x2a0>
jmp    13a5 <__pscpy+0x2a5>
pop    %rbp
ret

x86 assembly (clang, -O2):
<__pscpy>:
mov    0x8(%rsp),%rax
lea    (%r9,%rax,1),%r11
add    $0xffffffffffffffff,%r11
cmp    %r9,%r11
jae    111c <__pscpy+0x1c>
cmp    $0x1,%rsi
jne    111b <__pscpy+0x1b>
andb   $0x1,(%rdi)
ret
mov    %rcx,%r10
jmp    1141 <__pscpy+0x41>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
andb   $0xfe,(%rdi,%rdx,1)
add    $0x1,%r9
add    $0x1,%rdx
cmp    %r11,%r9
ja     1112 <__pscpy+0x12>
cmp    $0x1,%r8
ja     1170 <__pscpy+0x70>
movzbl (%r10),%eax
mov    %r9d,%ecx
shr    %cl,%eax
test   $0x1,%al
je     1179 <__pscpy+0x79>
cmp    $0x1,%rsi
ja     1190 <__pscpy+0x90>
mov    $0x1,%eax
mov    %edx,%ecx
shl    %cl,%eax
or     %al,(%rdi)
jmp    1134 <__pscpy+0x34>
nopw   0x0(%rax,%rax,1)
movzbl (%r10,%r9,1),%eax
test   $0x1,%al
jne    1154 <__pscpy+0x54>
cmp    $0x1,%rsi
ja     1130 <__pscpy+0x30>
mov    $0x1,%eax
mov    %edx,%ecx
shl    %cl,%eax
not    %al
and    %al,(%rdi)
jmp    1134 <__pscpy+0x34>
xchg   %ax,%ax
orb    $0x1,(%rdi,%rdx,1)
jmp    1134 <__pscpy+0x34>

LLVM IR (-O0):
define void @__pscpy(i8* %0, i64 %1, i64 %2, i8* %3, i64 %4, i64 %5, i64 %6) {
%8 = alloca i8*
%9 = alloca i64
%10 = alloca i64
%11 = alloca i8*
%12 = alloca i64
%13 = alloca i64
%14 = alloca i64
%15 = alloca i64
%16 = alloca i64
%17 = alloca i64
%18 = alloca i8
store i8* %0, i8** %8
store i64 %1, i64* %9
store i64 %2, i64* %10
store i8* %3, i8** %11
store i64 %4, i64* %12
store i64 %5, i64* %13
store i64 %6, i64* %14
%19 = load i64, i64* %13
%20 = load i64, i64* %14
%21 = add i64 %19, %20
%22 = sub i64 %21, 1
store i64 %22, i64* %15
%23 = load i64, i64* %13
store i64 %23, i64* %16
%24 = load i64, i64* %10
store i64 %24, i64* %17
br label %25
25: ; preds = %154, %7
%26 = load i64, i64* %16
%27 = load i64, i64* %15
%28 = icmp ule i64 %26, %27
br i1 %28, label %29, label %159
29: ; preds = %25
%30 = load i64, i64* %12
%31 = icmp ule i64 %30, 1
br i1 %31, label %32, label %41
32: ; preds = %29
%33 = load i8*, i8** %11
%34 = load i8, i8* %33
%35 = zext i8 %34 to i32
%36 = load i64, i64* %16
%37 = trunc i64 %36 to i32
%38 = ashr i32 %35, %37
%39 = and i32 %38, 1
%40 = trunc i32 %39 to i8
store i8 %40, i8* %18
br label %67
41: ; preds = %29
%42 = load i64, i64* %12
%43 = icmp ule i64 %42, 1
br i1 %43, label %44, label %53
44: ; preds = %41
%45 = load i8*, i8** %11
%46 = load i8, i8* %45
%47 = zext i8 %46 to i32
%48 = load i64, i64* %16
%49 = trunc i64 %48 to i32
%50 = ashr i32 %47, %49
%51 = and i32 %50, 1
%52 = trunc i32 %51 to i8
store i8 %52, i8* %18
br label %66
53: ; preds = %41
%54 = load i8*, i8** %11
%55 = load i64, i64* %16
%56 = udiv i64 %55, 1
%57 = getelementptr inbounds i8, i8* %54, i64 %56
%58 = load i8, i8* %57
%59 = zext i8 %58 to i32
%60 = load i64, i64* %16
%61 = urem i64 %60, 1
%62 = trunc i64 %61 to i32
%63 = ashr i32 %59, %62
%64 = and i32 %63, 1
%65 = trunc i32 %64 to i8
store i8 %65, i8* %18
br label %66
66: ; preds = %53, %44
br label %67
67: ; preds = %66, %32
%68 = load i8, i8* %18
%69 = sext i8 %68 to i32
%70 = and i32 %69, 1
%71 = icmp ne i32 %70, 0
br i1 %71, label %72, label %111
72: ; preds = %67
%73 = load i64, i64* %9
%74 = icmp ule i64 %73, 1
br i1 %74, label %75, label %84
75: ; preds = %72
%76 = load i64, i64* %17
%77 = trunc i64 %76 to i32
%78 = shl i32 1, %77
%79 = load i8*, i8** %8
%80 = load i8, i8* %79
%81 = zext i8 %80 to i32
%82 = or i32 %81, %78
%83 = trunc i32 %82 to i8
store i8 %83, i8* %79
br label %110
84: ; preds = %72
%85 = load i64, i64* %9
%86 = icmp ule i64 %85, 1
br i1 %86, label %87, label %96
87: ; preds = %84
%88 = load i64, i64* %17
%89 = trunc i64 %88 to i32
%90 = shl i32 1, %89
%91 = load i8*, i8** %8
%92 = load i8, i8* %91
%93 = zext i8 %92 to i32
%94 = or i32 %93, %90
%95 = trunc i32 %94 to i8
store i8 %95, i8* %91
br label %109
96: ; preds = %84
%97 = load i64, i64* %17
%98 = urem i64 %97, 1
%99 = trunc i64 %98 to i32
%100 = shl i32 1, %99
%101 = load i8*, i8** %8
%102 = load i64, i64* %17
%103 = udiv i64 %102, 1
%104 = getelementptr inbounds i8, i8* %101, i64 %103
%105 = load i8, i8* %104
%106 = zext i8 %105 to i32
%107 = or i32 %106, %100
%108 = trunc i32 %107 to i8
store i8 %108, i8* %104
br label %109
109: ; preds = %96, %87
br label %110
110: ; preds = %109, %75
br label %153
111: ; preds = %67
%112 = load i64, i64* %9
%113 = icmp ule i64 %112, 1
br i1 %113, label %114, label %124
114: ; preds = %111
%115 = load i64, i64* %17
%116 = trunc i64 %115 to i32
%117 = shl i32 1, %116
%118 = xor i32 %117, -1
%119 = load i8*, i8** %8
%120 = load i8, i8* %119
%121 = zext i8 %120 to i32
%122 = and i32 %121, %118
%123 = trunc i32 %122 to i8
store i8 %123, i8* %119
br label %152
124: ; preds = %111
%125 = load i64, i64* %9
%126 = icmp ule i64 %125, 1
br i1 %126, label %127, label %137
127: ; preds = %124
%128 = load i64, i64* %17
%129 = trunc i64 %128 to i32
%130 = shl i32 1, %129
%131 = xor i32 %130, -1
%132 = load i8*, i8** %8
%133 = load i8, i8* %132
%134 = zext i8 %133 to i32
%135 = and i32 %134, %131
%136 = trunc i32 %135 to i8
store i8 %136, i8* %132
br label %151
137: ; preds = %124
%138 = load i64, i64* %17
%139 = urem i64 %138, 1
%140 = trunc i64 %139 to i32
%141 = shl i32 1, %140
%142 = xor i32 %141, -1
%143 = load i8*, i8** %8
%144 = load i64, i64* %17
%145 = udiv i64 %144, 1
%146 = getelementptr inbounds i8, i8* %143, i64 %145
%147 = load i8, i8* %146
%148 = zext i8 %147 to i32
%149 = and i32 %148, %142
%150 = trunc i32 %149 to i8
store i8 %150, i8* %146
br label %151
151: ; preds = %137, %127
br label %152
152: ; preds = %151, %114
br label %153
153: ; preds = %152, %110
br label %154
154: ; preds = %153
%155 = load i64, i64* %16
%156 = add i64 %155, 1
store i64 %156, i64* %16
%157 = load i64, i64* %17
%158 = add i64 %157, 1
store i64 %158, i64* %17
br label %25
159: ; preds = %25
%160 = load i64, i64* %9
%161 = icmp ule i64 %160, 1
br i1 %161, label %162, label %176
162: ; preds = %159
%163 = load i64, i64* %9
%164 = icmp ne i64 %163, 0
br i1 %164, label %165, label %175
165: ; preds = %162
%166 = load i64, i64* %9
%167 = trunc i64 %166 to i32
%168 = shl i32 -1, %167
%169 = xor i32 %168, -1
%170 = load i8*, i8** %8
%171 = load i8, i8* %170
%172 = zext i8 %171 to i32
%173 = and i32 %172, %169
%174 = trunc i32 %173 to i8
store i8 %174, i8* %170
br label %175
175: ; preds = %165, %162
br label %213
176: ; preds = %159
%177 = load i64, i64* %9
%178 = icmp ule i64 %177, 1
br i1 %178, label %179, label %193
179: ; preds = %176
%180 = load i64, i64* %9
%181 = icmp ne i64 %180, 0
br i1 %181, label %182, label %192
182: ; preds = %179
%183 = load i64, i64* %9
%184 = trunc i64 %183 to i32
%185 = shl i32 -1, %184
%186 = xor i32 %185, -1
%187 = load i8*, i8** %8
%188 = load i8, i8* %187
%189 = zext i8 %188 to i32
%190 = and i32 %189, %186
%191 = trunc i32 %190 to i8
store i8 %191, i8* %187
br label %192
192: ; preds = %182, %179
br label %212
193: ; preds = %176
%194 = load i64, i64* %9
%195 = urem i64 %194, 1
%196 = icmp ne i64 %195, 0
br i1 %196, label %197, label %211
197: ; preds = %193
%198 = load i64, i64* %9
%199 = urem i64 %198, 1
%200 = trunc i64 %199 to i32
%201 = shl i32 -1, %200
%202 = xor i32 %201, -1
%203 = load i8*, i8** %8
%204 = load i64, i64* %9
%205 = udiv i64 %204, 1
%206 = getelementptr inbounds i8, i8* %203, i64 %205
%207 = load i8, i8* %206
%208 = zext i8 %207 to i32
%209 = and i32 %208, %202
%210 = trunc i32 %209 to i8
store i8 %210, i8* %206
br label %211
211: ; preds = %197, %193
br label %212
212: ; preds = %211, %192
br label %213
213: ; preds = %212, %175
ret void
}

LLVM IR (-O2):
define void @__pscpy(i8* nocapture %0, i64 %1, i64 %2, i8* nocapture %3, i64 %4, i64 %5, i64 %6) {
%8 = add i64 %5, -1
%9 = add i64 %8, %6
%10 = icmp ult i64 %9, %5
br i1 %10, label %57, label %11
11: ; preds = %7
%12 = icmp ult i64 %4, 2
%13 = icmp ult i64 %1, 2
br label %14
14: ; preds = %11, %53
%15 = phi i64 [ %2, %11 ], [ %55, %53 ]
%16 = phi i64 [ %5, %11 ], [ %54, %53 ]
br i1 %12, label %17, label %23
17: ; preds = %14
%18 = load i8, i8* %3
%19 = zext i8 %18 to i32
%20 = trunc i64 %16 to i32
%21 = lshr i32 %19, %20
%22 = trunc i32 %21 to i8
br label %26
23: ; preds = %14
%24 = getelementptr inbounds i8, i8* %3, i64 %16
%25 = load i8, i8* %24
br label %26
26: ; preds = %23, %17
%27 = phi i8 [ %22, %17 ], [ %25, %23 ]
%28 = and i8 %27, 1
%29 = icmp eq i8 %28, 0
br i1 %29, label %41, label %30
30: ; preds = %26
br i1 %13, label %31, label %37
31: ; preds = %30
%32 = trunc i64 %15 to i32
%33 = shl nuw i32 1, %32
%34 = load i8, i8* %0
%35 = trunc i32 %33 to i8
%36 = or i8 %34, %35
store i8 %36, i8* %0
br label %53
37: ; preds = %30
%38 = getelementptr inbounds i8, i8* %0, i64 %15
%39 = load i8, i8* %38
%40 = or i8 %39, 1
store i8 %40, i8* %38
br label %53
41: ; preds = %26
br i1 %13, label %42, label %49
42: ; preds = %41
%43 = trunc i64 %15 to i32
%44 = shl nuw i32 1, %43
%45 = load i8, i8* %0
%46 = trunc i32 %44 to i8
%47 = xor i8 %46, -1
%48 = and i8 %45, %47
store i8 %48, i8* %0
br label %53
49: ; preds = %41
%50 = getelementptr inbounds i8, i8* %0, i64 %15
%51 = load i8, i8* %50
%52 = and i8 %51, -2
store i8 %52, i8* %50
br label %53
53: ; preds = %42, %49, %31, %37
%54 = add i64 %16, 1
%55 = add i64 %15, 1
%56 = icmp ugt i64 %54, %9
br i1 %56, label %57, label %14
57: ; preds = %53, %7
%58 = icmp eq i64 %1, 1
br i1 %58, label %59, label %62
59: ; preds = %57
%60 = load i8, i8* %0
%61 = and i8 %60, 1
store i8 %61, i8* %0
br label %62
62: ; preds = %57, %59
ret void
}