#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 */
typedef int /*<<< orphan*/ time_t;
struct tm {
  char tm_mon;
  char tm_mday;
  char tm_hour;
  char tm_min;
  char tm_year;
  int tm_isdst;
};
struct timespec {
  int tv_sec;
  scalar_t__ tv_nsec;
};

/* Variables and functions */
int /*<<< orphan*/ err(int, char *);
int /*<<< orphan*/ errx(int, char *);
struct tm *localtime(int /*<<< orphan*/ *);
int mktime(struct tm *);
int /*<<< orphan*/ time(int /*<<< orphan*/ *);
void stime_arg2(const char *arg, int year, struct timespec *tvp) {
  time_t now;
  struct tm *t;
  now = time(NULL);
  if ((t = localtime(&now)) == NULL)
    err(1, "localtime");
  t->tm_mon = ((arg)[0] - '0') * 10 + ((arg)[1] - '0');
  (arg) += 2;
  ;
  --t->tm_mon;
  t->tm_mday = ((arg)[0] - '0') * 10 + ((arg)[1] - '0');
  (arg) += 2;
  ;
  t->tm_hour = ((arg)[0] - '0') * 10 + ((arg)[1] - '0');
  (arg) += 2;
  ;
  t->tm_min = ((arg)[0] - '0') * 10 + ((arg)[1] - '0');
  (arg) += 2;
  ;
  if (year) {
    t->tm_year = ((arg)[0] - '0') * 10 + ((arg)[1] - '0');
    (arg) += 2;
    ;
    if (t->tm_year < 39)
      t->tm_year += 100;
  }
  t->tm_isdst = -1;
  tvp[0].tv_sec = tvp[1].tv_sec = mktime(t);
  if (tvp[0].tv_sec == -1)
    errx(1, "out of range or illegal time specification: MMDDhhmm[yy]");
  tvp[0].tv_nsec = tvp[1].tv_nsec = 0;
}


