#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*/ wchar_t;

/* Variables and functions */
int /*<<< orphan*/ docheck(int, char *, int /*<<< orphan*/);
int /*<<< orphan*/ isalnum(unsigned char);
int /*<<< orphan*/ isalpha(unsigned char);
int /*<<< orphan*/ isblank(unsigned char);
int /*<<< orphan*/ iscntrl(unsigned char);
int /*<<< orphan*/ isdigit(unsigned char);
int /*<<< orphan*/ isgraph(unsigned char);
int /*<<< orphan*/ islower(unsigned char);
int /*<<< orphan*/ isprint(unsigned char);
int /*<<< orphan*/ ispunct(unsigned char);
int /*<<< orphan*/ isspace(unsigned char);
int /*<<< orphan*/ isupper(unsigned char);
scalar_t__ iswalnum(int /*<<< orphan*/);
scalar_t__ iswalpha(int /*<<< orphan*/);
scalar_t__ iswblank(int /*<<< orphan*/);
scalar_t__ iswcntrl(int /*<<< orphan*/);
scalar_t__ iswctype(int /*<<< orphan*/, int /*<<< orphan*/);
scalar_t__ iswdigit(int /*<<< orphan*/);
scalar_t__ iswgraph(int /*<<< orphan*/);
scalar_t__ iswlower(int /*<<< orphan*/);
scalar_t__ iswprint(int /*<<< orphan*/);
scalar_t__ iswpunct(int /*<<< orphan*/);
scalar_t__ iswspace(int /*<<< orphan*/);
scalar_t__ iswupper(int /*<<< orphan*/);
scalar_t__ iswxdigit(int /*<<< orphan*/);
int /*<<< orphan*/ isxdigit(unsigned char);
int /*<<< orphan*/ wctype(char *);
void verifywc(unsigned char x, wchar_t wx) {
  docheck(!!iswalnum(wx) == !!isalnum(x), "!!iswalnum(wx) == !!isalnum(x)", wx);
  docheck(!!iswalpha(wx) == !!isalpha(x), "!!iswalpha(wx) == !!isalpha(x)", wx);
  docheck(!!iswblank(wx) == !!isblank(x), "!!iswblank(wx) == !!isblank(x)", wx);
  docheck(!!iswcntrl(wx) == !!iscntrl(x), "!!iswcntrl(wx) == !!iscntrl(x)", wx);
  docheck(!!iswdigit(wx) == !!isdigit(x), "!!iswdigit(wx) == !!isdigit(x)", wx);
  docheck(!!iswgraph(wx) == !!isgraph(x), "!!iswgraph(wx) == !!isgraph(x)", wx);
  docheck(!!iswlower(wx) == !!islower(x), "!!iswlower(wx) == !!islower(x)", wx);
  docheck(!!iswprint(wx) == !!isprint(x), "!!iswprint(wx) == !!isprint(x)", wx);
  docheck(!!iswpunct(wx) == !!ispunct(x), "!!iswpunct(wx) == !!ispunct(x)", wx);
  docheck(!!iswspace(wx) == !!isspace(x), "!!iswspace(wx) == !!isspace(x)", wx);
  docheck(!!iswupper(wx) == !!isupper(x), "!!iswupper(wx) == !!isupper(x)", wx);
  docheck(!!iswxdigit(wx) == !!isxdigit(x), "!!iswxdigit(wx) == !!isxdigit(x)",
          wx);
  docheck(iswalnum(wx) == iswctype(wx, wctype("alnum")),
          "iswalnum(wx) == iswctype(wx, wctype(\"alnum\"))", wx);
  docheck(iswalpha(wx) == iswctype(wx, wctype("alpha")),
          "iswalpha(wx) == iswctype(wx, wctype(\"alpha\"))", wx);
  docheck(iswblank(wx) == iswctype(wx, wctype("blank")),
          "iswblank(wx) == iswctype(wx, wctype(\"blank\"))", wx);
  docheck(iswcntrl(wx) == iswctype(wx, wctype("cntrl")),
          "iswcntrl(wx) == iswctype(wx, wctype(\"cntrl\"))", wx);
  docheck(iswdigit(wx) == iswctype(wx, wctype("digit")),
          "iswdigit(wx) == iswctype(wx, wctype(\"digit\"))", wx);
  docheck(iswgraph(wx) == iswctype(wx, wctype("graph")),
          "iswgraph(wx) == iswctype(wx, wctype(\"graph\"))", wx);
  docheck(iswlower(wx) == iswctype(wx, wctype("lower")),
          "iswlower(wx) == iswctype(wx, wctype(\"lower\"))", wx);
  docheck(iswprint(wx) == iswctype(wx, wctype("print")),
          "iswprint(wx) == iswctype(wx, wctype(\"print\"))", wx);
  docheck(iswpunct(wx) == iswctype(wx, wctype("punct")),
          "iswpunct(wx) == iswctype(wx, wctype(\"punct\"))", wx);
  docheck(iswspace(wx) == iswctype(wx, wctype("space")),
          "iswspace(wx) == iswctype(wx, wctype(\"space\"))", wx);
  docheck(iswupper(wx) == iswctype(wx, wctype("upper")),
          "iswupper(wx) == iswctype(wx, wctype(\"upper\"))", wx);
  docheck(iswxdigit(wx) == iswctype(wx, wctype("xdigit")),
          "iswxdigit(wx) == iswctype(wx, wctype(\"xdigit\"))", wx);
}


