#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 time_t;

/* Variables and functions */
scalar_t__ isdigit(char);
size_t strspn(char *, char *);
int offset(char *env, time_t *off) {
  int n, sign;
  size_t len, retlen;
  retlen = 0;
  sign = 1;
  if (*env == '-' || *env == '+') {
    if (*env++ == '-')
      sign = -1;
    retlen++;
  }
  if ((len = strspn(env, ":0123456789")) == 0)
    return 0;
  retlen += len;
  for (*off = 0; len && isdigit(*env); len--)
    *off = *off * 10 + (*env++ - '0') * 60 * 60;
  if (len) {
    if (*env++ != ':')
      return 0;
    len--;
  }
  for (n = 0; len && isdigit(*env); len--)
    n = n * 10 + (*env++ - '0') * 60;
  *off += n;
  if (len) {
    if (*env++ != ':')
      return 0;
    len--;
  }
  for (n = 0; len && isdigit(*env); len--)
    n = n * 10 + (*env++ - '0');
  *off = (*off + n) * sign;
  return retlen;
}


x86 assembly (clang, -O0):
<offset>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
movq   $0x0,-0x30(%rbp)
movl   $0x1,-0x20(%rbp)
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x2d,%eax
je     115f <offset+0x3f>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x2b,%eax
jne    118d <offset+0x6d>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
movsbl (%rax),%eax
cmp    $0x2d,%eax
jne    1181 <offset+0x61>
movl   $0xffffffff,-0x20(%rbp)
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
mov    -0x10(%rbp),%rdi
lea    0xe68(%rip),%rsi
call   1040 <strspn@plt>
mov    %rax,-0x28(%rbp)
cmp    $0x0,%rax
jne    11b7 <offset+0x97>
movl   $0x0,-0x4(%rbp)
jmp    13ba <offset+0x29a>
mov    -0x28(%rbp),%rax
add    -0x30(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x18(%rbp),%rax
movl   $0x0,(%rax)
xor    %eax,%eax
cmpq   $0x0,-0x28(%rbp)
mov    %al,-0x31(%rbp)
je     11f3 <offset+0xd3>
mov    -0x10(%rbp),%rax
movsbl (%rax),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%rax
setne  %al
mov    %al,-0x31(%rbp)
mov    -0x31(%rbp),%al
test   $0x1,%al
jne    1203 <offset+0xe3>
jmp    123e <offset+0x11e>
mov    -0x18(%rbp),%rax
imul   $0xa,(%rax),%ecx
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
movsbl (%rax),%eax
sub    $0x30,%eax
imul   $0x3c,%eax,%eax
imul   $0x3c,%eax,%eax
add    %eax,%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x28(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x28(%rbp)
jmp    11cd <offset+0xad>
cmpq   $0x0,-0x28(%rbp)
je     127c <offset+0x15c>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
movsbl (%rax),%eax
cmp    $0x3a,%eax
je     1270 <offset+0x150>
movl   $0x0,-0x4(%rbp)
jmp    13ba <offset+0x29a>
mov    -0x28(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x28(%rbp)
movl   $0x0,-0x1c(%rbp)
xor    %eax,%eax
cmpq   $0x0,-0x28(%rbp)
mov    %al,-0x32(%rbp)
je     12a9 <offset+0x189>
mov    -0x10(%rbp),%rax
movsbl (%rax),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%rax
setne  %al
mov    %al,-0x32(%rbp)
mov    -0x32(%rbp),%al
test   $0x1,%al
jne    12b9 <offset+0x199>
jmp    12eb <offset+0x1cb>
imul   $0xa,-0x1c(%rbp),%eax
mov    -0x10(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
movsbl (%rcx),%ecx
sub    $0x30,%ecx
imul   $0x3c,%ecx,%ecx
add    %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x28(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x28(%rbp)
jmp    1283 <offset+0x163>
mov    -0x1c(%rbp),%ecx
mov    -0x18(%rbp),%rax
add    (%rax),%ecx
mov    %ecx,(%rax)
cmpq   $0x0,-0x28(%rbp)
je     1334 <offset+0x214>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
movsbl (%rax),%eax
cmp    $0x3a,%eax
je     1328 <offset+0x208>
movl   $0x0,-0x4(%rbp)
jmp    13ba <offset+0x29a>
mov    -0x28(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x28(%rbp)
movl   $0x0,-0x1c(%rbp)
xor    %eax,%eax
cmpq   $0x0,-0x28(%rbp)
mov    %al,-0x33(%rbp)
je     1361 <offset+0x241>
mov    -0x10(%rbp),%rax
movsbl (%rax),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%rax
setne  %al
mov    %al,-0x33(%rbp)
mov    -0x33(%rbp),%al
test   $0x1,%al
jne    1371 <offset+0x251>
jmp    13a0 <offset+0x280>
imul   $0xa,-0x1c(%rbp),%eax
mov    -0x10(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
movsbl (%rcx),%ecx
sub    $0x30,%ecx
add    %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x28(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x28(%rbp)
jmp    133b <offset+0x21b>
mov    -0x18(%rbp),%rax
mov    (%rax),%ecx
add    -0x1c(%rbp),%ecx
imul   -0x20(%rbp),%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x30(%rbp),%rax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<offset>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    %rsi,%r14
mov    %rdi,%rbx
mov    (%rdi),%al
cmp    $0x2d,%al
je     113e <offset+0x1e>
cmp    $0x2b,%al
jne    1157 <offset+0x37>
add    $0x1,%rbx
xor    %ecx,%ecx
cmp    $0x2d,%al
setne  %cl
lea    (%rcx,%rcx,1),%ebp
add    $0xffffffff,%ebp
mov    $0x1,%r12d
jmp    115f <offset+0x3f>
mov    $0x1,%ebp
xor    %r12d,%r12d
lea    0xe9a(%rip),%rsi
mov    %rbx,%rdi
call   1040 <strspn@plt>
test   %rax,%rax
je     11cc <offset+0xac>
mov    %rax,%r15
mov    %ebp,0xc(%rsp)
add    %rax,%r12
movl   $0x0,(%r14)
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
movsbl (%rbx,%rbp,1),%edi
call   1030 <isdigit@plt>
test   %rax,%rax
je     11d0 <offset+0xb0>
mov    (%r14),%eax
lea    (%rax,%rax,4),%eax
movsbl (%rbx,%rbp,1),%ecx
imul   $0xe10,%ecx,%ecx
lea    (%rcx,%rax,2),%eax
add    $0xfffd5d00,%eax
mov    %eax,(%r14)
add    $0x1,%rbp
cmp    %rbp,%r15
jne    1190 <offset+0x70>
mov    %r12,0x10(%rsp)
xor    %r13d,%r13d
jmp    1220 <offset+0x100>
xor    %eax,%eax
jmp    1237 <offset+0x117>
xor    %eax,%eax
cmpb   $0x3a,(%rbx,%rbp,1)
jne    1237 <offset+0x117>
mov    %r12,0x10(%rsp)
lea    -0x1(%r15),%r12
xor    %r13d,%r13d
cmp    %rbp,%r12
je     1220 <offset+0x100>
xor    %r13d,%r13d
nopl   0x0(%rax)
movsbl 0x1(%rbx,%rbp,1),%edi
call   1030 <isdigit@plt>
test   %rax,%rax
je     1246 <offset+0x126>
lea    0x0(%r13,%r13,4),%eax
movsbl 0x1(%rbx,%rbp,1),%ecx
imul   $0x3c,%ecx,%ecx
lea    (%rcx,%rax,2),%r13d
add    $0xfffff4c0,%r13d
add    $0x1,%rbp
cmp    %rbp,%r12
jne    11f0 <offset+0xd0>
add    (%r14),%r13d
xor    %r12d,%r12d
add    %r12d,%r13d
imul   0xc(%rsp),%r13d
mov    %r13d,(%r14)
mov    0x10(%rsp),%rax
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
add    (%r14),%r13d
mov    %r13d,(%r14)
xor    %eax,%eax
cmpb   $0x3a,0x1(%rbx,%rbp,1)
jne    1237 <offset+0x117>
add    $0xfffffffffffffffe,%r15
xor    %r12d,%r12d
cmp    %rbp,%r15
je     1226 <offset+0x106>
xor    %r12d,%r12d
movsbl 0x2(%rbx,%rbp,1),%edi
call   1030 <isdigit@plt>
test   %rax,%rax
je     128d <offset+0x16d>
lea    (%r12,%r12,4),%eax
movsbl 0x2(%rbx,%rbp,1),%ecx
lea    (%rcx,%rax,2),%r12d
add    $0xffffffd0,%r12d
add    $0x1,%rbp
cmp    %rbp,%r15
jne    1264 <offset+0x144>
mov    (%r14),%r13d
jmp    1226 <offset+0x106>

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

LLVM IR (-O2):
@.str = [12 x i8] c":0123456789\00"
define i32 @offset(i8* nocapture %0, i32* nocapture %1) {
%3 = load i8, i8* %0
switch i8 %3, label %8 [
i8 45, label %4
i8 43, label %4
]
4: ; preds = %2, %2
%5 = getelementptr inbounds i8, i8* %0, i64 1
%6 = icmp eq i8 %3, 45
%7 = select i1 %6, i32 -1, i32 1
br label %8
8: ; preds = %2, %4
%9 = phi i8* [ %5, %4 ], [ %0, %2 ]
%10 = phi i32 [ %7, %4 ], [ 1, %2 ]
%11 = phi i64 [ 1, %4 ], [ 0, %2 ]
%12 = tail call i64 @strspn(i8* %9, i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str, i64 0, i64 0))
%13 = icmp eq i64 %12, 0
br i1 %13, label %95, label %14
14: ; preds = %8
%15 = add i64 %12, %11
store i32 0, i32* %1
br label %16
16: ; preds = %14, %22
%17 = phi i64 [ %12, %14 ], [ %31, %22 ]
%18 = phi i8* [ %9, %14 ], [ %25, %22 ]
%19 = load i8, i8* %18
%20 = tail call i64 @isdigit(i8 signext %19)
%21 = icmp eq i64 %20, 0
br i1 %21, label %33, label %22
22: ; preds = %16
%23 = load i32, i32* %1
%24 = mul nsw i32 %23, 10
%25 = getelementptr inbounds i8, i8* %18, i64 1
%26 = load i8, i8* %18
%27 = sext i8 %26 to i32
%28 = mul nsw i32 %27, 3600
%29 = add i32 %24, -172800
%30 = add i32 %29, %28
store i32 %30, i32* %1
%31 = add i64 %17, -1
%32 = icmp eq i64 %31, 0
br i1 %32, label %61, label %16
33: ; preds = %16
%34 = load i8, i8* %18
%35 = icmp eq i8 %34, 58
br i1 %35, label %36, label %95
36: ; preds = %33
%37 = add i64 %17, -1
%38 = icmp eq i64 %37, 0
br i1 %38, label %61, label %39
39: ; preds = %36, %47
%40 = phi i64 [ %54, %47 ], [ %37, %36 ]
%41 = phi i32 [ %53, %47 ], [ 0, %36 ]
%42 = phi i8* [ %43, %47 ], [ %18, %36 ]
%43 = getelementptr inbounds i8, i8* %42, i64 1
%44 = load i8, i8* %43
%45 = tail call i64 @isdigit(i8 signext %44)
%46 = icmp eq i64 %45, 0
br i1 %46, label %56, label %47
47: ; preds = %39
%48 = mul nsw i32 %41, 10
%49 = load i8, i8* %43
%50 = sext i8 %49 to i32
%51 = mul nsw i32 %50, 60
%52 = add i32 %48, -2880
%53 = add i32 %52, %51
%54 = add i64 %40, -1
%55 = icmp eq i64 %54, 0
br i1 %55, label %61, label %39
56: ; preds = %39
%57 = load i32, i32* %1
%58 = add nsw i32 %57, %41
store i32 %58, i32* %1
%59 = load i8, i8* %43
%60 = icmp eq i8 %59, 58
br i1 %60, label %65, label %95
61: ; preds = %22, %47, %36
%62 = phi i32 [ 0, %36 ], [ %53, %47 ], [ 0, %22 ]
%63 = load i32, i32* %1
%64 = add nsw i32 %63, %62
br label %89
65: ; preds = %56
%66 = add i64 %40, -1
%67 = icmp eq i64 %66, 0
br i1 %67, label %89, label %68
68: ; preds = %65
%69 = getelementptr inbounds i8, i8* %42, i64 2
br label %70
70: ; preds = %68, %77
%71 = phi i64 [ %84, %77 ], [ %66, %68 ]
%72 = phi i32 [ %83, %77 ], [ 0, %68 ]
%73 = phi i8* [ %79, %77 ], [ %69, %68 ]
%74 = load i8, i8* %73
%75 = tail call i64 @isdigit(i8 signext %74)
%76 = icmp eq i64 %75, 0
br i1 %76, label %86, label %77
77: ; preds = %70
%78 = mul nsw i32 %72, 10
%79 = getelementptr inbounds i8, i8* %73, i64 1
%80 = load i8, i8* %73
%81 = sext i8 %80 to i32
%82 = add i32 %78, -48
%83 = add i32 %82, %81
%84 = add i64 %71, -1
%85 = icmp eq i64 %84, 0
br i1 %85, label %86, label %70
86: ; preds = %77, %70
%87 = phi i32 [ %72, %70 ], [ %83, %77 ]
%88 = load i32, i32* %1
br label %89
89: ; preds = %61, %86, %65
%90 = phi i32 [ %58, %65 ], [ %88, %86 ], [ %64, %61 ]
%91 = phi i32 [ 0, %65 ], [ %87, %86 ], [ 0, %61 ]
%92 = add nsw i32 %90, %91
%93 = mul nsw i32 %92, %10
store i32 %93, i32* %1
%94 = trunc i64 %15 to i32
br label %95
95: ; preds = %56, %33, %8, %89
%96 = phi i32 [ %94, %89 ], [ 0, %8 ], [ 0, %33 ], [ 0, %56 ]
ret i32 %96
}