x86 assembly (clang, -O0):
<stime_arg2>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
xor    %eax,%eax
mov    %eax,%edi
call   1050 <time@plt>
mov    %eax,-0x1c(%rbp)
lea    -0x1c(%rbp),%rdi
call   1030 <localtime@plt>
mov    %rax,-0x28(%rbp)
cmp    $0x0,%rax
jne    1197 <stime_arg2+0x47>
mov    $0x1,%edi
lea    0xe6e(%rip),%rsi
call   1060 <err@plt>
mov    -0x8(%rbp),%rax
movsbl (%rax),%eax
sub    $0x30,%eax
imul   $0xa,%eax,%eax
mov    -0x8(%rbp),%rcx
movsbl 0x1(%rcx),%ecx
sub    $0x30,%ecx
add    %ecx,%eax
mov    %al,%cl
mov    -0x28(%rbp),%rax
mov    %cl,(%rax)
mov    -0x8(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x8(%rbp)
mov    -0x28(%rbp),%rax
mov    (%rax),%cl
add    $0xff,%cl
mov    %cl,(%rax)
mov    -0x8(%rbp),%rax
movsbl (%rax),%eax
sub    $0x30,%eax
imul   $0xa,%eax,%eax
mov    -0x8(%rbp),%rcx
movsbl 0x1(%rcx),%ecx
sub    $0x30,%ecx
add    %ecx,%eax
mov    %al,%cl
mov    -0x28(%rbp),%rax
mov    %cl,0x1(%rax)
mov    -0x8(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
movsbl (%rax),%eax
sub    $0x30,%eax
imul   $0xa,%eax,%eax
mov    -0x8(%rbp),%rcx
movsbl 0x1(%rcx),%ecx
sub    $0x30,%ecx
add    %ecx,%eax
mov    %al,%cl
mov    -0x28(%rbp),%rax
mov    %cl,0x2(%rax)
mov    -0x8(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
movsbl (%rax),%eax
sub    $0x30,%eax
imul   $0xa,%eax,%eax
mov    -0x8(%rbp),%rcx
movsbl 0x1(%rcx),%ecx
sub    $0x30,%ecx
add    %ecx,%eax
mov    %al,%cl
mov    -0x28(%rbp),%rax
mov    %cl,0x3(%rax)
mov    -0x8(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x8(%rbp)
cmpl   $0x0,-0xc(%rbp)
je     12ba <stime_arg2+0x16a>
mov    -0x8(%rbp),%rax
movsbl (%rax),%eax
sub    $0x30,%eax
imul   $0xa,%eax,%eax
mov    -0x8(%rbp),%rcx
movsbl 0x1(%rcx),%ecx
sub    $0x30,%ecx
add    %ecx,%eax
mov    %al,%cl
mov    -0x28(%rbp),%rax
mov    %cl,0x4(%rax)
mov    -0x8(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x8(%rbp)
mov    -0x28(%rbp),%rax
movsbl 0x4(%rax),%eax
cmp    $0x27,%eax
jge    12b5 <stime_arg2+0x165>
mov    -0x28(%rbp),%rax
movsbl 0x4(%rax),%ecx
add    $0x64,%ecx
mov    %cl,0x4(%rax)
jmp    12ba <stime_arg2+0x16a>
mov    -0x28(%rbp),%rax
movl   $0xffffffff,0x8(%rax)
mov    -0x28(%rbp),%rdi
call   1070 <mktime@plt>
mov    %eax,%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,0x10(%rax)
mov    -0x18(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x18(%rbp),%rax
cmpl   $0xffffffff,(%rax)
jne    12fb <stime_arg2+0x1ab>
mov    $0x1,%edi
lea    0xd14(%rip),%rsi
call   1040 <errx@plt>
mov    -0x18(%rbp),%rax
movq   $0x0,0x18(%rax)
mov    -0x18(%rbp),%rax
movq   $0x0,0x8(%rax)
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<stime_arg2>:
push   %rbp
push   %r15
push   %r14
push   %rbx
push   %rax
mov    %rdx,%r14
mov    %esi,%ebp
mov    %rdi,%rbx
xor    %edi,%edi
call   1050 <time@plt>
mov    %eax,0x4(%rsp)
lea    0x4(%rsp),%rdi
call   1030 <localtime@plt>
mov    %rax,%r15
test   %rax,%rax
jne    118d <stime_arg2+0x3d>
lea    0xe7d(%rip),%rsi
mov    $0x1,%edi
call   1060 <err@plt>
movzbl (%rbx),%eax
add    %eax,%eax
lea    (%rax,%rax,4),%eax
add    0x1(%rbx),%al
add    $0xef,%al
mov    %al,(%r15)
movzbl 0x2(%rbx),%eax
add    %eax,%eax
lea    (%rax,%rax,4),%eax
add    0x3(%rbx),%al
add    $0xf0,%al
mov    %al,0x1(%r15)
movzbl 0x4(%rbx),%eax
add    %eax,%eax
lea    (%rax,%rax,4),%eax
add    0x5(%rbx),%al
add    $0xf0,%al
mov    %al,0x2(%r15)
movzbl 0x6(%rbx),%eax
add    %eax,%eax
lea    (%rax,%rax,4),%eax
add    0x7(%rbx),%al
add    $0xf0,%al
mov    %al,0x3(%r15)
test   %ebp,%ebp
je     11f5 <stime_arg2+0xa5>
movzbl 0x8(%rbx),%eax
add    %eax,%eax
lea    (%rax,%rax,4),%eax
add    0x9(%rbx),%al
lea    -0x10(%rax),%ecx
mov    %cl,0x4(%r15)
cmp    $0x26,%cl
jg     11f5 <stime_arg2+0xa5>
add    $0x54,%al
mov    %al,0x4(%r15)
movl   $0xffffffff,0x8(%r15)
ff
mov    %r15,%rdi
call   1070 <mktime@plt>
mov    %eax,0x10(%r14)
mov    %eax,(%r14)
cmp    $0xffffffff,%eax
jne    1222 <stime_arg2+0xd2>
lea    0xdf2(%rip),%rsi
mov    $0x1,%edi
call   1040 <errx@plt>
movq   $0x0,0x18(%r14)
movq   $0x0,0x8(%r14)
add    $0x8,%rsp
pop    %rbx
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
%struct.timespec = type { i32, i64 }
%struct.tm = type { i8, i8, i8, i8, i8, i32 }
@.str = [10 x i8] c"localtime\00"
@.str.1 = [57 x i8] c"out of range or illegal time specification: MMDDhhmm[yy]\00"
define void @stime_arg2(i8* %0, i32 %1, %struct.timespec* %2) {
%4 = alloca i8*
%5 = alloca i32
%6 = alloca %struct.timespec*
%7 = alloca i32
%8 = alloca %struct.tm*
store i8* %0, i8** %4
store i32 %1, i32* %5
store %struct.timespec* %2, %struct.timespec** %6
%9 = call i32 @time(i32* null)
store i32 %9, i32* %7
%10 = call %struct.tm* @localtime(i32* %7)
store %struct.tm* %10, %struct.tm** %8
%11 = icmp eq %struct.tm* %10, null
br i1 %11, label %12, label %14
12: ; preds = %3
%13 = call i32 @err(i32 1, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i64 0, i64 0))
br label %14
14: ; preds = %12, %3
%15 = load i8*, i8** %4
%16 = getelementptr inbounds i8, i8* %15, i64 0
%17 = load i8, i8* %16
%18 = sext i8 %17 to i32
%19 = sub nsw i32 %18, 48
%20 = mul nsw i32 %19, 10
%21 = load i8*, i8** %4
%22 = getelementptr inbounds i8, i8* %21, i64 1
%23 = load i8, i8* %22
%24 = sext i8 %23 to i32
%25 = sub nsw i32 %24, 48
%26 = add nsw i32 %20, %25
%27 = trunc i32 %26 to i8
%28 = load %struct.tm*, %struct.tm** %8
%29 = getelementptr inbounds %struct.tm, %struct.tm* %28, i32 0, i32 0
store i8 %27, i8* %29
%30 = load i8*, i8** %4
%31 = getelementptr inbounds i8, i8* %30, i64 2
store i8* %31, i8** %4
%32 = load %struct.tm*, %struct.tm** %8
%33 = getelementptr inbounds %struct.tm, %struct.tm* %32, i32 0, i32 0
%34 = load i8, i8* %33
%35 = add i8 %34, -1
store i8 %35, i8* %33
%36 = load i8*, i8** %4
%37 = getelementptr inbounds i8, i8* %36, i64 0
%38 = load i8, i8* %37
%39 = sext i8 %38 to i32
%40 = sub nsw i32 %39, 48
%41 = mul nsw i32 %40, 10
%42 = load i8*, i8** %4
%43 = getelementptr inbounds i8, i8* %42, i64 1
%44 = load i8, i8* %43
%45 = sext i8 %44 to i32
%46 = sub nsw i32 %45, 48
%47 = add nsw i32 %41, %46
%48 = trunc i32 %47 to i8
%49 = load %struct.tm*, %struct.tm** %8
%50 = getelementptr inbounds %struct.tm, %struct.tm* %49, i32 0, i32 1
store i8 %48, i8* %50
%51 = load i8*, i8** %4
%52 = getelementptr inbounds i8, i8* %51, i64 2
store i8* %52, i8** %4
%53 = load i8*, i8** %4
%54 = getelementptr inbounds i8, i8* %53, i64 0
%55 = load i8, i8* %54
%56 = sext i8 %55 to i32
%57 = sub nsw i32 %56, 48
%58 = mul nsw i32 %57, 10
%59 = load i8*, i8** %4
%60 = getelementptr inbounds i8, i8* %59, i64 1
%61 = load i8, i8* %60
%62 = sext i8 %61 to i32
%63 = sub nsw i32 %62, 48
%64 = add nsw i32 %58, %63
%65 = trunc i32 %64 to i8
%66 = load %struct.tm*, %struct.tm** %8
%67 = getelementptr inbounds %struct.tm, %struct.tm* %66, i32 0, i32 2
store i8 %65, i8* %67
%68 = load i8*, i8** %4
%69 = getelementptr inbounds i8, i8* %68, i64 2
store i8* %69, i8** %4
%70 = load i8*, i8** %4
%71 = getelementptr inbounds i8, i8* %70, i64 0
%72 = load i8, i8* %71
%73 = sext i8 %72 to i32
%74 = sub nsw i32 %73, 48
%75 = mul nsw i32 %74, 10
%76 = load i8*, i8** %4
%77 = getelementptr inbounds i8, i8* %76, i64 1
%78 = load i8, i8* %77
%79 = sext i8 %78 to i32
%80 = sub nsw i32 %79, 48
%81 = add nsw i32 %75, %80
%82 = trunc i32 %81 to i8
%83 = load %struct.tm*, %struct.tm** %8
%84 = getelementptr inbounds %struct.tm, %struct.tm* %83, i32 0, i32 3
store i8 %82, i8* %84
%85 = load i8*, i8** %4
%86 = getelementptr inbounds i8, i8* %85, i64 2
store i8* %86, i8** %4
%87 = load i32, i32* %5
%88 = icmp ne i32 %87, 0
br i1 %88, label %89, label %120
89: ; preds = %14
%90 = load i8*, i8** %4
%91 = getelementptr inbounds i8, i8* %90, i64 0
%92 = load i8, i8* %91
%93 = sext i8 %92 to i32
%94 = sub nsw i32 %93, 48
%95 = mul nsw i32 %94, 10
%96 = load i8*, i8** %4
%97 = getelementptr inbounds i8, i8* %96, i64 1
%98 = load i8, i8* %97
%99 = sext i8 %98 to i32
%100 = sub nsw i32 %99, 48
%101 = add nsw i32 %95, %100
%102 = trunc i32 %101 to i8
%103 = load %struct.tm*, %struct.tm** %8
%104 = getelementptr inbounds %struct.tm, %struct.tm* %103, i32 0, i32 4
store i8 %102, i8* %104
%105 = load i8*, i8** %4
%106 = getelementptr inbounds i8, i8* %105, i64 2
store i8* %106, i8** %4
%107 = load %struct.tm*, %struct.tm** %8
%108 = getelementptr inbounds %struct.tm, %struct.tm* %107, i32 0, i32 4
%109 = load i8, i8* %108
%110 = sext i8 %109 to i32
%111 = icmp slt i32 %110, 39
br i1 %111, label %112, label %119
112: ; preds = %89
%113 = load %struct.tm*, %struct.tm** %8
%114 = getelementptr inbounds %struct.tm, %struct.tm* %113, i32 0, i32 4
%115 = load i8, i8* %114
%116 = sext i8 %115 to i32
%117 = add nsw i32 %116, 100
%118 = trunc i32 %117 to i8
store i8 %118, i8* %114
br label %119
119: ; preds = %112, %89
br label %120
120: ; preds = %119, %14
%121 = load %struct.tm*, %struct.tm** %8
%122 = getelementptr inbounds %struct.tm, %struct.tm* %121, i32 0, i32 5
store i32 -1, i32* %122
%123 = load %struct.tm*, %struct.tm** %8
%124 = call i32 @mktime(%struct.tm* %123)
%125 = load %struct.timespec*, %struct.timespec** %6
%126 = getelementptr inbounds %struct.timespec, %struct.timespec* %125, i64 1
%127 = getelementptr inbounds %struct.timespec, %struct.timespec* %126, i32 0, i32 0
store i32 %124, i32* %127
%128 = load %struct.timespec*, %struct.timespec** %6
%129 = getelementptr inbounds %struct.timespec, %struct.timespec* %128, i64 0
%130 = getelementptr inbounds %struct.timespec, %struct.timespec* %129, i32 0, i32 0
store i32 %124, i32* %130
%131 = load %struct.timespec*, %struct.timespec** %6
%132 = getelementptr inbounds %struct.timespec, %struct.timespec* %131, i64 0
%133 = getelementptr inbounds %struct.timespec, %struct.timespec* %132, i32 0, i32 0
%134 = load i32, i32* %133
%135 = icmp eq i32 %134, -1
br i1 %135, label %136, label %138
136: ; preds = %120
%137 = call i32 @errx(i32 1, i8* getelementptr inbounds ([57 x i8], [57 x i8]* @.str.1, i64 0, i64 0))
br label %138
138: ; preds = %136, %120
%139 = load %struct.timespec*, %struct.timespec** %6
%140 = getelementptr inbounds %struct.timespec, %struct.timespec* %139, i64 1
%141 = getelementptr inbounds %struct.timespec, %struct.timespec* %140, i32 0, i32 1
store i64 0, i64* %141
%142 = load %struct.timespec*, %struct.timespec** %6
%143 = getelementptr inbounds %struct.timespec, %struct.timespec* %142, i64 0
%144 = getelementptr inbounds %struct.timespec, %struct.timespec* %143, i32 0, i32 1
store i64 0, i64* %144
ret void
}

LLVM IR (-O2):
%struct.timespec = type { i32, i64 }
%struct.tm = type { i8, i8, i8, i8, i8, i32 }
@.str = [10 x i8] c"localtime\00"
@.str.1 = [57 x i8] c"out of range or illegal time specification: MMDDhhmm[yy]\00"
define void @stime_arg2(i8* nocapture %0, i32 %1, %struct.timespec* nocapture writeonly %2) {
%4 = alloca i32
%5 = bitcast i32* %4 to i8*
%6 = tail call i32 @time(i32* null)
store i32 %6, i32* %4
%7 = call %struct.tm* @localtime(i32* %4)
%8 = icmp eq %struct.tm* %7, null
br i1 %8, label %9, label %11
9: ; preds = %3
%10 = call i32 @err(i32 1, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i64 0, i64 0))
br label %11
11: ; preds = %9, %3
%12 = load i8, i8* %0
%13 = mul i8 %12, 10
%14 = getelementptr inbounds i8, i8* %0, i64 1
%15 = load i8, i8* %14
%16 = getelementptr inbounds %struct.tm, %struct.tm* %7, i64 0, i32 0
%17 = getelementptr inbounds i8, i8* %0, i64 2
%18 = add i8 %15, -17
%19 = add i8 %18, %13
store i8 %19, i8* %16
%20 = load i8, i8* %17
%21 = mul i8 %20, 10
%22 = getelementptr inbounds i8, i8* %0, i64 3
%23 = load i8, i8* %22
%24 = add i8 %23, -16
%25 = add i8 %24, %21
%26 = getelementptr inbounds %struct.tm, %struct.tm* %7, i64 0, i32 1
store i8 %25, i8* %26
%27 = getelementptr inbounds i8, i8* %0, i64 4
%28 = load i8, i8* %27
%29 = mul i8 %28, 10
%30 = getelementptr inbounds i8, i8* %0, i64 5
%31 = load i8, i8* %30
%32 = add i8 %31, -16
%33 = add i8 %32, %29
%34 = getelementptr inbounds %struct.tm, %struct.tm* %7, i64 0, i32 2
store i8 %33, i8* %34
%35 = getelementptr inbounds i8, i8* %0, i64 6
%36 = load i8, i8* %35
%37 = mul i8 %36, 10
%38 = getelementptr inbounds i8, i8* %0, i64 7
%39 = load i8, i8* %38
%40 = add i8 %39, -16
%41 = add i8 %40, %37
%42 = getelementptr inbounds %struct.tm, %struct.tm* %7, i64 0, i32 3
store i8 %41, i8* %42
%43 = icmp eq i32 %1, 0
br i1 %43, label %56, label %44
44: ; preds = %11
%45 = getelementptr inbounds i8, i8* %0, i64 8
%46 = load i8, i8* %45
%47 = mul i8 %46, 10
%48 = getelementptr inbounds i8, i8* %0, i64 9
%49 = load i8, i8* %48
%50 = add i8 %47, %49
%51 = add i8 %50, -16
%52 = getelementptr inbounds %struct.tm, %struct.tm* %7, i64 0, i32 4
store i8 %51, i8* %52
%53 = icmp slt i8 %51, 39
br i1 %53, label %54, label %56
54: ; preds = %44
%55 = add i8 %50, 84
store i8 %55, i8* %52
br label %56
56: ; preds = %44, %54, %11
%57 = getelementptr inbounds %struct.tm, %struct.tm* %7, i64 0, i32 5
store i32 -1, i32* %57
%58 = call i32 @mktime(%struct.tm* %7)
%59 = getelementptr inbounds %struct.timespec, %struct.timespec* %2, i64 1, i32 0
store i32 %58, i32* %59
%60 = getelementptr inbounds %struct.timespec, %struct.timespec* %2, i64 0, i32 0
store i32 %58, i32* %60
%61 = icmp eq i32 %58, -1
br i1 %61, label %62, label %64
62: ; preds = %56
%63 = call i32 @errx(i32 1, i8* getelementptr inbounds ([57 x i8], [57 x i8]* @.str.1, i64 0, i64 0))
br label %64
64: ; preds = %62, %56
%65 = getelementptr inbounds %struct.timespec, %struct.timespec* %2, i64 1, i32 1
store i64 0, i64* %65
%66 = getelementptr inbounds %struct.timespec, %struct.timespec* %2, i64 0, i32 1
store i64 0, i64* %66
ret void
}