x86 assembly (clang, -O0):
<verifywc>:
push   %rbp
mov    %rsp,%rbp
sub    $0x100,%rsp
mov    %dil,%al
mov    %al,-0x1(%rbp)
mov    %esi,-0x8(%rbp)
mov    -0x8(%rbp),%edi
call   1140 <iswalnum@plt>
cmp    $0x0,%rax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0xf4(%rbp)
movzbl -0x1(%rbp),%edi
call   10b0 <isalnum@plt>
mov    %eax,%ecx
mov    -0xf4(%rbp),%eax
cmp    $0x0,%ecx
setne  %cl
xor    $0xff,%cl
xor    $0xff,%cl
and    $0x1,%cl
movzbl %cl,%ecx
cmp    %ecx,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
mov    -0x8(%rbp),%edx
lea    0xce7(%rip),%rsi
call   11b0 <docheck@plt>
mov    -0x8(%rbp),%edi
call   1190 <iswalpha@plt>
cmp    $0x0,%rax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0xf0(%rbp)
movzbl -0x1(%rbp),%edi
call   1150 <isalpha@plt>
mov    %eax,%ecx
mov    -0xf0(%rbp),%eax
cmp    $0x0,%ecx
setne  %cl
xor    $0xff,%cl
xor    $0xff,%cl
and    $0x1,%cl
movzbl %cl,%ecx
cmp    %ecx,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
mov    -0x8(%rbp),%edx
lea    0xcac(%rip),%rsi
call   11b0 <docheck@plt>
mov    -0x8(%rbp),%edi
call   10e0 <iswblank@plt>
cmp    $0x0,%rax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0xec(%rbp)
movzbl -0x1(%rbp),%edi
call   10c0 <isblank@plt>
mov    %eax,%ecx
mov    -0xec(%rbp),%eax
cmp    $0x0,%ecx
setne  %cl
xor    $0xff,%cl
xor    $0xff,%cl
and    $0x1,%cl
movzbl %cl,%ecx
cmp    %ecx,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
mov    -0x8(%rbp),%edx
lea    0xc71(%rip),%rsi
call   11b0 <docheck@plt>
mov    -0x8(%rbp),%edi
call   1070 <iswcntrl@plt>
cmp    $0x0,%rax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0xe8(%rbp)
movzbl -0x1(%rbp),%edi
call   1090 <iscntrl@plt>
mov    %eax,%ecx
mov    -0xe8(%rbp),%eax
cmp    $0x0,%ecx
setne  %cl
xor    $0xff,%cl
xor    $0xff,%cl
and    $0x1,%cl
movzbl %cl,%ecx
cmp    %ecx,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
mov    -0x8(%rbp),%edx
lea    0xc36(%rip),%rsi
call   11b0 <docheck@plt>
mov    -0x8(%rbp),%edi
call   10d0 <iswdigit@plt>
cmp    $0x0,%rax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0xe4(%rbp)
movzbl -0x1(%rbp),%edi
call   1040 <isdigit@plt>
mov    %eax,%ecx
mov    -0xe4(%rbp),%eax
cmp    $0x0,%ecx
setne  %cl
xor    $0xff,%cl
xor    $0xff,%cl
and    $0x1,%cl
movzbl %cl,%ecx
cmp    %ecx,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
mov    -0x8(%rbp),%edx
lea    0xbfb(%rip),%rsi
call   11b0 <docheck@plt>
mov    -0x8(%rbp),%edi
call   1120 <iswgraph@plt>
cmp    $0x0,%rax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0xe0(%rbp)
movzbl -0x1(%rbp),%edi
call   11d0 <isgraph@plt>
mov    %eax,%ecx
mov    -0xe0(%rbp),%eax
cmp    $0x0,%ecx
setne  %cl
xor    $0xff,%cl
xor    $0xff,%cl
and    $0x1,%cl
movzbl %cl,%ecx
cmp    %ecx,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
mov    -0x8(%rbp),%edx
lea    0xbc0(%rip),%rsi
call   11b0 <docheck@plt>
mov    -0x8(%rbp),%edi
call   1030 <iswlower@plt>
cmp    $0x0,%rax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0xdc(%rbp)
movzbl -0x1(%rbp),%edi
call   1050 <islower@plt>
mov    %eax,%ecx
mov    -0xdc(%rbp),%eax
cmp    $0x0,%ecx
setne  %cl
xor    $0xff,%cl
xor    $0xff,%cl
and    $0x1,%cl
movzbl %cl,%ecx
cmp    %ecx,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
mov    -0x8(%rbp),%edx
lea    0xb85(%rip),%rsi
call   11b0 <docheck@plt>
mov    -0x8(%rbp),%edi
call   11c0 <iswprint@plt>
cmp    $0x0,%rax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0xd8(%rbp)
movzbl -0x1(%rbp),%edi
call   1170 <isprint@plt>
mov    %eax,%ecx
mov    -0xd8(%rbp),%eax
cmp    $0x0,%ecx
setne  %cl
xor    $0xff,%cl
xor    $0xff,%cl
and    $0x1,%cl
movzbl %cl,%ecx
cmp    %ecx,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
mov    -0x8(%rbp),%edx
lea    0xb4a(%rip),%rsi
call   11b0 <docheck@plt>
mov    -0x8(%rbp),%edi
call   1060 <iswpunct@plt>
cmp    $0x0,%rax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0xd4(%rbp)
movzbl -0x1(%rbp),%edi
call   10f0 <ispunct@plt>
mov    %eax,%ecx
mov    -0xd4(%rbp),%eax
cmp    $0x0,%ecx
setne  %cl
xor    $0xff,%cl
xor    $0xff,%cl
and    $0x1,%cl
movzbl %cl,%ecx
cmp    %ecx,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
mov    -0x8(%rbp),%edx
lea    0xb0f(%rip),%rsi
call   11b0 <docheck@plt>
mov    -0x8(%rbp),%edi
call   1180 <iswspace@plt>
cmp    $0x0,%rax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0xd0(%rbp)
movzbl -0x1(%rbp),%edi
call   1100 <isspace@plt>
mov    %eax,%ecx
mov    -0xd0(%rbp),%eax
cmp    $0x0,%ecx
setne  %cl
xor    $0xff,%cl
xor    $0xff,%cl
and    $0x1,%cl
movzbl %cl,%ecx
cmp    %ecx,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
mov    -0x8(%rbp),%edx
lea    0xad4(%rip),%rsi
call   11b0 <docheck@plt>
mov    -0x8(%rbp),%edi
call   1130 <iswupper@plt>
cmp    $0x0,%rax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0xcc(%rbp)
movzbl -0x1(%rbp),%edi
call   1160 <isupper@plt>
mov    %eax,%ecx
mov    -0xcc(%rbp),%eax
cmp    $0x0,%ecx
setne  %cl
xor    $0xff,%cl
xor    $0xff,%cl
and    $0x1,%cl
movzbl %cl,%ecx
cmp    %ecx,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
mov    -0x8(%rbp),%edx
lea    0xa99(%rip),%rsi
call   11b0 <docheck@plt>
mov    -0x8(%rbp),%edi
call   1080 <iswxdigit@plt>
cmp    $0x0,%rax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0xc8(%rbp)
movzbl -0x1(%rbp),%edi
call   11a0 <isxdigit@plt>
mov    %eax,%ecx
mov    -0xc8(%rbp),%eax
cmp    $0x0,%ecx
setne  %cl
xor    $0xff,%cl
xor    $0xff,%cl
and    $0x1,%cl
movzbl %cl,%ecx
cmp    %ecx,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
mov    -0x8(%rbp),%edx
lea    0xa5e(%rip),%rsi
call   11b0 <docheck@plt>
mov    -0x8(%rbp),%edi
call   1140 <iswalnum@plt>
mov    %rax,-0xc0(%rbp)
mov    -0x8(%rbp),%eax
mov    %eax,-0xc4(%rbp)
lea    0xa5b(%rip),%rdi
call   1110 <wctype@plt>
mov    -0xc4(%rbp),%edi
mov    %eax,%esi
call   10a0 <iswctype@plt>
mov    %rax,%rcx
mov    -0xc0(%rbp),%rax
cmp    %rcx,%rax
sete   %al
and    $0x1,%al
movzbl %al,%edi
mov    -0x8(%rbp),%edx
lea    0xa30(%rip),%rsi
call   11b0 <docheck@plt>
mov    -0x8(%rbp),%edi
call   1190 <iswalpha@plt>
mov    %rax,-0xb0(%rbp)
mov    -0x8(%rbp),%eax
mov    %eax,-0xb4(%rbp)
lea    0xa3a(%rip),%rdi
call   1110 <wctype@plt>
mov    -0xb4(%rbp),%edi
mov    %eax,%esi
call   10a0 <iswctype@plt>
mov    %rax,%rcx
mov    -0xb0(%rbp),%rax
cmp    %rcx,%rax
sete   %al
and    $0x1,%al
movzbl %al,%edi
mov    -0x8(%rbp),%edx
lea    0xa0f(%rip),%rsi
call   11b0 <docheck@plt>
mov    -0x8(%rbp),%edi
call   10e0 <iswblank@plt>
mov    %rax,-0xa0(%rbp)
mov    -0x8(%rbp),%eax
mov    %eax,-0xa4(%rbp)
lea    0xa19(%rip),%rdi
call   1110 <wctype@plt>
mov    -0xa4(%rbp),%edi
mov    %eax,%esi
call   10a0 <iswctype@plt>
mov    %rax,%rcx
mov    -0xa0(%rbp),%rax
cmp    %rcx,%rax
sete   %al
and    $0x1,%al
movzbl %al,%edi
mov    -0x8(%rbp),%edx
lea    0x9ee(%rip),%rsi
call   11b0 <docheck@plt>
mov    -0x8(%rbp),%edi
call   1070 <iswcntrl@plt>
mov    %rax,-0x90(%rbp)
mov    -0x8(%rbp),%eax
mov    %eax,-0x94(%rbp)
lea    0x9f8(%rip),%rdi
call   1110 <wctype@plt>
mov    -0x94(%rbp),%edi
mov    %eax,%esi
call   10a0 <iswctype@plt>
mov    %rax,%rcx
mov    -0x90(%rbp),%rax
cmp    %rcx,%rax
sete   %al
and    $0x1,%al
movzbl %al,%edi
mov    -0x8(%rbp),%edx
lea    0x9cd(%rip),%rsi
call   11b0 <docheck@plt>
mov    -0x8(%rbp),%edi
call   10d0 <iswdigit@plt>
mov    %rax,-0x80(%rbp)
mov    -0x8(%rbp),%eax
mov    %eax,-0x84(%rbp)
lea    0xb41(%rip),%rdi
call   1110 <wctype@plt>
mov    -0x84(%rbp),%edi
mov    %eax,%esi
call   10a0 <iswctype@plt>
mov    %rax,%rcx
mov    -0x80(%rbp),%rax
cmp    %rcx,%rax
sete   %al
and    $0x1,%al
movzbl %al,%edi
mov    -0x8(%rbp),%edx
lea    0x9ac(%rip),%rsi
call   11b0 <docheck@plt>
mov    -0x8(%rbp),%edi
call   1120 <iswgraph@plt>
mov    %rax,-0x70(%rbp)
mov    -0x8(%rbp),%eax
mov    %eax,-0x74(%rbp)
lea    0x9bc(%rip),%rdi
call   1110 <wctype@plt>
mov    -0x74(%rbp),%edi
mov    %eax,%esi
call   10a0 <iswctype@plt>
mov    %rax,%rcx
mov    -0x70(%rbp),%rax
cmp    %rcx,%rax
sete   %al
and    $0x1,%al
movzbl %al,%edi
mov    -0x8(%rbp),%edx
lea    0x997(%rip),%rsi
call   11b0 <docheck@plt>
mov    -0x8(%rbp),%edi
call   1030 <iswlower@plt>
mov    %rax,-0x60(%rbp)
mov    -0x8(%rbp),%eax
mov    %eax,-0x64(%rbp)
lea    0x9a7(%rip),%rdi
call   1110 <wctype@plt>
mov    -0x64(%rbp),%edi
mov    %eax,%esi
call   10a0 <iswctype@plt>
mov    %rax,%rcx
mov    -0x60(%rbp),%rax
cmp    %rcx,%rax
sete   %al
and    $0x1,%al
movzbl %al,%edi
mov    -0x8(%rbp),%edx
lea    0x982(%rip),%rsi
call   11b0 <docheck@plt>
mov    -0x8(%rbp),%edi
call   11c0 <iswprint@plt>
mov    %rax,-0x50(%rbp)
mov    -0x8(%rbp),%eax
mov    %eax,-0x54(%rbp)
lea    0x992(%rip),%rdi
call   1110 <wctype@plt>
mov    -0x54(%rbp),%edi
mov    %eax,%esi
call   10a0 <iswctype@plt>
mov    %rax,%rcx
mov    -0x50(%rbp),%rax
cmp    %rcx,%rax
sete   %al
and    $0x1,%al
movzbl %al,%edi
mov    -0x8(%rbp),%edx
lea    0x96d(%rip),%rsi
call   11b0 <docheck@plt>
mov    -0x8(%rbp),%edi
call   1060 <iswpunct@plt>
mov    %rax,-0x40(%rbp)
mov    -0x8(%rbp),%eax
mov    %eax,-0x44(%rbp)
lea    0x97d(%rip),%rdi
call   1110 <wctype@plt>
mov    -0x44(%rbp),%edi
mov    %eax,%esi
call   10a0 <iswctype@plt>
mov    %rax,%rcx
mov    -0x40(%rbp),%rax
cmp    %rcx,%rax
sete   %al
and    $0x1,%al
movzbl %al,%edi
mov    -0x8(%rbp),%edx
lea    0x958(%rip),%rsi
call   11b0 <docheck@plt>
mov    -0x8(%rbp),%edi
call   1180 <iswspace@plt>
mov    %rax,-0x30(%rbp)
mov    -0x8(%rbp),%eax
mov    %eax,-0x34(%rbp)
lea    0x968(%rip),%rdi
call   1110 <wctype@plt>
mov    -0x34(%rbp),%edi
mov    %eax,%esi
call   10a0 <iswctype@plt>
mov    %rax,%rcx
mov    -0x30(%rbp),%rax
cmp    %rcx,%rax
sete   %al
and    $0x1,%al
movzbl %al,%edi
mov    -0x8(%rbp),%edx
lea    0x943(%rip),%rsi
call   11b0 <docheck@plt>
mov    -0x8(%rbp),%edi
call   1130 <iswupper@plt>
mov    %rax,-0x20(%rbp)
mov    -0x8(%rbp),%eax
mov    %eax,-0x24(%rbp)
lea    0x953(%rip),%rdi
call   1110 <wctype@plt>
mov    -0x24(%rbp),%edi
mov    %eax,%esi
call   10a0 <iswctype@plt>
mov    %rax,%rcx
mov    -0x20(%rbp),%rax
cmp    %rcx,%rax
sete   %al
and    $0x1,%al
movzbl %al,%edi
mov    -0x8(%rbp),%edx
lea    0x92e(%rip),%rsi
call   11b0 <docheck@plt>
mov    -0x8(%rbp),%edi
call   1080 <iswxdigit@plt>
mov    %rax,-0x10(%rbp)
mov    -0x8(%rbp),%eax
mov    %eax,-0x14(%rbp)
lea    0x93e(%rip),%rdi
call   1110 <wctype@plt>
mov    -0x14(%rbp),%edi
mov    %eax,%esi
call   10a0 <iswctype@plt>
mov    %rax,%rcx
mov    -0x10(%rbp),%rax
cmp    %rcx,%rax
sete   %al
and    $0x1,%al
movzbl %al,%edi
mov    -0x8(%rbp),%edx
lea    0x91a(%rip),%rsi
call   11b0 <docheck@plt>
add    $0x100,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<verifywc>:
push   %rbp
push   %r14
push   %rbx
mov    %esi,%ebx
mov    %edi,%ebp
mov    %esi,%edi
call   1140 <iswalnum@plt>
test   %rax,%rax
sete   %r14b
mov    %ebp,%edi
call   10b0 <isalnum@plt>
test   %eax,%eax
setne  %al
xor    %r14b,%al
movzbl %al,%edi
lea    0xd21(%rip),%rsi
mov    %ebx,%edx
call   11b0 <docheck@plt>
mov    %ebx,%edi
call   1190 <iswalpha@plt>
test   %rax,%rax
sete   %r14b
mov    %ebp,%edi
call   1150 <isalpha@plt>
test   %eax,%eax
setne  %al
xor    %r14b,%al
movzbl %al,%edi
lea    0xd12(%rip),%rsi
mov    %ebx,%edx
call   11b0 <docheck@plt>
mov    %ebx,%edi
call   10e0 <iswblank@plt>
test   %rax,%rax
sete   %r14b
mov    %ebp,%edi
call   10c0 <isblank@plt>
test   %eax,%eax
setne  %al
xor    %r14b,%al
movzbl %al,%edi
lea    0xd03(%rip),%rsi
mov    %ebx,%edx
call   11b0 <docheck@plt>
mov    %ebx,%edi
call   1070 <iswcntrl@plt>
test   %rax,%rax
sete   %r14b
mov    %ebp,%edi
call   1090 <iscntrl@plt>
test   %eax,%eax
setne  %al
xor    %r14b,%al
movzbl %al,%edi
lea    0xcf4(%rip),%rsi
mov    %ebx,%edx
call   11b0 <docheck@plt>
mov    %ebx,%edi
call   10d0 <iswdigit@plt>
test   %rax,%rax
sete   %r14b
mov    %ebp,%edi
call   1040 <isdigit@plt>
test   %eax,%eax
setne  %al
xor    %r14b,%al
movzbl %al,%edi
lea    0xce5(%rip),%rsi
mov    %ebx,%edx
call   11b0 <docheck@plt>
mov    %ebx,%edi
call   1120 <iswgraph@plt>
test   %rax,%rax
sete   %r14b
mov    %ebp,%edi
call   11d0 <isgraph@plt>
test   %eax,%eax
setne  %al
xor    %r14b,%al
movzbl %al,%edi
lea    0xcd6(%rip),%rsi
mov    %ebx,%edx
call   11b0 <docheck@plt>
mov    %ebx,%edi
call   1030 <iswlower@plt>
test   %rax,%rax
sete   %r14b
mov    %ebp,%edi
call   1050 <islower@plt>
test   %eax,%eax
setne  %al
xor    %r14b,%al
movzbl %al,%edi
lea    0xcc7(%rip),%rsi
mov    %ebx,%edx
call   11b0 <docheck@plt>
mov    %ebx,%edi
call   11c0 <iswprint@plt>
test   %rax,%rax
sete   %r14b
mov    %ebp,%edi
call   1170 <isprint@plt>
test   %eax,%eax
setne  %al
xor    %r14b,%al
movzbl %al,%edi
lea    0xcb8(%rip),%rsi
mov    %ebx,%edx
call   11b0 <docheck@plt>
mov    %ebx,%edi
call   1060 <iswpunct@plt>
test   %rax,%rax
sete   %r14b
mov    %ebp,%edi
call   10f0 <ispunct@plt>
test   %eax,%eax
setne  %al
xor    %r14b,%al
movzbl %al,%edi
lea    0xca9(%rip),%rsi
mov    %ebx,%edx
call   11b0 <docheck@plt>
mov    %ebx,%edi
call   1180 <iswspace@plt>
test   %rax,%rax
sete   %r14b
mov    %ebp,%edi
call   1100 <isspace@plt>
test   %eax,%eax
setne  %al
xor    %r14b,%al
movzbl %al,%edi
lea    0xc9a(%rip),%rsi
mov    %ebx,%edx
call   11b0 <docheck@plt>
mov    %ebx,%edi
call   1130 <iswupper@plt>
test   %rax,%rax
sete   %r14b
mov    %ebp,%edi
call   1160 <isupper@plt>
test   %eax,%eax
setne  %al
xor    %r14b,%al
movzbl %al,%edi
lea    0xc8b(%rip),%rsi
mov    %ebx,%edx
call   11b0 <docheck@plt>
mov    %ebx,%edi
call   1080 <iswxdigit@plt>
test   %rax,%rax
sete   %r14b
mov    %ebp,%edi
call   11a0 <isxdigit@plt>
test   %eax,%eax
setne  %al
xor    %r14b,%al
movzbl %al,%edi
lea    0xc7c(%rip),%rsi
mov    %ebx,%edx
call   11b0 <docheck@plt>
mov    %ebx,%edi
call   1140 <iswalnum@plt>
mov    %rax,%rbp
lea    0xc85(%rip),%rdi
call   1110 <wctype@plt>
mov    %ebx,%edi
mov    %eax,%esi
call   10a0 <iswctype@plt>
xor    %edi,%edi
cmp    %rax,%rbp
sete   %dil
lea    0xc6d(%rip),%rsi
mov    %ebx,%edx
call   11b0 <docheck@plt>
mov    %ebx,%edi
call   1190 <iswalpha@plt>
mov    %rax,%rbp
lea    0xc83(%rip),%rdi
call   1110 <wctype@plt>
mov    %ebx,%edi
mov    %eax,%esi
call   10a0 <iswctype@plt>
xor    %edi,%edi
cmp    %rax,%rbp
sete   %dil
lea    0xc6b(%rip),%rsi
mov    %ebx,%edx
call   11b0 <docheck@plt>
mov    %ebx,%edi
call   10e0 <iswblank@plt>
mov    %rax,%rbp
lea    0xc81(%rip),%rdi
call   1110 <wctype@plt>
mov    %ebx,%edi
mov    %eax,%esi
call   10a0 <iswctype@plt>
xor    %edi,%edi
cmp    %rax,%rbp
sete   %dil
lea    0xc69(%rip),%rsi
mov    %ebx,%edx
call   11b0 <docheck@plt>
mov    %ebx,%edi
call   1070 <iswcntrl@plt>
mov    %rax,%rbp
lea    0xc7f(%rip),%rdi
call   1110 <wctype@plt>
mov    %ebx,%edi
mov    %eax,%esi
call   10a0 <iswctype@plt>
xor    %edi,%edi
cmp    %rax,%rbp
sete   %dil
lea    0xc67(%rip),%rsi
mov    %ebx,%edx
call   11b0 <docheck@plt>
mov    %ebx,%edi
call   10d0 <iswdigit@plt>
mov    %rax,%rbp
lea    0xde4(%rip),%rdi
call   1110 <wctype@plt>
mov    %ebx,%edi
mov    %eax,%esi
call   10a0 <iswctype@plt>
xor    %edi,%edi
cmp    %rax,%rbp
sete   %dil
lea    0xc5f(%rip),%rsi
mov    %ebx,%edx
call   11b0 <docheck@plt>
mov    %ebx,%edi
call   1120 <iswgraph@plt>
mov    %rax,%rbp
lea    0xc75(%rip),%rdi
call   1110 <wctype@plt>
mov    %ebx,%edi
mov    %eax,%esi
call   10a0 <iswctype@plt>
xor    %edi,%edi
cmp    %rax,%rbp
sete   %dil
lea    0xc5d(%rip),%rsi
mov    %ebx,%edx
call   11b0 <docheck@plt>
mov    %ebx,%edi
call   1030 <iswlower@plt>
mov    %rax,%rbp
lea    0xc73(%rip),%rdi
call   1110 <wctype@plt>
mov    %ebx,%edi
mov    %eax,%esi
call   10a0 <iswctype@plt>
xor    %edi,%edi
cmp    %rax,%rbp
sete   %dil
lea    0xc5b(%rip),%rsi
mov    %ebx,%edx
call   11b0 <docheck@plt>
mov    %ebx,%edi
call   11c0 <iswprint@plt>
mov    %rax,%rbp
lea    0xc71(%rip),%rdi
call   1110 <wctype@plt>
mov    %ebx,%edi
mov    %eax,%esi
call   10a0 <iswctype@plt>
xor    %edi,%edi
cmp    %rax,%rbp
sete   %dil
lea    0xc59(%rip),%rsi
mov    %ebx,%edx
call   11b0 <docheck@plt>
mov    %ebx,%edi
call   1060 <iswpunct@plt>
mov    %rax,%rbp
lea    0xc6f(%rip),%rdi
call   1110 <wctype@plt>
mov    %ebx,%edi
mov    %eax,%esi
call   10a0 <iswctype@plt>
xor    %edi,%edi
cmp    %rax,%rbp
sete   %dil
lea    0xc57(%rip),%rsi
mov    %ebx,%edx
call   11b0 <docheck@plt>
mov    %ebx,%edi
call   1180 <iswspace@plt>
mov    %rax,%rbp
lea    0xc6d(%rip),%rdi
call   1110 <wctype@plt>
mov    %ebx,%edi
mov    %eax,%esi
call   10a0 <iswctype@plt>
xor    %edi,%edi
cmp    %rax,%rbp
sete   %dil
lea    0xc55(%rip),%rsi
mov    %ebx,%edx
call   11b0 <docheck@plt>
mov    %ebx,%edi
call   1130 <iswupper@plt>
mov    %rax,%rbp
lea    0xc6b(%rip),%rdi
call   1110 <wctype@plt>
mov    %ebx,%edi
mov    %eax,%esi
call   10a0 <iswctype@plt>
xor    %edi,%edi
cmp    %rax,%rbp
sete   %dil
lea    0xc53(%rip),%rsi
mov    %ebx,%edx
call   11b0 <docheck@plt>
mov    %ebx,%edi
call   1080 <iswxdigit@plt>
mov    %rax,%rbp
lea    0xc69(%rip),%rdi
call   1110 <wctype@plt>
mov    %ebx,%edi
mov    %eax,%esi
call   10a0 <iswctype@plt>
xor    %edi,%edi
cmp    %rax,%rbp
sete   %dil
lea    0xc52(%rip),%rsi
mov    %ebx,%edx
pop    %rbx
pop    %r14
pop    %rbp
jmp    11b0 <docheck@plt>

