#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 */
size_t UCHAR_MAX;
char *my__stpcpy(char *restrict d, const char *restrict s) {
  size_t *wd;
  const size_t *ws;
  if ((uintptr_t)s % (sizeof(size_t)) == (uintptr_t)d % (sizeof(size_t))) {
    for (; (uintptr_t)s % (sizeof(size_t)); s++, d++)
      if (!(*d = *s))
        return d;
    wd = (void *)d;
    ws = (const void *)s;
    for (; !((*ws) - ((size_t)-1 / UCHAR_MAX) & ~(*ws) &
             (((size_t)-1 / UCHAR_MAX) * (UCHAR_MAX / 2 + 1)));
         *wd++ = *ws++)
      ;
    d = (void *)wd;
    s = (const void *)ws;
  }
  for (; (*d = *s); s++, d++)
    ;
  return d;
}


x86 assembly (clang, -O0):
<my__stpcpy>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    -0x18(%rbp),%rax
and    $0x7,%rax
mov    -0x10(%rbp),%rcx
and    $0x7,%rcx
cmp    %rcx,%rax
jne    1250 <my__stpcpy+0x150>
jmp    112a <my__stpcpy+0x2a>
mov    -0x18(%rbp),%rax
and    $0x7,%rax
cmp    $0x0,%rax
je     117f <my__stpcpy+0x7f>
mov    -0x18(%rbp),%rax
mov    (%rax),%al
mov    -0x10(%rbp),%rcx
mov    %al,(%rcx)
cmp    $0x0,%al
jne    115d <my__stpcpy+0x5d>
mov    -0x10(%rbp),%rax
mov    %rax,-0x8(%rbp)
jmp    1293 <my__stpcpy+0x193>
jmp    1162 <my__stpcpy+0x62>
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    112a <my__stpcpy+0x2a>
mov    -0x10(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x38(%rbp)
mov    $0xffffffffffffffff,%rax
mov    0x2e48(%rip),%rcx
xor    %edx,%edx
divq   (%rcx)
mov    %rax,%rcx
mov    -0x38(%rbp),%rax
sub    %rcx,%rax
mov    -0x28(%rbp),%rcx
mov    (%rcx),%rcx
xor    $0xffffffffffffffff,%rcx
and    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    $0xffffffffffffffff,%rax
mov    0x2e19(%rip),%rcx
xor    %edx,%edx
divq   (%rcx)
mov    %rax,%rcx
mov    -0x30(%rbp),%rax
mov    0x2e06(%rip),%rdx
mov    (%rdx),%rdx
shr    $0x1,%rdx
add    $0x1,%rdx
imul   %rdx,%rcx
and    %rcx,%rax
cmp    $0x0,%rax
setne  %al
xor    $0xff,%al
test   $0x1,%al
jne    1212 <my__stpcpy+0x112>
jmp    1240 <my__stpcpy+0x140>
jmp    1217 <my__stpcpy+0x117>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x28(%rbp)
mov    (%rax),%rcx
mov    -0x20(%rbp),%rax
mov    %rax,%rdx
add    $0x8,%rdx
mov    %rdx,-0x20(%rbp)
mov    %rcx,(%rax)
jmp    118f <my__stpcpy+0x8f>
mov    -0x20(%rbp),%rax
mov    %rax,-0x10(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,-0x18(%rbp)
jmp    1255 <my__stpcpy+0x155>
mov    -0x18(%rbp),%rax
mov    (%rax),%al
mov    -0x10(%rbp),%rcx
mov    %al,(%rcx)
cmp    $0x0,%al
je     128b <my__stpcpy+0x18b>
jmp    126e <my__stpcpy+0x16e>
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    1255 <my__stpcpy+0x155>
mov    -0x10(%rbp),%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
pop    %rbp
ret

x86 assembly (clang, -O2):
<my__stpcpy>:
mov    %esi,%eax
xor    %edi,%eax
test   $0x7,%al
je     1133 <my__stpcpy+0x33>
mov    %rdi,%rax
mov    (%rsi),%cl
mov    %cl,(%rax)
test   %cl,%cl
je     1132 <my__stpcpy+0x32>
add    $0x1,%rsi
nopw   0x0(%rax,%rax,1)
movzbl (%rsi),%ecx
mov    %cl,0x1(%rax)
add    $0x1,%rax
add    $0x1,%rsi
test   %cl,%cl
jne    1120 <my__stpcpy+0x20>
ret
test   $0x7,%sil
je     1200 <my__stpcpy+0x100>
mov    (%rsi),%al
mov    %al,(%rdi)
test   %al,%al
je     1278 <my__stpcpy+0x178>
lea    0x1(%rsi),%rcx
lea    0x1(%rdi),%rax
test   $0x7,%cl
je     11fa <my__stpcpy+0xfa>
mov    (%rcx),%cl
mov    %cl,(%rax)
test   %cl,%cl
je     1132 <my__stpcpy+0x32>
lea    0x2(%rsi),%rcx
lea    0x2(%rdi),%rax
test   $0x7,%cl
je     11fa <my__stpcpy+0xfa>
mov    (%rcx),%cl
mov    %cl,(%rax)
test   %cl,%cl
je     1132 <my__stpcpy+0x32>
lea    0x3(%rsi),%rcx
lea    0x3(%rdi),%rax
test   $0x7,%cl
je     11fa <my__stpcpy+0xfa>
mov    (%rcx),%cl
mov    %cl,(%rax)
test   %cl,%cl
je     1132 <my__stpcpy+0x32>
lea    0x4(%rsi),%rcx
lea    0x4(%rdi),%rax
test   $0x7,%cl
je     11fa <my__stpcpy+0xfa>
mov    (%rcx),%cl
mov    %cl,(%rax)
test   %cl,%cl
je     1132 <my__stpcpy+0x32>
lea    0x5(%rsi),%rcx
lea    0x5(%rdi),%rax
test   $0x7,%cl
je     11fa <my__stpcpy+0xfa>
mov    (%rcx),%cl
mov    %cl,(%rax)
test   %cl,%cl
je     1132 <my__stpcpy+0x32>
lea    0x6(%rsi),%rcx
lea    0x6(%rdi),%rax
test   $0x7,%cl
je     11fa <my__stpcpy+0xfa>
mov    (%rcx),%cl
mov    %cl,(%rax)
test   %cl,%cl
je     1132 <my__stpcpy+0x32>
lea    0x7(%rsi),%rcx
lea    0x7(%rdi),%rax
test   $0x7,%cl
je     11fa <my__stpcpy+0xfa>
mov    (%rcx),%cl
mov    %cl,(%rax)
test   %cl,%cl
je     1132 <my__stpcpy+0x32>
add    $0x8,%rsi
add    $0x8,%rdi
jmp    1200 <my__stpcpy+0x100>
mov    %rax,%rdi
mov    %rcx,%rsi
mov    0x2de9(%rip),%rax
mov    (%rax),%r9
mov    $0xffffffffffffffff,%rax
xor    %edx,%edx
div    %r9
mov    %rax,%r8
shr    %r9
add    $0x1,%r9
imul   %rax,%r9
mov    (%rsi),%rcx
mov    %rcx,%rax
sub    %r8,%rax
mov    %rcx,%rdx
not    %rdx
and    %rax,%rdx
mov    %rdi,%rax
test   %r9,%rdx
jne    110b <my__stpcpy+0xb>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %rcx,(%rax)
add    $0x8,%rax
mov    0x8(%rsi),%rcx
add    $0x8,%rsi
mov    %rcx,%rdx
sub    %r8,%rdx
mov    %rcx,%rdi
not    %rdi
and    %rdx,%rdi
test   %r9,%rdi
je     1250 <my__stpcpy+0x150>
jmp    110b <my__stpcpy+0xb>
mov    %rdi,%rax
ret

LLVM IR (-O0):
@UCHAR_MAX = global i64 0
define i8* @my__stpcpy(i8* noalias %0, i8* noalias %1) {
%3 = alloca i8*
%4 = alloca i8*
%5 = alloca i8*
%6 = alloca i64*
%7 = alloca i64*
store i8* %0, i8** %4
store i8* %1, i8** %5
%8 = load i8*, i8** %5
%9 = ptrtoint i8* %8 to i64
%10 = urem i64 %9, 8
%11 = load i8*, i8** %4
%12 = ptrtoint i8* %11 to i64
%13 = urem i64 %12, 8
%14 = icmp eq i64 %10, %13
br i1 %14, label %15, label %70
15: ; preds = %2
br label %16
16: ; preds = %29, %15
%17 = load i8*, i8** %5
%18 = ptrtoint i8* %17 to i64
%19 = urem i64 %18, 8
%20 = icmp ne i64 %19, 0
br i1 %20, label %21, label %34
21: ; preds = %16
%22 = load i8*, i8** %5
%23 = load i8, i8* %22
%24 = load i8*, i8** %4
store i8 %23, i8* %24
%25 = icmp ne i8 %23, 0
br i1 %25, label %28, label %26
26: ; preds = %21
%27 = load i8*, i8** %4
store i8* %27, i8** %3
br label %84
28: ; preds = %21
br label %29
29: ; preds = %28
%30 = load i8*, i8** %5
%31 = getelementptr inbounds i8, i8* %30, i32 1
store i8* %31, i8** %5
%32 = load i8*, i8** %4
%33 = getelementptr inbounds i8, i8* %32, i32 1
store i8* %33, i8** %4
br label %16
34: ; preds = %16
%35 = load i8*, i8** %4
%36 = bitcast i8* %35 to i64*
store i64* %36, i64** %6
%37 = load i8*, i8** %5
%38 = bitcast i8* %37 to i64*
store i64* %38, i64** %7
br label %39
39: ; preds = %59, %34
%40 = load i64*, i64** %7
%41 = load i64, i64* %40
%42 = load i64, i64* @UCHAR_MAX
%43 = udiv i64 -1, %42
%44 = sub i64 %41, %43
%45 = load i64*, i64** %7
%46 = load i64, i64* %45
%47 = xor i64 %46, -1
%48 = and i64 %44, %47
%49 = load i64, i64* @UCHAR_MAX
%50 = udiv i64 -1, %49
%51 = load i64, i64* @UCHAR_MAX
%52 = udiv i64 %51, 2
%53 = add i64 %52, 1
%54 = mul i64 %50, %53
%55 = and i64 %48, %54
%56 = icmp ne i64 %55, 0
%57 = xor i1 %56, true
br i1 %57, label %58, label %65
58: ; preds = %39
br label %59
59: ; preds = %58
%60 = load i64*, i64** %7
%61 = getelementptr inbounds i64, i64* %60, i32 1
store i64* %61, i64** %7
%62 = load i64, i64* %60
%63 = load i64*, i64** %6
%64 = getelementptr inbounds i64, i64* %63, i32 1
store i64* %64, i64** %6
store i64 %62, i64* %63
br label %39
65: ; preds = %39
%66 = load i64*, i64** %6
%67 = bitcast i64* %66 to i8*
store i8* %67, i8** %4
%68 = load i64*, i64** %7
%69 = bitcast i64* %68 to i8*
store i8* %69, i8** %5
br label %70
70: ; preds = %65, %2
br label %71
71: ; preds = %77, %70
%72 = load i8*, i8** %5
%73 = load i8, i8* %72
%74 = load i8*, i8** %4
store i8 %73, i8* %74
%75 = icmp ne i8 %73, 0
br i1 %75, label %76, label %82
76: ; preds = %71
br label %77
77: ; preds = %76
%78 = load i8*, i8** %5
%79 = getelementptr inbounds i8, i8* %78, i32 1
store i8* %79, i8** %5
%80 = load i8*, i8** %4
%81 = getelementptr inbounds i8, i8* %80, i32 1
store i8* %81, i8** %4
br label %71
82: ; preds = %71
%83 = load i8*, i8** %4
store i8* %83, i8** %3
br label %84
84: ; preds = %82, %26
%85 = load i8*, i8** %3
ret i8* %85
}

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