#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 */
int /*<<< orphan*/ Warn(char *);
int copy_alignment_line(char *aseq, int apos, int name_rcol, char *buffer,
                        int lcol, int rcol) {
  char *s1, *s2;
  int i;
  s1 = aseq + apos;
  s2 = buffer;
  for (i = 0; i < lcol; i++)
    if (*s2)
      s2++;
  for (i = lcol; i <= rcol; i++) {
    if (*s2 == '\t') {
      Warn("TAB characters will corrupt a SELEX alignment! Please remove them "
           "first.");
      return 0;
    }
    if (name_rcol >= i)
      *s1 = '.';
    else if (*s2 == '\0' || *s2 == '\n')
      *s1 = '.';
    else
      *s1 = *s2;
    s1++;
    if (*s2)
      s2++;
  }
  return 1;
}


x86 assembly (clang, -O0):
<copy_alignment_line>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
mov    %edx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8d,-0x24(%rbp)
mov    %r9d,-0x28(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x38(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1184 <copy_alignment_line+0x74>
mov    -0x38(%rbp),%rax
cmpb   $0x0,(%rax)
je     1171 <copy_alignment_line+0x61>
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    1176 <copy_alignment_line+0x66>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    114c <copy_alignment_line+0x3c>
mov    -0x24(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jg     124b <copy_alignment_line+0x13b>
mov    -0x38(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x9,%eax
jne    11be <copy_alignment_line+0xae>
lea    0xe53(%rip),%rdi
call   1030 <Warn@plt>
movl   $0x0,-0x4(%rbp)
jmp    1252 <copy_alignment_line+0x142>
mov    -0x18(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jl     11d6 <copy_alignment_line+0xc6>
mov    -0x30(%rbp),%rax
movb   $0x2e,(%rax)
jmp    1213 <copy_alignment_line+0x103>
mov    -0x38(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x0,%eax
je     11f6 <copy_alignment_line+0xe6>
mov    -0x38(%rbp),%rax
movsbl (%rax),%eax
cmp    $0xa,%eax
jne    1202 <copy_alignment_line+0xf2>
mov    -0x30(%rbp),%rax
movb   $0x2e,(%rax)
jmp    120e <copy_alignment_line+0xfe>
mov    -0x38(%rbp),%rax
mov    (%rax),%cl
mov    -0x30(%rbp),%rax
mov    %cl,(%rax)
jmp    1213 <copy_alignment_line+0x103>
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
mov    -0x38(%rbp),%rax
cmpb   $0x0,(%rax)
je     1238 <copy_alignment_line+0x128>
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    123d <copy_alignment_line+0x12d>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    118a <copy_alignment_line+0x7a>
movl   $0x1,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<copy_alignment_line>:
push   %rax
test   %r8d,%r8d
jle    116d <copy_alignment_line+0x5d>
lea    -0x1(%r8),%eax
mov    %r8d,%r10d
and    $0x3,%r10d
cmp    $0x3,%eax
jb     1151 <copy_alignment_line+0x41>
mov    %r8d,%eax
and    $0xfffffffc,%eax
nopl   0x0(%rax)
cmpb   $0x1,(%rcx)
sbb    $0xffffffffffffffff,%rcx
cmpb   $0x1,(%rcx)
sbb    $0xffffffffffffffff,%rcx
cmpb   $0x1,(%rcx)
sbb    $0xffffffffffffffff,%rcx
cmpb   $0x1,(%rcx)
sbb    $0xffffffffffffffff,%rcx
add    $0xfffffffc,%eax
jne    1130 <copy_alignment_line+0x20>
test   %r10d,%r10d
je     116d <copy_alignment_line+0x5d>
cs nopw 0x0(%rax,%rax,1)
cmpb   $0x1,(%rcx)
sbb    $0xffffffffffffffff,%rcx
add    $0xffffffff,%r10d
jne    1160 <copy_alignment_line+0x50>
mov    $0x1,%eax
cmp    %r9d,%r8d
jle    1179 <copy_alignment_line+0x69>
pop    %rcx
ret
movslq %esi,%rsi
add    %rsi,%rdi
add    $0x1,%r9d
jmp    11a7 <copy_alignment_line+0x97>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %sil,(%rdi)
add    $0x1,%rdi
cmpb   $0x1,(%rcx)
sbb    $0xffffffffffffffff,%rcx
add    $0x1,%r8d
cmp    %r8d,%r9d
je     1177 <copy_alignment_line+0x67>
movzbl (%rcx),%r10d
cmp    $0x9,%r10b
je     11c9 <copy_alignment_line+0xb9>
mov    $0x2e,%sil
cmp    %edx,%r8d
jle    1190 <copy_alignment_line+0x80>
test   %r10b,%r10b
je     1190 <copy_alignment_line+0x80>
cmp    $0xa,%r10b
je     1190 <copy_alignment_line+0x80>
mov    %r10d,%esi
jmp    1190 <copy_alignment_line+0x80>
lea    0xe30(%rip),%rdi
call   1030 <Warn@plt>
xor    %eax,%eax
pop    %rcx
ret

LLVM IR (-O0):
@.str = [73 x i8] c"TAB characters will corrupt a SELEX alignment! Please remove them first.\00"
define i32 @copy_alignment_line(i8* %0, i32 %1, i32 %2, i8* %3, i32 %4, i32 %5) {
%7 = alloca i32
%8 = alloca i8*
%9 = alloca i32
%10 = alloca i32
%11 = alloca i8*
%12 = alloca i32
%13 = alloca i32
%14 = alloca i8*
%15 = alloca i8*
%16 = alloca i32
store i8* %0, i8** %8
store i32 %1, i32* %9
store i32 %2, i32* %10
store i8* %3, i8** %11
store i32 %4, i32* %12
store i32 %5, i32* %13
%17 = load i8*, i8** %8
%18 = load i32, i32* %9
%19 = sext i32 %18 to i64
%20 = getelementptr inbounds i8, i8* %17, i64 %19
store i8* %20, i8** %14
%21 = load i8*, i8** %11
store i8* %21, i8** %15
store i32 0, i32* %16
br label %22
22: ; preds = %34, %6
%23 = load i32, i32* %16
%24 = load i32, i32* %12
%25 = icmp slt i32 %23, %24
br i1 %25, label %26, label %37
26: ; preds = %22
%27 = load i8*, i8** %15
%28 = load i8, i8* %27
%29 = icmp ne i8 %28, 0
br i1 %29, label %30, label %33
30: ; preds = %26
%31 = load i8*, i8** %15
%32 = getelementptr inbounds i8, i8* %31, i32 1
store i8* %32, i8** %15
br label %33
33: ; preds = %30, %26
br label %34
34: ; preds = %33
%35 = load i32, i32* %16
%36 = add nsw i32 %35, 1
store i32 %36, i32* %16
br label %22
37: ; preds = %22
%38 = load i32, i32* %12
store i32 %38, i32* %16
br label %39
39: ; preds = %83, %37
%40 = load i32, i32* %16
%41 = load i32, i32* %13
%42 = icmp sle i32 %40, %41
br i1 %42, label %43, label %86
43: ; preds = %39
%44 = load i8*, i8** %15
%45 = load i8, i8* %44
%46 = sext i8 %45 to i32
%47 = icmp eq i32 %46, 9
br i1 %47, label %48, label %50
48: ; preds = %43
%49 = call i32 @Warn(i8* getelementptr inbounds ([73 x i8], [73 x i8]* @.str, i64 0, i64 0))
store i32 0, i32* %7
br label %87
50: ; preds = %43
%51 = load i32, i32* %10
%52 = load i32, i32* %16
%53 = icmp sge i32 %51, %52
br i1 %53, label %54, label %56
54: ; preds = %50
%55 = load i8*, i8** %14
store i8 46, i8* %55
br label %73
56: ; preds = %50
%57 = load i8*, i8** %15
%58 = load i8, i8* %57
%59 = sext i8 %58 to i32
%60 = icmp eq i32 %59, 0
br i1 %60, label %66, label %61
61: ; preds = %56
%62 = load i8*, i8** %15
%63 = load i8, i8* %62
%64 = sext i8 %63 to i32
%65 = icmp eq i32 %64, 10
br i1 %65, label %66, label %68
66: ; preds = %61, %56
%67 = load i8*, i8** %14
store i8 46, i8* %67
br label %72
68: ; preds = %61
%69 = load i8*, i8** %15
%70 = load i8, i8* %69
%71 = load i8*, i8** %14
store i8 %70, i8* %71
br label %72
72: ; preds = %68, %66
br label %73
73: ; preds = %72, %54
%74 = load i8*, i8** %14
%75 = getelementptr inbounds i8, i8* %74, i32 1
store i8* %75, i8** %14
%76 = load i8*, i8** %15
%77 = load i8, i8* %76
%78 = icmp ne i8 %77, 0
br i1 %78, label %79, label %82
79: ; preds = %73
%80 = load i8*, i8** %15
%81 = getelementptr inbounds i8, i8* %80, i32 1
store i8* %81, i8** %15
br label %82
82: ; preds = %79, %73
br label %83
83: ; preds = %82
%84 = load i32, i32* %16
%85 = add nsw i32 %84, 1
store i32 %85, i32* %16
br label %39
86: ; preds = %39
store i32 1, i32* %7
br label %87
87: ; preds = %86, %48
%88 = load i32, i32* %7
ret i32 %88
}

LLVM IR (-O2):
@.str = [73 x i8] c"TAB characters will corrupt a SELEX alignment! Please remove them first.\00"
define i32 @copy_alignment_line(i8* nocapture writeonly %0, i32 %1, i32 %2, i8* nocapture %3, i32 %4, i32 %5) {
%7 = sext i32 %1 to i64
%8 = getelementptr inbounds i8, i8* %0, i64 %7
%9 = icmp sgt i32 %4, 0
br i1 %9, label %10, label %29
10: ; preds = %6
%11 = add i32 %4, -1
%12 = and i32 %4, 3
%13 = icmp ult i32 %11, 3
br i1 %13, label %16, label %14
14: ; preds = %10
%15 = and i32 %4, -4
br label %32
16: ; preds = %32, %10
%17 = phi i8* [ undef, %10 ], [ %50, %32 ]
%18 = phi i8* [ %3, %10 ], [ %50, %32 ]
%19 = icmp eq i32 %12, 0
br i1 %19, label %29, label %20
20: ; preds = %16, %20
%21 = phi i8* [ %26, %20 ], [ %18, %16 ]
%22 = phi i32 [ %27, %20 ], [ 0, %16 ]
%23 = load i8, i8* %21
%24 = icmp ne i8 %23, 0
%25 = zext i1 %24 to i64
%26 = getelementptr i8, i8* %21, i64 %25
%27 = add i32 %22, 1
%28 = icmp eq i32 %27, %12
br i1 %28, label %29, label %20
29: ; preds = %16, %20, %6
%30 = phi i8* [ %3, %6 ], [ %17, %16 ], [ %26, %20 ]
%31 = icmp sgt i32 %4, %5
br i1 %31, label %74, label %53
32: ; preds = %32, %14
%33 = phi i8* [ %3, %14 ], [ %50, %32 ]
%34 = phi i32 [ 0, %14 ], [ %51, %32 ]
%35 = load i8, i8* %33
%36 = icmp ne i8 %35, 0
%37 = zext i1 %36 to i64
%38 = getelementptr i8, i8* %33, i64 %37
%39 = load i8, i8* %38
%40 = icmp ne i8 %39, 0
%41 = zext i1 %40 to i64
%42 = getelementptr i8, i8* %38, i64 %41
%43 = load i8, i8* %42
%44 = icmp ne i8 %43, 0
%45 = zext i1 %44 to i64
%46 = getelementptr i8, i8* %42, i64 %45
%47 = load i8, i8* %46
%48 = icmp ne i8 %47, 0
%49 = zext i1 %48 to i64
%50 = getelementptr i8, i8* %46, i64 %49
%51 = add i32 %34, 4
%52 = icmp eq i32 %51, %15
br i1 %52, label %16, label %32
53: ; preds = %29, %65
%54 = phi i32 [ %72, %65 ], [ %4, %29 ]
%55 = phi i8* [ %71, %65 ], [ %30, %29 ]
%56 = phi i8* [ %67, %65 ], [ %8, %29 ]
%57 = load i8, i8* %55
%58 = icmp eq i8 %57, 9
br i1 %58, label %59, label %61
59: ; preds = %53
%60 = tail call i32 @Warn(i8* getelementptr inbounds ([73 x i8], [73 x i8]* @.str, i64 0, i64 0))
br label %74
61: ; preds = %53
%62 = icmp sgt i32 %54, %2
br i1 %62, label %63, label %65
63: ; preds = %61
switch i8 %57, label %64 [
i8 0, label %65
i8 10, label %65
]
64: ; preds = %63
br label %65
65: ; preds = %63, %63, %61, %64
%66 = phi i8 [ %57, %64 ], [ 46, %61 ], [ 46, %63 ], [ 46, %63 ]
store i8 %66, i8* %56
%67 = getelementptr inbounds i8, i8* %56, i64 1
%68 = load i8, i8* %55
%69 = icmp ne i8 %68, 0
%70 = zext i1 %69 to i64
%71 = getelementptr i8, i8* %55, i64 %70
%72 = add i32 %54, 1
%73 = icmp eq i32 %54, %5
br i1 %73, label %74, label %53
74: ; preds = %65, %29, %59
%75 = phi i32 [ 0, %59 ], [ 1, %29 ], [ 1, %65 ]
ret i32 %75
}