LLVM IR (-O0):
@.str = [31 x i8] c"!!iswalnum(wx) == !!isalnum(x)\00"
@.str.1 = [31 x i8] c"!!iswalpha(wx) == !!isalpha(x)\00"
@.str.2 = [31 x i8] c"!!iswblank(wx) == !!isblank(x)\00"
@.str.3 = [31 x i8] c"!!iswcntrl(wx) == !!iscntrl(x)\00"
@.str.4 = [31 x i8] c"!!iswdigit(wx) == !!isdigit(x)\00"
@.str.5 = [31 x i8] c"!!iswgraph(wx) == !!isgraph(x)\00"
@.str.6 = [31 x i8] c"!!iswlower(wx) == !!islower(x)\00"
@.str.7 = [31 x i8] c"!!iswprint(wx) == !!isprint(x)\00"
@.str.8 = [31 x i8] c"!!iswpunct(wx) == !!ispunct(x)\00"
@.str.9 = [31 x i8] c"!!iswspace(wx) == !!isspace(x)\00"
@.str.10 = [31 x i8] c"!!iswupper(wx) == !!isupper(x)\00"
@.str.11 = [33 x i8] c"!!iswxdigit(wx) == !!isxdigit(x)\00"
@.str.12 = [6 x i8] c"alnum\00"
@.str.13 = [46 x i8] c"iswalnum(wx) == iswctype(wx, wctype(\22alnum\22))\00"
@.str.14 = [6 x i8] c"alpha\00"
@.str.15 = [46 x i8] c"iswalpha(wx) == iswctype(wx, wctype(\22alpha\22))\00"
@.str.16 = [6 x i8] c"blank\00"
@.str.17 = [46 x i8] c"iswblank(wx) == iswctype(wx, wctype(\22blank\22))\00"
@.str.18 = [6 x i8] c"cntrl\00"
@.str.19 = [46 x i8] c"iswcntrl(wx) == iswctype(wx, wctype(\22cntrl\22))\00"
@.str.20 = [6 x i8] c"digit\00"
@.str.21 = [46 x i8] c"iswdigit(wx) == iswctype(wx, wctype(\22digit\22))\00"
@.str.22 = [6 x i8] c"graph\00"
@.str.23 = [46 x i8] c"iswgraph(wx) == iswctype(wx, wctype(\22graph\22))\00"
@.str.24 = [6 x i8] c"lower\00"
@.str.25 = [46 x i8] c"iswlower(wx) == iswctype(wx, wctype(\22lower\22))\00"
@.str.26 = [6 x i8] c"print\00"
@.str.27 = [46 x i8] c"iswprint(wx) == iswctype(wx, wctype(\22print\22))\00"
@.str.28 = [6 x i8] c"punct\00"
@.str.29 = [46 x i8] c"iswpunct(wx) == iswctype(wx, wctype(\22punct\22))\00"
@.str.30 = [6 x i8] c"space\00"
@.str.31 = [46 x i8] c"iswspace(wx) == iswctype(wx, wctype(\22space\22))\00"
@.str.32 = [6 x i8] c"upper\00"
@.str.33 = [46 x i8] c"iswupper(wx) == iswctype(wx, wctype(\22upper\22))\00"
@.str.34 = [7 x i8] c"xdigit\00"
@.str.35 = [48 x i8] c"iswxdigit(wx) == iswctype(wx, wctype(\22xdigit\22))\00"
define void @verifywc(i8 zeroext %0, i32 %1) {
%3 = alloca i8
%4 = alloca i32
store i8 %0, i8* %3
store i32 %1, i32* %4
%5 = load i32, i32* %4
%6 = call i64 @iswalnum(i32 %5)
%7 = icmp ne i64 %6, 0
%8 = xor i1 %7, true
%9 = xor i1 %8, true
%10 = zext i1 %9 to i32
%11 = load i8, i8* %3
%12 = call i32 @isalnum(i8 zeroext %11)
%13 = icmp ne i32 %12, 0
%14 = xor i1 %13, true
%15 = xor i1 %14, true
%16 = zext i1 %15 to i32
%17 = icmp eq i32 %10, %16
%18 = zext i1 %17 to i32
%19 = load i32, i32* %4
%20 = call i32 @docheck(i32 %18, i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str, i64 0, i64 0), i32 %19)
%21 = load i32, i32* %4
%22 = call i64 @iswalpha(i32 %21)
%23 = icmp ne i64 %22, 0
%24 = xor i1 %23, true
%25 = xor i1 %24, true
%26 = zext i1 %25 to i32
%27 = load i8, i8* %3
%28 = call i32 @isalpha(i8 zeroext %27)
%29 = icmp ne i32 %28, 0
%30 = xor i1 %29, true
%31 = xor i1 %30, true
%32 = zext i1 %31 to i32
%33 = icmp eq i32 %26, %32
%34 = zext i1 %33 to i32
%35 = load i32, i32* %4
%36 = call i32 @docheck(i32 %34, i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str.1, i64 0, i64 0), i32 %35)
%37 = load i32, i32* %4
%38 = call i64 @iswblank(i32 %37)
%39 = icmp ne i64 %38, 0
%40 = xor i1 %39, true
%41 = xor i1 %40, true
%42 = zext i1 %41 to i32
%43 = load i8, i8* %3
%44 = call i32 @isblank(i8 zeroext %43)
%45 = icmp ne i32 %44, 0
%46 = xor i1 %45, true
%47 = xor i1 %46, true
%48 = zext i1 %47 to i32
%49 = icmp eq i32 %42, %48
%50 = zext i1 %49 to i32
%51 = load i32, i32* %4
%52 = call i32 @docheck(i32 %50, i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str.2, i64 0, i64 0), i32 %51)
%53 = load i32, i32* %4
%54 = call i64 @iswcntrl(i32 %53)
%55 = icmp ne i64 %54, 0
%56 = xor i1 %55, true
%57 = xor i1 %56, true
%58 = zext i1 %57 to i32
%59 = load i8, i8* %3
%60 = call i32 @iscntrl(i8 zeroext %59)
%61 = icmp ne i32 %60, 0
%62 = xor i1 %61, true
%63 = xor i1 %62, true
%64 = zext i1 %63 to i32
%65 = icmp eq i32 %58, %64
%66 = zext i1 %65 to i32
%67 = load i32, i32* %4
%68 = call i32 @docheck(i32 %66, i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str.3, i64 0, i64 0), i32 %67)
%69 = load i32, i32* %4
%70 = call i64 @iswdigit(i32 %69)
%71 = icmp ne i64 %70, 0
%72 = xor i1 %71, true
%73 = xor i1 %72, true
%74 = zext i1 %73 to i32
%75 = load i8, i8* %3
%76 = call i32 @isdigit(i8 zeroext %75)
%77 = icmp ne i32 %76, 0
%78 = xor i1 %77, true
%79 = xor i1 %78, true
%80 = zext i1 %79 to i32
%81 = icmp eq i32 %74, %80
%82 = zext i1 %81 to i32
%83 = load i32, i32* %4
%84 = call i32 @docheck(i32 %82, i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str.4, i64 0, i64 0), i32 %83)
%85 = load i32, i32* %4
%86 = call i64 @iswgraph(i32 %85)
%87 = icmp ne i64 %86, 0
%88 = xor i1 %87, true
%89 = xor i1 %88, true
%90 = zext i1 %89 to i32
%91 = load i8, i8* %3
%92 = call i32 @isgraph(i8 zeroext %91)
%93 = icmp ne i32 %92, 0
%94 = xor i1 %93, true
%95 = xor i1 %94, true
%96 = zext i1 %95 to i32
%97 = icmp eq i32 %90, %96
%98 = zext i1 %97 to i32
%99 = load i32, i32* %4
%100 = call i32 @docheck(i32 %98, i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str.5, i64 0, i64 0), i32 %99)
%101 = load i32, i32* %4
%102 = call i64 @iswlower(i32 %101)
%103 = icmp ne i64 %102, 0
%104 = xor i1 %103, true
%105 = xor i1 %104, true
%106 = zext i1 %105 to i32
%107 = load i8, i8* %3
%108 = call i32 @islower(i8 zeroext %107)
%109 = icmp ne i32 %108, 0
%110 = xor i1 %109, true
%111 = xor i1 %110, true
%112 = zext i1 %111 to i32
%113 = icmp eq i32 %106, %112
%114 = zext i1 %113 to i32
%115 = load i32, i32* %4
%116 = call i32 @docheck(i32 %114, i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str.6, i64 0, i64 0), i32 %115)
%117 = load i32, i32* %4
%118 = call i64 @iswprint(i32 %117)
%119 = icmp ne i64 %118, 0
%120 = xor i1 %119, true
%121 = xor i1 %120, true
%122 = zext i1 %121 to i32
%123 = load i8, i8* %3
%124 = call i32 @isprint(i8 zeroext %123)
%125 = icmp ne i32 %124, 0
%126 = xor i1 %125, true
%127 = xor i1 %126, true
%128 = zext i1 %127 to i32
%129 = icmp eq i32 %122, %128
%130 = zext i1 %129 to i32
%131 = load i32, i32* %4
%132 = call i32 @docheck(i32 %130, i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str.7, i64 0, i64 0), i32 %131)
%133 = load i32, i32* %4
%134 = call i64 @iswpunct(i32 %133)
%135 = icmp ne i64 %134, 0
%136 = xor i1 %135, true
%137 = xor i1 %136, true
%138 = zext i1 %137 to i32
%139 = load i8, i8* %3
%140 = call i32 @ispunct(i8 zeroext %139)
%141 = icmp ne i32 %140, 0
%142 = xor i1 %141, true
%143 = xor i1 %142, true
%144 = zext i1 %143 to i32
%145 = icmp eq i32 %138, %144
%146 = zext i1 %145 to i32
%147 = load i32, i32* %4
%148 = call i32 @docheck(i32 %146, i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str.8, i64 0, i64 0), i32 %147)
%149 = load i32, i32* %4
%150 = call i64 @iswspace(i32 %149)
%151 = icmp ne i64 %150, 0
%152 = xor i1 %151, true
%153 = xor i1 %152, true
%154 = zext i1 %153 to i32
%155 = load i8, i8* %3
%156 = call i32 @isspace(i8 zeroext %155)
%157 = icmp ne i32 %156, 0
%158 = xor i1 %157, true
%159 = xor i1 %158, true
%160 = zext i1 %159 to i32
%161 = icmp eq i32 %154, %160
%162 = zext i1 %161 to i32
%163 = load i32, i32* %4
%164 = call i32 @docheck(i32 %162, i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str.9, i64 0, i64 0), i32 %163)
%165 = load i32, i32* %4
%166 = call i64 @iswupper(i32 %165)
%167 = icmp ne i64 %166, 0
%168 = xor i1 %167, true
%169 = xor i1 %168, true
%170 = zext i1 %169 to i32
%171 = load i8, i8* %3
%172 = call i32 @isupper(i8 zeroext %171)
%173 = icmp ne i32 %172, 0
%174 = xor i1 %173, true
%175 = xor i1 %174, true
%176 = zext i1 %175 to i32
%177 = icmp eq i32 %170, %176
%178 = zext i1 %177 to i32
%179 = load i32, i32* %4
%180 = call i32 @docheck(i32 %178, i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str.10, i64 0, i64 0), i32 %179)
%181 = load i32, i32* %4
%182 = call i64 @iswxdigit(i32 %181)
%183 = icmp ne i64 %182, 0
%184 = xor i1 %183, true
%185 = xor i1 %184, true
%186 = zext i1 %185 to i32
%187 = load i8, i8* %3
%188 = call i32 @isxdigit(i8 zeroext %187)
%189 = icmp ne i32 %188, 0
%190 = xor i1 %189, true
%191 = xor i1 %190, true
%192 = zext i1 %191 to i32
%193 = icmp eq i32 %186, %192
%194 = zext i1 %193 to i32
%195 = load i32, i32* %4
%196 = call i32 @docheck(i32 %194, i8* getelementptr inbounds ([33 x i8], [33 x i8]* @.str.11, i64 0, i64 0), i32 %195)
%197 = load i32, i32* %4
%198 = call i64 @iswalnum(i32 %197)
%199 = load i32, i32* %4
%200 = call i32 @wctype(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.12, i64 0, i64 0))
%201 = call i64 @iswctype(i32 %199, i32 %200)
%202 = icmp eq i64 %198, %201
%203 = zext i1 %202 to i32
%204 = load i32, i32* %4
%205 = call i32 @docheck(i32 %203, i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.13, i64 0, i64 0), i32 %204)
%206 = load i32, i32* %4
%207 = call i64 @iswalpha(i32 %206)
%208 = load i32, i32* %4
%209 = call i32 @wctype(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.14, i64 0, i64 0))
%210 = call i64 @iswctype(i32 %208, i32 %209)
%211 = icmp eq i64 %207, %210
%212 = zext i1 %211 to i32
%213 = load i32, i32* %4
%214 = call i32 @docheck(i32 %212, i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.15, i64 0, i64 0), i32 %213)
%215 = load i32, i32* %4
%216 = call i64 @iswblank(i32 %215)
%217 = load i32, i32* %4
%218 = call i32 @wctype(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.16, i64 0, i64 0))
%219 = call i64 @iswctype(i32 %217, i32 %218)
%220 = icmp eq i64 %216, %219
%221 = zext i1 %220 to i32
%222 = load i32, i32* %4
%223 = call i32 @docheck(i32 %221, i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.17, i64 0, i64 0), i32 %222)
%224 = load i32, i32* %4
%225 = call i64 @iswcntrl(i32 %224)
%226 = load i32, i32* %4
%227 = call i32 @wctype(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.18, i64 0, i64 0))
%228 = call i64 @iswctype(i32 %226, i32 %227)
%229 = icmp eq i64 %225, %228
%230 = zext i1 %229 to i32
%231 = load i32, i32* %4
%232 = call i32 @docheck(i32 %230, i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.19, i64 0, i64 0), i32 %231)
%233 = load i32, i32* %4
%234 = call i64 @iswdigit(i32 %233)
%235 = load i32, i32* %4
%236 = call i32 @wctype(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.20, i64 0, i64 0))
%237 = call i64 @iswctype(i32 %235, i32 %236)
%238 = icmp eq i64 %234, %237
%239 = zext i1 %238 to i32
%240 = load i32, i32* %4
%241 = call i32 @docheck(i32 %239, i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.21, i64 0, i64 0), i32 %240)
%242 = load i32, i32* %4
%243 = call i64 @iswgraph(i32 %242)
%244 = load i32, i32* %4
%245 = call i32 @wctype(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.22, i64 0, i64 0))
%246 = call i64 @iswctype(i32 %244, i32 %245)
%247 = icmp eq i64 %243, %246
%248 = zext i1 %247 to i32
%249 = load i32, i32* %4
%250 = call i32 @docheck(i32 %248, i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.23, i64 0, i64 0), i32 %249)
%251 = load i32, i32* %4
%252 = call i64 @iswlower(i32 %251)
%253 = load i32, i32* %4
%254 = call i32 @wctype(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.24, i64 0, i64 0))
%255 = call i64 @iswctype(i32 %253, i32 %254)
%256 = icmp eq i64 %252, %255
%257 = zext i1 %256 to i32
%258 = load i32, i32* %4
%259 = call i32 @docheck(i32 %257, i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.25, i64 0, i64 0), i32 %258)
%260 = load i32, i32* %4
%261 = call i64 @iswprint(i32 %260)
%262 = load i32, i32* %4
%263 = call i32 @wctype(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.26, i64 0, i64 0))
%264 = call i64 @iswctype(i32 %262, i32 %263)
%265 = icmp eq i64 %261, %264
%266 = zext i1 %265 to i32
%267 = load i32, i32* %4
%268 = call i32 @docheck(i32 %266, i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.27, i64 0, i64 0), i32 %267)
%269 = load i32, i32* %4
%270 = call i64 @iswpunct(i32 %269)
%271 = load i32, i32* %4
%272 = call i32 @wctype(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.28, i64 0, i64 0))
%273 = call i64 @iswctype(i32 %271, i32 %272)
%274 = icmp eq i64 %270, %273
%275 = zext i1 %274 to i32
%276 = load i32, i32* %4
%277 = call i32 @docheck(i32 %275, i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.29, i64 0, i64 0), i32 %276)
%278 = load i32, i32* %4
%279 = call i64 @iswspace(i32 %278)
%280 = load i32, i32* %4
%281 = call i32 @wctype(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.30, i64 0, i64 0))
%282 = call i64 @iswctype(i32 %280, i32 %281)
%283 = icmp eq i64 %279, %282
%284 = zext i1 %283 to i32
%285 = load i32, i32* %4
%286 = call i32 @docheck(i32 %284, i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.31, i64 0, i64 0), i32 %285)
%287 = load i32, i32* %4
%288 = call i64 @iswupper(i32 %287)
%289 = load i32, i32* %4
%290 = call i32 @wctype(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.32, i64 0, i64 0))
%291 = call i64 @iswctype(i32 %289, i32 %290)
%292 = icmp eq i64 %288, %291
%293 = zext i1 %292 to i32
%294 = load i32, i32* %4
%295 = call i32 @docheck(i32 %293, i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.33, i64 0, i64 0), i32 %294)
%296 = load i32, i32* %4
%297 = call i64 @iswxdigit(i32 %296)
%298 = load i32, i32* %4
%299 = call i32 @wctype(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.34, i64 0, i64 0))
%300 = call i64 @iswctype(i32 %298, i32 %299)
%301 = icmp eq i64 %297, %300
%302 = zext i1 %301 to i32
%303 = load i32, i32* %4
%304 = call i32 @docheck(i32 %302, i8* getelementptr inbounds ([48 x i8], [48 x i8]* @.str.35, i64 0, i64 0), i32 %303)
ret void
}

LLVM IR (-O2):
@.str = [31 x i8] c"!!iswalnum(wx) == !!isalnum(x)\00"
@.str.1 = [31 x i8] c"!!iswalpha(wx) == !!isalpha(x)\00"
@.str.2 = [31 x i8] c"!!iswblank(wx) == !!isblank(x)\00"
@.str.3 = [31 x i8] c"!!iswcntrl(wx) == !!iscntrl(x)\00"
@.str.4 = [31 x i8] c"!!iswdigit(wx) == !!isdigit(x)\00"
@.str.5 = [31 x i8] c"!!iswgraph(wx) == !!isgraph(x)\00"
@.str.6 = [31 x i8] c"!!iswlower(wx) == !!islower(x)\00"
@.str.7 = [31 x i8] c"!!iswprint(wx) == !!isprint(x)\00"
@.str.8 = [31 x i8] c"!!iswpunct(wx) == !!ispunct(x)\00"
@.str.9 = [31 x i8] c"!!iswspace(wx) == !!isspace(x)\00"
@.str.10 = [31 x i8] c"!!iswupper(wx) == !!isupper(x)\00"
@.str.11 = [33 x i8] c"!!iswxdigit(wx) == !!isxdigit(x)\00"
@.str.12 = [6 x i8] c"alnum\00"
@.str.13 = [46 x i8] c"iswalnum(wx) == iswctype(wx, wctype(\22alnum\22))\00"
@.str.14 = [6 x i8] c"alpha\00"
@.str.15 = [46 x i8] c"iswalpha(wx) == iswctype(wx, wctype(\22alpha\22))\00"
@.str.16 = [6 x i8] c"blank\00"
@.str.17 = [46 x i8] c"iswblank(wx) == iswctype(wx, wctype(\22blank\22))\00"
@.str.18 = [6 x i8] c"cntrl\00"
@.str.19 = [46 x i8] c"iswcntrl(wx) == iswctype(wx, wctype(\22cntrl\22))\00"
@.str.20 = [6 x i8] c"digit\00"
@.str.21 = [46 x i8] c"iswdigit(wx) == iswctype(wx, wctype(\22digit\22))\00"
@.str.22 = [6 x i8] c"graph\00"
@.str.23 = [46 x i8] c"iswgraph(wx) == iswctype(wx, wctype(\22graph\22))\00"
@.str.24 = [6 x i8] c"lower\00"
@.str.25 = [46 x i8] c"iswlower(wx) == iswctype(wx, wctype(\22lower\22))\00"
@.str.26 = [6 x i8] c"print\00"
@.str.27 = [46 x i8] c"iswprint(wx) == iswctype(wx, wctype(\22print\22))\00"
@.str.28 = [6 x i8] c"punct\00"
@.str.29 = [46 x i8] c"iswpunct(wx) == iswctype(wx, wctype(\22punct\22))\00"
@.str.30 = [6 x i8] c"space\00"
@.str.31 = [46 x i8] c"iswspace(wx) == iswctype(wx, wctype(\22space\22))\00"
@.str.32 = [6 x i8] c"upper\00"
@.str.33 = [46 x i8] c"iswupper(wx) == iswctype(wx, wctype(\22upper\22))\00"
@.str.34 = [7 x i8] c"xdigit\00"
@.str.35 = [48 x i8] c"iswxdigit(wx) == iswctype(wx, wctype(\22xdigit\22))\00"
define void @verifywc(i8 zeroext %0, i32 %1) {
%3 = tail call i64 @iswalnum(i32 %1)
%4 = icmp eq i64 %3, 0
%5 = tail call i32 @isalnum(i8 zeroext %0)
%6 = icmp ne i32 %5, 0
%7 = xor i1 %4, %6
%8 = zext i1 %7 to i32
%9 = tail call i32 @docheck(i32 %8, i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str, i64 0, i64 0), i32 %1)
%10 = tail call i64 @iswalpha(i32 %1)
%11 = icmp eq i64 %10, 0
%12 = tail call i32 @isalpha(i8 zeroext %0)
%13 = icmp ne i32 %12, 0
%14 = xor i1 %11, %13
%15 = zext i1 %14 to i32
%16 = tail call i32 @docheck(i32 %15, i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str.1, i64 0, i64 0), i32 %1)
%17 = tail call i64 @iswblank(i32 %1)
%18 = icmp eq i64 %17, 0
%19 = tail call i32 @isblank(i8 zeroext %0)
%20 = icmp ne i32 %19, 0
%21 = xor i1 %18, %20
%22 = zext i1 %21 to i32
%23 = tail call i32 @docheck(i32 %22, i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str.2, i64 0, i64 0), i32 %1)
%24 = tail call i64 @iswcntrl(i32 %1)
%25 = icmp eq i64 %24, 0
%26 = tail call i32 @iscntrl(i8 zeroext %0)
%27 = icmp ne i32 %26, 0
%28 = xor i1 %25, %27
%29 = zext i1 %28 to i32
%30 = tail call i32 @docheck(i32 %29, i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str.3, i64 0, i64 0), i32 %1)
%31 = tail call i64 @iswdigit(i32 %1)
%32 = icmp eq i64 %31, 0
%33 = tail call i32 @isdigit(i8 zeroext %0)
%34 = icmp ne i32 %33, 0
%35 = xor i1 %32, %34
%36 = zext i1 %35 to i32
%37 = tail call i32 @docheck(i32 %36, i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str.4, i64 0, i64 0), i32 %1)
%38 = tail call i64 @iswgraph(i32 %1)
%39 = icmp eq i64 %38, 0
%40 = tail call i32 @isgraph(i8 zeroext %0)
%41 = icmp ne i32 %40, 0
%42 = xor i1 %39, %41
%43 = zext i1 %42 to i32
%44 = tail call i32 @docheck(i32 %43, i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str.5, i64 0, i64 0), i32 %1)
%45 = tail call i64 @iswlower(i32 %1)
%46 = icmp eq i64 %45, 0
%47 = tail call i32 @islower(i8 zeroext %0)
%48 = icmp ne i32 %47, 0
%49 = xor i1 %46, %48
%50 = zext i1 %49 to i32
%51 = tail call i32 @docheck(i32 %50, i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str.6, i64 0, i64 0), i32 %1)
%52 = tail call i64 @iswprint(i32 %1)
%53 = icmp eq i64 %52, 0
%54 = tail call i32 @isprint(i8 zeroext %0)
%55 = icmp ne i32 %54, 0
%56 = xor i1 %53, %55
%57 = zext i1 %56 to i32
%58 = tail call i32 @docheck(i32 %57, i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str.7, i64 0, i64 0), i32 %1)
%59 = tail call i64 @iswpunct(i32 %1)
%60 = icmp eq i64 %59, 0
%61 = tail call i32 @ispunct(i8 zeroext %0)
%62 = icmp ne i32 %61, 0
%63 = xor i1 %60, %62
%64 = zext i1 %63 to i32
%65 = tail call i32 @docheck(i32 %64, i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str.8, i64 0, i64 0), i32 %1)
%66 = tail call i64 @iswspace(i32 %1)
%67 = icmp eq i64 %66, 0
%68 = tail call i32 @isspace(i8 zeroext %0)
%69 = icmp ne i32 %68, 0
%70 = xor i1 %67, %69
%71 = zext i1 %70 to i32
%72 = tail call i32 @docheck(i32 %71, i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str.9, i64 0, i64 0), i32 %1)
%73 = tail call i64 @iswupper(i32 %1)
%74 = icmp eq i64 %73, 0
%75 = tail call i32 @isupper(i8 zeroext %0)
%76 = icmp ne i32 %75, 0
%77 = xor i1 %74, %76
%78 = zext i1 %77 to i32
%79 = tail call i32 @docheck(i32 %78, i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str.10, i64 0, i64 0), i32 %1)
%80 = tail call i64 @iswxdigit(i32 %1)
%81 = icmp eq i64 %80, 0
%82 = tail call i32 @isxdigit(i8 zeroext %0)
%83 = icmp ne i32 %82, 0
%84 = xor i1 %81, %83
%85 = zext i1 %84 to i32
%86 = tail call i32 @docheck(i32 %85, i8* getelementptr inbounds ([33 x i8], [33 x i8]* @.str.11, i64 0, i64 0), i32 %1)
%87 = tail call i64 @iswalnum(i32 %1)
%88 = tail call i32 @wctype(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.12, i64 0, i64 0))
%89 = tail call i64 @iswctype(i32 %1, i32 %88)
%90 = icmp eq i64 %87, %89
%91 = zext i1 %90 to i32
%92 = tail call i32 @docheck(i32 %91, i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.13, i64 0, i64 0), i32 %1)
%93 = tail call i64 @iswalpha(i32 %1)
%94 = tail call i32 @wctype(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.14, i64 0, i64 0))
%95 = tail call i64 @iswctype(i32 %1, i32 %94)
%96 = icmp eq i64 %93, %95
%97 = zext i1 %96 to i32
%98 = tail call i32 @docheck(i32 %97, i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.15, i64 0, i64 0), i32 %1)
%99 = tail call i64 @iswblank(i32 %1)
%100 = tail call i32 @wctype(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.16, i64 0, i64 0))
%101 = tail call i64 @iswctype(i32 %1, i32 %100)
%102 = icmp eq i64 %99, %101
%103 = zext i1 %102 to i32
%104 = tail call i32 @docheck(i32 %103, i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.17, i64 0, i64 0), i32 %1)
%105 = tail call i64 @iswcntrl(i32 %1)
%106 = tail call i32 @wctype(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.18, i64 0, i64 0))
%107 = tail call i64 @iswctype(i32 %1, i32 %106)
%108 = icmp eq i64 %105, %107
%109 = zext i1 %108 to i32
%110 = tail call i32 @docheck(i32 %109, i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.19, i64 0, i64 0), i32 %1)
%111 = tail call i64 @iswdigit(i32 %1)
%112 = tail call i32 @wctype(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.20, i64 0, i64 0))
%113 = tail call i64 @iswctype(i32 %1, i32 %112)
%114 = icmp eq i64 %111, %113
%115 = zext i1 %114 to i32
%116 = tail call i32 @docheck(i32 %115, i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.21, i64 0, i64 0), i32 %1)
%117 = tail call i64 @iswgraph(i32 %1)
%118 = tail call i32 @wctype(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.22, i64 0, i64 0))
%119 = tail call i64 @iswctype(i32 %1, i32 %118)
%120 = icmp eq i64 %117, %119
%121 = zext i1 %120 to i32
%122 = tail call i32 @docheck(i32 %121, i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.23, i64 0, i64 0), i32 %1)
%123 = tail call i64 @iswlower(i32 %1)
%124 = tail call i32 @wctype(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.24, i64 0, i64 0))
%125 = tail call i64 @iswctype(i32 %1, i32 %124)
%126 = icmp eq i64 %123, %125
%127 = zext i1 %126 to i32
%128 = tail call i32 @docheck(i32 %127, i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.25, i64 0, i64 0), i32 %1)
%129 = tail call i64 @iswprint(i32 %1)
%130 = tail call i32 @wctype(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.26, i64 0, i64 0))
%131 = tail call i64 @iswctype(i32 %1, i32 %130)
%132 = icmp eq i64 %129, %131
%133 = zext i1 %132 to i32
%134 = tail call i32 @docheck(i32 %133, i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.27, i64 0, i64 0), i32 %1)
%135 = tail call i64 @iswpunct(i32 %1)
%136 = tail call i32 @wctype(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.28, i64 0, i64 0))
%137 = tail call i64 @iswctype(i32 %1, i32 %136)
%138 = icmp eq i64 %135, %137
%139 = zext i1 %138 to i32
%140 = tail call i32 @docheck(i32 %139, i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.29, i64 0, i64 0), i32 %1)
%141 = tail call i64 @iswspace(i32 %1)
%142 = tail call i32 @wctype(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.30, i64 0, i64 0))
%143 = tail call i64 @iswctype(i32 %1, i32 %142)
%144 = icmp eq i64 %141, %143
%145 = zext i1 %144 to i32
%146 = tail call i32 @docheck(i32 %145, i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.31, i64 0, i64 0), i32 %1)
%147 = tail call i64 @iswupper(i32 %1)
%148 = tail call i32 @wctype(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.32, i64 0, i64 0))
%149 = tail call i64 @iswctype(i32 %1, i32 %148)
%150 = icmp eq i64 %147, %149
%151 = zext i1 %150 to i32
%152 = tail call i32 @docheck(i32 %151, i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.33, i64 0, i64 0), i32 %1)
%153 = tail call i64 @iswxdigit(i32 %1)
%154 = tail call i32 @wctype(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.34, i64 0, i64 0))
%155 = tail call i64 @iswctype(i32 %1, i32 %154)
%156 = icmp eq i64 %153, %155
%157 = zext i1 %156 to i32
%158 = tail call i32 @docheck(i32 %157, i8* getelementptr inbounds ([48 x i8], [48 x i8]* @.str.35, i64 0, i64 0), i32 %1)
ret void
}